blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
171
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
8
| license_type
stringclasses 2
values | repo_name
stringlengths 6
82
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 13
values | visit_date
timestamp[ns] | revision_date
timestamp[ns] | committer_date
timestamp[ns] | github_id
int64 1.59k
594M
⌀ | star_events_count
int64 0
77.1k
| fork_events_count
int64 0
33.7k
| gha_license_id
stringclasses 12
values | gha_event_created_at
timestamp[ns] | gha_created_at
timestamp[ns] | gha_language
stringclasses 46
values | src_encoding
stringclasses 14
values | language
stringclasses 2
values | is_vendor
bool 2
classes | is_generated
bool 1
class | length_bytes
int64 4
7.87M
| extension
stringclasses 101
values | filename
stringlengths 2
149
| content
stringlengths 4
7.87M
| has_macro_def
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f4ab6ffaaacef581fba60bc6153aa1123ae4cd6a
|
15b3f9425594407e43dd57411a458daae76d56f6
|
/bin/test/load3.scm
|
df861d32fb9e42ba9a1d08c025a5fbf6ced2578d
|
[] |
no_license
|
aa10000/scheme
|
ecc2d50b9d5500257ace9ebbbae44dfcc0a16917
|
47633d7fc4d82d739a62ceec75c111f6549b1650
|
refs/heads/master
| 2021-05-30T06:06:32.004446 | 2015-02-12T23:42:25 | 2015-02-12T23:42:25 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 41 |
scm
|
load3.scm
|
(display (current-input-port))
(newline)
| false |
821c6511da34c8db6683fb543c2be690df70b738
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System.Data/system/data/sql-client/sql-client-factory.sls
|
3ab6882ed6385ade9a4b420e59ebd47cc5b59976
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,266 |
sls
|
sql-client-factory.sls
|
(library (system data sql-client sql-client-factory)
(export is?
sql-client-factory?
create-connection
create-permission
create-command-builder
create-data-adapter
create-connection-string-builder
create-parameter
create-data-source-enumerator
create-command
instance
can-create-data-source-enumerator?)
(import (ironscheme-clr-port))
(define (is? a) (clr-is System.Data.SqlClient.SqlClientFactory a))
(define (sql-client-factory? a)
(clr-is System.Data.SqlClient.SqlClientFactory a))
(define-method-port
create-connection
System.Data.SqlClient.SqlClientFactory
CreateConnection
(System.Data.Common.DbConnection))
(define-method-port
create-permission
System.Data.SqlClient.SqlClientFactory
CreatePermission
(System.Security.CodeAccessPermission
System.Security.Permissions.PermissionState))
(define-method-port
create-command-builder
System.Data.SqlClient.SqlClientFactory
CreateCommandBuilder
(System.Data.Common.DbCommandBuilder))
(define-method-port
create-data-adapter
System.Data.SqlClient.SqlClientFactory
CreateDataAdapter
(System.Data.Common.DbDataAdapter))
(define-method-port
create-connection-string-builder
System.Data.SqlClient.SqlClientFactory
CreateConnectionStringBuilder
(System.Data.Common.DbConnectionStringBuilder))
(define-method-port
create-parameter
System.Data.SqlClient.SqlClientFactory
CreateParameter
(System.Data.Common.DbParameter))
(define-method-port
create-data-source-enumerator
System.Data.SqlClient.SqlClientFactory
CreateDataSourceEnumerator
(System.Data.Common.DbDataSourceEnumerator))
(define-method-port
create-command
System.Data.SqlClient.SqlClientFactory
CreateCommand
(System.Data.Common.DbCommand))
(define-field-port
instance
#f
#f
(static:)
System.Data.SqlClient.SqlClientFactory
Instance
System.Data.SqlClient.SqlClientFactory)
(define-field-port
can-create-data-source-enumerator?
#f
#f
(property:)
System.Data.SqlClient.SqlClientFactory
CanCreateDataSourceEnumerator
System.Boolean))
| false |
323a47a3e6d5f32fc81b90f7f1ef693f004448fe
|
b12446d5e0210a91d11dce731ace0deb845d9e38
|
/inclass/lec14_pair_mutation.scm
|
ed0f66cf8c15a67cb4ff51818e3a8108995ef1c8
|
[] |
no_license
|
metehangelgi/Lisp
|
b0d1ad0c9eafeaee7ea8e8324b45cd34ab8e4117
|
40167847728cd8e6bb7969560bca474a717ff2b4
|
refs/heads/master
| 2022-10-05T17:45:38.504354 | 2020-06-08T15:59:16 | 2020-06-08T15:59:16 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 688 |
scm
|
lec14_pair_mutation.scm
|
;Pair Mutation as Change in State
(load "error.scm")
(define (my-cons x y)
(lambda (msg)
(cond ((eq? msg 'CAR) x)
((eq? msg 'CDR) y)
((eq? msg 'PAIR?) #t)
((eq? msg 'SET-CAR!)
(lambda (new-car) (set! x new-car)))
((eq? msg 'SET-CDR!)
(lambda (new-cdr) (set! y new-cdr)))
(else (error "pair cannot" msg)))))
(define (my-car p)
(p 'CAR))
(define (my-cdr p)
(p 'CDR))
(define (my-pair? p)
(and (procedure? p) (p 'PAIR?)))
(define (my-set-car! p new-car)
((p 'SET-CAR!) new-car))
(define (my-set-cdr! p new-cdr)
((p 'SET-CDR!) new-cdr))
(define bar (my-cons 3 4))
(my-set-car! bar 0)
(my-car bar)
| false |
92eb5572502669cde3db275e436a4bf6a89607d0
|
4b480cab3426c89e3e49554d05d1b36aad8aeef4
|
/chapter-02/ex2.17-Solidone.ss
|
899a02f90986d1560aaf2688cbb047c57420811b
|
[] |
no_license
|
tuestudy/study-sicp
|
a5dc423719ca30a30ae685e1686534a2c9183b31
|
a2d5d65e711ac5fee3914e45be7d5c2a62bfc20f
|
refs/heads/master
| 2021-01-12T13:37:56.874455 | 2016-10-04T12:26:45 | 2016-10-04T12:26:45 | 69,962,129 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 221 |
ss
|
ex2.17-Solidone.ss
|
(define squares (list 1 4 9 16 26))
(define odds (list 1 3 5 7))
(define (last-pair items)
(if (= 1 (length items))
(car items)
(last-pair (cdr items))))
(= 26 (last-pair squares))
(= 7 (last-pair odds))
| false |
9e479e1d2a856db816f208edf68b3fe5ef3f5a1d
|
972c2c3dbdddd7fd358f4f68b99137e970ef02de
|
/scheme/cairo-object.scm
|
17fd1bea8ebc5ce04d54a8cb03dc502bf4c4ed7f
|
[
"Apache-2.0"
] |
permissive
|
geotyper/contouring
|
91bf8f970d405c74e8d613e421d9a8357f4cc8ad
|
f5fa92724ce211d4e133c329fcdbf0a71c27ab64
|
refs/heads/master
| 2020-11-27T20:19:44.557006 | 2019-09-21T21:48:40 | 2019-09-21T21:48:40 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 804 |
scm
|
cairo-object.scm
|
(library (cairo-object)
(export cairo)
(import (contexts)
(cairo))
(define-object cairo
(save) (restore) (paint)
(fill) (fill-preserve) (stroke) (stroke-preserve)
(set-source-rgb r g b) (set-source-rgba r g b a)
(set-source-surface s x y)
(set-source pattern)
(set-line-width w) (set-line-cap c) (set-line-join j)
(set-operator o)
(mask-surface surf x y)
(mask pattern)
(get-target)
; paths
(new-path)
(close-path)
(arc x y r t0 t1) (arc-negative x y r t0 t1)
(line-to x y)
(move-to x y)
(curve-to sx0 sy0 sx1 sy1 x1 y1)
(rectangle x y width height)
; transformations
(translate tx ty)
(scale sx sy)
(rotate angle)
(transform m)
(set-matrix m)
(get-matrix m)
(identity-matrix)))
| false |
6628f04c57065df0f808cd616b6479688494de34
|
e055ebdd14f926b813c125931eb102db3f6d39af
|
/kernel.scm
|
49a38036c9b34f89a741fd0694f71886b53c09a2
|
[] |
no_license
|
AllenHsu4390/FCL
|
8ed5a9c024005a219defab7de1a1da9c7cc046c0
|
9f2588f4a7d30e0b001909652db9b84918745d32
|
refs/heads/master
| 2020-05-25T12:03:32.234683 | 2019-09-02T23:03:49 | 2019-09-02T23:03:49 | 27,059,193 | 0 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,637 |
scm
|
kernel.scm
|
;;;; File: kernel.scm
;;;; Description: functions relating to creating a OpenCL kernel
;;;; Author: Allen Hsu
(define (kernel-has-double? inputs output)
;; checks if any of the inputs or outputs are of type double
;; doubles require extra extension declaring in OpenCL
(let ((o-type (ast-arg-type output))
(i-types (map ast-arg-type inputs)))
(or (string= "double" o-type) (member "double" i-types))))
(define (base-type-access-format arg base-type)
(format "~a[i]=rtn.~a" (ast-arg-name arg) base-type))
(define (kernel-statements inputs output instruction declarations shared)
;; create c like statements for the OpenCL kernel using the user ast expanded
;; glanguage s expressions
(let* ((record (assoc (ast-arg-type output) (alias-record-dictionary)))
(output-statement (if record
(map base-type-access-format
(record-arg->base-args output)
(grecord-type-attributes (cdr record)))
(format "~a[i]=rtn" (ast-arg-name output)))))
(flatlist
"int i = get_global_id(0)"
declarations
(format "~a rtn=~a;" (ast-arg-type output) instruction)
output-statement)))
(define (global-format arg)
(format "global ~a* ~a" (ast-arg-type arg) (ast-arg-name arg)))
(define (kernel-parameters inputs output shared)
;; returns string specifying the parameters of the kernel
(flatlist
(map global-format inputs)
(map (lambda (s) (format "global ~a* ~a" (ast-shared-type s) (ast-shared-name s)))
shared)
(if (assoc (ast-arg-type output) (alias-record-dictionary))
(map global-format (record-arg->base-args output))
(global-format output))))
(define enable-double "#pragma OPENCL EXTENSION cl_khr_fp64 : enable
")
(define (kernel-source-code inputs
output
instruction
top-level-declarations
shared
local-declarations)
(let* ((header (flatlist "typedef void* record;"
top-level-declarations)))
(make-cprogram header: header
type: "kernel void"
name: "func_kernel"
parameters: (kernel-parameters inputs output shared)
body: (kernel-statements inputs
output
instruction
local-declarations
shared))))
| false |
2e649f1cb97d6c706324dd86a739d227543dfe08
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/mscorlib/system/runtime/interop-services/comexception.sls
|
496e60a575601fa69c0666de1458f031d365a541
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 611 |
sls
|
comexception.sls
|
(library (system runtime interop-services comexception)
(export new is? comexception? to-string)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Runtime.InteropServices.COMException
a
...)))))
(define (is? a)
(clr-is System.Runtime.InteropServices.COMException a))
(define (comexception? a)
(clr-is System.Runtime.InteropServices.COMException a))
(define-method-port
to-string
System.Runtime.InteropServices.COMException
ToString
(System.String)))
| true |
26da86ad8af422179d207f118d9baecc03e05c8a
|
4e5868b0beb9485138dfcd4a125fc0d60414d2ac
|
/build/standard-libraries.scm
|
28e1baa25f58b81253dbb04f5c5e65931efdbb9d
|
[] |
permissive
|
JKTKops/Thcheme
|
08dece12c3fd67b781bb9eb38d5ce1c1f2e68c39
|
f7f73fae244477ccdcd71b23792d2ed50a844d68
|
refs/heads/master
| 2021-08-15T22:14:53.077162 | 2021-08-04T03:11:34 | 2021-08-04T03:11:34 | 158,151,157 | 2 | 0 |
BSD-3-Clause
| 2020-12-21T06:04:22 | 2018-11-19T02:34:01 |
Haskell
|
UTF-8
|
Scheme
| false | false | 42,718 |
scm
|
standard-libraries.scm
|
;;;=====================================================================
;;;
;;; Derived forms:
;;;
;;; Copyright (c) 2006 Andre van Tonder
;;;
;;; Copyright statement at http://srfi.schemers.org/srfi-process.html
;;;
;;;=====================================================================
;;;
;;; As allowed by that copyright statement, modified for Thcheme
;;; by Max Kopinsky, 2021.
;;;
;;;=====================================================================
;;;
;;; This file builds r7rs up using a sequence of libraries.
;;; It constitutes a nontrivial example, tutorial and test
;;; of the library system.
;;;
;;; It is meant to be expanded by expander.scm and compiled
;;; together with the latter before using in a production system.
;;;
;;; Various of the standard macros were copied from
;;; SRFI-93 reference implementation.
;;;
;;; An explicit renaming library is included for easier
;;; porting of legacy macros in some implementations.
;;;
;;;=====================================================================
(library (core primitives)
(export
;; Macros defined in core expander:
begin if lambda quote set! and or
define define-syntax let-syntax letrec-syntax
macroexpand
_ ... syntax syntax-case
;; Procedures and values defined in core expander:
(rename (ex:make-variable-transformer make-variable-transformer)
(ex:identifier? identifier?)
(ex:bound-identifier=? bound-identifier=?)
(ex:free-identifier=? free-identifier=?)
(ex:generate-temporaries generate-temporaries)
(ex:datum->syntax datum->syntax)
(ex:syntax->datum syntax->datum)
(ex:syntax-violation syntax-violation)
(ex:environment environment)
(ex:environment-bindings environment-bindings)
(ex:eval eval)
(ex:undefined undefined)))
(import
(only (core primitive-macros)
begin if set! and or lambda quote
define define-syntax let-syntax letrec-syntax
macroexpand
syntax syntax-case _ ...)
;; An extension to the r6rs import syntax, used here to make
;; available variable bindings provided natively.
;; This will not work for macros, which have to be defined
;; within the context of this expander.
(primitives
;; Procedures and values defined in the core expander:
ex:make-variable-transformer ex:identifier? ex:bound-identifier=?
ex:free-identifier=? ex:generate-temporaries ex:datum->syntax ex:syntax->datum
ex:syntax-violation ex:environment ex:environment-bindings ex:eval
ex:undefined
))
) ;; core primitives
(library (core with-syntax)
(export with-syntax)
(import (for (core primitives) run expand)
(primitives list))
(define-syntax with-syntax
(lambda (x)
(syntax-case x ()
((_ () e1 e2 ...) (syntax (begin e1 e2 ...)))
((_ ((out in)) e1 e2 ...) (syntax (syntax-case in ()
(out (begin e1 e2 ...)))))
((_ ((out in) ...) e1 e2 ...) (syntax (syntax-case (list in ...) ()
((out ...) (begin e1 e2 ...))))))))
)
(library (core syntax-rules)
(export syntax-rules)
(import (for (core primitives) expand run)
(for (core with-syntax) expand)
(for (primitives for-all map) expand))
(define-syntax syntax-rules
(lambda (x)
(define clause
(lambda (y)
(syntax-case y ()
(((keyword . pattern) template)
(syntax ((dummy . pattern) (syntax template))))
(_
(syntax-violation 'syntax-rules "Invalid expression" x)))))
(syntax-case x ()
((_ (k ...) cl ...)
(for-all identifier? (syntax (k ...)))
(with-syntax (((cl ...) (map clause (syntax (cl ...)))))
(syntax
(lambda (x) (syntax-case x (k ...) cl ...))))))))
)
(library (core let)
(export let letrec letrec*)
(import (for (core primitives) expand run)
(for (core with-syntax) expand)
(for (primitives for-all) expand))
(define-syntax let
(lambda (x)
(syntax-case x ()
((_ ((x v) ...) e1 e2 ...)
(for-all identifier? (syntax (x ...)))
(syntax ((lambda (x ...) e1 e2 ...) v ...)))
((_ f ((x v) ...) e1 e2 ...)
(for-all identifier? (syntax (f x ...)))
(syntax ((letrec ((f (lambda (x ...) e1 e2 ...))) f) v ...))))))
(define-syntax letrec
(lambda (x)
(syntax-case x ()
((_ ((i v) ...) e1 e2 ...)
(with-syntax (((t ...) (generate-temporaries (syntax (i ...)))))
(syntax (let ((i undefined) ...)
(let ((t v) ...)
(set! i t) ...
(let () e1 e2 ...)))))))))
(define-syntax letrec*
(lambda (x)
(syntax-case x ()
((_ ((i v) ...) e1 e2 ...)
(syntax (let ()
(define i v) ...
(let () e1 e2 ...)))))))
) ; let
(library (core derived)
(export let* cond case else =>)
(import (for (core primitives) expand run)
(for (core let) expand run)
(for (core with-syntax) expand)
(for (core syntax-rules) expand)
(for (primitives for-all null? memv car cdr) expand run))
(define-syntax let*
(lambda (x)
(syntax-case x ()
((_ () e1 e2 ...)
(syntax (let () e1 e2 ...)))
((_ ((x v) ...) e1 e2 ...)
(for-all identifier? (syntax (x ...)))
(let f ((bindings (syntax ((x v) ...))))
(syntax-case bindings ()
(((x v)) (syntax (let ((x v)) e1 e2 ...)))
(((x v) . rest) (with-syntax ((body (f (syntax rest))))
(syntax (let ((x v)) body))))))))))
(define-syntax cond
(lambda (x)
(syntax-case x ()
((_ c1 c2 ...)
(let f ((c1 (syntax c1))
(c2* (syntax (c2 ...))))
(syntax-case c2* ()
(()
(syntax-case c1 (else =>)
((else e1 e2 ...) (syntax (begin e1 e2 ...)))
((e0) (syntax (let ((t e0)) (if t t))))
((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...))))
(_ (syntax-violation 'cond "Invalid expression" x))))
((c2 c3 ...)
(with-syntax ((rest (f (syntax c2)
(syntax (c3 ...)))))
(syntax-case c1 (else =>)
((e0) (syntax (let ((t e0)) (if t t rest))))
((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...) rest)))
(_ (syntax-violation 'cond "Invalid expression" x)))))))))))
(define-syntax case
(lambda (x)
(syntax-case x ()
((_ e c1 c2 ...)
(with-syntax ((body
(let f ((c1 (syntax c1))
(cmore (syntax (c2 ...))))
(if (null? cmore)
(syntax-case c1 (else)
((else e1 e2 ...) (syntax (begin e1 e2 ...)))
(((k ...) e1 e2 ...) (syntax (if (memv t '(k ...))
(begin e1 e2 ...)))))
(with-syntax ((rest (f (car cmore) (cdr cmore))))
(syntax-case c1 ()
(((k ...) e1 e2 ...)
(syntax (if (memv t '(k ...))
(begin e1 e2 ...)
rest)))))))))
(syntax (let ((t e)) body)))))))
(define-syntax =>
(lambda (x)
(syntax-violation '=> "Invalid expression" x)))
(define-syntax else
(lambda (x)
(syntax-violation 'else "Invalid expression" x)))
) ; derived
(library (core identifier-syntax)
(export identifier-syntax)
(import (for (core primitives)
expand
run
;; since generated macro contains (syntax set!) at level 0
(meta -1)))
(define-syntax identifier-syntax
(lambda (x)
(syntax-case x (set!)
((_ e)
(syntax (lambda (x)
(syntax-case x ()
(id (identifier? (syntax id)) (syntax e))
((_ x (... ...)) (syntax (e x (... ...))))))))
((_ (id exp1)
((set! var val) exp2))
(and (identifier? (syntax id))
(identifier? (syntax var)))
(syntax
(make-variable-transformer
(lambda (x)
(syntax-case x (set!)
((set! var val) (syntax exp2))
((id x (... ...)) (syntax (exp1 x (... ...))))
(id (identifier? (syntax id)) (syntax exp1))))))))))
)
;;;=========================================================
;;;
;;; Quasisyntax in terms of syntax-case.
;;;
;;;=========================================================
;;;
;;; To make nested unquote-splicing behave in a useful way,
;;; the R5RS-compatible extension of quasiquote in appendix B
;;; of the following paper is here ported to quasisyntax:
;;;
;;; Alan Bawden - Quasiquotation in Lisp
;;; http://citeseer.ist.psu.edu/bawden99quasiquotation.html
;;;
;;; The algorithm converts a quasisyntax expression to an
;;; equivalent with-syntax expression.
;;; For example:
;;;
;;; (quasisyntax (set! #,a #,b))
;;; ==> (with-syntax ((t0 a)
;;; (t1 b))
;;; (syntax (set! t0 t1)))
;;;
;;; (quasisyntax (list #,@args))
;;; ==> (with-syntax (((t ...) args))
;;; (syntax (list t ...)))
;;;
;;; Note that quasisyntax is expanded first, before any
;;; ellipses act. For example:
;;;
;;; (quasisyntax (f ((b #,a) ...))
;;; ==> (with-syntax ((t a))
;;; (syntax (f ((b t) ...))))
;;;
;;; so that
;;;
;;; (let-syntax ((test-ellipses-over-unsyntax
;;; (lambda (e)
;;; (let ((a (syntax a)))
;;; (with-syntax (((b ...) (syntax (1 2 3))))
;;; (quasisyntax
;;; (quote ((b #,a) ...))))))))
;;; (test-ellipses-over-unsyntax))
;;;
;;; ==> ((1 a) (2 a) (3 a))
(library (core quasisyntax)
(export quasisyntax unsyntax unsyntax-splicing)
(import (for (core primitives) run expand)
(for (core let) run expand)
(for (core derived) run expand)
(for (core with-syntax) run expand)
(for (primitives = > + - vector->list) run expand))
(define-syntax quasisyntax
(lambda (e)
;; Expand returns a list of the form
;; [template[t/e, ...] (replacement ...)]
;; Here template[t/e ...] denotes the original template
;; with unquoted expressions e replaced by fresh
;; variables t, followed by the appropriate ellipses
;; if e is also spliced.
;; The second part of the return value is the list of
;; replacements, each of the form (t e) if e is just
;; unquoted, or ((t ...) e) if e is also spliced.
;; This will be the list of bindings of the resulting
;; with-syntax expression.
(define (expand x level)
(syntax-case x (quasisyntax unsyntax unsyntax-splicing)
((quasisyntax e)
(with-syntax (((k _) x) ;; original identifier must be copied
((e* reps) (expand (syntax e) (+ level 1))))
(syntax ((k e*) reps))))
((unsyntax e)
(= level 0)
(with-syntax (((t) (generate-temporaries '(t))))
(syntax (t ((t e))))))
(((unsyntax e ...) . r)
(= level 0)
(with-syntax (((r* (rep ...)) (expand (syntax r) 0))
((t ...) (generate-temporaries (syntax (e ...)))))
(syntax ((t ... . r*)
((t e) ... rep ...)))))
(((unsyntax-splicing e ...) . r)
(= level 0)
(with-syntax (((r* (rep ...)) (expand (syntax r) 0))
((t ...) (generate-temporaries (syntax (e ...)))))
(with-syntax ((((t ...) ...) (syntax ((t (... ...)) ...))))
(syntax ((t ... ... . r*)
(((t ...) e) ... rep ...))))))
((k . r)
(and (> level 0)
(identifier? (syntax k))
(or (free-identifier=? (syntax k) (syntax unsyntax))
(free-identifier=? (syntax k) (syntax unsyntax-splicing))))
(with-syntax (((r* reps) (expand (syntax r) (- level 1))))
(syntax ((k . r*) reps))))
((h . t)
(with-syntax (((h* (rep1 ...)) (expand (syntax h) level))
((t* (rep2 ...)) (expand (syntax t) level)))
(syntax ((h* . t*)
(rep1 ... rep2 ...)))))
(#(e ...)
(with-syntax ((((e* ...) reps)
(expand (vector->list (syntax #(e ...))) level)))
(syntax (#(e* ...) reps))))
(other
(syntax (other ())))))
(syntax-case e ()
((_ template)
(with-syntax (((template* replacements) (expand (syntax template) 0)))
(syntax
(with-syntax replacements (syntax template*))))))))
(define-syntax unsyntax
(lambda (e)
(syntax-violation 'unsyntax "Invalid expression" e)))
(define-syntax unsyntax-splicing
(lambda (e)
(syntax-violation 'unsyntax "Invalid expression" e)))
)
(library (core quasiquote)
(export quasiquote unquote unquote-splicing)
(import (for (core primitives) run expand)
(for (core let) run expand)
(for (core derived) run expand)
(for (core with-syntax) expand)
(for (core quasisyntax) expand)
(for (primitives = + - null? cons car cdr append map list vector list->vector)
run expand))
;; Optimised version copied from portable syntax-case (Dybvig)
(define-syntax quasiquote
(let ()
(define (quasi p lev)
(syntax-case p (unquote quasiquote)
((unquote p)
(if (= lev 0)
(syntax ("value" p))
(quasicons (syntax ("quote" unquote)) (quasi (syntax (p)) (- lev 1)))))
((quasiquote p) (quasicons (syntax ("quote" quasiquote)) (quasi (syntax (p)) (+ lev 1))))
((p . q)
(syntax-case (syntax p) (unquote unquote-splicing)
((unquote p ...)
(if (= lev 0)
(quasilist* (syntax (("value" p) ...)) (quasi (syntax q) lev))
(quasicons
(quasicons (syntax ("quote" unquote)) (quasi (syntax (p ...)) (- lev 1)))
(quasi (syntax q) lev))))
((unquote-splicing p ...)
(if (= lev 0)
(quasiappend (syntax (("value" p) ...)) (quasi (syntax q) lev))
(quasicons
(quasicons (syntax ("quote" unquote-splicing)) (quasi (syntax (p ...)) (- lev 1)))
(quasi (syntax q) lev))))
(_ (quasicons (quasi (syntax p) lev) (quasi (syntax q) lev)))))
(#(x ...) (quasivector (vquasi (syntax (x ...)) lev)))
(p (syntax ("quote" p)))))
(define (vquasi p lev)
(syntax-case p ()
((p . q)
(syntax-case (syntax p) (unquote unquote-splicing)
((unquote p ...)
(if (= lev 0)
(quasilist* (syntax (("value" p) ...)) (vquasi (syntax q) lev))
(quasicons
(quasicons (syntax ("quote" unquote)) (quasi (syntax (p ...)) (- lev 1)))
(vquasi (syntax q) lev))))
((unquote-splicing p ...)
(if (= lev 0)
(quasiappend (syntax (("value" p) ...)) (vquasi (syntax q) lev))
(quasicons
(quasicons
(syntax ("quote" unquote-splicing))
(quasi (syntax (p ...)) (- lev 1)))
(vquasi (syntax q) lev))))
(_ (quasicons (quasi (syntax p) lev) (vquasi (syntax q) lev)))))
(() (syntax ("quote" ())))))
(define (quasicons x y)
(with-syntax ((x x) (y y))
(syntax-case (syntax y) ()
(("quote" dy)
(syntax-case (syntax x) ()
(("quote" dx) (syntax ("quote" (dx . dy))))
(_ (if (null? (syntax dy)) (syntax ("list" x)) (syntax ("list*" x y))))))
(("list" . stuff) (syntax ("list" x . stuff)))
(("list*" . stuff) (syntax ("list*" x . stuff)))
(_ (syntax ("list*" x y))))))
(define (quasiappend x y)
(syntax-case y ()
(("quote" ())
(cond
((null? x) (syntax ("quote" ())))
((null? (cdr x)) (car x))
(else (with-syntax (((p ...) x)) (syntax ("append" p ...))))))
(_
(cond
((null? x) y)
(else (with-syntax (((p ...) x) (y y)) (syntax ("append" p ... y))))))))
(define (quasilist* x y)
(let f ((x x))
(if (null? x)
y
(quasicons (car x) (f (cdr x))))))
(define (quasivector x)
(syntax-case x ()
(("quote" (x ...)) (syntax ("quote" #(x ...))))
(_
(let f ((y x) (k (lambda (ls) (quasisyntax ("vector" (unsyntax-splicing ls))))))
(syntax-case y ()
(("quote" (y ...)) (k (syntax (("quote" y) ...))))
(("list" y ...) (k (syntax (y ...))))
(("list*" y ... z) (f (syntax z) (lambda (ls) (k (append (syntax (y ...)) ls)))))
(else (quasisyntax ("list->vector" (unsyntax x)))))))))
(define (emit x)
(syntax-case x ()
(("quote" x) (syntax 'x))
(("list" x ...) (quasisyntax (list (unsyntax-splicing (map emit (syntax (x ...)))))))
;; could emit list* for 3+ arguments if implementation supports list*
(("list*" x ... y)
(let f ((x* (syntax (x ...))))
(if (null? x*)
(emit (syntax y))
(quasisyntax (cons (unsyntax (emit (car x*))) (unsyntax (f (cdr x*))))))))
(("append" x ...) (quasisyntax (append (unsyntax-splicing (map emit (syntax (x ...)))))))
(("vector" x ...) (quasisyntax (vector (unsyntax-splicing (map emit (syntax (x ...)))))))
(("list->vector" x) (quasisyntax (list->vector (unsyntax (emit (syntax x))))))
(("value" x) (syntax x))))
(lambda (x)
(syntax-case x ()
;; convert to intermediate language, combining introduced (but not
;; unquoted source) quote expressions where possible and choosing
;; optimal construction code otherwise, then emit Scheme code
;; corresponding to the intermediate language forms.
((_ e) (emit (quasi (syntax e) 0)))))))
(define-syntax unquote
(lambda (e)
(syntax-violation 'unquote "Invalid expression" e)))
(define-syntax unquote-splicing
(lambda (e)
(syntax-violation 'unquote-splicing "Invalid expression" e)))
)
(library (core let-values)
(export let-values let*-values)
(import (for (core primitives) expand run)
(for (core syntax-rules) expand)
(core let)
(primitives call-with-values))
(define-syntax let-values
(syntax-rules ()
((let-values (?binding ...) ?body0 ?body1 ...)
(let-values "bind" (?binding ...) () (begin ?body0 ?body1 ...)))
((let-values "bind" () ?tmps ?body)
(let ?tmps ?body))
((let-values "bind" ((?b0 ?e0) ?binding ...) ?tmps ?body)
(let-values "mktmp" ?b0 ?e0 () (?binding ...) ?tmps ?body))
((let-values "mktmp" () ?e0 ?args ?bindings ?tmps ?body)
(call-with-values
(lambda () ?e0)
(lambda ?args
(let-values "bind" ?bindings ?tmps ?body))))
((let-values "mktmp" (?a . ?b) ?e0 (?arg ...) ?bindings (?tmp ...) ?body)
(let-values "mktmp" ?b ?e0 (?arg ... x) ?bindings (?tmp ... (?a x)) ?body))
((let-values "mktmp" ?a ?e0 (?arg ...) ?bindings (?tmp ...) ?body)
(call-with-values
(lambda () ?e0)
(lambda (?arg ... . x)
(let-values "bind" ?bindings (?tmp ... (?a x)) ?body))))))
(define-syntax let*-values
(syntax-rules ()
((let*-values () ?body0 ?body1 ...)
(begin ?body0 ?body1 ...))
((let*-values (?binding0 ?binding1 ...) ?body0 ?body1 ...)
(let-values (?binding0)
(let*-values (?binding1 ...) ?body0 ?body1 ...)))))
) ; core let-values
(library (core define-values)
(export define-values)
(import (for (core primitives) expand run)
(for (core syntax-rules) expand)
(core let)
(primitives call-with-values car cadr cddr set-cdr! list))
(define-syntax define-values
(syntax-rules ()
((define-values () expr)
(define dummy
(call-with-values (lambda () expr)
(lambda args #f))))
((define-values (var) expr)
(define var expr))
((define-values (var0 var1 ... varn) expr)
(begin
(define var0
(call-with-values (lambda () expr) list))
(define var1
(let ([v (cadr var0)])
(set-cdr! var0 (cddr var0))
v)) ...
(define varn
(let ([v (cadr var0)])
(set! var0 (car var0))
v))))
((define-values var expr)
(define var
(call-with-values (lambda () expr) list)))))
) ; core define-values
(library (core define-record-type)
(export define-record-type)
(import (for (prefix (primitives define-record-type) records:) expand)
(for (core primitives) expand run)
(for (primitives apply) expand))
(define-syntax define-record-type
(lambda (x)
(syntax-case x ()
((k name constr pred field* ...)
(datum->syntax (syntax k)
(apply records:define-record-type
(syntax->datum (syntax name))
(syntax->datum (syntax constr))
(syntax->datum (syntax pred))
(syntax->datum (syntax (field* ...)))))))))
)
(library (rnrs control (6))
(export when unless do case-lambda)
(import (for (core primitives) expand run)
(for (core let) expand run)
(for (core with-syntax) expand)
(for (core syntax-rules) expand)
(for (primitives not map length assertion-violation = >= apply)
expand run) )
(define-syntax when
(syntax-rules ()
((when test result1 result2 ...)
(if test
(begin result1 result2 ...)))))
(define-syntax unless
(syntax-rules ()
((unless test result1 result2 ...)
(if (not test)
(begin result1 result2 ...)))))
(define-syntax do
(lambda (orig-x)
(syntax-case orig-x ()
((_ ((var init . step) ...) (e0 e1 ...) c ...)
(with-syntax (((step ...)
(map (lambda (v s)
(syntax-case s ()
(() v)
((e) (syntax e))
(_ (syntax-violation 'do "Invalid step" orig-x s))))
(syntax (var ...))
(syntax (step ...)))))
(syntax-case (syntax (e1 ...)) ()
(() (syntax (let do ((var init) ...)
(if (not e0)
(begin c ... (do step ...))))))
((e1 e2 ...) (syntax (let do ((var init) ...)
(if e0
(begin e1 e2 ...)
(begin c ... (do step ...))))))))))))
(define-syntax case-lambda
(syntax-rules ()
((_ (fmls b1 b2 ...))
(lambda fmls b1 b2 ...))
((_ (fmls b1 b2 ...) ...)
(lambda args
(let ((n (length args)))
(case-lambda-help args n
(fmls b1 b2 ...) ...))))))
(define-syntax case-lambda-help
(syntax-rules ()
((_ args n)
(assertion-violation #f "unexpected number of arguments"))
((_ args n ((x ...) b1 b2 ...) more ...)
(if (= n (length '(x ...)))
(apply (lambda (x ...) b1 b2 ...) args)
(case-lambda-help args n more ...)))
((_ args n ((x1 x2 ... . r) b1 b2 ...) more ...)
(if (>= n (length '(x1 x2 ...)))
(apply (lambda (x1 x2 ... . r) b1 b2 ...)
args)
(case-lambda-help args n more ...)))
((_ args n (r b1 b2 ...) more ...)
(apply (lambda r b1 b2 ...) args))))
) ; rnrs control
(library (thcheme syntax-error (7))
(export syntax-error)
(import (for (core primitives) expand run)
(for (primitives apply error) expand))
(define-syntax syntax-error
(lambda (e)
(syntax-case e ()
((_ msg args ...)
(apply error #'(msg args ...))))))
) ; rnrs syntax-error
(library (thcheme parameters (7))
(export make-parameter parameterize)
(import (for (core syntax-rules) expand)
(for (core primitives) expand run)
(for (core derived) expand run)
(core let)
(primitives dynamic-wind id eq? error list
pair? null? cons car cadr))
(define <param-set!> (list '<param-set!>))
(define <param-convert> (list '<param-convert>))
(define (make-parameter init . converter)
(let* ([converter (if (pair? converter)
(car converter)
id)]
[value (converter init)])
(lambda args
(cond
[(null? args) value]
[(eq? (car args) <param-set!>)
(set! value (cadr args))]
[(eq? (car args) <param-convert>)
converter]
[else
(error "bad parameter syntax: " (cons '<parameter> args))]))))
(define-syntax parameterize
(syntax-rules ()
((parameterize "step"
((param value p old new) ...)
()
body)
(let ([p param] ...)
(let ([old (p)] ...
[new ((p <param-convert>) value)] ...)
(dynamic-wind
(lambda () (p <param-set!> new) ...)
(lambda () . body)
(lambda () (p <param-set!> old) ...)))))
((parameterize "step"
args
((param value) . rest)
body)
(parameterize "step"
((param value p old new) . args)
rest
body))
((parameterize ((param value) ...) . body)
(parameterize "step"
()
((param value) ...)
body))))
) ; thcheme parameters
(library (thcheme ports)
(export call-with-port call-with-input-file call-with-output-file
input-port? output-port? textual-port? binary-port? port?
input-port-open? output-port-open?
current-input-port current-output-port current-error-port
with-input-from-file with-output-to-file
with-input-from-string with-output-to-string
open-input-file open-output-file
close-port close-input-port close-output-port
open-input-string open-output-string get-output-string)
(import (core primitives)
(thcheme parameters)
(primitives
call-with-port call-with-input-file call-with-output-file
input-port? output-port? textual-port? binary-port? port?
input-port-open? output-port-open?
open-input-file open-output-file
close-port close-input-port close-output-port
open-input-string open-output-string get-output-string
standard-input-port standard-output-port standard-error-port))
(define current-input-port (make-parameter (standard-input-port)))
(define current-output-port (make-parameter (standard-output-port)))
(define current-error-port (make-parameter (standard-error-port)))
(define (with-input-from-file filename thunk)
(define p (open-input-file filename))
(define result
(parameterize ([current-input-port p])
(thunk)))
(close-input-port p)
result)
(define (with-output-to-file filename thunk)
(define p (open-output-file filename))
(define result
(parameterize ([current-output-port p])
(thunk)))
(close-output-port p)
result)
(define (with-input-from-string string thunk)
(define p (open-input-string string))
(define result
(parameterize ([current-input-port p])
(thunk)))
(close-input-port p)
result)
(define (with-output-to-string thunk)
(define p (open-output-string))
(parameterize ([current-output-port p])
(thunk))
(get-output-string p))
) ; thcheme ports
(library (thcheme with-default-port)
(export with-default-port0 with-default-port1)
(import (core primitives)
(core let)
(core derived)
(primitives null? pair? car))
(define (with-default-port0 get-port proc)
(lambda port
(let ([port (cond [(null? port) (get-port)]
[(pair? port) (car port)])])
(proc port))))
(define (with-default-port1 get-port proc)
(lambda (obj . port)
(let ([port (cond [(null? port) (get-port)]
[(pair? port) (car port)])])
(proc obj port))))
) ; thcheme with-default-port
; probably want (thcheme input) and (thcheme output) libraries here.
(library (scheme base (7))
(export
;; Macros defined in core expander:
begin if lambda quote set! and or
define define-syntax let-syntax letrec-syntax
macroexpand
_ ...
;; Derived syntax:
let let* letrec letrec* let-values let*-values
case cond else =>
define-values define-record-type
; guard
when unless do
parameterize
quasiquote unquote unquote-splicing
syntax-error
syntax-rules identifier-syntax
;; R5RS primitives:
* + - / < <= = > >= abs append apply
boolean? call-with-current-continuation
call-with-values car cdr caar cadr cdar cddr
ceiling char? char->integer
complex? cons
denominator dynamic-wind
eq? equal? eqv? even? exact? expt floor for-each
gcd imag-part inexact? integer->char integer?
lcm length list list->string
list->vector list-ref list-tail list?
make-string make-vector map max min
negative? not null? number->string number? numerator
odd? pair?
positive? procedure? rational? rationalize
real-part real? reverse round
string string->list string->number string->symbol
string-append
string-copy string-length string-ref string<=? string<?
string=? string>=? string>? string? substring symbol->string symbol?
truncate values vector vector->list
vector-fill! vector-length vector-ref vector-set! vector? zero?
;; R7RS additional procedures
assoc assq assv
binary-port? boolean=? bytevector?
call-with-port call/cc char-ready? char<=? char<? char=? char>=? char>?
close-input-port close-output-port close-port
current-input-port current-output-port current-error-port
eof-object eof-object? error error-object-irritants error-object-message
exact exact-integer-sqrt exact-integer?
features file-error? floor-quotient floor-remainder floor/ flush-output-port
get-output-string
inexact input-port-open? input-port?
list-copy list-set!
make-list make-parameter member memq memv modulo
newline
open-input-string open-output-string output-port-open? output-port?
peek-char port?
quotient
raise raise-continuable read-char read-error? read-line read-string
remainder
set-car! set-cdr!
square string->vector string-copy! string-fill! string-for-each string-map
string-set! symbol=?
textual-port? truncate-quotient truncate-remainder truncate/
vector->string vector-append vector-copy vector-copy! vector-for-each
vector-map
with-exception-handler write-char write-string)
(import
(except (core primitives) _ ...)
(for (only (core primitives) _ ... set!) expand)
(core let)
(core derived)
(core quasiquote)
(core let-values)
(core define-values)
(core define-record-type)
(rnrs control)
(thcheme syntax-error)
(thcheme parameters)
(thcheme ports)
(for (core syntax-rules) expand)
(for (core identifier-syntax) expand)
(primitives
;; R5RS primitives:
* + - / < <= = > >= abs append apply
boolean? call-with-current-continuation
call-with-values car cdr caar cadr cdar cddr
ceiling char? char->integer
complex? cons
denominator dynamic-wind
eq? equal? eqv? even? exact? expt floor for-each
gcd imag-part inexact? integer->char integer?
lcm length list list->string
list->vector list-ref list-tail list?
make-string make-vector map max min
negative? not null? number->string number? numerator
odd? pair?
positive? procedure? rational? rationalize
real-part real? reverse round
string string->list string->number string->symbol
string-append
string-copy string-length string-ref string<=? string<?
string=? string>=? string>? string? substring symbol->string symbol?
truncate values vector vector->list
vector-fill! vector-length vector-ref vector-set! vector? zero?
;; R7RS additional procedures
assoc assq assv
binary-port? boolean=? bytevector?
call-with-port call/cc char-ready? char<=? char<? char=? char>=? char>?
close-input-port close-output-port close-port
eof-object eof-object? error error-object-irritants error-object-message
exact exact-integer-sqrt exact-integer?
features file-error? floor-quotient floor-remainder floor/ flush-output-port
get-output-string
inexact input-port-open? input-port?
list-copy list-set!
make-list member memq memv modulo
newline
open-input-string open-output-string output-port-open? output-port?
peek-char port?
quotient
raise raise-continuable read-char read-error? read-line read-string
remainder
set-car! set-cdr!
square string->vector string-copy! string-fill! string-for-each string-map
string-set! symbol=?
textual-port? truncate-quotient truncate-remainder truncate/
vector->string vector-append vector-copy vector-copy! vector-for-each
vector-map
with-exception-handler write-char write-string
zero?))
) ; scheme base
(library (scheme case-lambda)
(export case-lambda)
(import (rnrs control)))
(library (scheme char)
(export ; TODO
)
(import (primitives ; TODO
)))
(library (scheme complex)
(export angle imag-part magnitude make-polar make-rectangular real-part)
(import
(primitives
angle imag-part magnitude make-polar make-rectangular real-part)))
(library (scheme cxr)
(export
caaar caadr cadar caddr cdaar cdadr cddar cdddr
caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr)
(import (primitives
caaar caadr cadar caddr cdaar cdadr cddar cdddr
caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr)))
(library (scheme eval)
(export environment eval)
(import (core primitives)))
(library (thcheme eval reflection)
(export environment-bindings)
(import (core primitives)))
(library (scheme file)
(export
call-with-input-file call-with-output-file delete-file file-exists?
open-input-file open-output-file with-input-from-file with-output-to-file)
(import
(thcheme ports)
(primitives delete-file file-exists?)))
(library (scheme inexact)
(export acos asin atan cos exp finite? infinite? log nan? sin sqrt tan)
(import (primitives
acos asin atan cos exp finite? infinite? log nan? sin sqrt tan)))
#| We can't load this library until define-record-type is known to the expander
which will require probably a (core define-record-type) library, I guess.
It also might not load for other reasons, but the logic should be right.
(library (scheme lazy)
(export delay delay-force force make-promise promise?)
(import (rnrs base)
(primitives define-record-type))
(define-record-type
promise
(box-promise payload)
promise?
;; payload is a pair, because we need to be able to share the cons cell
(payload payload-get payload-set!))
(define (build-promise done? proc)
(box-promise (cons done? proc)))
(define (promise-done? p)
(car (payload-get p)))
(define (promise-value p)
(cdr (payload-get p)))
(define (promise-update! new old)
(set-car! (payload-get old) (promise-done? new))
(set-cdr! (payload-get old) (promise-value new))
(payload-set! new (payload-get old)))
(define-syntax delay-force
(syntax-rules ()
((delay-force expression)
(build-promise #f (lambda () expression)))))
(define-syntax delay
(syntax-rules ()
((delay expression)
(delay-force (build-promise #t expression)))))
(define (force promise)
(if (promise-done? promise)
(promise-value promise)
(let ([promise* ((promise-value promise))])
(unless (promise-done? promise)
(promise-update! promise* promise))
(force promise))))
(define (make-promise obj)
(if (promise? obj)
obj
(delay obj)))
) ; scheme lazy
|#
(library (scheme load)
(export (rename (ex:load load)))
(import (primitives ex:load)))
(library (scheme process-context)
(export command-line emergency-exit exit
get-environment-variable get-environment-variables)
(import
(primitives
command-line emergency-exit exit
get-environment-variable get-environment-variables)))
(library (scheme read)
(export read)
(import (core primitives)
(thcheme ports)
(thcheme with-default-port)
(prefix (primitives read) thcheme:))
(define read (with-default-port0 current-input-port thcheme:read))
) ; scheme read
(library (scheme repl)
(export (rename (ex:interaction-environment interaction-environment)))
(import (primitives ex:interaction-environment)))
(library (scheme time)
(export current-jiffy current-second jiffies-per-second)
(import (primitives current-jiffy current-second jiffies-per-second)))
(library (scheme write)
(export display write write-shared write-simple)
(import (core primitives)
(thcheme ports)
(thcheme with-default-port)
(prefix (primitives display write write-shared write-simple)
thcheme:))
(define write (with-default-port1 current-output-port thcheme:write))
(define write-simple
(with-default-port1 current-output-port thcheme:write-simple))
(define write-shared
(with-default-port1 current-output-port thcheme:write-shared))
(define display
(with-default-port1 current-output-port thcheme:display))
) ; scheme write
(library (rnrs syntax-case (6))
(export make-variable-transformer
identifier? bound-identifier=? free-identifier=?
generate-temporaries datum->syntax syntax->datum
syntax-violation syntax syntax-case quasisyntax
unsyntax unsyntax-splicing with-syntax
_ ...)
(import (core primitives)
(core with-syntax)
(core quasisyntax))
) ;; rnrs syntax-case
;; Nonstandard explicit renaming library:
;; See also examples and discussion in file examples.scm.
;;
;; Exports:
;;
;; er-transformer (syntax)
;; bound-identifier=? (procedure)
;; datum->syntax (procedure)
;;
;; Differences with traditional explicit renaming:
;;
;; - The renaming procedure has signature <symbol> -> <identifier>,
;; where the <identifier> type is disjoint from the <symbol> type.
;;
;; - The renaming procedure acts as a mathematical function in the sense that
;; the identifiers obtained from any two calls with the same argument will
;; be the same in the sense of bound-identifier=?, not eqv?
;;
;; - The output may not contain raw symbols, so implicit identifiers must
;; be introduced using datum->syntax.
;;
;; - Breaking hygiene with datum->syntax allows more modular macro
;; programming than traditional explicit renaming.
;; See in particular the example of while in terms of loop below.
;;
;; - The renaming procedure is aware of the transformer environment,
;; so that identifiers not bound at the usage site will resolve to
;; the r6rs library-local bindings at the transformer site.
;; More precisely, they will be resolved in the lexical environment
;; of the er-transformer keyword.
;;
;; - Fully compatible with my r6rs syntax-case macro system.
;;
;; Portability and complexity note:
;;
;; This library is not r6rs-portable, since it assumes that the input
;; to a transformer is always an unwrapped syntax object, which is
;; allowed but not required by r6rs, and is currently only true for my
;; implementation. The library could be ported to other implementations
;; by inserting a step that unwrapped the input to the transformer.
;; However, that would adversely modify the complexity class of
;; er-transformer macros in those implementations.
(library (explicit-renaming helper)
(export er-transformer)
(import (for (only (core primitives)
define-syntax lambda syntax-case syntax datum->syntax free-identifier=?)
expand run))
(define-syntax er-transformer
(lambda (exp)
(syntax-case exp ()
((k proc)
(syntax
(lambda (form)
(proc form
(lambda (symbol) (datum->syntax (syntax k) symbol))
free-identifier=?))))))))
(library (explicit-renaming)
(export er-transformer identifier? bound-identifier=? datum->syntax)
(import (explicit-renaming helper)
(rnrs syntax-case)))
| true |
a25ae96d44a38a104f0d1af6de53eba567b26c8a
|
bf1c9803ae38f9aad027fbe4569ccc6f85ba63ab
|
/chapter_4/4.2.Variations.on.a.Scheme.-.Lazy.Evaluation/ex_4.25.scm
|
f135269e47685225a0b62e372d1f0eeb423e6024
|
[] |
no_license
|
mehese/sicp
|
7fec8750d3b971dd2383c240798dbed339d0345a
|
611b09280ab2f09cceb2479be98ccc5403428c6c
|
refs/heads/master
| 2021-06-12T04:43:27.049197 | 2021-04-04T22:22:47 | 2021-04-04T22:23:12 | 161,924,666 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 542 |
scm
|
ex_4.25.scm
|
#lang sicp
(define (unless condition
usual-value
exceptional-value)
(if condition
exceptional-value
usual-value))
(define (factorial n)
(unless (= n 1)
(* n (factorial (- n 1)))
1))
; (factorial 5)→ ∞ loop. As all the arguments of unless need to be computed before running it
; (unlike using cond or if) using unless will never get us out of a recursive loop the way
; if and cond did.
; In an normal-order language this should work as well as an if statement
| false |
fc33c4db32b0f9530d412f43dc53f031396616fd
|
be3e2276496ef3fba68fbd6e6250b64e6ba997c1
|
/etc/guile-wm/init.scm
|
3f5a7783e5e8622b3e2d7bbcaa5aea42528a9680
|
[] |
no_license
|
TaylanUB/misc
|
70e2e54c9bf4c2a810572230605a49e1bc03cb21
|
a9b191a7d0d56b08d4c0f5404243c1ef0ffc4111
|
refs/heads/master
| 2021-01-19T07:02:07.307611 | 2018-07-15T20:59:01 | 2018-07-15T20:59:01 | 2,027,313 | 2 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 180 |
scm
|
init.scm
|
(use-modules (guile-wm keymap))
(use-wm-modules
fullscreen message minibuffer time window-cycle)
(define-keymap top
((s-a) (window-cycle))
((s-o) (window-cycle))
((s-n) )
)
| false |
cb7ad9d2078ac21e08869d0c608cd0b04989ad17
|
f5f5bf46a162365eb5f5955d185cfa9380376fa8
|
/srfi/:204.chezscheme.sls
|
e20cae550f66ffefdf231ec3e36acfbd0bcb6b5f
|
[] |
no_license
|
fthibault1969/srfi-204
|
60ebad1fc5de79a25cde5827b766cca8123ad4ae
|
add561acc23002165ac864bd7fa443dae9d4b01a
|
refs/heads/master
| 2023-08-17T11:06:13.522151 | 2021-10-10T18:36:21 | 2021-10-10T18:36:21 | 280,735,657 | 0 | 0 | null | 2021-07-13T03:39:32 | 2020-07-18T20:38:52 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,553 |
sls
|
:204.chezscheme.sls
|
;; Copyright (C) Felix Thibault (2020). All Rights Reserved.
;; Permission is hereby granted, free of charge, to any person
;; obtaining a copy of this software and associated documentation
;; files (the "Software"), to deal in the Software without
;; restriction, including without limitation the rights to use, copy,
;; modify, merge, publish, distribute, sublicense, and/or sell copies
;; of the Software, and to permit persons to whom the Software is
;; furnished to do so, subject to the following conditions:
;; The above copyright notice and this permission notice (including
;; the next paragraph) shall be included in all copies or substantial
;; portions of the Software.
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;; SOFTWARE.
(library
(srfi :204)
(export
;;(chibi match) exports
match match-lambda match-lambda* match-let
match-letrec match-let*
;;auxilary syntax exports
___ **1 =.. *.. *** ?
$ struct object get!
)
(import (chezscheme)
(srfi :0)
(srfi private include))
(begin
(include/resolve ("srfi" "204") "auxiliary-syntax.scm")
(define-auxiliary-keywords ___ **1 =.. *.. *** ? $ struct object get!)
(define-syntax is-a?
(syntax-rules ()
((_ rec rtd)
((record-predicate (record-type-descriptor rtd)) rec))))
(define-syntax slot-ref
(syntax-rules ()
((_ rtd rec n)
(let ((rtd (record-type-descriptor rtd)))
(if (integer? n)
((record-accessor rtd n) rec)
((record-accessor rtd (name->idx rtd n)) rec))))))
(define-syntax slot-set!
(syntax-rules ()
((_ rtd rec n value)
(let ((rtd (record-type-descriptor rtd)))
(if (integer? n)
((record-mutator rtd n) rec value)
((record-mutator rtd (name->idx rtd n)) rec value))))))
(define-syntax name->idx
(syntax-rules ()
((_ rtd n)
(let* ((names (record-type-field-names rtd))
(len (vector-length names)))
(let lp ((i 0))
(cond
((> i len) (error "name not in record" n))
((eq? n (vector-ref names i)) i)
(else (lp (+ i 1 )))))))))
(include/resolve ("srfi" "204") "204.scm")))
| true |
a83be1c9d7367fd81b0d5e5afb35c7d94bdbd9e6
|
6c6cf6e4b77640825c2457e54052a56d5de6f4d2
|
/ch2/2_67-test.scm
|
bba72f9e73b70e0b6340e63174862765938619ed
|
[] |
no_license
|
leonacwa/sicp
|
a469c7bc96e0c47e4658dccd7c5309350090a746
|
d880b482d8027b7111678eff8d1c848e156d5374
|
refs/heads/master
| 2018-12-28T07:20:30.118868 | 2015-02-07T16:40:10 | 2015-02-07T16:40:10 | 11,738,761 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 150 |
scm
|
2_67-test.scm
|
;ex 2.67 test
(load "s2_3_3-tree.scm")
(load "s2_3_4-huffman.scm")
(load "2_67-sample.scm")
(display (decode sample-message sample-tree))
(newline)
| false |
3ab8ee031b8716990e850327535e1daeadeae1c6
|
43612e5ed60c14068da312fd9d7081c1b2b7220d
|
/tools/benchtimes/bench-sav/compiler.scm
|
835aa4580e96ba92784185407f29d6b043a21456
|
[
"BSD-3-Clause"
] |
permissive
|
bsaleil/lc
|
b1794065183b8f5fca018d3ece2dffabda6dd9a8
|
ee7867fd2bdbbe88924300e10b14ea717ee6434b
|
refs/heads/master
| 2021-03-19T09:44:18.905063 | 2019-05-11T01:36:38 | 2019-05-11T01:36:38 | 41,703,251 | 27 | 1 |
BSD-3-Clause
| 2018-08-29T19:13:33 | 2015-08-31T22:13:05 |
Scheme
|
UTF-8
|
Scheme
| false | false | 463,482 |
scm
|
compiler.scm
|
;(define integer->char ascii->char)
;(define char->integer char->ascii)
(define open-input-file* open-input-file)
(define (pp-expression expr port) (write expr port) (newline port))
(define (write-returning-len obj port) (write obj port) 1)
(define (display-returning-len obj port) (display obj port) 1)
(define (write-word w port)
(write-char (integer->char (quotient w 256)) port)
(write-char (integer->char (modulo w 256)) port))
(define char-nul (integer->char 0))
(define char-tab (integer->char 9))
(define char-newline (integer->char 10))
(define character-encoding char->integer)
(define max-character-encoding 255)
(define (fatal-err msg arg) (fatal-error msg arg))
(define (scheme-global-var name) name)
(define (scheme-global-var-ref var) (scheme-global-eval var fatal-err))
(define (scheme-global-var-set! var val)
(scheme-global-eval (list 'set! var (list 'quote val)) fatal-err))
(define (scheme-global-eval expr err) `(eval ,expr)) ;; eval not needed for test
(define (pinpoint-error filename line char) #t)
(define file-path-sep #\:)
(define file-ext-sep #\.)
(define (path-absolute? x)
(and (> (string-length x) 0)
(let ((c (string-ref x 0))) (or (char=? c #\/) (char=? c #\~)))))
(define (file-path x)
(let loop1 ((i (string-length x)))
(if (and (> i 0) (not (char=? (string-ref x (- i 1)) file-path-sep)))
(loop1 (- i 1))
(let ((result (make-string i)))
(let loop2 ((j (- i 1)))
(if (< j 0)
result
(begin
(string-set! result j (string-ref x j))
(loop2 (- j 1)))))))))
(define (file-name x)
(let loop1 ((i (string-length x)))
(if (and (> i 0) (not (char=? (string-ref x (- i 1)) file-path-sep)))
(loop1 (- i 1))
(let ((result (make-string (- (string-length x) i))))
(let loop2 ((j (- (string-length x) 1)))
(if (< j i)
result
(begin
(string-set! result (- j i) (string-ref x j))
(loop2 (- j 1)))))))))
(define (file-ext x)
(let loop1 ((i (string-length x)))
(if (or (= i 0) (char=? (string-ref x (- i 1)) file-path-sep))
#f
(if (not (char=? (string-ref x (- i 1)) file-ext-sep))
(loop1 (- i 1))
(let ((result (make-string (- (string-length x) i))))
(let loop2 ((j (- (string-length x) 1)))
(if (< j i)
result
(begin
(string-set! result (- j i) (string-ref x j))
(loop2 (- j 1))))))))))
(define (file-root x)
(let loop1 ((i (string-length x)))
(if (or (= i 0) (char=? (string-ref x (- i 1)) file-path-sep))
x
(if (not (char=? (string-ref x (- i 1)) file-ext-sep))
(loop1 (- i 1))
(let ((result (make-string (- i 1))))
(let loop2 ((j (- i 2)))
(if (< j 0)
result
(begin
(string-set! result j (string-ref x j))
(loop2 (- j 1))))))))))
(define (make-counter next limit limit-error)
(lambda ()
(if (< next limit)
(let ((result next)) (set! next (+ next 1)) result)
(limit-error))))
(define (pos-in-list x l)
(let loop ((l l) (i 0))
(cond ((not (pair? l)) #f)
((eq? (car l) x) i)
(else (loop (cdr l) (+ i 1))))))
(define (string-pos-in-list x l)
(let loop ((l l) (i 0))
(cond ((not (pair? l)) #f)
((string=? (car l) x) i)
(else (loop (cdr l) (+ i 1))))))
(define (nth-after l n)
(let loop ((l l) (n n)) (if (> n 0) (loop (cdr l) (- n 1)) l)))
(define (pair-up l1 l2)
(define (pair l1 l2)
(if (pair? l1)
(cons (cons (car l1) (car l2)) (pair (cdr l1) (cdr l2)))
'()))
(pair l1 l2))
(define (my-last-pair l)
(let loop ((l l)) (if (pair? (cdr l)) (loop (cdr l)) l)))
(define (sort-list l <?)
(define (mergesort l)
(define (merge l1 l2)
(cond ((null? l1) l2)
((null? l2) l1)
(else
(let ((e1 (car l1)) (e2 (car l2)))
(if (<? e1 e2)
(cons e1 (merge (cdr l1) l2))
(cons e2 (merge l1 (cdr l2))))))))
(define (split l)
(if (or (null? l) (null? (cdr l))) l (cons (car l) (split (cddr l)))))
(if (or (null? l) (null? (cdr l)))
l
(let* ((l1 (mergesort (split l))) (l2 (mergesort (split (cdr l)))))
(merge l1 l2))))
(mergesort l))
(define (lst->vector l)
(let* ((n (length l)) (v (make-vector n)))
(let loop ((l l) (i 0))
(if (pair? l)
(begin (vector-set! v i (car l)) (loop (cdr l) (+ i 1)))
v))))
(define (vector->lst v)
(let loop ((l '()) (i (- (vector-length v) 1)))
(if (< i 0) l (loop (cons (vector-ref v i) l) (- i 1)))))
(define (lst->string l)
(let* ((n (length l)) (s (make-string n)))
(let loop ((l l) (i 0))
(if (pair? l)
(begin (string-set! s i (car l)) (loop (cdr l) (+ i 1)))
s))))
(define (string->lst s)
(let loop ((l '()) (i (- (string-length s) 1)))
(if (< i 0) l (loop (cons (string-ref s i) l) (- i 1)))))
(define (with-exception-handling proc)
(let ((old-exception-handler throw-to-exception-handler))
(let ((val (call-with-current-continuation
(lambda (cont)
(set! throw-to-exception-handler cont)
(proc)))))
(set! throw-to-exception-handler old-exception-handler)
val)))
(define (throw-to-exception-handler val)
(fatal-err "Internal error, no exception handler at this point" val))
(define (compiler-error msg . args)
(newline)
(display "*** ERROR -- ")
(display msg)
(for-each (lambda (x) (display " ") (write x)) args)
(newline)
(compiler-abort))
(define (compiler-user-error loc msg . args)
(newline)
(display "*** ERROR -- In ")
(locat-show loc)
(newline)
(display "*** ")
(display msg)
(for-each (lambda (x) (display " ") (write x)) args)
(newline)
(compiler-abort))
(define (compiler-internal-error msg . args)
(newline)
(display "*** ERROR -- Compiler internal error detected")
(newline)
(display "*** in procedure ")
(display msg)
(for-each (lambda (x) (display " ") (write x)) args)
(newline)
(compiler-abort))
(define (compiler-limitation-error msg . args)
(newline)
(display "*** ERROR -- Compiler limit reached")
(newline)
(display "*** ")
(display msg)
(for-each (lambda (x) (display " ") (write x)) args)
(newline)
(compiler-abort))
(define (compiler-abort) (throw-to-exception-handler #f))
(define (make-gnode label edges) (vector label edges))
(define (gnode-label x) (vector-ref x 0))
(define (gnode-edges x) (vector-ref x 1))
(define (transitive-closure graph)
(define changed? #f)
(define (closure edges)
(list->set
(set-union
edges
(apply set-union
(map (lambda (label) (gnode-edges (gnode-find label graph)))
(set->list edges))))))
(let ((new-graph
(set-map (lambda (x)
(let ((new-edges (closure (gnode-edges x))))
(if (not (set-equal? new-edges (gnode-edges x)))
(set! changed? #t))
(make-gnode (gnode-label x) new-edges)))
graph)))
(if changed? (transitive-closure new-graph) new-graph)))
(define (gnode-find label graph)
(define (find label l)
(cond ((null? l) #f)
((eq? (gnode-label (car l)) label) (car l))
(else (find label (cdr l)))))
(find label (set->list graph)))
(define (topological-sort graph)
(if (set-empty? graph)
'()
(let ((to-remove (or (remove-no-edges graph) (remove-cycle graph))))
(let ((labels (set-map gnode-label to-remove)))
(cons labels
(topological-sort
(set-map (lambda (x)
(make-gnode
(gnode-label x)
(set-difference (gnode-edges x) labels)))
(set-difference graph to-remove))))))))
(define (remove-no-edges graph)
(let ((nodes-with-no-edges
(set-keep (lambda (x) (set-empty? (gnode-edges x))) graph)))
(if (set-empty? nodes-with-no-edges) #f nodes-with-no-edges)))
(define (remove-cycle graph)
(define (remove l)
(let ((edges (gnode-edges (car l))))
(define (equal-edges? x) (set-equal? (gnode-edges x) edges))
(define (member-edges? x) (set-member? (gnode-label x) edges))
(if (set-member? (gnode-label (car l)) edges)
(let ((edge-graph (set-keep member-edges? graph)))
(if (set-every? equal-edges? edge-graph)
edge-graph
(remove (cdr l))))
(remove (cdr l)))))
(remove (set->list graph)))
(define (list->set list) list)
(define (set->list set) set)
(define (set-empty) '())
(define (set-empty? set) (null? set))
(define (set-member? x set) (memq x set))
(define (set-singleton x) (list x))
(define (set-adjoin set x) (if (memq x set) set (cons x set)))
(define (set-remove set x)
(cond ((null? set) '())
((eq? (car set) x) (cdr set))
(else (cons (car set) (set-remove (cdr set) x)))))
(define (set-equal? s1 s2)
(cond ((null? s1) (null? s2))
((memq (car s1) s2) (set-equal? (cdr s1) (set-remove s2 (car s1))))
(else #f)))
(define (set-difference set . other-sets)
(define (difference s1 s2)
(cond ((null? s1) '())
((memq (car s1) s2) (difference (cdr s1) s2))
(else (cons (car s1) (difference (cdr s1) s2)))))
(n-ary difference set other-sets))
(define (set-union . sets)
(define (union s1 s2)
(cond ((null? s1) s2)
((memq (car s1) s2) (union (cdr s1) s2))
(else (cons (car s1) (union (cdr s1) s2)))))
(n-ary union '() sets))
(define (set-intersection set . other-sets)
(define (intersection s1 s2)
(cond ((null? s1) '())
((memq (car s1) s2) (cons (car s1) (intersection (cdr s1) s2)))
(else (intersection (cdr s1) s2))))
(n-ary intersection set other-sets))
(define (n-ary function first rest)
(if (null? rest)
first
(n-ary function (function first (car rest)) (cdr rest))))
(define (set-keep keep? set)
(cond ((null? set) '())
((keep? (car set)) (cons (car set) (set-keep keep? (cdr set))))
(else (set-keep keep? (cdr set)))))
(define (set-every? pred? set)
(or (null? set) (and (pred? (car set)) (set-every? pred? (cdr set)))))
(define (set-map proc set)
(if (null? set) '() (cons (proc (car set)) (set-map proc (cdr set)))))
(define (list->queue list)
(cons list (if (pair? list) (my-last-pair list) '())))
(define (queue->list queue) (car queue))
(define (queue-empty) (cons '() '()))
(define (queue-empty? queue) (null? (car queue)))
(define (queue-get! queue)
(if (null? (car queue))
(compiler-internal-error "queue-get!, queue is empty")
(let ((x (caar queue)))
(set-car! queue (cdar queue))
(if (null? (car queue)) (set-cdr! queue '()))
x)))
(define (queue-put! queue x)
(let ((entry (cons x '())))
(if (null? (car queue))
(set-car! queue entry)
(set-cdr! (cdr queue) entry))
(set-cdr! queue entry)
x))
(define (string->canonical-symbol str)
(let ((len (string-length str)))
(let loop ((str str) (s (make-string len)) (i (- len 1)))
(if (>= i 0)
(begin
(string-set! s i (char-downcase (string-ref str i)))
(loop str s (- i 1)))
(string->symbol s)))))
(define quote-sym (string->canonical-symbol "QUOTE"))
(define quasiquote-sym (string->canonical-symbol "QUASIQUOTE"))
(define unquote-sym (string->canonical-symbol "UNQUOTE"))
(define unquote-splicing-sym (string->canonical-symbol "UNQUOTE-SPLICING"))
(define lambda-sym (string->canonical-symbol "LAMBDA"))
(define if-sym (string->canonical-symbol "IF"))
(define set!-sym (string->canonical-symbol "SET!"))
(define cond-sym (string->canonical-symbol "COND"))
(define =>-sym (string->canonical-symbol "=>"))
(define else-sym (string->canonical-symbol "ELSE"))
(define and-sym (string->canonical-symbol "AND"))
(define or-sym (string->canonical-symbol "OR"))
(define case-sym (string->canonical-symbol "CASE"))
(define let-sym (string->canonical-symbol "LET"))
(define let*-sym (string->canonical-symbol "LET*"))
(define letrec-sym (string->canonical-symbol "LETREC"))
(define begin-sym (string->canonical-symbol "BEGIN"))
(define do-sym (string->canonical-symbol "DO"))
(define define-sym (string->canonical-symbol "DEFINE"))
(define delay-sym (string->canonical-symbol "DELAY"))
(define future-sym (string->canonical-symbol "FUTURE"))
(define **define-macro-sym (string->canonical-symbol "DEFINE-MACRO"))
(define **declare-sym (string->canonical-symbol "DECLARE"))
(define **include-sym (string->canonical-symbol "INCLUDE"))
(define not-sym (string->canonical-symbol "NOT"))
(define **c-declaration-sym (string->canonical-symbol "C-DECLARATION"))
(define **c-init-sym (string->canonical-symbol "C-INIT"))
(define **c-procedure-sym (string->canonical-symbol "C-PROCEDURE"))
(define void-sym (string->canonical-symbol "VOID"))
(define char-sym (string->canonical-symbol "CHAR"))
(define signed-char-sym (string->canonical-symbol "SIGNED-CHAR"))
(define unsigned-char-sym (string->canonical-symbol "UNSIGNED-CHAR"))
(define short-sym (string->canonical-symbol "SHORT"))
(define unsigned-short-sym (string->canonical-symbol "UNSIGNED-SHORT"))
(define int-sym (string->canonical-symbol "INT"))
(define unsigned-int-sym (string->canonical-symbol "UNSIGNED-INT"))
(define long-sym (string->canonical-symbol "LONG"))
(define unsigned-long-sym (string->canonical-symbol "UNSIGNED-LONG"))
(define float-sym (string->canonical-symbol "FLOAT"))
(define double-sym (string->canonical-symbol "DOUBLE"))
(define pointer-sym (string->canonical-symbol "POINTER"))
(define boolean-sym (string->canonical-symbol "BOOLEAN"))
(define string-sym (string->canonical-symbol "STRING"))
(define scheme-object-sym (string->canonical-symbol "SCHEME-OBJECT"))
(define c-id-prefix "___")
(define false-object (if (eq? '() #f) (string->symbol "#f") #f))
(define (false-object? obj) (eq? obj false-object))
(define undef-object (string->symbol "#[undefined]"))
(define (undef-object? obj) (eq? obj undef-object))
(define (symbol-object? obj)
(and (not (false-object? obj)) (not (undef-object? obj)) (symbol? obj)))
(define scm-file-exts '("scm" #f))
(define compiler-version "2.2.2")
(define (open-sf filename)
(define (open-err) (compiler-error "Can't find file" filename))
(if (not (file-ext filename))
(let loop ((exts scm-file-exts))
(if (pair? exts)
(let* ((ext (car exts))
(full-name
(if ext (string-append filename "." ext) filename))
(port (open-input-file* full-name)))
(if port (vector port full-name 0 1 0) (loop (cdr exts))))
(open-err)))
(let ((port (open-input-file* filename)))
(if port (vector port filename 0 1 0) (open-err)))))
(define (close-sf sf) (close-input-port (vector-ref sf 0)))
(define (sf-read-char sf)
(let ((c (read-char (vector-ref sf 0))))
(cond ((eof-object? c))
((char=? c char-newline)
(vector-set! sf 3 (+ (vector-ref sf 3) 1))
(vector-set! sf 4 0))
(else (vector-set! sf 4 (+ (vector-ref sf 4) 1))))
c))
(define (sf-peek-char sf) (peek-char (vector-ref sf 0)))
(define (sf-read-error sf msg . args)
(apply compiler-user-error
(cons (sf->locat sf)
(cons (string-append "Read error -- " msg) args))))
(define (sf->locat sf)
(vector 'file
(vector-ref sf 1)
(vector-ref sf 2)
(vector-ref sf 3)
(vector-ref sf 4)))
(define (expr->locat expr source) (vector 'expr expr source))
(define (locat-show loc)
(if loc
(case (vector-ref loc 0)
((file)
(if (pinpoint-error
(vector-ref loc 1)
(vector-ref loc 3)
(vector-ref loc 4))
(begin
(display "file \"")
(display (vector-ref loc 1))
(display "\", line ")
(display (vector-ref loc 3))
(display ", character ")
(display (vector-ref loc 4)))))
((expr)
(display "expression ")
(write (vector-ref loc 1))
(if (vector-ref loc 2)
(begin
(display " ")
(locat-show (source-locat (vector-ref loc 2))))))
(else (compiler-internal-error "locat-show, unknown location tag")))
(display "unknown location")))
(define (locat-filename loc)
(if loc
(case (vector-ref loc 0)
((file) (vector-ref loc 1))
((expr)
(let ((source (vector-ref loc 2)))
(if source (locat-filename (source-locat source)) "")))
(else
(compiler-internal-error "locat-filename, unknown location tag")))
""))
(define (make-source code locat) (vector code locat))
(define (source-code x) (vector-ref x 0))
(define (source-code-set! x y) (vector-set! x 0 y) x)
(define (source-locat x) (vector-ref x 1))
(define (expression->source expr source)
(define (expr->source x)
(make-source
(cond ((pair? x) (list->source x))
((vector? x) (vector->source x))
((symbol-object? x) (string->canonical-symbol (symbol->string x)))
(else x))
(expr->locat x source)))
(define (list->source l)
(cond ((pair? l) (cons (expr->source (car l)) (list->source (cdr l))))
((null? l) '())
(else (expr->source l))))
(define (vector->source v)
(let* ((len (vector-length v)) (x (make-vector len)))
(let loop ((i (- len 1)))
(if (>= i 0)
(begin
(vector-set! x i (expr->source (vector-ref v i)))
(loop (- i 1)))))
x))
(expr->source expr))
(define (source->expression source)
(define (list->expression l)
(cond ((pair? l)
(cons (source->expression (car l)) (list->expression (cdr l))))
((null? l) '())
(else (source->expression l))))
(define (vector->expression v)
(let* ((len (vector-length v)) (x (make-vector len)))
(let loop ((i (- len 1)))
(if (>= i 0)
(begin
(vector-set! x i (source->expression (vector-ref v i)))
(loop (- i 1)))))
x))
(let ((code (source-code source)))
(cond ((pair? code) (list->expression code))
((vector? code) (vector->expression code))
(else code))))
(define (file->sources filename info-port)
(if info-port
(begin
(display "(reading \"" info-port)
(display filename info-port)
(display "\"" info-port)))
(let ((sf (open-sf filename)))
(define (read-sources)
(let ((source (read-source sf)))
(if (not (eof-object? source))
(begin
(if info-port (display "." info-port))
(cons source (read-sources)))
'())))
(let ((sources (read-sources)))
(if info-port (display ")" info-port))
(close-sf sf)
sources)))
(define (file->sources* filename info-port loc)
(file->sources
(if (path-absolute? filename)
filename
(string-append (file-path (locat-filename loc)) filename))
info-port))
(define (read-source sf)
(define (read-char*)
(let ((c (sf-read-char sf)))
(if (eof-object? c)
(sf-read-error sf "Premature end of file encountered")
c)))
(define (read-non-whitespace-char)
(let ((c (read-char*)))
(cond ((< 0 (vector-ref read-table (char->integer c)))
(read-non-whitespace-char))
((char=? c #\;)
(let loop ()
(if (not (char=? (read-char*) char-newline))
(loop)
(read-non-whitespace-char))))
(else c))))
(define (delimiter? c)
(or (eof-object? c) (not (= (vector-ref read-table (char->integer c)) 0))))
(define (read-list first)
(let ((result (cons first '())))
(let loop ((end result))
(let ((c (read-non-whitespace-char)))
(cond ((char=? c #\)))
((and (char=? c #\.) (delimiter? (sf-peek-char sf)))
(let ((x (read-source sf)))
(if (char=? (read-non-whitespace-char) #\))
(set-cdr! end x)
(sf-read-error sf "')' expected"))))
(else
(let ((tail (cons (rd* c) '())))
(set-cdr! end tail)
(loop tail))))))
result))
(define (read-vector)
(define (loop i)
(let ((c (read-non-whitespace-char)))
(if (char=? c #\))
(make-vector i '())
(let* ((x (rd* c)) (v (loop (+ i 1)))) (vector-set! v i x) v))))
(loop 0))
(define (read-string)
(define (loop i)
(let ((c (read-char*)))
(cond ((char=? c #\") (make-string i #\space))
((char=? c #\\)
(let* ((c (read-char*)) (s (loop (+ i 1))))
(string-set! s i c)
s))
(else (let ((s (loop (+ i 1)))) (string-set! s i c) s)))))
(loop 0))
(define (read-symbol/number-string i)
(if (delimiter? (sf-peek-char sf))
(make-string i #\space)
(let* ((c (sf-read-char sf)) (s (read-symbol/number-string (+ i 1))))
(string-set! s i (char-downcase c))
s)))
(define (read-symbol/number c)
(let ((s (read-symbol/number-string 1)))
(string-set! s 0 (char-downcase c))
(or (string->number s 10) (string->canonical-symbol s))))
(define (read-prefixed-number c)
(let ((s (read-symbol/number-string 2)))
(string-set! s 0 #\#)
(string-set! s 1 c)
(string->number s 10)))
(define (read-special-symbol)
(let ((s (read-symbol/number-string 2)))
(string-set! s 0 #\#)
(string-set! s 1 #\#)
(string->canonical-symbol s)))
(define (rd c)
(cond ((eof-object? c) c)
((< 0 (vector-ref read-table (char->integer c)))
(rd (sf-read-char sf)))
((char=? c #\;)
(let loop ()
(let ((c (sf-read-char sf)))
(cond ((eof-object? c) c)
((char=? c char-newline) (rd (sf-read-char sf)))
(else (loop))))))
(else (rd* c))))
(define (rd* c)
(let ((source (make-source #f (sf->locat sf))))
(source-code-set!
source
(cond ((char=? c #\()
(let ((x (read-non-whitespace-char)))
(if (char=? x #\)) '() (read-list (rd* x)))))
((char=? c #\#)
(let ((c (char-downcase (sf-read-char sf))))
(cond ((char=? c #\() (read-vector))
((char=? c #\f) false-object)
((char=? c #\t) #t)
((char=? c #\\)
(let ((c (read-char*)))
(if (or (not (char-alphabetic? c))
(delimiter? (sf-peek-char sf)))
c
(let ((name (read-symbol/number c)))
(let ((x (assq name named-char-table)))
(if x
(cdr x)
(sf-read-error
sf
"Unknown character name"
name)))))))
((char=? c #\#) (read-special-symbol))
(else
(let ((num (read-prefixed-number c)))
(or num
(sf-read-error
sf
"Unknown '#' read macro"
c)))))))
((char=? c #\") (read-string))
((char=? c #\')
(list (make-source quote-sym (sf->locat sf)) (read-source sf)))
((char=? c #\`)
(list (make-source quasiquote-sym (sf->locat sf))
(read-source sf)))
((char=? c #\,)
(if (char=? (sf-peek-char sf) #\@)
(let ((x (make-source unquote-splicing-sym (sf->locat sf))))
(sf-read-char sf)
(list x (read-source sf)))
(list (make-source unquote-sym (sf->locat sf))
(read-source sf))))
((char=? c #\)) (sf-read-error sf "Misplaced ')'"))
((or (char=? c #\[) (char=? c #\]) (char=? c #\{) (char=? c #\}))
(sf-read-error sf "Illegal character" c))
(else
(if (char=? c #\.)
(if (delimiter? (sf-peek-char sf))
(sf-read-error sf "Misplaced '.'")))
(read-symbol/number c))))))
(rd (sf-read-char sf)))
(define named-char-table
(list (cons (string->canonical-symbol "NUL") char-nul)
(cons (string->canonical-symbol "TAB") char-tab)
(cons (string->canonical-symbol "NEWLINE") char-newline)
(cons (string->canonical-symbol "SPACE") #\space)))
(define read-table
(let ((rt (make-vector (+ max-character-encoding 1) 0)))
(vector-set! rt (char->integer char-tab) 1)
(vector-set! rt (char->integer char-newline) 1)
(vector-set! rt (char->integer #\space) 1)
(vector-set! rt (char->integer #\;) -1)
(vector-set! rt (char->integer #\() -1)
(vector-set! rt (char->integer #\)) -1)
(vector-set! rt (char->integer #\") -1)
(vector-set! rt (char->integer #\') -1)
(vector-set! rt (char->integer #\`) -1)
rt))
(define (make-var name bound refs sets source)
(vector var-tag name bound refs sets source #f))
(define (var? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) var-tag)))
(define (var-name x) (vector-ref x 1))
(define (var-bound x) (vector-ref x 2))
(define (var-refs x) (vector-ref x 3))
(define (var-sets x) (vector-ref x 4))
(define (var-source x) (vector-ref x 5))
(define (var-info x) (vector-ref x 6))
(define (var-name-set! x y) (vector-set! x 1 y))
(define (var-bound-set! x y) (vector-set! x 2 y))
(define (var-refs-set! x y) (vector-set! x 3 y))
(define (var-sets-set! x y) (vector-set! x 4 y))
(define (var-source-set! x y) (vector-set! x 5 y))
(define (var-info-set! x y) (vector-set! x 6 y))
(define var-tag (list 'var-tag))
(define (var-copy var)
(make-var (var-name var) #t (set-empty) (set-empty) (var-source var)))
(define (make-temp-var name) (make-var name #t (set-empty) (set-empty) #f))
(define (temp-var? var) (eq? (var-bound var) #t))
(define ret-var (make-temp-var 'ret))
(define ret-var-set (set-singleton ret-var))
(define closure-env-var (make-temp-var 'closure-env))
(define empty-var (make-temp-var #f))
(define make-global-environment #f)
(set! make-global-environment (lambda () (env-frame #f '())))
(define (env-frame env vars) (vector (cons vars #f) '() '() env))
(define (env-new-var! env name source)
(let* ((glob (not (env-parent-ref env)))
(var (make-var name (not glob) (set-empty) (set-empty) source)))
(env-vars-set! env (cons var (env-vars-ref env)))
var))
(define (env-macro env name def)
(let ((name* (if (full-name? name)
name
(let ((prefix (env-namespace-prefix env name)))
(if prefix (make-full-name prefix name) name)))))
(vector (vector-ref env 0)
(cons (cons name* def) (env-macros-ref env))
(env-decls-ref env)
(env-parent-ref env))))
(define (env-declare env decl)
(vector (vector-ref env 0)
(env-macros-ref env)
(cons decl (env-decls-ref env))
(env-parent-ref env)))
(define (env-vars-ref env) (car (vector-ref env 0)))
(define (env-vars-set! env vars) (set-car! (vector-ref env 0) vars))
(define (env-macros-ref env) (vector-ref env 1))
(define (env-decls-ref env) (vector-ref env 2))
(define (env-parent-ref env) (vector-ref env 3))
(define (env-namespace-prefix env name)
(let loop ((decls (env-decls-ref env)))
(if (pair? decls)
(let ((decl (car decls)))
(if (eq? (car decl) namespace-sym)
(let ((syms (cddr decl)))
(if (or (null? syms) (memq name syms))
(cadr decl)
(loop (cdr decls))))
(loop (cdr decls))))
#f)))
(define (env-lookup env name stop-at-first-frame? proc)
(define (search env name full?)
(if full?
(search* env name full?)
(let ((prefix (env-namespace-prefix env name)))
(if prefix
(search* env (make-full-name prefix name) #t)
(search* env name full?)))))
(define (search* env name full?)
(define (search-macros macros)
(if (pair? macros)
(let ((m (car macros)))
(if (eq? (car m) name)
(proc env name (cdr m))
(search-macros (cdr macros))))
(search-vars (env-vars-ref env))))
(define (search-vars vars)
(if (pair? vars)
(let ((v (car vars)))
(if (eq? (var-name v) name)
(proc env name v)
(search-vars (cdr vars))))
(let ((env* (env-parent-ref env)))
(if (or stop-at-first-frame? (not env*))
(proc env name #f)
(search env* name full?)))))
(search-macros (env-macros-ref env)))
(search env name (full-name? name)))
(define (valid-prefix? str)
(let ((l (string-length str)))
(or (= l 0) (and (>= l 2) (char=? (string-ref str (- l 1)) #\#)))))
(define (full-name? sym)
(let ((str (symbol->string sym)))
(let loop ((i (- (string-length str) 1)))
(if (< i 0) #f (if (char=? (string-ref str i) #\#) #t (loop (- i 1)))))))
(define (make-full-name prefix sym)
(if (= (string-length prefix) 0)
sym
(string->canonical-symbol (string-append prefix (symbol->string sym)))))
(define (env-lookup-var env name source)
(env-lookup
env
name
#f
(lambda (env name x)
(if x
(if (var? x)
x
(compiler-internal-error
"env-lookup-var, name is that of a macro"
name))
(env-new-var! env name source)))))
(define (env-define-var env name source)
(env-lookup
env
name
#t
(lambda (env name x)
(if x
(if (var? x)
(pt-syntax-error source "Duplicate definition of a variable")
(compiler-internal-error
"env-define-var, name is that of a macro"
name))
(env-new-var! env name source)))))
(define (env-lookup-global-var env name)
(let ((env* (env-global-env env)))
(define (search-vars vars)
(if (pair? vars)
(let ((v (car vars)))
(if (eq? (var-name v) name) v (search-vars (cdr vars))))
(env-new-var! env* name #f)))
(search-vars (env-vars-ref env*))))
(define (env-global-variables env) (env-vars-ref (env-global-env env)))
(define (env-global-env env)
(let loop ((env env))
(let ((env* (env-parent-ref env))) (if env* (loop env*) env))))
(define (env-lookup-macro env name)
(env-lookup
env
name
#f
(lambda (env name x) (if (or (not x) (var? x)) #f x))))
(define (env-declarations env) env)
(define flag-declarations '())
(define parameterized-declarations '())
(define boolean-declarations '())
(define namable-declarations '())
(define namable-boolean-declarations '())
(define namable-string-declarations '())
(define (define-flag-decl name type)
(set! flag-declarations (cons (cons name type) flag-declarations))
'())
(define (define-parameterized-decl name)
(set! parameterized-declarations (cons name parameterized-declarations))
'())
(define (define-boolean-decl name)
(set! boolean-declarations (cons name boolean-declarations))
'())
(define (define-namable-decl name type)
(set! namable-declarations (cons (cons name type) namable-declarations))
'())
(define (define-namable-boolean-decl name)
(set! namable-boolean-declarations (cons name namable-boolean-declarations))
'())
(define (define-namable-string-decl name)
(set! namable-string-declarations (cons name namable-string-declarations))
'())
(define (flag-decl source type val) (list type val))
(define (parameterized-decl source id parm) (list id parm))
(define (boolean-decl source id pos) (list id pos))
(define (namable-decl source type val names) (cons type (cons val names)))
(define (namable-boolean-decl source id pos names) (cons id (cons pos names)))
(define (namable-string-decl source id str names)
(if (and (eq? id namespace-sym) (not (valid-prefix? str)))
(pt-syntax-error source "Illegal namespace"))
(cons id (cons str names)))
(define (declaration-value name element default decls)
(if (not decls)
default
(let loop ((l (env-decls-ref decls)))
(if (pair? l)
(let ((d (car l)))
(if (and (eq? (car d) name)
(or (null? (cddr d)) (memq element (cddr d))))
(cadr d)
(loop (cdr l))))
(declaration-value name element default (env-parent-ref decls))))))
(define namespace-sym (string->canonical-symbol "NAMESPACE"))
(define-namable-string-decl namespace-sym)
(define (node-parent x) (vector-ref x 1))
(define (node-children x) (vector-ref x 2))
(define (node-fv x) (vector-ref x 3))
(define (node-decl x) (vector-ref x 4))
(define (node-source x) (vector-ref x 5))
(define (node-parent-set! x y) (vector-set! x 1 y))
(define (node-fv-set! x y) (vector-set! x 3 y))
(define (node-decl-set! x y) (vector-set! x 4 y))
(define (node-source-set! x y) (vector-set! x 5 y))
(define (node-children-set! x y)
(vector-set! x 2 y)
(for-each (lambda (child) (node-parent-set! child x)) y)
(node-fv-invalidate! x))
(define (node-fv-invalidate! x)
(let loop ((node x))
(if node (begin (node-fv-set! node #t) (loop (node-parent node))))))
(define (make-cst parent children fv decl source val)
(vector cst-tag parent children fv decl source val))
(define (cst? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) cst-tag)))
(define (cst-val x) (vector-ref x 6))
(define (cst-val-set! x y) (vector-set! x 6 y))
(define cst-tag (list 'cst-tag))
(define (make-ref parent children fv decl source var)
(vector ref-tag parent children fv decl source var))
(define (ref? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) ref-tag)))
(define (ref-var x) (vector-ref x 6))
(define (ref-var-set! x y) (vector-set! x 6 y))
(define ref-tag (list 'ref-tag))
(define (make-set parent children fv decl source var)
(vector set-tag parent children fv decl source var))
(define (set? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) set-tag)))
(define (set-var x) (vector-ref x 6))
(define (set-var-set! x y) (vector-set! x 6 y))
(define set-tag (list 'set-tag))
(define (make-def parent children fv decl source var)
(vector def-tag parent children fv decl source var))
(define (def? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) def-tag)))
(define (def-var x) (vector-ref x 6))
(define (def-var-set! x y) (vector-set! x 6 y))
(define def-tag (list 'def-tag))
(define (make-tst parent children fv decl source)
(vector tst-tag parent children fv decl source))
(define (tst? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) tst-tag)))
(define tst-tag (list 'tst-tag))
(define (make-conj parent children fv decl source)
(vector conj-tag parent children fv decl source))
(define (conj? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) conj-tag)))
(define conj-tag (list 'conj-tag))
(define (make-disj parent children fv decl source)
(vector disj-tag parent children fv decl source))
(define (disj? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) disj-tag)))
(define disj-tag (list 'disj-tag))
(define (make-prc parent children fv decl source name min rest parms)
(vector prc-tag parent children fv decl source name min rest parms))
(define (prc? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) prc-tag)))
(define (prc-name x) (vector-ref x 6))
(define (prc-min x) (vector-ref x 7))
(define (prc-rest x) (vector-ref x 8))
(define (prc-parms x) (vector-ref x 9))
(define (prc-name-set! x y) (vector-set! x 6 y))
(define (prc-min-set! x y) (vector-set! x 7 y))
(define (prc-rest-set! x y) (vector-set! x 8 y))
(define (prc-parms-set! x y) (vector-set! x 9 y))
(define prc-tag (list 'prc-tag))
(define (make-app parent children fv decl source)
(vector app-tag parent children fv decl source))
(define (app? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) app-tag)))
(define app-tag (list 'app-tag))
(define (make-fut parent children fv decl source)
(vector fut-tag parent children fv decl source))
(define (fut? x)
(and (vector? x) (> (vector-length x) 0) (eq? (vector-ref x 0) fut-tag)))
(define fut-tag (list 'fut-tag))
(define (new-cst source decl val) (make-cst #f '() #t decl source val))
(define (new-ref source decl var)
(let ((node (make-ref #f '() #t decl source var)))
(var-refs-set! var (set-adjoin (var-refs var) node))
node))
(define (new-ref-extended-bindings source name env)
(new-ref source
(add-extended-bindings (env-declarations env))
(env-lookup-global-var env name)))
(define (new-set source decl var val)
(let ((node (make-set #f (list val) #t decl source var)))
(var-sets-set! var (set-adjoin (var-sets var) node))
(node-parent-set! val node)
node))
(define (set-val x)
(if (set? x)
(car (node-children x))
(compiler-internal-error "set-val, 'set' node expected" x)))
(define (new-def source decl var val)
(let ((node (make-def #f (list val) #t decl source var)))
(var-sets-set! var (set-adjoin (var-sets var) node))
(node-parent-set! val node)
node))
(define (def-val x)
(if (def? x)
(car (node-children x))
(compiler-internal-error "def-val, 'def' node expected" x)))
(define (new-tst source decl pre con alt)
(let ((node (make-tst #f (list pre con alt) #t decl source)))
(node-parent-set! pre node)
(node-parent-set! con node)
(node-parent-set! alt node)
node))
(define (tst-pre x)
(if (tst? x)
(car (node-children x))
(compiler-internal-error "tst-pre, 'tst' node expected" x)))
(define (tst-con x)
(if (tst? x)
(cadr (node-children x))
(compiler-internal-error "tst-con, 'tst' node expected" x)))
(define (tst-alt x)
(if (tst? x)
(caddr (node-children x))
(compiler-internal-error "tst-alt, 'tst' node expected" x)))
(define (new-conj source decl pre alt)
(let ((node (make-conj #f (list pre alt) #t decl source)))
(node-parent-set! pre node)
(node-parent-set! alt node)
node))
(define (conj-pre x)
(if (conj? x)
(car (node-children x))
(compiler-internal-error "conj-pre, 'conj' node expected" x)))
(define (conj-alt x)
(if (conj? x)
(cadr (node-children x))
(compiler-internal-error "conj-alt, 'conj' node expected" x)))
(define (new-disj source decl pre alt)
(let ((node (make-disj #f (list pre alt) #t decl source)))
(node-parent-set! pre node)
(node-parent-set! alt node)
node))
(define (disj-pre x)
(if (disj? x)
(car (node-children x))
(compiler-internal-error "disj-pre, 'disj' node expected" x)))
(define (disj-alt x)
(if (disj? x)
(cadr (node-children x))
(compiler-internal-error "disj-alt, 'disj' node expected" x)))
(define (new-prc source decl name min rest parms body)
(let ((node (make-prc #f (list body) #t decl source name min rest parms)))
(for-each (lambda (x) (var-bound-set! x node)) parms)
(node-parent-set! body node)
node))
(define (prc-body x)
(if (prc? x)
(car (node-children x))
(compiler-internal-error "prc-body, 'proc' node expected" x)))
(define (new-call source decl oper args)
(let ((node (make-app #f (cons oper args) #t decl source)))
(node-parent-set! oper node)
(for-each (lambda (x) (node-parent-set! x node)) args)
node))
(define (new-call* source decl oper args)
(if *ptree-port*
(if (ref? oper)
(let ((var (ref-var oper)))
(if (global? var)
(let ((proc (standard-procedure
(var-name var)
(node-decl oper))))
(if (and proc
(not (nb-args-conforms?
(length args)
(standard-procedure-call-pattern proc))))
(begin
(display "*** WARNING -- \"" *ptree-port*)
(display (var-name var) *ptree-port*)
(display "\" is called with " *ptree-port*)
(display (length args) *ptree-port*)
(display " argument(s)." *ptree-port*)
(newline *ptree-port*))))))))
(new-call source decl oper args))
(define (app-oper x)
(if (app? x)
(car (node-children x))
(compiler-internal-error "app-oper, 'call' node expected" x)))
(define (app-args x)
(if (app? x)
(cdr (node-children x))
(compiler-internal-error "app-args, 'call' node expected" x)))
(define (oper-pos? node)
(let ((parent (node-parent node)))
(if parent (and (app? parent) (eq? (app-oper parent) node)) #f)))
(define (new-fut source decl val)
(let ((node (make-fut #f (list val) #t decl source)))
(node-parent-set! val node)
node))
(define (fut-val x)
(if (fut? x)
(car (node-children x))
(compiler-internal-error "fut-val, 'fut' node expected" x)))
(define (new-disj-call source decl pre oper alt)
(new-call*
source
decl
(let* ((parms (new-temps source '(temp))) (temp (car parms)))
(new-prc source
decl
#f
1
#f
parms
(new-tst source
decl
(new-ref source decl temp)
(new-call*
source
decl
oper
(list (new-ref source decl temp)))
alt)))
(list pre)))
(define (new-seq source decl before after)
(new-call*
source
decl
(new-prc source decl #f 1 #f (new-temps source '(temp)) after)
(list before)))
(define (new-let ptree proc vars vals body)
(if (pair? vars)
(new-call
(node-source ptree)
(node-decl ptree)
(new-prc (node-source proc)
(node-decl proc)
(prc-name proc)
(length vars)
#f
(reverse vars)
body)
(reverse vals))
body))
(define (new-temps source names)
(if (null? names)
'()
(cons (make-var (car names) #t (set-empty) (set-empty) source)
(new-temps source (cdr names)))))
(define (new-variables vars)
(if (null? vars)
'()
(cons (make-var
(source-code (car vars))
#t
(set-empty)
(set-empty)
(car vars))
(new-variables (cdr vars)))))
(define (set-prc-names! vars vals)
(let loop ((vars vars) (vals vals))
(if (not (null? vars))
(let ((var (car vars)) (val (car vals)))
(if (prc? val) (prc-name-set! val (symbol->string (var-name var))))
(loop (cdr vars) (cdr vals))))))
(define (free-variables node)
(if (eq? (node-fv node) #t)
(let ((x (apply set-union (map free-variables (node-children node)))))
(node-fv-set!
node
(cond ((ref? node)
(if (global? (ref-var node)) x (set-adjoin x (ref-var node))))
((set? node)
(if (global? (set-var node)) x (set-adjoin x (set-var node))))
((prc? node) (set-difference x (list->set (prc-parms node))))
((and (app? node) (prc? (app-oper node)))
(set-difference x (list->set (prc-parms (app-oper node)))))
(else x)))))
(node-fv node))
(define (bound-variables node) (list->set (prc-parms node)))
(define (not-mutable? var) (set-empty? (var-sets var)))
(define (mutable? var) (not (not-mutable? var)))
(define (bound? var) (var-bound var))
(define (global? var) (not (bound? var)))
(define (global-val var)
(and (global? var)
(let ((sets (set->list (var-sets var))))
(and (pair? sets)
(null? (cdr sets))
(def? (car sets))
(eq? (compilation-strategy (node-decl (car sets))) block-sym)
(def-val (car sets))))))
(define **not-sym (string->canonical-symbol "##NOT"))
(define **quasi-append-sym (string->canonical-symbol "##QUASI-APPEND"))
(define **quasi-list-sym (string->canonical-symbol "##QUASI-LIST"))
(define **quasi-cons-sym (string->canonical-symbol "##QUASI-CONS"))
(define **quasi-list->vector-sym
(string->canonical-symbol "##QUASI-LIST->VECTOR"))
(define **case-memv-sym (string->canonical-symbol "##CASE-MEMV"))
(define **unassigned?-sym (string->canonical-symbol "##UNASSIGNED?"))
(define **make-cell-sym (string->canonical-symbol "##MAKE-CELL"))
(define **cell-ref-sym (string->canonical-symbol "##CELL-REF"))
(define **cell-set!-sym (string->canonical-symbol "##CELL-SET!"))
(define **make-placeholder-sym (string->canonical-symbol "##MAKE-PLACEHOLDER"))
(define ieee-scheme-sym (string->canonical-symbol "IEEE-SCHEME"))
(define r4rs-scheme-sym (string->canonical-symbol "R4RS-SCHEME"))
(define multilisp-sym (string->canonical-symbol "MULTILISP"))
(define lambda-lift-sym (string->canonical-symbol "LAMBDA-LIFT"))
(define block-sym (string->canonical-symbol "BLOCK"))
(define separate-sym (string->canonical-symbol "SEPARATE"))
(define standard-bindings-sym (string->canonical-symbol "STANDARD-BINDINGS"))
(define extended-bindings-sym (string->canonical-symbol "EXTENDED-BINDINGS"))
(define safe-sym (string->canonical-symbol "SAFE"))
(define interrupts-enabled-sym (string->canonical-symbol "INTERRUPTS-ENABLED"))
(define-flag-decl ieee-scheme-sym 'dialect)
(define-flag-decl r4rs-scheme-sym 'dialect)
(define-flag-decl multilisp-sym 'dialect)
(define-boolean-decl lambda-lift-sym)
(define-flag-decl block-sym 'compilation-strategy)
(define-flag-decl separate-sym 'compilation-strategy)
(define-namable-boolean-decl standard-bindings-sym)
(define-namable-boolean-decl extended-bindings-sym)
(define-boolean-decl safe-sym)
(define-boolean-decl interrupts-enabled-sym)
(define (scheme-dialect decl)
(declaration-value 'dialect #f ieee-scheme-sym decl))
(define (lambda-lift? decl) (declaration-value lambda-lift-sym #f #t decl))
(define (compilation-strategy decl)
(declaration-value 'compilation-strategy #f separate-sym decl))
(define (standard-binding? name decl)
(declaration-value standard-bindings-sym name #f decl))
(define (extended-binding? name decl)
(declaration-value extended-bindings-sym name #f decl))
(define (add-extended-bindings decl)
(add-decl (list extended-bindings-sym #t) decl))
(define (intrs-enabled? decl)
(declaration-value interrupts-enabled-sym #f #t decl))
(define (add-not-interrupts-enabled decl)
(add-decl (list interrupts-enabled-sym #f) decl))
(define (safe? decl) (declaration-value safe-sym #f #f decl))
(define (add-not-safe decl) (add-decl (list safe-sym #f) decl))
(define (dialect-specific-keywords dialect)
(cond ((eq? dialect ieee-scheme-sym) ieee-scheme-specific-keywords)
((eq? dialect r4rs-scheme-sym) r4rs-scheme-specific-keywords)
((eq? dialect multilisp-sym) multilisp-specific-keywords)
(else
(compiler-internal-error
"dialect-specific-keywords, unknown dialect"
dialect))))
(define (dialect-specific-procedures dialect)
(cond ((eq? dialect ieee-scheme-sym) ieee-scheme-specific-procedures)
((eq? dialect r4rs-scheme-sym) r4rs-scheme-specific-procedures)
((eq? dialect multilisp-sym) multilisp-specific-procedures)
(else
(compiler-internal-error
"dialect-specific-procedures, unknown dialect"
dialect))))
(define (make-standard-procedure x)
(cons (string->canonical-symbol (car x)) (cdr x)))
(define (standard-procedure name decl)
(or (assq name (dialect-specific-procedures (scheme-dialect decl)))
(assq name common-procedures)))
(define (standard-procedure-call-pattern proc) (cdr proc))
(define ieee-scheme-specific-keywords '())
(define ieee-scheme-specific-procedures (map make-standard-procedure '()))
(define r4rs-scheme-specific-keywords (list delay-sym))
(define r4rs-scheme-specific-procedures
(map make-standard-procedure
'(("LIST-TAIL" 2)
("-" . 1)
("/" . 1)
("STRING->LIST" 1)
("LIST->STRING" 1)
("STRING-COPY" 1)
("STRING-FILL!" 2)
("VECTOR->LIST" 1)
("LIST->VECTOR" 1)
("VECTOR-FILL!" 2)
("FORCE" 1)
("WITH-INPUT-FROM-FILE" 2)
("WITH-OUTPUT-TO-FILE" 2)
("CHAR-READY?" 0 1)
("LOAD" 1)
("TRANSCRIPT-ON" 1)
("TRANSCRIPT-OFF" 0))))
(define multilisp-specific-keywords (list delay-sym future-sym))
(define multilisp-specific-procedures
(map make-standard-procedure '(("FORCE" 1) ("TOUCH" 1))))
(define common-keywords
(list quote-sym
quasiquote-sym
unquote-sym
unquote-splicing-sym
lambda-sym
if-sym
set!-sym
cond-sym
=>-sym
else-sym
and-sym
or-sym
case-sym
let-sym
let*-sym
letrec-sym
begin-sym
do-sym
define-sym
**define-macro-sym
**declare-sym
**include-sym))
(define common-procedures
(map make-standard-procedure
'(("NOT" 1)
("BOOLEAN?" 1)
("EQV?" 2)
("EQ?" 2)
("EQUAL?" 2)
("PAIR?" 1)
("CONS" 2)
("CAR" 1)
("CDR" 1)
("SET-CAR!" 2)
("SET-CDR!" 2)
("CAAR" 1)
("CADR" 1)
("CDAR" 1)
("CDDR" 1)
("CAAAR" 1)
("CAADR" 1)
("CADAR" 1)
("CADDR" 1)
("CDAAR" 1)
("CDADR" 1)
("CDDAR" 1)
("CDDDR" 1)
("CAAAAR" 1)
("CAAADR" 1)
("CAADAR" 1)
("CAADDR" 1)
("CADAAR" 1)
("CADADR" 1)
("CADDAR" 1)
("CADDDR" 1)
("CDAAAR" 1)
("CDAADR" 1)
("CDADAR" 1)
("CDADDR" 1)
("CDDAAR" 1)
("CDDADR" 1)
("CDDDAR" 1)
("CDDDDR" 1)
("NULL?" 1)
("LIST?" 1)
("LIST" . 0)
("LENGTH" 1)
("APPEND" . 0)
("REVERSE" 1)
("LIST-REF" 2)
("MEMQ" 2)
("MEMV" 2)
("MEMBER" 2)
("ASSQ" 2)
("ASSV" 2)
("ASSOC" 2)
("SYMBOL?" 1)
("SYMBOL->STRING" 1)
("STRING->SYMBOL" 1)
("NUMBER?" 1)
("COMPLEX?" 1)
("REAL?" 1)
("RATIONAL?" 1)
("INTEGER?" 1)
("EXACT?" 1)
("INEXACT?" 1)
("=" . 2)
("<" . 2)
(">" . 2)
("<=" . 2)
(">=" . 2)
("ZERO?" 1)
("POSITIVE?" 1)
("NEGATIVE?" 1)
("ODD?" 1)
("EVEN?" 1)
("MAX" . 1)
("MIN" . 1)
("+" . 0)
("*" . 0)
("-" 1 2)
("/" 1 2)
("ABS" 1)
("QUOTIENT" 2)
("REMAINDER" 2)
("MODULO" 2)
("GCD" . 0)
("LCM" . 0)
("NUMERATOR" 1)
("DENOMINATOR" 1)
("FLOOR" 1)
("CEILING" 1)
("TRUNCATE" 1)
("ROUND" 1)
("RATIONALIZE" 2)
("EXP" 1)
("LOG" 1)
("SIN" 1)
("COS" 1)
("TAN" 1)
("ASIN" 1)
("ACOS" 1)
("ATAN" 1 2)
("SQRT" 1)
("EXPT" 2)
("MAKE-RECTANGULAR" 2)
("MAKE-POLAR" 2)
("REAL-PART" 1)
("IMAG-PART" 1)
("MAGNITUDE" 1)
("ANGLE" 1)
("EXACT->INEXACT" 1)
("INEXACT->EXACT" 1)
("NUMBER->STRING" 1 2)
("STRING->NUMBER" 1 2)
("CHAR?" 1)
("CHAR=?" 2)
("CHAR<?" 2)
("CHAR>?" 2)
("CHAR<=?" 2)
("CHAR>=?" 2)
("CHAR-CI=?" 2)
("CHAR-CI<?" 2)
("CHAR-CI>?" 2)
("CHAR-CI<=?" 2)
("CHAR-CI>=?" 2)
("CHAR-ALPHABETIC?" 1)
("CHAR-NUMERIC?" 1)
("CHAR-WHITESPACE?" 1)
("CHAR-UPPER-CASE?" 1)
("CHAR-LOWER-CASE?" 1)
("CHAR->INTEGER" 1)
("INTEGER->CHAR" 1)
("CHAR-UPCASE" 1)
("CHAR-DOWNCASE" 1)
("STRING?" 1)
("MAKE-STRING" 1 2)
("STRING" . 0)
("STRING-LENGTH" 1)
("STRING-REF" 2)
("STRING-SET!" 3)
("STRING=?" 2)
("STRING<?" 2)
("STRING>?" 2)
("STRING<=?" 2)
("STRING>=?" 2)
("STRING-CI=?" 2)
("STRING-CI<?" 2)
("STRING-CI>?" 2)
("STRING-CI<=?" 2)
("STRING-CI>=?" 2)
("SUBSTRING" 3)
("STRING-APPEND" . 0)
("VECTOR?" 1)
("MAKE-VECTOR" 1 2)
("VECTOR" . 0)
("VECTOR-LENGTH" 1)
("VECTOR-REF" 2)
("VECTOR-SET!" 3)
("PROCEDURE?" 1)
("APPLY" . 2)
("MAP" . 2)
("FOR-EACH" . 2)
("CALL-WITH-CURRENT-CONTINUATION" 1)
("CALL-WITH-INPUT-FILE" 2)
("CALL-WITH-OUTPUT-FILE" 2)
("INPUT-PORT?" 1)
("OUTPUT-PORT?" 1)
("CURRENT-INPUT-PORT" 0)
("CURRENT-OUTPUT-PORT" 0)
("OPEN-INPUT-FILE" 1)
("OPEN-OUTPUT-FILE" 1)
("CLOSE-INPUT-PORT" 1)
("CLOSE-OUTPUT-PORT" 1)
("EOF-OBJECT?" 1)
("READ" 0 1)
("READ-CHAR" 0 1)
("PEEK-CHAR" 0 1)
("WRITE" 1 2)
("DISPLAY" 1 2)
("NEWLINE" 0 1)
("WRITE-CHAR" 1 2))))
(define (parse-program program env module-name proc)
(define (parse-prog program env lst proc)
(if (null? program)
(proc (reverse lst) env)
(let ((source (car program)))
(cond ((macro-expr? source env)
(parse-prog
(cons (macro-expand source env) (cdr program))
env
lst
proc))
((begin-defs-expr? source)
(parse-prog
(append (begin-defs-body source) (cdr program))
env
lst
proc))
((include-expr? source)
(if *ptree-port* (display " " *ptree-port*))
(let ((x (file->sources*
(include-filename source)
*ptree-port*
(source-locat source))))
(if *ptree-port* (newline *ptree-port*))
(parse-prog (append x (cdr program)) env lst proc)))
((define-macro-expr? source env)
(if *ptree-port*
(begin
(display " \"macro\"" *ptree-port*)
(newline *ptree-port*)))
(parse-prog (cdr program) (add-macro source env) lst proc))
((declare-expr? source)
(if *ptree-port*
(begin
(display " \"decl\"" *ptree-port*)
(newline *ptree-port*)))
(parse-prog
(cdr program)
(add-declarations source env)
lst
proc))
((define-expr? source env)
(let* ((var** (definition-variable source))
(var* (source-code var**))
(var (env-lookup-var env var* var**)))
(if *ptree-port*
(begin
(display " " *ptree-port*)
(display (var-name var) *ptree-port*)
(newline *ptree-port*)))
(let ((node (pt (definition-value source) env 'true)))
(set-prc-names! (list var) (list node))
(parse-prog
(cdr program)
env
(cons (cons (new-def source
(env-declarations env)
var
node)
env)
lst)
proc))))
((c-declaration-expr? source)
(if *ptree-port*
(begin
(display " \"c-decl\"" *ptree-port*)
(newline *ptree-port*)))
(add-c-declaration (source-code (cadr (source-code source))))
(parse-prog (cdr program) env lst proc))
((c-init-expr? source)
(if *ptree-port*
(begin
(display " \"c-init\"" *ptree-port*)
(newline *ptree-port*)))
(add-c-init (source-code (cadr (source-code source))))
(parse-prog (cdr program) env lst proc))
(else
(if *ptree-port*
(begin
(display " \"expr\"" *ptree-port*)
(newline *ptree-port*)))
(parse-prog
(cdr program)
env
(cons (cons (pt source env 'true) env) lst)
proc))))))
(if *ptree-port*
(begin (display "Parsing:" *ptree-port*) (newline *ptree-port*)))
(c-interface-begin module-name)
(parse-prog
program
env
'()
(lambda (lst env)
(if *ptree-port* (newline *ptree-port*))
(proc lst env (c-interface-end)))))
(define (c-interface-begin module-name)
(set! c-interface-module-name module-name)
(set! c-interface-proc-count 0)
(set! c-interface-decls '())
(set! c-interface-procs '())
(set! c-interface-inits '())
#f)
(define (c-interface-end)
(let ((i (make-c-intf
(reverse c-interface-decls)
(reverse c-interface-procs)
(reverse c-interface-inits))))
(set! c-interface-module-name #f)
(set! c-interface-proc-count #f)
(set! c-interface-decls #f)
(set! c-interface-procs #f)
(set! c-interface-inits #f)
i))
(define c-interface-module-name #f)
(define c-interface-proc-count #f)
(define c-interface-decls #f)
(define c-interface-procs #f)
(define c-interface-inits #f)
(define (make-c-intf decls procs inits) (vector decls procs inits))
(define (c-intf-decls c-intf) (vector-ref c-intf 0))
(define (c-intf-decls-set! c-intf x) (vector-set! c-intf 0 x))
(define (c-intf-procs c-intf) (vector-ref c-intf 1))
(define (c-intf-procs-set! c-intf x) (vector-set! c-intf 1 x))
(define (c-intf-inits c-intf) (vector-ref c-intf 2))
(define (c-intf-inits-set! c-intf x) (vector-set! c-intf 2 x))
(define (c-declaration-expr? source)
(and (mymatch **c-declaration-sym 1 source)
(let ((code (source-code source)))
(or (string? (source-code (cadr code)))
(pt-syntax-error
source
"Argument to '##c-declaration' must be a string")))))
(define (c-init-expr? source)
(and (mymatch **c-init-sym 1 source)
(let ((code (source-code source)))
(or (string? (source-code (cadr code)))
(pt-syntax-error
source
"Argument to '##c-init' must be a string")))))
(define (c-procedure-expr? source)
(and (mymatch **c-procedure-sym 3 source)
(let ((code (source-code source)))
(if (not (string? (source-code (cadddr code))))
(pt-syntax-error
source
"Last argument to '##c-procedure' must be a string")
(check-arg-and-result-types source (cadr code) (caddr code))))))
(define scheme-to-c-notation
(list (list void-sym "VOID" "void")
(list char-sym "CHAR" "char")
(list signed-char-sym "SCHAR" "signed char")
(list unsigned-char-sym "UCHAR" "unsigned char")
(list short-sym "SHORT" "short")
(list unsigned-short-sym "USHORT" "unsigned short")
(list int-sym "INT" "int")
(list unsigned-int-sym "UINT" "unsigned int")
(list long-sym "LONG" "long")
(list unsigned-long-sym "ULONG" "unsigned long")
(list float-sym "FLOAT" "float")
(list double-sym "DOUBLE" "double")
(list pointer-sym "POINTER" "void*")
(list boolean-sym "BOOLEAN" "int")
(list string-sym "STRING" "char*")
(list scheme-object-sym "SCMOBJ" "long")))
(define (convert-type typ) (if (assq typ scheme-to-c-notation) typ #f))
(define (check-arg-and-result-types source arg-typs-source res-typ-source)
(let ((arg-typs (source-code arg-typs-source))
(res-typ (source-code res-typ-source)))
(let ((res-type (convert-type res-typ)))
(if (not res-type)
(pt-syntax-error res-typ-source "Invalid result type")
(if (not (proper-length arg-typs))
(pt-syntax-error
arg-typs-source
"Ill-terminated argument type list")
(let loop ((lst arg-typs))
(if (pair? lst)
(let* ((arg-typ (source-code (car lst)))
(arg-type (convert-type arg-typ)))
(if (or (not arg-type) (eq? arg-type void-sym))
(pt-syntax-error (car lst) "Invalid argument type")
(loop (cdr lst))))
#t)))))))
(define (add-c-declaration declaration-string)
(set! c-interface-decls (cons declaration-string c-interface-decls))
#f)
(define (add-c-init initialization-code-string)
(set! c-interface-inits (cons initialization-code-string c-interface-inits))
#f)
(define (add-c-proc scheme-name c-name arity def)
(set! c-interface-procs
(cons (vector scheme-name c-name arity def) c-interface-procs))
#f)
(define (pt-c-procedure source env use)
(let* ((code (source-code source))
(name (build-c-procedure
(map source-code (source-code (cadr code)))
(source-code (caddr code))
(source-code (cadddr code))))
(decl (env-declarations env)))
(new-ref source decl (env-lookup-global-var env (string->symbol name)))))
(define (build-c-procedure argument-types result-type proc-name-or-code)
(define proc-name?
(let loop ((i (- (string-length proc-name-or-code) 1)))
(if (>= i 0)
(let ((c (string-ref proc-name-or-code i)))
(if (or (char-alphabetic? c) (char=? c #\_)) (loop (- i 1)) #f))
#t)))
(define nl (string #\newline))
(define undefined-value "UND")
(define scheme-arg-prefix "ARG")
(define scheme-result-name "RESULT")
(define c-arg-prefix "arg")
(define c-result-name "result")
(define scheme-to-c-prefix "SCMOBJ_TO_")
(define c-to-scheme-suffix "_TO_SCMOBJ")
(define (c-type-name typ) (cadr (assq typ scheme-to-c-notation)))
(define (c-type-decl typ) (caddr (assq typ scheme-to-c-notation)))
(define (listify strings)
(if (null? strings)
""
(string-append
(car strings)
(apply string-append
(map (lambda (s) (string-append "," s)) (cdr strings))))))
(define (scheme-arg-var t)
(string-append c-id-prefix scheme-arg-prefix (number->string (cdr t))))
(define (c-arg-var t)
(string-append c-id-prefix c-arg-prefix (number->string (cdr t))))
(define (make-c-procedure arg-types res-type)
(define (make-arg-decl)
(apply string-append
(map (lambda (t)
(string-append
(c-type-decl (car t))
" "
(c-arg-var t)
";"
nl))
arg-types)))
(define (make-conversions)
(if (not (null? arg-types))
(let loop ((lst arg-types) (str (string-append "if (" nl)))
(if (null? lst)
(string-append str " )" nl)
(let ((t (car lst)) (rest (cdr lst)))
(loop rest
(string-append
str
" "
c-id-prefix
scheme-to-c-prefix
(c-type-name (car t))
"("
(scheme-arg-var t)
","
(c-arg-var t)
")"
(if (null? rest) "" " &&")
nl)))))
""))
(define (make-body)
(if proc-name?
(let* ((param-list (listify (map c-arg-var arg-types)))
(call (string-append proc-name-or-code "(" param-list ")")))
(if (eq? res-type void-sym)
(string-append
"{"
nl
call
";"
nl
c-id-prefix
scheme-result-name
" = "
c-id-prefix
undefined-value
";"
nl
"}"
nl)
(string-append
c-id-prefix
(c-type-name res-type)
c-to-scheme-suffix
"("
call
","
c-id-prefix
scheme-result-name
");"
nl)))
(if (eq? res-type void-sym)
(string-append
"{"
nl
proc-name-or-code
nl
c-id-prefix
scheme-result-name
" = "
c-id-prefix
undefined-value
";"
nl
"}"
nl)
(string-append
"{"
nl
proc-name-or-code
nl
c-id-prefix
(c-type-name res-type)
c-to-scheme-suffix
"("
c-id-prefix
c-result-name
","
c-id-prefix
scheme-result-name
");"
nl
"}"
nl))))
(let* ((index (number->string c-interface-proc-count))
(scheme-name (string-append "#!" c-interface-module-name "#" index))
(c-name (string-append c-id-prefix (scheme-id->c-id scheme-name)))
(arity (length argument-types))
(def (string-append
(if (or proc-name? (eq? res-type void-sym))
""
(string-append
(c-type-decl res-type)
" "
c-id-prefix
c-result-name
";"
nl))
(make-arg-decl)
(make-conversions)
(make-body))))
(set! c-interface-proc-count (+ c-interface-proc-count 1))
(add-c-proc scheme-name c-name arity def)
scheme-name))
(let loop ((i 1) (lst1 argument-types) (lst2 '()))
(if (pair? lst1)
(loop (+ i 1) (cdr lst1) (cons (cons (car lst1) i) lst2))
(make-c-procedure (reverse lst2) result-type))))
(define (scheme-id->c-id s)
(define (hex->char i) (string-ref "0123456789abcdef" i))
(let loop ((i (- (string-length s) 1)) (l '()))
(if (>= i 0)
(let ((c (string-ref s i)))
(cond ((or (char-alphabetic? c) (char-numeric? c))
(loop (- i 1) (cons c l)))
((char=? c #\_) (loop (- i 1) (cons c (cons c l))))
(else
(let ((n (character-encoding c)))
(loop (- i 1)
(cons #\_
(cons (hex->char (quotient n 16))
(cons (hex->char (modulo n 16)) l))))))))
(lst->string l))))
(define (pt-syntax-error source msg . args)
(apply compiler-user-error
(cons (source-locat source)
(cons (string-append "Syntax error -- " msg) args))))
(define (pt source env use)
(cond ((macro-expr? source env) (pt (macro-expand source env) env use))
((self-eval-expr? source) (pt-self-eval source env use))
((quote-expr? source) (pt-quote source env use))
((quasiquote-expr? source) (pt-quasiquote source env use))
((unquote-expr? source)
(pt-syntax-error source "Ill-placed 'unquote'"))
((unquote-splicing-expr? source)
(pt-syntax-error source "Ill-placed 'unquote-splicing'"))
((var-expr? source env) (pt-var source env use))
((set!-expr? source env) (pt-set! source env use))
((lambda-expr? source env) (pt-lambda source env use))
((if-expr? source) (pt-if source env use))
((cond-expr? source) (pt-cond source env use))
((and-expr? source) (pt-and source env use))
((or-expr? source) (pt-or source env use))
((case-expr? source) (pt-case source env use))
((let-expr? source env) (pt-let source env use))
((let*-expr? source env) (pt-let* source env use))
((letrec-expr? source env) (pt-letrec source env use))
((begin-expr? source) (pt-begin source env use))
((do-expr? source env) (pt-do source env use))
((define-expr? source env)
(pt-syntax-error source "Ill-placed 'define'"))
((delay-expr? source env) (pt-delay source env use))
((future-expr? source env) (pt-future source env use))
((define-macro-expr? source env)
(pt-syntax-error source "Ill-placed '##define-macro'"))
((begin-defs-expr? source)
(pt-syntax-error source "Ill-placed 'begin' style definitions"))
((declare-expr? source)
(pt-syntax-error source "Ill-placed '##declare'"))
((c-declaration-expr? source)
(pt-syntax-error source "Ill-placed '##c-declaration'"))
((c-init-expr? source)
(pt-syntax-error source "Ill-placed '##c-init'"))
((c-procedure-expr? source) (pt-c-procedure source env use))
((combination-expr? source) (pt-combination source env use))
(else (compiler-internal-error "pt, unknown expression type" source))))
(define (macro-expand source env)
(let ((code (source-code source)))
(expression->source
(apply (cdr (env-lookup-macro env (source-code (car code))))
(cdr (source->expression source)))
source)))
(define (pt-self-eval source env use)
(let ((val (source->expression source)))
(if (eq? use 'none)
(new-cst source (env-declarations env) undef-object)
(new-cst source (env-declarations env) val))))
(define (pt-quote source env use)
(let ((code (source-code source)))
(if (eq? use 'none)
(new-cst source (env-declarations env) undef-object)
(new-cst source
(env-declarations env)
(source->expression (cadr code))))))
(define (pt-quasiquote source env use)
(let ((code (source-code source))) (pt-quasiquotation (cadr code) 1 env)))
(define (pt-quasiquotation form level env)
(cond ((= level 0) (pt form env 'true))
((quasiquote-expr? form)
(pt-quasiquotation-list form (source-code form) (+ level 1) env))
((unquote-expr? form)
(if (= level 1)
(pt (cadr (source-code form)) env 'true)
(pt-quasiquotation-list form (source-code form) (- level 1) env)))
((unquote-splicing-expr? form)
(if (= level 1)
(pt-syntax-error form "Ill-placed 'unquote-splicing'")
(pt-quasiquotation-list form (source-code form) (- level 1) env)))
((pair? (source-code form))
(pt-quasiquotation-list form (source-code form) level env))
((vector? (source-code form))
(vector-form
form
(pt-quasiquotation-list
form
(vector->lst (source-code form))
level
env)
env))
(else
(new-cst form (env-declarations env) (source->expression form)))))
(define (pt-quasiquotation-list form l level env)
(cond ((pair? l)
(if (and (unquote-splicing-expr? (car l)) (= level 1))
(let ((x (pt (cadr (source-code (car l))) env 'true)))
(if (null? (cdr l))
x
(append-form
(car l)
x
(pt-quasiquotation-list form (cdr l) 1 env)
env)))
(cons-form
form
(pt-quasiquotation (car l) level env)
(pt-quasiquotation-list form (cdr l) level env)
env)))
((null? l) (new-cst form (env-declarations env) '()))
(else (pt-quasiquotation l level env))))
(define (append-form source ptree1 ptree2 env)
(cond ((and (cst? ptree1) (cst? ptree2))
(new-cst source
(env-declarations env)
(append (cst-val ptree1) (cst-val ptree2))))
((and (cst? ptree2) (null? (cst-val ptree2))) ptree1)
(else
(new-call*
source
(add-not-safe (env-declarations env))
(new-ref-extended-bindings source **quasi-append-sym env)
(list ptree1 ptree2)))))
(define (cons-form source ptree1 ptree2 env)
(cond ((and (cst? ptree1) (cst? ptree2))
(new-cst source
(env-declarations env)
(cons (cst-val ptree1) (cst-val ptree2))))
((and (cst? ptree2) (null? (cst-val ptree2)))
(new-call*
source
(add-not-safe (env-declarations env))
(new-ref-extended-bindings source **quasi-list-sym env)
(list ptree1)))
(else
(new-call*
source
(add-not-safe (env-declarations env))
(new-ref-extended-bindings source **quasi-cons-sym env)
(list ptree1 ptree2)))))
(define (vector-form source ptree env)
(if (cst? ptree)
(new-cst source (env-declarations env) (lst->vector (cst-val ptree)))
(new-call*
source
(add-not-safe (env-declarations env))
(new-ref-extended-bindings source **quasi-list->vector-sym env)
(list ptree))))
(define (pt-var source env use)
(if (eq? use 'none)
(new-cst source (env-declarations env) undef-object)
(new-ref source
(env-declarations env)
(env-lookup-var env (source-code source) source))))
(define (pt-set! source env use)
(let ((code (source-code source)))
(new-set source
(env-declarations env)
(env-lookup-var env (source-code (cadr code)) (cadr code))
(pt (caddr code) env 'true))))
(define (pt-lambda source env use)
(let ((code (source-code source)))
(define (new-params parms)
(cond ((pair? parms)
(let* ((parm* (car parms))
(parm (source-code parm*))
(p* (if (pair? parm) (car parm) parm*)))
(cons (make-var (source-code p*) #t (set-empty) (set-empty) p*)
(new-params (cdr parms)))))
((null? parms) '())
(else
(list (make-var
(source-code parms)
#t
(set-empty)
(set-empty)
parms)))))
(define (min-params parms)
(let loop ((l parms) (n 0))
(if (pair? l)
(if (pair? (source-code (car l))) n (loop (cdr l) (+ n 1)))
n)))
(define (rest-param? parms)
(if (pair? parms) (rest-param? (cdr parms)) (not (null? parms))))
(define (optionals parms source body env)
(if (pair? parms)
(let* ((parm* (car parms)) (parm (source-code parm*)))
(if (and (pair? parm) (length? parm 2))
(let* ((var (car parm))
(vars (new-variables (list var)))
(decl (env-declarations env)))
(new-call*
parm*
decl
(new-prc parm*
decl
#f
1
#f
vars
(optionals
(cdr parms)
source
body
(env-frame env vars)))
(list (new-tst parm*
decl
(new-call*
parm*
decl
(new-ref-extended-bindings
parm*
**unassigned?-sym
env)
(list (new-ref parm*
decl
(env-lookup-var
env
(source-code var)
var))))
(pt (cadr parm) env 'true)
(new-ref parm*
decl
(env-lookup-var
env
(source-code var)
var))))))
(optionals (cdr parms) source body env)))
(pt-body source body env 'true)))
(if (eq? use 'none)
(new-cst source (env-declarations env) undef-object)
(let* ((parms (source->parms (cadr code))) (frame (new-params parms)))
(new-prc source
(env-declarations env)
#f
(min-params parms)
(rest-param? parms)
frame
(optionals
parms
source
(cddr code)
(env-frame env frame)))))))
(define (source->parms source)
(let ((x (source-code source))) (if (or (pair? x) (null? x)) x source)))
(define (pt-body source body env use)
(define (letrec-defines vars vals envs body env)
(cond ((null? body)
(pt-syntax-error
source
"Body must contain at least one evaluable expression"))
((macro-expr? (car body) env)
(letrec-defines
vars
vals
envs
(cons (macro-expand (car body) env) (cdr body))
env))
((begin-defs-expr? (car body))
(letrec-defines
vars
vals
envs
(append (begin-defs-body (car body)) (cdr body))
env))
((include-expr? (car body))
(if *ptree-port* (display " " *ptree-port*))
(let ((x (file->sources*
(include-filename (car body))
*ptree-port*
(source-locat (car body)))))
(if *ptree-port* (newline *ptree-port*))
(letrec-defines vars vals envs (append x (cdr body)) env)))
((define-expr? (car body) env)
(let* ((var** (definition-variable (car body)))
(var* (source-code var**))
(var (env-define-var env var* var**)))
(letrec-defines
(cons var vars)
(cons (definition-value (car body)) vals)
(cons env envs)
(cdr body)
env)))
((declare-expr? (car body))
(letrec-defines
vars
vals
envs
(cdr body)
(add-declarations (car body) env)))
((define-macro-expr? (car body) env)
(letrec-defines
vars
vals
envs
(cdr body)
(add-macro (car body) env)))
((c-declaration-expr? (car body))
(add-c-declaration (source-code (cadr (source-code (car body)))))
(letrec-defines vars vals envs (cdr body) env))
((c-init-expr? (car body))
(add-c-init (source-code (cadr (source-code (car body)))))
(letrec-defines vars vals envs (cdr body) env))
((null? vars) (pt-sequence source body env use))
(else
(let ((vars* (reverse vars)))
(let loop ((vals* '()) (l1 vals) (l2 envs))
(if (not (null? l1))
(loop (cons (pt (car l1) (car l2) 'true) vals*)
(cdr l1)
(cdr l2))
(pt-recursive-let source vars* vals* body env use)))))))
(letrec-defines '() '() '() body (env-frame env '())))
(define (pt-sequence source seq env use)
(if (length? seq 1)
(pt (car seq) env use)
(new-seq source
(env-declarations env)
(pt (car seq) env 'none)
(pt-sequence source (cdr seq) env use))))
(define (pt-if source env use)
(let ((code (source-code source)))
(new-tst source
(env-declarations env)
(pt (cadr code) env 'pred)
(pt (caddr code) env use)
(if (length? code 3)
(new-cst source (env-declarations env) undef-object)
(pt (cadddr code) env use)))))
(define (pt-cond source env use)
(define (pt-clauses clauses)
(if (length? clauses 0)
(new-cst source (env-declarations env) undef-object)
(let* ((clause* (car clauses)) (clause (source-code clause*)))
(cond ((eq? (source-code (car clause)) else-sym)
(pt-sequence clause* (cdr clause) env use))
((length? clause 1)
(new-disj
clause*
(env-declarations env)
(pt (car clause) env (if (eq? use 'true) 'true 'pred))
(pt-clauses (cdr clauses))))
((eq? (source-code (cadr clause)) =>-sym)
(new-disj-call
clause*
(env-declarations env)
(pt (car clause) env 'true)
(pt (caddr clause) env 'true)
(pt-clauses (cdr clauses))))
(else
(new-tst clause*
(env-declarations env)
(pt (car clause) env 'pred)
(pt-sequence clause* (cdr clause) env use)
(pt-clauses (cdr clauses))))))))
(pt-clauses (cdr (source-code source))))
(define (pt-and source env use)
(define (pt-exprs exprs)
(cond ((length? exprs 0) (new-cst source (env-declarations env) #t))
((length? exprs 1) (pt (car exprs) env use))
(else
(new-conj
(car exprs)
(env-declarations env)
(pt (car exprs) env (if (eq? use 'true) 'true 'pred))
(pt-exprs (cdr exprs))))))
(pt-exprs (cdr (source-code source))))
(define (pt-or source env use)
(define (pt-exprs exprs)
(cond ((length? exprs 0)
(new-cst source (env-declarations env) false-object))
((length? exprs 1) (pt (car exprs) env use))
(else
(new-disj
(car exprs)
(env-declarations env)
(pt (car exprs) env (if (eq? use 'true) 'true 'pred))
(pt-exprs (cdr exprs))))))
(pt-exprs (cdr (source-code source))))
(define (pt-case source env use)
(let ((code (source-code source)) (temp (new-temps source '(temp))))
(define (pt-clauses clauses)
(if (length? clauses 0)
(new-cst source (env-declarations env) undef-object)
(let* ((clause* (car clauses)) (clause (source-code clause*)))
(if (eq? (source-code (car clause)) else-sym)
(pt-sequence clause* (cdr clause) env use)
(new-tst clause*
(env-declarations env)
(new-call*
clause*
(add-not-safe (env-declarations env))
(new-ref-extended-bindings
clause*
**case-memv-sym
env)
(list (new-ref clause*
(env-declarations env)
(car temp))
(new-cst (car clause)
(env-declarations env)
(source->expression (car clause)))))
(pt-sequence clause* (cdr clause) env use)
(pt-clauses (cdr clauses)))))))
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
1
#f
temp
(pt-clauses (cddr code)))
(list (pt (cadr code) env 'true)))))
(define (pt-let source env use)
(let ((code (source-code source)))
(if (bindable-var? (cadr code) env)
(let* ((self (new-variables (list (cadr code))))
(bindings (map source-code (source-code (caddr code))))
(vars (new-variables (map car bindings)))
(vals (map (lambda (x) (pt (cadr x) env 'true)) bindings))
(env (env-frame (env-frame env vars) self))
(self-proc
(list (new-prc source
(env-declarations env)
#f
(length vars)
#f
vars
(pt-body source (cdddr code) env use)))))
(set-prc-names! self self-proc)
(set-prc-names! vars vals)
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
1
#f
self
(new-call*
source
(env-declarations env)
(new-ref source (env-declarations env) (car self))
vals))
self-proc))
(if (null? (source-code (cadr code)))
(pt-body source (cddr code) env use)
(let* ((bindings (map source-code (source-code (cadr code))))
(vars (new-variables (map car bindings)))
(vals (map (lambda (x) (pt (cadr x) env 'true)) bindings))
(env (env-frame env vars)))
(set-prc-names! vars vals)
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
(length vars)
#f
vars
(pt-body source (cddr code) env use))
vals))))))
(define (pt-let* source env use)
(let ((code (source-code source)))
(define (pt-bindings bindings env use)
(if (null? bindings)
(pt-body source (cddr code) env use)
(let* ((binding* (car bindings))
(binding (source-code binding*))
(vars (new-variables (list (car binding))))
(vals (list (pt (cadr binding) env 'true)))
(env (env-frame env vars)))
(set-prc-names! vars vals)
(new-call*
binding*
(env-declarations env)
(new-prc binding*
(env-declarations env)
#f
1
#f
vars
(pt-bindings (cdr bindings) env use))
vals))))
(pt-bindings (source-code (cadr code)) env use)))
(define (pt-letrec source env use)
(let* ((code (source-code source))
(bindings (map source-code (source-code (cadr code))))
(vars* (new-variables (map car bindings)))
(env* (env-frame env vars*)))
(pt-recursive-let
source
vars*
(map (lambda (x) (pt (cadr x) env* 'true)) bindings)
(cddr code)
env*
use)))
(define (pt-recursive-let source vars vals body env use)
(define (dependency-graph vars vals)
(define (dgraph vars* vals*)
(if (null? vars*)
(set-empty)
(let ((var (car vars*)) (val (car vals*)))
(set-adjoin
(dgraph (cdr vars*) (cdr vals*))
(make-gnode
var
(set-intersection (list->set vars) (free-variables val)))))))
(dgraph vars vals))
(define (val-of var)
(list-ref vals (- (length vars) (length (memq var vars)))))
(define (bind-in-order order)
(if (null? order)
(pt-body source body env use)
(let* ((vars-set (car order)) (vars (set->list vars-set)))
(let loop1 ((l (reverse vars))
(vars-b '())
(vals-b '())
(vars-a '()))
(if (not (null? l))
(let* ((var (car l)) (val (val-of var)))
(if (or (prc? val)
(set-empty?
(set-intersection (free-variables val) vars-set)))
(loop1 (cdr l)
(cons var vars-b)
(cons val vals-b)
vars-a)
(loop1 (cdr l) vars-b vals-b (cons var vars-a))))
(let* ((result1 (let loop2 ((l vars-a))
(if (not (null? l))
(let* ((var (car l)) (val (val-of var)))
(new-seq source
(env-declarations env)
(new-set source
(env-declarations
env)
var
val)
(loop2 (cdr l))))
(bind-in-order (cdr order)))))
(result2 (if (null? vars-b)
result1
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
(length vars-b)
#f
vars-b
result1)
vals-b)))
(result3 (if (null? vars-a)
result2
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
(length vars-a)
#f
vars-a
result2)
(map (lambda (var)
(new-cst source
(env-declarations env)
undef-object))
vars-a)))))
result3))))))
(set-prc-names! vars vals)
(bind-in-order
(topological-sort (transitive-closure (dependency-graph vars vals)))))
(define (pt-begin source env use)
(pt-sequence source (cdr (source-code source)) env use))
(define (pt-do source env use)
(let* ((code (source-code source))
(loop (new-temps source '(loop)))
(bindings (map source-code (source-code (cadr code))))
(vars (new-variables (map car bindings)))
(init (map (lambda (x) (pt (cadr x) env 'true)) bindings))
(env (env-frame env vars))
(step (map (lambda (x)
(pt (if (length? x 2) (car x) (caddr x)) env 'true))
bindings))
(exit (source-code (caddr code))))
(set-prc-names! vars init)
(new-call*
source
(env-declarations env)
(new-prc source
(env-declarations env)
#f
1
#f
loop
(new-call*
source
(env-declarations env)
(new-ref source (env-declarations env) (car loop))
init))
(list (new-prc source
(env-declarations env)
#f
(length vars)
#f
vars
(new-tst source
(env-declarations env)
(pt (car exit) env 'pred)
(if (length? exit 1)
(new-cst (caddr code)
(env-declarations env)
undef-object)
(pt-sequence (caddr code) (cdr exit) env use))
(if (length? code 3)
(new-call*
source
(env-declarations env)
(new-ref source
(env-declarations env)
(car loop))
step)
(new-seq source
(env-declarations env)
(pt-sequence
source
(cdddr code)
env
'none)
(new-call*
source
(env-declarations env)
(new-ref source
(env-declarations env)
(car loop))
step)))))))))
(define (pt-combination source env use)
(let* ((code (source-code source))
(oper (pt (car code) env 'true))
(decl (node-decl oper)))
(new-call*
source
(env-declarations env)
oper
(map (lambda (x) (pt x env 'true)) (cdr code)))))
(define (pt-delay source env use)
(let ((code (source-code source)))
(new-call*
source
(add-not-safe (env-declarations env))
(new-ref-extended-bindings source **make-placeholder-sym env)
(list (new-prc source
(env-declarations env)
#f
0
#f
'()
(pt (cadr code) env 'true))))))
(define (pt-future source env use)
(let ((decl (env-declarations env)) (code (source-code source)))
(new-fut source decl (pt (cadr code) env 'true))))
(define (self-eval-expr? source)
(let ((code (source-code source)))
(and (not (pair? code)) (not (symbol-object? code)))))
(define (quote-expr? source) (mymatch quote-sym 1 source))
(define (quasiquote-expr? source) (mymatch quasiquote-sym 1 source))
(define (unquote-expr? source) (mymatch unquote-sym 1 source))
(define (unquote-splicing-expr? source)
(mymatch unquote-splicing-sym 1 source))
(define (var-expr? source env)
(let ((code (source-code source)))
(and (symbol-object? code)
(not-keyword source env code)
(not-macro source env code))))
(define (not-macro source env name)
(if (env-lookup-macro env name)
(pt-syntax-error source "Macro name can't be used as a variable:" name)
#t))
(define (bindable-var? source env)
(let ((code (source-code source)))
(and (symbol-object? code) (not-keyword source env code))))
(define (not-keyword source env name)
(if (or (memq name common-keywords)
(memq name
(dialect-specific-keywords
(scheme-dialect (env-declarations env)))))
(pt-syntax-error
source
"Predefined keyword can't be used as a variable:"
name)
#t))
(define (set!-expr? source env)
(and (mymatch set!-sym 2 source)
(var-expr? (cadr (source-code source)) env)))
(define (lambda-expr? source env)
(and (mymatch lambda-sym -2 source)
(proper-parms? (source->parms (cadr (source-code source))) env)))
(define (if-expr? source)
(and (mymatch if-sym -2 source)
(or (<= (length (source-code source)) 4)
(pt-syntax-error source "Ill-formed special form" if-sym))))
(define (cond-expr? source)
(and (mymatch cond-sym -1 source) (proper-clauses? source)))
(define (and-expr? source) (mymatch and-sym 0 source))
(define (or-expr? source) (mymatch or-sym 0 source))
(define (case-expr? source)
(and (mymatch case-sym -2 source) (proper-case-clauses? source)))
(define (let-expr? source env)
(and (mymatch let-sym -2 source)
(let ((code (source-code source)))
(if (bindable-var? (cadr code) env)
(and (proper-bindings? (caddr code) #t env)
(or (> (length code) 3)
(pt-syntax-error source "Ill-formed named 'let'")))
(proper-bindings? (cadr code) #t env)))))
(define (let*-expr? source env)
(and (mymatch let*-sym -2 source)
(proper-bindings? (cadr (source-code source)) #f env)))
(define (letrec-expr? source env)
(and (mymatch letrec-sym -2 source)
(proper-bindings? (cadr (source-code source)) #t env)))
(define (begin-expr? source) (mymatch begin-sym -1 source))
(define (do-expr? source env)
(and (mymatch do-sym -2 source)
(proper-do-bindings? source env)
(proper-do-exit? source)))
(define (define-expr? source env)
(and (mymatch define-sym -1 source)
(proper-definition? source env)
(let ((v (definition-variable source)))
(not-macro v env (source-code v)))))
(define (combination-expr? source)
(let ((length (proper-length (source-code source))))
(if length
(or (> length 0) (pt-syntax-error source "Ill-formed procedure call"))
(pt-syntax-error source "Ill-terminated procedure call"))))
(define (delay-expr? source env)
(and (not (eq? (scheme-dialect (env-declarations env)) ieee-scheme-sym))
(mymatch delay-sym 1 source)))
(define (future-expr? source env)
(and (eq? (scheme-dialect (env-declarations env)) multilisp-sym)
(mymatch future-sym 1 source)))
(define (macro-expr? source env)
(let ((code (source-code source)))
(and (pair? code)
(symbol-object? (source-code (car code)))
(let ((macr (env-lookup-macro env (source-code (car code)))))
(and macr
(let ((len (proper-length (cdr code))))
(if len
(let ((len* (+ len 1)) (size (car macr)))
(or (if (> size 0) (= len* size) (>= len* (- size)))
(pt-syntax-error source "Ill-formed macro form")))
(pt-syntax-error
source
"Ill-terminated macro form"))))))))
(define (define-macro-expr? source env)
(and (mymatch **define-macro-sym -1 source) (proper-definition? source env)))
(define (declare-expr? source) (mymatch **declare-sym -1 source))
(define (include-expr? source) (mymatch **include-sym 1 source))
(define (begin-defs-expr? source) (mymatch begin-sym 0 source))
(define (mymatch keyword size source)
(let ((code (source-code source)))
(and (pair? code)
(eq? (source-code (car code)) keyword)
(let ((length (proper-length (cdr code))))
(if length
(or (if (> size 0) (= length size) (>= length (- size)))
(pt-syntax-error source "Ill-formed special form" keyword))
(pt-syntax-error
source
"Ill-terminated special form"
keyword))))))
(define (proper-length l)
(define (length l n)
(cond ((pair? l) (length (cdr l) (+ n 1))) ((null? l) n) (else #f)))
(length l 0))
(define (proper-definition? source env)
(let* ((code (source-code source))
(pattern* (cadr code))
(pattern (source-code pattern*))
(body (cddr code)))
(cond ((bindable-var? pattern* env)
(cond ((length? body 0) #t)
((length? body 1) #t)
(else (pt-syntax-error source "Ill-formed definition body"))))
((pair? pattern)
(if (length? body 0)
(pt-syntax-error
source
"Body of a definition must have at least one expression"))
(if (bindable-var? (car pattern) env)
(proper-parms? (cdr pattern) env)
(pt-syntax-error
(car pattern)
"Procedure name must be an identifier")))
(else (pt-syntax-error pattern* "Ill-formed definition pattern")))))
(define (definition-variable def)
(let* ((code (source-code def)) (pattern (cadr code)))
(if (pair? (source-code pattern)) (car (source-code pattern)) pattern)))
(define (definition-value def)
(let ((code (source-code def)) (loc (source-locat def)))
(cond ((pair? (source-code (cadr code)))
(make-source
(cons (make-source lambda-sym loc)
(cons (parms->source (cdr (source-code (cadr code))) loc)
(cddr code)))
loc))
((null? (cddr code))
(make-source
(list (make-source quote-sym loc) (make-source undef-object loc))
loc))
(else (caddr code)))))
(define (parms->source parms loc)
(if (or (pair? parms) (null? parms)) (make-source parms loc) parms))
(define (proper-parms? parms env)
(define (proper-parms parms seen optional-seen)
(cond ((pair? parms)
(let* ((parm* (car parms)) (parm (source-code parm*)))
(cond ((pair? parm)
(if (eq? (scheme-dialect (env-declarations env))
multilisp-sym)
(let ((length (proper-length parm)))
(if (or (eqv? length 1) (eqv? length 2))
(let ((var (car parm)))
(if (bindable-var? var env)
(if (memq (source-code var) seen)
(pt-syntax-error
var
"Duplicate parameter in parameter list")
(proper-parms
(cdr parms)
(cons (source-code var) seen)
#t))
(pt-syntax-error
var
"Parameter must be an identifier")))
(pt-syntax-error
parm*
"Ill-formed optional parameter")))
(pt-syntax-error
parm*
"optional parameters illegal in this dialect")))
(optional-seen
(pt-syntax-error parm* "Optional parameter expected"))
((bindable-var? parm* env)
(if (memq parm seen)
(pt-syntax-error
parm*
"Duplicate parameter in parameter list"))
(proper-parms (cdr parms) (cons parm seen) #f))
(else
(pt-syntax-error
parm*
"Parameter must be an identifier")))))
((null? parms) #t)
((bindable-var? parms env)
(if (memq (source-code parms) seen)
(pt-syntax-error parms "Duplicate parameter in parameter list")
#t))
(else
(pt-syntax-error parms "Rest parameter must be an identifier"))))
(proper-parms parms '() #f))
(define (proper-clauses? source)
(define (proper-clauses clauses)
(or (null? clauses)
(let* ((clause* (car clauses))
(clause (source-code clause*))
(length (proper-length clause)))
(if length
(if (>= length 1)
(if (eq? (source-code (car clause)) else-sym)
(cond ((= length 1)
(pt-syntax-error
clause*
"Else clause must have a body"))
((not (null? (cdr clauses)))
(pt-syntax-error
clause*
"Else clause must be the last clause"))
(else (proper-clauses (cdr clauses))))
(if (and (>= length 2)
(eq? (source-code (cadr clause)) =>-sym)
(not (= length 3)))
(pt-syntax-error
(cadr clause)
"'=>' must be followed by a single expression")
(proper-clauses (cdr clauses))))
(pt-syntax-error clause* "Ill-formed 'cond' clause"))
(pt-syntax-error clause* "Ill-terminated 'cond' clause")))))
(proper-clauses (cdr (source-code source))))
(define (proper-case-clauses? source)
(define (proper-case-clauses clauses)
(or (null? clauses)
(let* ((clause* (car clauses))
(clause (source-code clause*))
(length (proper-length clause)))
(if length
(if (>= length 2)
(if (eq? (source-code (car clause)) else-sym)
(if (not (null? (cdr clauses)))
(pt-syntax-error
clause*
"Else clause must be the last clause")
(proper-case-clauses (cdr clauses)))
(begin
(proper-selector-list? (car clause))
(proper-case-clauses (cdr clauses))))
(pt-syntax-error
clause*
"A 'case' clause must have a selector list and a body"))
(pt-syntax-error clause* "Ill-terminated 'case' clause")))))
(proper-case-clauses (cddr (source-code source))))
(define (proper-selector-list? source)
(let* ((code (source-code source)) (length (proper-length code)))
(if length
(or (>= length 1)
(pt-syntax-error
source
"Selector list must contain at least one element"))
(pt-syntax-error source "Ill-terminated selector list"))))
(define (proper-bindings? bindings check-dupl? env)
(define (proper-bindings l seen)
(cond ((pair? l)
(let* ((binding* (car l)) (binding (source-code binding*)))
(if (eqv? (proper-length binding) 2)
(let ((var (car binding)))
(if (bindable-var? var env)
(if (and check-dupl? (memq (source-code var) seen))
(pt-syntax-error
var
"Duplicate variable in bindings")
(proper-bindings
(cdr l)
(cons (source-code var) seen)))
(pt-syntax-error
var
"Binding variable must be an identifier")))
(pt-syntax-error binding* "Ill-formed binding"))))
((null? l) #t)
(else (pt-syntax-error bindings "Ill-terminated binding list"))))
(proper-bindings (source-code bindings) '()))
(define (proper-do-bindings? source env)
(let ((bindings (cadr (source-code source))))
(define (proper-bindings l seen)
(cond ((pair? l)
(let* ((binding* (car l))
(binding (source-code binding*))
(length (proper-length binding)))
(if (or (eqv? length 2) (eqv? length 3))
(let ((var (car binding)))
(if (bindable-var? var env)
(if (memq (source-code var) seen)
(pt-syntax-error
var
"Duplicate variable in bindings")
(proper-bindings
(cdr l)
(cons (source-code var) seen)))
(pt-syntax-error
var
"Binding variable must be an identifier")))
(pt-syntax-error binding* "Ill-formed binding"))))
((null? l) #t)
(else (pt-syntax-error bindings "Ill-terminated binding list"))))
(proper-bindings (source-code bindings) '())))
(define (proper-do-exit? source)
(let* ((code (source-code (caddr (source-code source))))
(length (proper-length code)))
(if length
(or (> length 0) (pt-syntax-error source "Ill-formed exit clause"))
(pt-syntax-error source "Ill-terminated exit clause"))))
(define (include-filename source) (source-code (cadr (source-code source))))
(define (begin-defs-body source) (cdr (source-code source)))
(define (length? l n)
(cond ((null? l) (= n 0)) ((> n 0) (length? (cdr l) (- n 1))) (else #f)))
(define (transform-declaration source)
(let ((code (source-code source)))
(if (not (pair? code))
(pt-syntax-error source "Ill-formed declaration")
(let* ((pos (not (eq? (source-code (car code)) not-sym)))
(x (if pos code (cdr code))))
(if (not (pair? x))
(pt-syntax-error source "Ill-formed declaration")
(let* ((id* (car x)) (id (source-code id*)))
(cond ((not (symbol-object? id))
(pt-syntax-error
id*
"Declaration name must be an identifier"))
((assq id flag-declarations)
(cond ((not pos)
(pt-syntax-error
id*
"Declaration can't be negated"))
((null? (cdr x))
(flag-decl
source
(cdr (assq id flag-declarations))
id))
(else
(pt-syntax-error
source
"Ill-formed declaration"))))
((memq id parameterized-declarations)
(cond ((not pos)
(pt-syntax-error
id*
"Declaration can't be negated"))
((eqv? (proper-length x) 2)
(parameterized-decl
source
id
(source->expression (cadr x))))
(else
(pt-syntax-error
source
"Ill-formed declaration"))))
((memq id boolean-declarations)
(if (null? (cdr x))
(boolean-decl source id pos)
(pt-syntax-error source "Ill-formed declaration")))
((assq id namable-declarations)
(cond ((not pos)
(pt-syntax-error
id*
"Declaration can't be negated"))
(else
(namable-decl
source
(cdr (assq id namable-declarations))
id
(map source->expression (cdr x))))))
((memq id namable-boolean-declarations)
(namable-boolean-decl
source
id
pos
(map source->expression (cdr x))))
((memq id namable-string-declarations)
(if (not (pair? (cdr x)))
(pt-syntax-error source "Ill-formed declaration")
(let* ((str* (cadr x)) (str (source-code str*)))
(cond ((not pos)
(pt-syntax-error
id*
"Declaration can't be negated"))
((not (string? str))
(pt-syntax-error str* "String expected"))
(else
(namable-string-decl
source
id
str
(map source->expression (cddr x))))))))
(else (pt-syntax-error id* "Unknown declaration")))))))))
(define (add-declarations source env)
(let loop ((l (cdr (source-code source))) (env env))
(if (pair? l)
(loop (cdr l) (env-declare env (transform-declaration (car l))))
env)))
(define (add-decl d decl) (env-declare decl d))
(define (add-macro source env)
(define (form-size parms)
(let loop ((l parms) (n 1))
(if (pair? l) (loop (cdr l) (+ n 1)) (if (null? l) n (- n)))))
(define (error-proc . msgs)
(apply compiler-user-error
(cons (source-locat source) (cons "(in macro body)" msgs))))
(let ((var (definition-variable source)) (proc (definition-value source)))
(if (lambda-expr? proc env)
(env-macro
env
(source-code var)
(cons (form-size (source->parms (cadr (source-code proc))))
(scheme-global-eval (source->expression proc) error-proc)))
(pt-syntax-error source "Macro value must be a lambda expression"))))
(define (ptree.begin! info-port) (set! *ptree-port* info-port) '())
(define (ptree.end!) '())
(define *ptree-port* '())
(define (normalize-parse-tree ptree env)
(define (normalize ptree)
(let ((tree (assignment-convert (partial-evaluate ptree) env)))
(lambda-lift! tree)
tree))
(if (def? ptree)
(begin
(node-children-set! ptree (list (normalize (def-val ptree))))
ptree)
(normalize ptree)))
(define (partial-evaluate ptree) (pe ptree '()))
(define (pe ptree consts)
(cond ((cst? ptree)
(new-cst (node-source ptree) (node-decl ptree) (cst-val ptree)))
((ref? ptree)
(let ((var (ref-var ptree)))
(var-refs-set! var (set-remove (var-refs var) ptree))
(let ((x (assq var consts)))
(if x
(new-cst (node-source ptree) (node-decl ptree) (cdr x))
(let ((y (global-val var)))
(if (and y (cst? y))
(new-cst (node-source ptree)
(node-decl ptree)
(cst-val y))
(new-ref (node-source ptree)
(node-decl ptree)
var)))))))
((set? ptree)
(let ((var (set-var ptree)) (val (pe (set-val ptree) consts)))
(var-sets-set! var (set-remove (var-sets var) ptree))
(new-set (node-source ptree) (node-decl ptree) var val)))
((tst? ptree)
(let ((pre (pe (tst-pre ptree) consts)))
(if (cst? pre)
(let ((val (cst-val pre)))
(if (false-object? val)
(pe (tst-alt ptree) consts)
(pe (tst-con ptree) consts)))
(new-tst (node-source ptree)
(node-decl ptree)
pre
(pe (tst-con ptree) consts)
(pe (tst-alt ptree) consts)))))
((conj? ptree)
(let ((pre (pe (conj-pre ptree) consts)))
(if (cst? pre)
(let ((val (cst-val pre)))
(if (false-object? val) pre (pe (conj-alt ptree) consts)))
(new-conj
(node-source ptree)
(node-decl ptree)
pre
(pe (conj-alt ptree) consts)))))
((disj? ptree)
(let ((pre (pe (disj-pre ptree) consts)))
(if (cst? pre)
(let ((val (cst-val pre)))
(if (false-object? val) (pe (disj-alt ptree) consts) pre))
(new-disj
(node-source ptree)
(node-decl ptree)
pre
(pe (disj-alt ptree) consts)))))
((prc? ptree)
(new-prc (node-source ptree)
(node-decl ptree)
(prc-name ptree)
(prc-min ptree)
(prc-rest ptree)
(prc-parms ptree)
(pe (prc-body ptree) consts)))
((app? ptree)
(let ((oper (app-oper ptree)) (args (app-args ptree)))
(if (and (prc? oper)
(not (prc-rest oper))
(= (length (prc-parms oper)) (length args)))
(pe-let ptree consts)
(new-call
(node-source ptree)
(node-decl ptree)
(pe oper consts)
(map (lambda (x) (pe x consts)) args)))))
((fut? ptree)
(new-fut (node-source ptree)
(node-decl ptree)
(pe (fut-val ptree) consts)))
(else (compiler-internal-error "pe, unknown parse tree node type"))))
(define (pe-let ptree consts)
(let* ((proc (app-oper ptree))
(vals (app-args ptree))
(vars (prc-parms proc))
(non-mut-vars (set-keep not-mutable? (list->set vars))))
(for-each
(lambda (var)
(var-refs-set! var (set-empty))
(var-sets-set! var (set-empty)))
vars)
(let loop ((l vars)
(v vals)
(new-vars '())
(new-vals '())
(new-consts consts))
(if (null? l)
(if (null? new-vars)
(pe (prc-body proc) new-consts)
(new-call
(node-source ptree)
(node-decl ptree)
(new-prc (node-source proc)
(node-decl proc)
#f
(length new-vars)
#f
(reverse new-vars)
(pe (prc-body proc) new-consts))
(reverse new-vals)))
(let ((var (car l)) (val (pe (car v) consts)))
(if (and (set-member? var non-mut-vars) (cst? val))
(loop (cdr l)
(cdr v)
new-vars
new-vals
(cons (cons var (cst-val val)) new-consts))
(loop (cdr l)
(cdr v)
(cons var new-vars)
(cons val new-vals)
new-consts)))))))
(define (assignment-convert ptree env)
(ac ptree (env-declare env (list safe-sym #f)) '()))
(define (ac ptree env mut)
(cond ((cst? ptree) ptree)
((ref? ptree)
(let ((var (ref-var ptree)))
(if (global? var)
ptree
(let ((x (assq var mut)))
(if x
(let ((source (node-source ptree)))
(var-refs-set! var (set-remove (var-refs var) ptree))
(new-call
source
(node-decl ptree)
(new-ref-extended-bindings source **cell-ref-sym env)
(list (new-ref source (node-decl ptree) (cdr x)))))
ptree)))))
((set? ptree)
(let ((var (set-var ptree))
(source (node-source ptree))
(val (ac (set-val ptree) env mut)))
(var-sets-set! var (set-remove (var-sets var) ptree))
(if (global? var)
(new-set source (node-decl ptree) var val)
(new-call
source
(node-decl ptree)
(new-ref-extended-bindings source **cell-set!-sym env)
(list (new-ref source (node-decl ptree) (cdr (assq var mut)))
val)))))
((tst? ptree)
(new-tst (node-source ptree)
(node-decl ptree)
(ac (tst-pre ptree) env mut)
(ac (tst-con ptree) env mut)
(ac (tst-alt ptree) env mut)))
((conj? ptree)
(new-conj
(node-source ptree)
(node-decl ptree)
(ac (conj-pre ptree) env mut)
(ac (conj-alt ptree) env mut)))
((disj? ptree)
(new-disj
(node-source ptree)
(node-decl ptree)
(ac (disj-pre ptree) env mut)
(ac (disj-alt ptree) env mut)))
((prc? ptree) (ac-proc ptree env mut))
((app? ptree)
(let ((oper (app-oper ptree)) (args (app-args ptree)))
(if (and (prc? oper)
(not (prc-rest oper))
(= (length (prc-parms oper)) (length args)))
(ac-let ptree env mut)
(new-call
(node-source ptree)
(node-decl ptree)
(ac oper env mut)
(map (lambda (x) (ac x env mut)) args)))))
((fut? ptree)
(new-fut (node-source ptree)
(node-decl ptree)
(ac (fut-val ptree) env mut)))
(else (compiler-internal-error "ac, unknown parse tree node type"))))
(define (ac-proc ptree env mut)
(let* ((mut-parms (ac-mutables (prc-parms ptree)))
(mut-parms-copies (map var-copy mut-parms))
(mut (append (pair-up mut-parms mut-parms-copies) mut))
(new-body (ac (prc-body ptree) env mut)))
(new-prc (node-source ptree)
(node-decl ptree)
(prc-name ptree)
(prc-min ptree)
(prc-rest ptree)
(prc-parms ptree)
(if (null? mut-parms)
new-body
(new-call
(node-source ptree)
(node-decl ptree)
(new-prc (node-source ptree)
(node-decl ptree)
#f
(length mut-parms-copies)
#f
mut-parms-copies
new-body)
(map (lambda (var)
(new-call
(var-source var)
(node-decl ptree)
(new-ref-extended-bindings
(var-source var)
**make-cell-sym
env)
(list (new-ref (var-source var)
(node-decl ptree)
var))))
mut-parms))))))
(define (ac-let ptree env mut)
(let* ((proc (app-oper ptree))
(vals (app-args ptree))
(vars (prc-parms proc))
(vals-fv (apply set-union (map free-variables vals)))
(mut-parms (ac-mutables vars))
(mut-parms-copies (map var-copy mut-parms))
(mut (append (pair-up mut-parms mut-parms-copies) mut)))
(let loop ((l vars)
(v vals)
(new-vars '())
(new-vals '())
(new-body (ac (prc-body proc) env mut)))
(if (null? l)
(new-let ptree proc new-vars new-vals new-body)
(let ((var (car l)) (val (car v)))
(if (memq var mut-parms)
(let ((src (node-source val))
(decl (node-decl val))
(var* (cdr (assq var mut))))
(if (set-member? var vals-fv)
(loop (cdr l)
(cdr v)
(cons var* new-vars)
(cons (new-call
src
decl
(new-ref-extended-bindings
src
**make-cell-sym
env)
(list (new-cst src decl undef-object)))
new-vals)
(new-seq src
decl
(new-call
src
decl
(new-ref-extended-bindings
src
**cell-set!-sym
env)
(list (new-ref src decl var*)
(ac val env mut)))
new-body))
(loop (cdr l)
(cdr v)
(cons var* new-vars)
(cons (new-call
src
decl
(new-ref-extended-bindings
src
**make-cell-sym
env)
(list (ac val env mut)))
new-vals)
new-body)))
(loop (cdr l)
(cdr v)
(cons var new-vars)
(cons (ac val env mut) new-vals)
new-body)))))))
(define (ac-mutables l)
(if (pair? l)
(let ((var (car l)) (rest (ac-mutables (cdr l))))
(if (mutable? var) (cons var rest) rest))
'()))
(define (lambda-lift! ptree) (ll! ptree (set-empty) '()))
(define (ll! ptree cst-procs env)
(define (new-env env vars)
(define (loop i l)
(if (pair? l)
(let ((var (car l)))
(cons (cons var (cons (length (set->list (var-refs var))) i))
(loop (+ i 1) (cdr l))))
env))
(loop (length env) vars))
(cond ((or (cst? ptree)
(ref? ptree)
(set? ptree)
(tst? ptree)
(conj? ptree)
(disj? ptree)
(fut? ptree))
(for-each
(lambda (child) (ll! child cst-procs env))
(node-children ptree)))
((prc? ptree)
(ll! (prc-body ptree) cst-procs (new-env env (prc-parms ptree))))
((app? ptree)
(let ((oper (app-oper ptree)) (args (app-args ptree)))
(if (and (prc? oper)
(not (prc-rest oper))
(= (length (prc-parms oper)) (length args)))
(ll!-let ptree cst-procs (new-env env (prc-parms oper)))
(for-each
(lambda (child) (ll! child cst-procs env))
(node-children ptree)))))
(else (compiler-internal-error "ll!, unknown parse tree node type"))))
(define (ll!-let ptree cst-procs env)
(let* ((proc (app-oper ptree))
(vals (app-args ptree))
(vars (prc-parms proc))
(var-val-map (pair-up vars vals)))
(define (var->val var) (cdr (assq var var-val-map)))
(define (liftable-proc-vars vars)
(let loop ((cst-proc-vars
(set-keep
(lambda (var)
(let ((val (var->val var)))
(and (prc? val)
(lambda-lift? (node-decl val))
(set-every? oper-pos? (var-refs var)))))
(list->set vars))))
(let* ((non-cst-proc-vars
(set-keep
(lambda (var)
(let ((val (var->val var)))
(and (prc? val) (not (set-member? var cst-proc-vars)))))
(list->set vars)))
(cst-proc-vars*
(set-keep
(lambda (var)
(let ((val (var->val var)))
(set-empty?
(set-intersection
(free-variables val)
non-cst-proc-vars))))
cst-proc-vars)))
(if (set-equal? cst-proc-vars cst-proc-vars*)
cst-proc-vars
(loop cst-proc-vars*)))))
(define (transitively-closed-free-variables vars)
(let ((tcfv-map
(map (lambda (var) (cons var (free-variables (var->val var))))
vars)))
(let loop ((changed? #f))
(for-each
(lambda (var-tcfv)
(let loop2 ((l (set->list (cdr var-tcfv))) (fv (cdr var-tcfv)))
(if (null? l)
(if (not (set-equal? fv (cdr var-tcfv)))
(begin (set-cdr! var-tcfv fv) (set! changed? #t)))
(let ((x (assq (car l) tcfv-map)))
(loop2 (cdr l) (if x (set-union fv (cdr x)) fv))))))
tcfv-map)
(if changed? (loop #f) tcfv-map))))
(let* ((tcfv-map
(transitively-closed-free-variables (liftable-proc-vars vars)))
(cst-proc-vars-list (map car tcfv-map))
(cst-procs* (set-union (list->set cst-proc-vars-list) cst-procs)))
(define (var->tcfv var) (cdr (assq var tcfv-map)))
(define (order-vars vars)
(map car
(sort-list
(map (lambda (var) (assq var env)) vars)
(lambda (x y)
(if (= (cadr x) (cadr y))
(< (cddr x) (cddr y))
(< (cadr x) (cadr y)))))))
(define (lifted-vars var)
(order-vars (set->list (set-difference (var->tcfv var) cst-procs*))))
(define (lift-app! var)
(let* ((val (var->val var)) (vars (lifted-vars var)))
(define (new-ref* var)
(new-ref (var-source var) (node-decl val) var))
(if (not (null? vars))
(for-each
(lambda (oper)
(let ((node (node-parent oper)))
(node-children-set!
node
(cons (app-oper node)
(append (map new-ref* vars) (app-args node))))))
(set->list (var-refs var))))))
(define (lift-prc! var)
(let* ((val (var->val var)) (vars (lifted-vars var)))
(if (not (null? vars))
(let ((var-copies (map var-copy vars)))
(prc-parms-set! val (append var-copies (prc-parms val)))
(for-each (lambda (x) (var-bound-set! x val)) var-copies)
(node-fv-invalidate! val)
(prc-min-set! val (+ (prc-min val) (length vars)))
(ll-rename! val (pair-up vars var-copies))))))
(for-each lift-app! cst-proc-vars-list)
(for-each lift-prc! cst-proc-vars-list)
(for-each (lambda (node) (ll! node cst-procs* env)) vals)
(ll! (prc-body proc) cst-procs* env))))
(define (ll-rename! ptree var-map)
(cond ((ref? ptree)
(let* ((var (ref-var ptree)) (x (assq var var-map)))
(if x
(begin
(var-refs-set! var (set-remove (var-refs var) ptree))
(var-refs-set! (cdr x) (set-adjoin (var-refs (cdr x)) ptree))
(ref-var-set! ptree (cdr x))))))
((set? ptree)
(let* ((var (set-var ptree)) (x (assq var var-map)))
(if x
(begin
(var-sets-set! var (set-remove (var-sets var) ptree))
(var-sets-set! (cdr x) (set-adjoin (var-sets (cdr x)) ptree))
(set-var-set! ptree (cdr x)))))))
(node-fv-set! ptree #t)
(for-each (lambda (child) (ll-rename! child var-map)) (node-children ptree)))
(define (parse-tree->expression ptree) (se ptree '() (list 0)))
(define (se ptree env num)
(cond ((cst? ptree) (list quote-sym (cst-val ptree)))
((ref? ptree)
(let ((x (assq (ref-var ptree) env)))
(if x (cdr x) (var-name (ref-var ptree)))))
((set? ptree)
(list set!-sym
(let ((x (assq (set-var ptree) env)))
(if x (cdr x) (var-name (set-var ptree))))
(se (set-val ptree) env num)))
((def? ptree)
(list define-sym
(let ((x (assq (def-var ptree) env)))
(if x (cdr x) (var-name (def-var ptree))))
(se (def-val ptree) env num)))
((tst? ptree)
(list if-sym
(se (tst-pre ptree) env num)
(se (tst-con ptree) env num)
(se (tst-alt ptree) env num)))
((conj? ptree)
(list and-sym
(se (conj-pre ptree) env num)
(se (conj-alt ptree) env num)))
((disj? ptree)
(list or-sym
(se (disj-pre ptree) env num)
(se (disj-alt ptree) env num)))
((prc? ptree)
(let ((new-env (se-rename (prc-parms ptree) env num)))
(list lambda-sym
(se-parameters
(prc-parms ptree)
(prc-rest ptree)
(prc-min ptree)
new-env)
(se (prc-body ptree) new-env num))))
((app? ptree)
(let ((oper (app-oper ptree)) (args (app-args ptree)))
(if (and (prc? oper)
(not (prc-rest oper))
(= (length (prc-parms oper)) (length args)))
(let ((new-env (se-rename (prc-parms oper) env num)))
(list (if (set-empty?
(set-intersection
(list->set (prc-parms oper))
(apply set-union (map free-variables args))))
let-sym
letrec-sym)
(se-bindings (prc-parms oper) args new-env num)
(se (prc-body oper) new-env num)))
(map (lambda (x) (se x env num)) (cons oper args)))))
((fut? ptree) (list future-sym (se (fut-val ptree) env num)))
(else (compiler-internal-error "se, unknown parse tree node type"))))
(define (se-parameters parms rest min env)
(define (se-parms parms rest n env)
(cond ((null? parms) '())
((and rest (null? (cdr parms))) (cdr (assq (car parms) env)))
(else
(let ((parm (cdr (assq (car parms) env))))
(cons (if (> n 0) parm (list parm))
(se-parms (cdr parms) rest (- n 1) env))))))
(se-parms parms rest min env))
(define (se-bindings vars vals env num)
(if (null? vars)
'()
(cons (list (cdr (assq (car vars) env)) (se (car vals) env num))
(se-bindings (cdr vars) (cdr vals) env num))))
(define (se-rename vars env num)
(define (rename vars)
(if (null? vars)
env
(cons (cons (car vars)
(string->canonical-symbol
(string-append
(symbol->string (var-name (car vars)))
"#"
(number->string (car num)))))
(rename (cdr vars)))))
(set-car! num (+ (car num) 1))
(rename vars))
(define *opnd-table* '())
(define *opnd-table-alloc* '())
(define opnd-table-size 10000)
(define (enter-opnd arg1 arg2)
(let loop ((i 0))
(if (< i *opnd-table-alloc*)
(let ((x (vector-ref *opnd-table* i)))
(if (and (eqv? (car x) arg1) (eqv? (cdr x) arg2)) i (loop (+ i 1))))
(if (< *opnd-table-alloc* opnd-table-size)
(begin
(set! *opnd-table-alloc* (+ *opnd-table-alloc* 1))
(vector-set! *opnd-table* i (cons arg1 arg2))
i)
(compiler-limitation-error
"program is too long [virtual machine operand table overflow]")))))
(define (contains-opnd? opnd1 opnd2)
(cond ((eqv? opnd1 opnd2) #t)
((clo? opnd2) (contains-opnd? opnd1 (clo-base opnd2)))
(else #f)))
(define (any-contains-opnd? opnd opnds)
(if (null? opnds)
#f
(or (contains-opnd? opnd (car opnds))
(any-contains-opnd? opnd (cdr opnds)))))
(define (make-reg num) num)
(define (reg? x) (< x 10000))
(define (reg-num x) (modulo x 10000))
(define (make-stk num) (+ num 10000))
(define (stk? x) (= (quotient x 10000) 1))
(define (stk-num x) (modulo x 10000))
(define (make-glo name) (+ (enter-opnd name #t) 30000))
(define (glo? x) (= (quotient x 10000) 3))
(define (glo-name x) (car (vector-ref *opnd-table* (modulo x 10000))))
(define (make-clo base index) (+ (enter-opnd base index) 40000))
(define (clo? x) (= (quotient x 10000) 4))
(define (clo-base x) (car (vector-ref *opnd-table* (modulo x 10000))))
(define (clo-index x) (cdr (vector-ref *opnd-table* (modulo x 10000))))
(define (make-lbl num) (+ num 20000))
(define (lbl? x) (= (quotient x 10000) 2))
(define (lbl-num x) (modulo x 10000))
(define label-limit 9999)
(define (make-obj val) (+ (enter-opnd val #f) 50000))
(define (obj? x) (= (quotient x 10000) 5))
(define (obj-val x) (car (vector-ref *opnd-table* (modulo x 10000))))
(define (make-pcontext fs map) (vector fs map))
(define (pcontext-fs x) (vector-ref x 0))
(define (pcontext-map x) (vector-ref x 1))
(define (make-frame size slots regs closed live)
(vector size slots regs closed live))
(define (frame-size x) (vector-ref x 0))
(define (frame-slots x) (vector-ref x 1))
(define (frame-regs x) (vector-ref x 2))
(define (frame-closed x) (vector-ref x 3))
(define (frame-live x) (vector-ref x 4))
(define (frame-eq? x y) (= (frame-size x) (frame-size y)))
(define (frame-truncate frame nb-slots)
(let ((fs (frame-size frame)))
(make-frame
nb-slots
(nth-after (frame-slots frame) (- fs nb-slots))
(frame-regs frame)
(frame-closed frame)
(frame-live frame))))
(define (frame-live? var frame)
(let ((live (frame-live frame)))
(if (eq? var closure-env-var)
(let ((closed (frame-closed frame)))
(if (or (set-member? var live)
(not (set-empty?
(set-intersection live (list->set closed)))))
closed
#f))
(if (set-member? var live) var #f))))
(define (frame-first-empty-slot frame)
(let loop ((i 1) (s (reverse (frame-slots frame))))
(if (pair? s)
(if (frame-live? (car s) frame) (loop (+ i 1) (cdr s)) i)
i)))
(define (make-proc-obj
name
primitive?
code
call-pat
side-effects?
strict-pat
type)
(let ((proc-obj
(vector proc-obj-tag
name
primitive?
code
call-pat
#f
#f
#f
side-effects?
strict-pat
type)))
(proc-obj-specialize-set! proc-obj (lambda (decls) proc-obj))
proc-obj))
(define proc-obj-tag (list 'proc-obj))
(define (proc-obj? x)
(and (vector? x)
(> (vector-length x) 0)
(eq? (vector-ref x 0) proc-obj-tag)))
(define (proc-obj-name obj) (vector-ref obj 1))
(define (proc-obj-primitive? obj) (vector-ref obj 2))
(define (proc-obj-code obj) (vector-ref obj 3))
(define (proc-obj-call-pat obj) (vector-ref obj 4))
(define (proc-obj-test obj) (vector-ref obj 5))
(define (proc-obj-inlinable obj) (vector-ref obj 6))
(define (proc-obj-specialize obj) (vector-ref obj 7))
(define (proc-obj-side-effects? obj) (vector-ref obj 8))
(define (proc-obj-strict-pat obj) (vector-ref obj 9))
(define (proc-obj-type obj) (vector-ref obj 10))
(define (proc-obj-code-set! obj x) (vector-set! obj 3 x))
(define (proc-obj-test-set! obj x) (vector-set! obj 5 x))
(define (proc-obj-inlinable-set! obj x) (vector-set! obj 6 x))
(define (proc-obj-specialize-set! obj x) (vector-set! obj 7 x))
(define (make-pattern min-args nb-parms rest?)
(let loop ((x (if rest? (- nb-parms 1) (list nb-parms)))
(y (if rest? (- nb-parms 1) nb-parms)))
(let ((z (- y 1))) (if (< z min-args) x (loop (cons z x) z)))))
(define (pattern-member? n pat)
(cond ((pair? pat) (if (= (car pat) n) #t (pattern-member? n (cdr pat))))
((null? pat) #f)
(else (<= pat n))))
(define (type-name type) (if (pair? type) (car type) type))
(define (type-pot-fut? type) (pair? type))
(define (make-bbs)
(vector (make-counter 1 label-limit bbs-limit-err) (queue-empty) '()))
(define (bbs-limit-err)
(compiler-limitation-error "procedure is too long [too many labels]"))
(define (bbs-lbl-counter bbs) (vector-ref bbs 0))
(define (bbs-lbl-counter-set! bbs cntr) (vector-set! bbs 0 cntr))
(define (bbs-bb-queue bbs) (vector-ref bbs 1))
(define (bbs-bb-queue-set! bbs bbq) (vector-set! bbs 1 bbq))
(define (bbs-entry-lbl-num bbs) (vector-ref bbs 2))
(define (bbs-entry-lbl-num-set! bbs lbl-num) (vector-set! bbs 2 lbl-num))
(define (bbs-new-lbl! bbs) ((bbs-lbl-counter bbs)))
(define (lbl-num->bb lbl-num bbs)
(let loop ((bb-list (queue->list (bbs-bb-queue bbs))))
(if (= (bb-lbl-num (car bb-list)) lbl-num)
(car bb-list)
(loop (cdr bb-list)))))
(define (make-bb label-instr bbs)
(let ((bb (vector label-instr (queue-empty) '() '() '())))
(queue-put! (vector-ref bbs 1) bb)
bb))
(define (bb-lbl-num bb) (label-lbl-num (vector-ref bb 0)))
(define (bb-label-type bb) (label-type (vector-ref bb 0)))
(define (bb-label-instr bb) (vector-ref bb 0))
(define (bb-label-instr-set! bb l) (vector-set! bb 0 l))
(define (bb-non-branch-instrs bb) (queue->list (vector-ref bb 1)))
(define (bb-non-branch-instrs-set! bb l) (vector-set! bb 1 (list->queue l)))
(define (bb-branch-instr bb) (vector-ref bb 2))
(define (bb-branch-instr-set! bb b) (vector-set! bb 2 b))
(define (bb-references bb) (vector-ref bb 3))
(define (bb-references-set! bb l) (vector-set! bb 3 l))
(define (bb-precedents bb) (vector-ref bb 4))
(define (bb-precedents-set! bb l) (vector-set! bb 4 l))
(define (bb-entry-frame-size bb)
(frame-size (gvm-instr-frame (bb-label-instr bb))))
(define (bb-exit-frame-size bb)
(frame-size (gvm-instr-frame (bb-branch-instr bb))))
(define (bb-slots-gained bb)
(- (bb-exit-frame-size bb) (bb-entry-frame-size bb)))
(define (bb-put-non-branch! bb gvm-instr)
(queue-put! (vector-ref bb 1) gvm-instr))
(define (bb-put-branch! bb gvm-instr) (vector-set! bb 2 gvm-instr))
(define (bb-add-reference! bb ref)
(if (not (memq ref (vector-ref bb 3)))
(vector-set! bb 3 (cons ref (vector-ref bb 3)))))
(define (bb-add-precedent! bb prec)
(if (not (memq prec (vector-ref bb 4)))
(vector-set! bb 4 (cons prec (vector-ref bb 4)))))
(define (bb-last-non-branch-instr bb)
(let ((non-branch-instrs (bb-non-branch-instrs bb)))
(if (null? non-branch-instrs)
(bb-label-instr bb)
(let loop ((l non-branch-instrs))
(if (pair? (cdr l)) (loop (cdr l)) (car l))))))
(define (gvm-instr-type gvm-instr) (vector-ref gvm-instr 0))
(define (gvm-instr-frame gvm-instr) (vector-ref gvm-instr 1))
(define (gvm-instr-comment gvm-instr) (vector-ref gvm-instr 2))
(define (make-label-simple lbl-num frame comment)
(vector 'label frame comment lbl-num 'simple))
(define (make-label-entry lbl-num nb-parms min rest? closed? frame comment)
(vector 'label frame comment lbl-num 'entry nb-parms min rest? closed?))
(define (make-label-return lbl-num frame comment)
(vector 'label frame comment lbl-num 'return))
(define (make-label-task-entry lbl-num frame comment)
(vector 'label frame comment lbl-num 'task-entry))
(define (make-label-task-return lbl-num frame comment)
(vector 'label frame comment lbl-num 'task-return))
(define (label-lbl-num gvm-instr) (vector-ref gvm-instr 3))
(define (label-lbl-num-set! gvm-instr n) (vector-set! gvm-instr 3 n))
(define (label-type gvm-instr) (vector-ref gvm-instr 4))
(define (label-entry-nb-parms gvm-instr) (vector-ref gvm-instr 5))
(define (label-entry-min gvm-instr) (vector-ref gvm-instr 6))
(define (label-entry-rest? gvm-instr) (vector-ref gvm-instr 7))
(define (label-entry-closed? gvm-instr) (vector-ref gvm-instr 8))
(define (make-apply prim opnds loc frame comment)
(vector 'apply frame comment prim opnds loc))
(define (apply-prim gvm-instr) (vector-ref gvm-instr 3))
(define (apply-opnds gvm-instr) (vector-ref gvm-instr 4))
(define (apply-loc gvm-instr) (vector-ref gvm-instr 5))
(define (make-copy opnd loc frame comment)
(vector 'copy frame comment opnd loc))
(define (copy-opnd gvm-instr) (vector-ref gvm-instr 3))
(define (copy-loc gvm-instr) (vector-ref gvm-instr 4))
(define (make-close parms frame comment) (vector 'close frame comment parms))
(define (close-parms gvm-instr) (vector-ref gvm-instr 3))
(define (make-closure-parms loc lbl opnds) (vector loc lbl opnds))
(define (closure-parms-loc x) (vector-ref x 0))
(define (closure-parms-lbl x) (vector-ref x 1))
(define (closure-parms-opnds x) (vector-ref x 2))
(define (make-ifjump test opnds true false poll? frame comment)
(vector 'ifjump frame comment test opnds true false poll?))
(define (ifjump-test gvm-instr) (vector-ref gvm-instr 3))
(define (ifjump-opnds gvm-instr) (vector-ref gvm-instr 4))
(define (ifjump-true gvm-instr) (vector-ref gvm-instr 5))
(define (ifjump-false gvm-instr) (vector-ref gvm-instr 6))
(define (ifjump-poll? gvm-instr) (vector-ref gvm-instr 7))
(define (make-jump opnd nb-args poll? frame comment)
(vector 'jump frame comment opnd nb-args poll?))
(define (jump-opnd gvm-instr) (vector-ref gvm-instr 3))
(define (jump-nb-args gvm-instr) (vector-ref gvm-instr 4))
(define (jump-poll? gvm-instr) (vector-ref gvm-instr 5))
(define (first-class-jump? gvm-instr) (jump-nb-args gvm-instr))
(define (make-comment) (cons 'comment '()))
(define (comment-put! comment name val)
(set-cdr! comment (cons (cons name val) (cdr comment))))
(define (comment-get comment name)
(and comment (let ((x (assq name (cdr comment)))) (if x (cdr x) #f))))
(define (bbs-purify! bbs)
(let loop ()
(bbs-remove-jump-cascades! bbs)
(bbs-remove-dead-code! bbs)
(let* ((changed1? (bbs-remove-common-code! bbs))
(changed2? (bbs-remove-useless-jumps! bbs)))
(if (or changed1? changed2?) (loop) (bbs-order! bbs)))))
(define (bbs-remove-jump-cascades! bbs)
(define (empty-bb? bb)
(and (eq? (bb-label-type bb) 'simple) (null? (bb-non-branch-instrs bb))))
(define (jump-to-non-entry-lbl? branch)
(and (eq? (gvm-instr-type branch) 'jump)
(not (first-class-jump? branch))
(jump-lbl? branch)))
(define (jump-cascade-to lbl-num fs poll? seen thunk)
(if (memq lbl-num seen)
(thunk lbl-num fs poll?)
(let ((bb (lbl-num->bb lbl-num bbs)))
(if (and (empty-bb? bb) (<= (bb-slots-gained bb) 0))
(let ((jump-lbl-num
(jump-to-non-entry-lbl? (bb-branch-instr bb))))
(if jump-lbl-num
(jump-cascade-to
jump-lbl-num
(+ fs (bb-slots-gained bb))
(or poll? (jump-poll? (bb-branch-instr bb)))
(cons lbl-num seen)
thunk)
(thunk lbl-num fs poll?)))
(thunk lbl-num fs poll?)))))
(define (equiv-lbl lbl-num seen)
(if (memq lbl-num seen)
lbl-num
(let ((bb (lbl-num->bb lbl-num bbs)))
(if (empty-bb? bb)
(let ((jump-lbl-num
(jump-to-non-entry-lbl? (bb-branch-instr bb))))
(if (and jump-lbl-num
(not (jump-poll? (bb-branch-instr bb)))
(= (bb-slots-gained bb) 0))
(equiv-lbl jump-lbl-num (cons lbl-num seen))
lbl-num))
lbl-num))))
(define (remove-cascade! bb)
(let ((branch (bb-branch-instr bb)))
(case (gvm-instr-type branch)
((ifjump)
(bb-put-branch!
bb
(make-ifjump
(ifjump-test branch)
(ifjump-opnds branch)
(equiv-lbl (ifjump-true branch) '())
(equiv-lbl (ifjump-false branch) '())
(ifjump-poll? branch)
(gvm-instr-frame branch)
(gvm-instr-comment branch))))
((jump)
(if (not (first-class-jump? branch))
(let ((dest-lbl-num (jump-lbl? branch)))
(if dest-lbl-num
(jump-cascade-to
dest-lbl-num
(frame-size (gvm-instr-frame branch))
(jump-poll? branch)
'()
(lambda (lbl-num fs poll?)
(let* ((dest-bb (lbl-num->bb lbl-num bbs))
(last-branch (bb-branch-instr dest-bb)))
(if (and (empty-bb? dest-bb)
(or (not poll?)
put-poll-on-ifjump?
(not (eq? (gvm-instr-type last-branch)
'ifjump))))
(let* ((new-fs (+ fs (bb-slots-gained dest-bb)))
(new-frame
(frame-truncate
(gvm-instr-frame branch)
new-fs)))
(define (adjust-opnd opnd)
(cond ((stk? opnd)
(make-stk
(+ (- fs (bb-entry-frame-size dest-bb))
(stk-num opnd))))
((clo? opnd)
(make-clo
(adjust-opnd (clo-base opnd))
(clo-index opnd)))
(else opnd)))
(case (gvm-instr-type last-branch)
((ifjump)
(bb-put-branch!
bb
(make-ifjump
(ifjump-test last-branch)
(map adjust-opnd (ifjump-opnds last-branch))
(equiv-lbl (ifjump-true last-branch) '())
(equiv-lbl (ifjump-false last-branch) '())
(or poll? (ifjump-poll? last-branch))
new-frame
(gvm-instr-comment last-branch))))
((jump)
(bb-put-branch!
bb
(make-jump
(adjust-opnd (jump-opnd last-branch))
(jump-nb-args last-branch)
(or poll? (jump-poll? last-branch))
new-frame
(gvm-instr-comment last-branch))))
(else
(compiler-internal-error
"bbs-remove-jump-cascades!, unknown branch type"))))
(bb-put-branch!
bb
(make-jump
(make-lbl lbl-num)
(jump-nb-args branch)
(or poll? (jump-poll? branch))
(frame-truncate (gvm-instr-frame branch) fs)
(gvm-instr-comment branch)))))))))))
(else
(compiler-internal-error
"bbs-remove-jump-cascades!, unknown branch type")))))
(for-each remove-cascade! (queue->list (bbs-bb-queue bbs))))
(define (jump-lbl? branch)
(let ((opnd (jump-opnd branch))) (if (lbl? opnd) (lbl-num opnd) #f)))
(define put-poll-on-ifjump? #f)
(set! put-poll-on-ifjump? #t)
(define (bbs-remove-dead-code! bbs)
(let ((new-bb-queue (queue-empty)) (scan-queue (queue-empty)))
(define (reachable ref bb)
(if bb (bb-add-reference! bb ref))
(if (not (memq ref (queue->list new-bb-queue)))
(begin
(bb-references-set! ref '())
(bb-precedents-set! ref '())
(queue-put! new-bb-queue ref)
(queue-put! scan-queue ref))))
(define (direct-jump to-bb from-bb)
(reachable to-bb from-bb)
(bb-add-precedent! to-bb from-bb))
(define (scan-instr gvm-instr bb)
(define (scan-opnd gvm-opnd)
(cond ((lbl? gvm-opnd)
(reachable (lbl-num->bb (lbl-num gvm-opnd) bbs) bb))
((clo? gvm-opnd) (scan-opnd (clo-base gvm-opnd)))))
(case (gvm-instr-type gvm-instr)
((label) '())
((apply)
(for-each scan-opnd (apply-opnds gvm-instr))
(if (apply-loc gvm-instr) (scan-opnd (apply-loc gvm-instr))))
((copy)
(scan-opnd (copy-opnd gvm-instr))
(scan-opnd (copy-loc gvm-instr)))
((close)
(for-each
(lambda (parm)
(reachable (lbl-num->bb (closure-parms-lbl parm) bbs) bb)
(scan-opnd (closure-parms-loc parm))
(for-each scan-opnd (closure-parms-opnds parm)))
(close-parms gvm-instr)))
((ifjump)
(for-each scan-opnd (ifjump-opnds gvm-instr))
(direct-jump (lbl-num->bb (ifjump-true gvm-instr) bbs) bb)
(direct-jump (lbl-num->bb (ifjump-false gvm-instr) bbs) bb))
((jump)
(let ((opnd (jump-opnd gvm-instr)))
(if (lbl? opnd)
(direct-jump (lbl-num->bb (lbl-num opnd) bbs) bb)
(scan-opnd (jump-opnd gvm-instr)))))
(else
(compiler-internal-error
"bbs-remove-dead-code!, unknown GVM instruction type"))))
(reachable (lbl-num->bb (bbs-entry-lbl-num bbs) bbs) #f)
(let loop ()
(if (not (queue-empty? scan-queue))
(let ((bb (queue-get! scan-queue)))
(begin
(scan-instr (bb-label-instr bb) bb)
(for-each
(lambda (gvm-instr) (scan-instr gvm-instr bb))
(bb-non-branch-instrs bb))
(scan-instr (bb-branch-instr bb) bb)
(loop)))))
(bbs-bb-queue-set! bbs new-bb-queue)))
(define (bbs-remove-useless-jumps! bbs)
(let ((changed? #f))
(define (remove-useless-jump bb)
(let ((branch (bb-branch-instr bb)))
(if (and (eq? (gvm-instr-type branch) 'jump)
(not (first-class-jump? branch))
(not (jump-poll? branch))
(jump-lbl? branch))
(let* ((dest-bb (lbl-num->bb (jump-lbl? branch) bbs))
(frame1 (gvm-instr-frame (bb-last-non-branch-instr bb)))
(frame2 (gvm-instr-frame (bb-label-instr dest-bb))))
(if (and (eq? (bb-label-type dest-bb) 'simple)
(frame-eq? frame1 frame2)
(= (length (bb-precedents dest-bb)) 1))
(begin
(set! changed? #t)
(bb-non-branch-instrs-set!
bb
(append (bb-non-branch-instrs bb)
(bb-non-branch-instrs dest-bb)
'()))
(bb-branch-instr-set! bb (bb-branch-instr dest-bb))
(remove-useless-jump bb)))))))
(for-each remove-useless-jump (queue->list (bbs-bb-queue bbs)))
changed?))
(define (bbs-remove-common-code! bbs)
(let* ((bb-list (queue->list (bbs-bb-queue bbs)))
(n (length bb-list))
(hash-table-length (cond ((< n 50) 43) ((< n 500) 403) (else 4003)))
(hash-table (make-vector hash-table-length '()))
(prim-table '())
(block-map '())
(changed? #f))
(define (hash-prim prim)
(let ((n (length prim-table)) (i (pos-in-list prim prim-table)))
(if i
(- n i)
(begin (set! prim-table (cons prim prim-table)) (+ n 1)))))
(define (hash-opnds l)
(let loop ((l l) (n 0))
(if (pair? l)
(loop (cdr l)
(let ((x (car l)))
(if (lbl? x)
n
(modulo (+ (* n 10000) x) hash-table-length))))
n)))
(define (hash-bb bb)
(let ((branch (bb-branch-instr bb)))
(modulo (case (gvm-instr-type branch)
((ifjump)
(+ (hash-opnds (ifjump-opnds branch))
(* 10 (hash-prim (ifjump-test branch)))
(* 100 (frame-size (gvm-instr-frame branch)))))
((jump)
(+ (hash-opnds (list (jump-opnd branch)))
(* 10 (or (jump-nb-args branch) -1))
(* 100 (frame-size (gvm-instr-frame branch)))))
(else 0))
hash-table-length)))
(define (replacement-lbl-num lbl)
(let ((x (assv lbl block-map))) (if x (cdr x) lbl)))
(define (fix-map! bb1 bb2)
(let loop ((l block-map))
(if (pair? l)
(let ((x (car l)))
(if (= bb1 (cdr x)) (set-cdr! x bb2))
(loop (cdr l))))))
(define (enter-bb! bb)
(let ((h (hash-bb bb)))
(vector-set! hash-table h (add-bb bb (vector-ref hash-table h)))))
(define (add-bb bb l)
(if (pair? l)
(let ((bb* (car l)))
(set! block-map
(cons (cons (bb-lbl-num bb) (bb-lbl-num bb*)) block-map))
(if (eqv-bb? bb bb*)
(begin
(fix-map! (bb-lbl-num bb) (bb-lbl-num bb*))
(set! changed? #t)
l)
(begin
(set! block-map (cdr block-map))
(if (eqv-gvm-instr?
(bb-branch-instr bb)
(bb-branch-instr bb*))
(extract-common-tail
bb
bb*
(lambda (head head* tail)
(if (null? tail)
(cons bb* (add-bb bb (cdr l)))
(let* ((lbl (bbs-new-lbl! bbs))
(branch (bb-branch-instr bb))
(fs** (need-gvm-instrs tail branch))
(frame (frame-truncate
(gvm-instr-frame
(if (null? head)
(bb-label-instr bb)
(car head)))
fs**))
(bb** (make-bb (make-label-simple
lbl
frame
#f)
bbs)))
(bb-non-branch-instrs-set! bb** tail)
(bb-branch-instr-set! bb** branch)
(bb-non-branch-instrs-set! bb* (reverse head*))
(bb-branch-instr-set!
bb*
(make-jump (make-lbl lbl) #f #f frame #f))
(bb-non-branch-instrs-set! bb (reverse head))
(bb-branch-instr-set!
bb
(make-jump (make-lbl lbl) #f #f frame #f))
(set! changed? #t)
(cons bb (cons bb* (add-bb bb** (cdr l))))))))
(cons bb* (add-bb bb (cdr l)))))))
(list bb)))
(define (extract-common-tail bb1 bb2 cont)
(let loop ((l1 (reverse (bb-non-branch-instrs bb1)))
(l2 (reverse (bb-non-branch-instrs bb2)))
(tail '()))
(if (and (pair? l1) (pair? l2))
(let ((i1 (car l1)) (i2 (car l2)))
(if (eqv-gvm-instr? i1 i2)
(loop (cdr l1) (cdr l2) (cons i1 tail))
(cont l1 l2 tail)))
(cont l1 l2 tail))))
(define (eqv-bb? bb1 bb2)
(let ((bb1-non-branch (bb-non-branch-instrs bb1))
(bb2-non-branch (bb-non-branch-instrs bb2)))
(and (= (length bb1-non-branch) (length bb2-non-branch))
(eqv-gvm-instr? (bb-label-instr bb1) (bb-label-instr bb2))
(eqv-gvm-instr? (bb-branch-instr bb1) (bb-branch-instr bb2))
(eqv-list? eqv-gvm-instr? bb1-non-branch bb2-non-branch))))
(define (eqv-list? pred? l1 l2)
(if (pair? l1)
(and (pair? l2)
(pred? (car l1) (car l2))
(eqv-list? pred? (cdr l1) (cdr l2)))
(not (pair? l2))))
(define (eqv-lbl-num? lbl1 lbl2)
(= (replacement-lbl-num lbl1) (replacement-lbl-num lbl2)))
(define (eqv-gvm-opnd? opnd1 opnd2)
(if (not opnd1)
(not opnd2)
(and opnd2
(cond ((lbl? opnd1)
(and (lbl? opnd2)
(eqv-lbl-num? (lbl-num opnd1) (lbl-num opnd2))))
((clo? opnd1)
(and (clo? opnd2)
(= (clo-index opnd1) (clo-index opnd2))
(eqv-gvm-opnd? (clo-base opnd1) (clo-base opnd2))))
(else (eqv? opnd1 opnd2))))))
(define (eqv-gvm-instr? instr1 instr2)
(define (eqv-closure-parms? p1 p2)
(and (eqv-gvm-opnd? (closure-parms-loc p1) (closure-parms-loc p2))
(eqv-lbl-num? (closure-parms-lbl p1) (closure-parms-lbl p2))
(eqv-list?
eqv-gvm-opnd?
(closure-parms-opnds p1)
(closure-parms-opnds p2))))
(let ((type1 (gvm-instr-type instr1)) (type2 (gvm-instr-type instr2)))
(and (eq? type1 type2)
(frame-eq? (gvm-instr-frame instr1) (gvm-instr-frame instr2))
(case type1
((label)
(let ((ltype1 (label-type instr1))
(ltype2 (label-type instr2)))
(and (eq? ltype1 ltype2)
(case ltype1
((simple return task-entry task-return) #t)
((entry)
(and (= (label-entry-min instr1)
(label-entry-min instr2))
(= (label-entry-nb-parms instr1)
(label-entry-nb-parms instr2))
(eq? (label-entry-rest? instr1)
(label-entry-rest? instr2))
(eq? (label-entry-closed? instr1)
(label-entry-closed? instr2))))
(else
(compiler-internal-error
"eqv-gvm-instr?, unknown label type"))))))
((apply)
(and (eq? (apply-prim instr1) (apply-prim instr2))
(eqv-list?
eqv-gvm-opnd?
(apply-opnds instr1)
(apply-opnds instr2))
(eqv-gvm-opnd? (apply-loc instr1) (apply-loc instr2))))
((copy)
(and (eqv-gvm-opnd? (copy-opnd instr1) (copy-opnd instr2))
(eqv-gvm-opnd? (copy-loc instr1) (copy-loc instr2))))
((close)
(eqv-list?
eqv-closure-parms?
(close-parms instr1)
(close-parms instr2)))
((ifjump)
(and (eq? (ifjump-test instr1) (ifjump-test instr2))
(eqv-list?
eqv-gvm-opnd?
(ifjump-opnds instr1)
(ifjump-opnds instr2))
(eqv-lbl-num? (ifjump-true instr1) (ifjump-true instr2))
(eqv-lbl-num? (ifjump-false instr1) (ifjump-false instr2))
(eq? (ifjump-poll? instr1) (ifjump-poll? instr2))))
((jump)
(and (eqv-gvm-opnd? (jump-opnd instr1) (jump-opnd instr2))
(eqv? (jump-nb-args instr1) (jump-nb-args instr2))
(eq? (jump-poll? instr1) (jump-poll? instr2))))
(else
(compiler-internal-error
"eqv-gvm-instr?, unknown 'gvm-instr':"
instr1))))))
(define (update-bb! bb) (replace-label-references! bb replacement-lbl-num))
(for-each enter-bb! bb-list)
(bbs-entry-lbl-num-set! bbs (replacement-lbl-num (bbs-entry-lbl-num bbs)))
(let loop ((i 0) (result '()))
(if (< i hash-table-length)
(let ((bb-kept (vector-ref hash-table i)))
(for-each update-bb! bb-kept)
(loop (+ i 1) (append bb-kept result)))
(bbs-bb-queue-set! bbs (list->queue result))))
changed?))
(define (replace-label-references! bb replacement-lbl-num)
(define (update-gvm-opnd opnd)
(if opnd
(cond ((lbl? opnd) (make-lbl (replacement-lbl-num (lbl-num opnd))))
((clo? opnd)
(make-clo (update-gvm-opnd (clo-base opnd)) (clo-index opnd)))
(else opnd))
opnd))
(define (update-gvm-instr instr)
(define (update-closure-parms p)
(make-closure-parms
(update-gvm-opnd (closure-parms-loc p))
(replacement-lbl-num (closure-parms-lbl p))
(map update-gvm-opnd (closure-parms-opnds p))))
(case (gvm-instr-type instr)
((apply)
(make-apply
(apply-prim instr)
(map update-gvm-opnd (apply-opnds instr))
(update-gvm-opnd (apply-loc instr))
(gvm-instr-frame instr)
(gvm-instr-comment instr)))
((copy)
(make-copy
(update-gvm-opnd (copy-opnd instr))
(update-gvm-opnd (copy-loc instr))
(gvm-instr-frame instr)
(gvm-instr-comment instr)))
((close)
(make-close
(map update-closure-parms (close-parms instr))
(gvm-instr-frame instr)
(gvm-instr-comment instr)))
((ifjump)
(make-ifjump
(ifjump-test instr)
(map update-gvm-opnd (ifjump-opnds instr))
(replacement-lbl-num (ifjump-true instr))
(replacement-lbl-num (ifjump-false instr))
(ifjump-poll? instr)
(gvm-instr-frame instr)
(gvm-instr-comment instr)))
((jump)
(make-jump
(update-gvm-opnd (jump-opnd instr))
(jump-nb-args instr)
(jump-poll? instr)
(gvm-instr-frame instr)
(gvm-instr-comment instr)))
(else
(compiler-internal-error "update-gvm-instr, unknown 'instr':" instr))))
(bb-non-branch-instrs-set!
bb
(map update-gvm-instr (bb-non-branch-instrs bb)))
(bb-branch-instr-set! bb (update-gvm-instr (bb-branch-instr bb))))
(define (bbs-order! bbs)
(let ((new-bb-queue (queue-empty))
(left-to-schedule (queue->list (bbs-bb-queue bbs))))
(define (remove x l)
(if (eq? (car l) x) (cdr l) (cons (car l) (remove x (cdr l)))))
(define (remove-bb! bb)
(set! left-to-schedule (remove bb left-to-schedule))
bb)
(define (prec-bb bb)
(let loop ((l (bb-precedents bb)) (best #f) (best-fs #f))
(if (null? l)
best
(let* ((x (car l)) (x-fs (bb-exit-frame-size x)))
(if (and (memq x left-to-schedule)
(or (not best) (< x-fs best-fs)))
(loop (cdr l) x x-fs)
(loop (cdr l) best best-fs))))))
(define (succ-bb bb)
(define (branches-to-lbl? bb)
(let ((branch (bb-branch-instr bb)))
(case (gvm-instr-type branch)
((ifjump) #t)
((jump) (lbl? (jump-opnd branch)))
(else
(compiler-internal-error "bbs-order!, unknown branch type")))))
(define (best-succ bb1 bb2)
(if (branches-to-lbl? bb1)
bb1
(if (branches-to-lbl? bb2)
bb2
(if (< (bb-exit-frame-size bb1) (bb-exit-frame-size bb2))
bb2
bb1))))
(let ((branch (bb-branch-instr bb)))
(case (gvm-instr-type branch)
((ifjump)
(let* ((true-bb (lbl-num->bb (ifjump-true branch) bbs))
(true-bb* (and (memq true-bb left-to-schedule) true-bb))
(false-bb (lbl-num->bb (ifjump-false branch) bbs))
(false-bb* (and (memq false-bb left-to-schedule) false-bb)))
(if (and true-bb* false-bb*)
(best-succ true-bb* false-bb*)
(or true-bb* false-bb*))))
((jump)
(let ((opnd (jump-opnd branch)))
(and (lbl? opnd)
(let ((bb (lbl-num->bb (lbl-num opnd) bbs)))
(and (memq bb left-to-schedule) bb)))))
(else (compiler-internal-error "bbs-order!, unknown branch type")))))
(define (schedule-from bb)
(queue-put! new-bb-queue bb)
(let ((x (succ-bb bb)))
(if x
(begin
(schedule-around (remove-bb! x))
(let ((y (succ-bb bb)))
(if y (schedule-around (remove-bb! y)))))))
(schedule-refs bb))
(define (schedule-around bb)
(let ((x (prec-bb bb)))
(if x
(let ((bb-list (schedule-back (remove-bb! x) '())))
(queue-put! new-bb-queue x)
(schedule-forw bb)
(for-each schedule-refs bb-list))
(schedule-from bb))))
(define (schedule-back bb bb-list)
(let ((bb-list* (cons bb bb-list)) (x (prec-bb bb)))
(if x
(let ((bb-list (schedule-back (remove-bb! x) bb-list*)))
(queue-put! new-bb-queue x)
bb-list)
bb-list*)))
(define (schedule-forw bb)
(queue-put! new-bb-queue bb)
(let ((x (succ-bb bb)))
(if x
(begin
(schedule-forw (remove-bb! x))
(let ((y (succ-bb bb)))
(if y (schedule-around (remove-bb! y)))))))
(schedule-refs bb))
(define (schedule-refs bb)
(for-each
(lambda (x)
(if (memq x left-to-schedule) (schedule-around (remove-bb! x))))
(bb-references bb)))
(schedule-from (remove-bb! (lbl-num->bb (bbs-entry-lbl-num bbs) bbs)))
(bbs-bb-queue-set! bbs new-bb-queue)
(let ((bb-list (queue->list new-bb-queue)))
(let loop ((l bb-list) (i 1) (lbl-map '()))
(if (pair? l)
(let* ((label-instr (bb-label-instr (car l)))
(old-lbl-num (label-lbl-num label-instr)))
(label-lbl-num-set! label-instr i)
(loop (cdr l) (+ i 1) (cons (cons old-lbl-num i) lbl-map)))
(let ()
(define (replacement-lbl-num x) (cdr (assv x lbl-map)))
(define (update-bb! bb)
(replace-label-references! bb replacement-lbl-num))
(for-each update-bb! bb-list)
(bbs-lbl-counter-set!
bbs
(make-counter
(* (+ 1 (quotient (bbs-new-lbl! bbs) 1000)) 1000)
label-limit
bbs-limit-err))))))))
(define (make-code bb gvm-instr sn) (vector bb gvm-instr sn))
(define (code-bb code) (vector-ref code 0))
(define (code-gvm-instr code) (vector-ref code 1))
(define (code-slots-needed code) (vector-ref code 2))
(define (code-slots-needed-set! code n) (vector-set! code 2 n))
(define (bbs->code-list bbs)
(let ((code-list (linearize bbs)))
(setup-slots-needed! code-list)
code-list))
(define (linearize bbs)
(let ((code-queue (queue-empty)))
(define (put-bb bb)
(define (put-instr gvm-instr)
(queue-put! code-queue (make-code bb gvm-instr #f)))
(put-instr (bb-label-instr bb))
(for-each put-instr (bb-non-branch-instrs bb))
(put-instr (bb-branch-instr bb)))
(for-each put-bb (queue->list (bbs-bb-queue bbs)))
(queue->list code-queue)))
(define (setup-slots-needed! code-list)
(if (null? code-list)
#f
(let* ((code (car code-list))
(gvm-instr (code-gvm-instr code))
(sn-rest (setup-slots-needed! (cdr code-list))))
(case (gvm-instr-type gvm-instr)
((label)
(if (> sn-rest (frame-size (gvm-instr-frame gvm-instr)))
(compiler-internal-error
"setup-slots-needed!, incoherent slots needed for LABEL"))
(code-slots-needed-set! code sn-rest)
#f)
((ifjump jump)
(let ((sn (frame-size (gvm-instr-frame gvm-instr))))
(code-slots-needed-set! code sn)
(need-gvm-instr gvm-instr sn)))
(else
(code-slots-needed-set! code sn-rest)
(need-gvm-instr gvm-instr sn-rest))))))
(define (need-gvm-instrs non-branch branch)
(if (pair? non-branch)
(need-gvm-instr
(car non-branch)
(need-gvm-instrs (cdr non-branch) branch))
(need-gvm-instr branch (frame-size (gvm-instr-frame branch)))))
(define (need-gvm-instr gvm-instr sn-rest)
(case (gvm-instr-type gvm-instr)
((label) sn-rest)
((apply)
(let ((loc (apply-loc gvm-instr)))
(need-gvm-opnds
(apply-opnds gvm-instr)
(need-gvm-loc-opnd loc (need-gvm-loc loc sn-rest)))))
((copy)
(let ((loc (copy-loc gvm-instr)))
(need-gvm-opnd
(copy-opnd gvm-instr)
(need-gvm-loc-opnd loc (need-gvm-loc loc sn-rest)))))
((close)
(let ((parms (close-parms gvm-instr)))
(define (need-parms-opnds p)
(if (null? p)
sn-rest
(need-gvm-opnds
(closure-parms-opnds (car p))
(need-parms-opnds (cdr p)))))
(define (need-parms-loc p)
(if (null? p)
(need-parms-opnds parms)
(let ((loc (closure-parms-loc (car p))))
(need-gvm-loc-opnd
loc
(need-gvm-loc loc (need-parms-loc (cdr p)))))))
(need-parms-loc parms)))
((ifjump) (need-gvm-opnds (ifjump-opnds gvm-instr) sn-rest))
((jump) (need-gvm-opnd (jump-opnd gvm-instr) sn-rest))
(else
(compiler-internal-error
"need-gvm-instr, unknown 'gvm-instr':"
gvm-instr))))
(define (need-gvm-loc loc sn-rest)
(if (and loc (stk? loc) (>= (stk-num loc) sn-rest))
(- (stk-num loc) 1)
sn-rest))
(define (need-gvm-loc-opnd gvm-loc slots-needed)
(if (and gvm-loc (clo? gvm-loc))
(need-gvm-opnd (clo-base gvm-loc) slots-needed)
slots-needed))
(define (need-gvm-opnd gvm-opnd slots-needed)
(cond ((stk? gvm-opnd) (max (stk-num gvm-opnd) slots-needed))
((clo? gvm-opnd) (need-gvm-opnd (clo-base gvm-opnd) slots-needed))
(else slots-needed)))
(define (need-gvm-opnds gvm-opnds slots-needed)
(if (null? gvm-opnds)
slots-needed
(need-gvm-opnd
(car gvm-opnds)
(need-gvm-opnds (cdr gvm-opnds) slots-needed))))
(define (write-bb bb port)
(write-gvm-instr (bb-label-instr bb) port)
(display " [precedents=" port)
(write (map bb-lbl-num (bb-precedents bb)) port)
(display "]" port)
(newline port)
(for-each
(lambda (x) (write-gvm-instr x port) (newline port))
(bb-non-branch-instrs bb))
(write-gvm-instr (bb-branch-instr bb) port))
(define (write-bbs bbs port)
(for-each
(lambda (bb)
(if (= (bb-lbl-num bb) (bbs-entry-lbl-num bbs))
(begin (display "**** Entry block:" port) (newline port)))
(write-bb bb port)
(newline port))
(queue->list (bbs-bb-queue bbs))))
(define (virtual.dump proc port)
(let ((proc-seen (queue-empty)) (proc-left (queue-empty)))
(define (scan-opnd gvm-opnd)
(cond ((obj? gvm-opnd)
(let ((val (obj-val gvm-opnd)))
(if (and (proc-obj? val)
(proc-obj-code val)
(not (memq val (queue->list proc-seen))))
(begin
(queue-put! proc-seen val)
(queue-put! proc-left val)))))
((clo? gvm-opnd) (scan-opnd (clo-base gvm-opnd)))))
(define (dump-proc p)
(define (scan-code code)
(let ((gvm-instr (code-gvm-instr code)))
(write-gvm-instr gvm-instr port)
(newline port)
(case (gvm-instr-type gvm-instr)
((apply)
(for-each scan-opnd (apply-opnds gvm-instr))
(if (apply-loc gvm-instr) (scan-opnd (apply-loc gvm-instr))))
((copy)
(scan-opnd (copy-opnd gvm-instr))
(scan-opnd (copy-loc gvm-instr)))
((close)
(for-each
(lambda (parms)
(scan-opnd (closure-parms-loc parms))
(for-each scan-opnd (closure-parms-opnds parms)))
(close-parms gvm-instr)))
((ifjump) (for-each scan-opnd (ifjump-opnds gvm-instr)))
((jump) (scan-opnd (jump-opnd gvm-instr)))
(else '()))))
(if (proc-obj-primitive? p)
(display "**** #[primitive " port)
(display "**** #[procedure " port))
(display (proc-obj-name p) port)
(display "] =" port)
(newline port)
(let loop ((l (bbs->code-list (proc-obj-code p)))
(prev-filename "")
(prev-line 0))
(if (pair? l)
(let* ((code (car l))
(instr (code-gvm-instr code))
(src (comment-get (gvm-instr-comment instr) 'source))
(loc (and src (source-locat src)))
(filename
(if (and loc (eq? (vector-ref loc 0) 'file))
(vector-ref loc 1)
prev-filename))
(line (if (and loc (eq? (vector-ref loc 0) 'file))
(vector-ref loc 3)
prev-line)))
(if (or (not (string=? filename prev-filename))
(not (= line prev-line)))
(begin
(display "#line " port)
(display line port)
(if (not (string=? filename prev-filename))
(begin (display " " port) (write filename port)))
(newline port)))
(scan-code code)
(loop (cdr l) filename line))
(newline port))))
(scan-opnd (make-obj proc))
(let loop ()
(if (not (queue-empty? proc-left))
(begin (dump-proc (queue-get! proc-left)) (loop))))))
(define (write-gvm-instr gvm-instr port)
(define (write-closure-parms parms)
(display " " port)
(let ((len (+ 1 (write-gvm-opnd (closure-parms-loc parms) port))))
(display " = (" port)
(let ((len (+ len (+ 4 (write-gvm-lbl (closure-parms-lbl parms) port)))))
(+ len
(write-terminated-opnd-list (closure-parms-opnds parms) port)))))
(define (write-terminated-opnd-list l port)
(let loop ((l l) (len 0))
(if (pair? l)
(let ((opnd (car l)))
(display " " port)
(loop (cdr l) (+ len (+ 1 (write-gvm-opnd opnd port)))))
(begin (display ")" port) (+ len 1)))))
(define (write-param-pattern gvm-instr port)
(let ((len (if (not (= (label-entry-min gvm-instr)
(label-entry-nb-parms gvm-instr)))
(let ((len (write-returning-len
(label-entry-min gvm-instr)
port)))
(display "-" port)
(+ len 1))
0)))
(let ((len (+ len
(write-returning-len
(label-entry-nb-parms gvm-instr)
port))))
(if (label-entry-rest? gvm-instr)
(begin (display "+" port) (+ len 1))
len))))
(define (write-prim-applic prim opnds port)
(display "(" port)
(let ((len (+ 1 (display-returning-len (proc-obj-name prim) port))))
(+ len (write-terminated-opnd-list opnds port))))
(define (write-instr gvm-instr)
(case (gvm-instr-type gvm-instr)
((label)
(let ((len (write-gvm-lbl (label-lbl-num gvm-instr) port)))
(display " " port)
(let ((len (+ len
(+ 1
(write-returning-len
(frame-size (gvm-instr-frame gvm-instr))
port)))))
(case (label-type gvm-instr)
((simple) len)
((entry)
(if (label-entry-closed? gvm-instr)
(begin
(display " closure-entry-point " port)
(+ len (+ 21 (write-param-pattern gvm-instr port))))
(begin
(display " entry-point " port)
(+ len (+ 13 (write-param-pattern gvm-instr port))))))
((return) (display " return-point" port) (+ len 13))
((task-entry) (display " task-entry-point" port) (+ len 17))
((task-return) (display " task-return-point" port) (+ len 18))
(else
(compiler-internal-error
"write-gvm-instr, unknown label type"))))))
((apply)
(display " " port)
(let ((len (+ 2
(if (apply-loc gvm-instr)
(let ((len (write-gvm-opnd
(apply-loc gvm-instr)
port)))
(display " = " port)
(+ len 3))
0))))
(+ len
(write-prim-applic
(apply-prim gvm-instr)
(apply-opnds gvm-instr)
port))))
((copy)
(display " " port)
(let ((len (+ 2 (write-gvm-opnd (copy-loc gvm-instr) port))))
(display " = " port)
(+ len (+ 3 (write-gvm-opnd (copy-opnd gvm-instr) port)))))
((close)
(display " close" port)
(let ((len (+ 7 (write-closure-parms (car (close-parms gvm-instr))))))
(let loop ((l (cdr (close-parms gvm-instr))) (len len))
(if (pair? l)
(let ((x (car l)))
(display "," port)
(loop (cdr l) (+ len (+ 1 (write-closure-parms x)))))
len))))
((ifjump)
(display " if " port)
(let ((len (+ 5
(write-prim-applic
(ifjump-test gvm-instr)
(ifjump-opnds gvm-instr)
port))))
(let ((len (+ len
(if (ifjump-poll? gvm-instr)
(begin (display " jump* " port) 7)
(begin (display " jump " port) 6)))))
(let ((len (+ len
(write-returning-len
(frame-size (gvm-instr-frame gvm-instr))
port))))
(display " " port)
(let ((len (+ len
(+ 1
(write-gvm-lbl (ifjump-true gvm-instr) port)))))
(display " else " port)
(+ len (+ 6 (write-gvm-lbl (ifjump-false gvm-instr) port))))))))
((jump)
(display " " port)
(let ((len (+ 2
(if (jump-poll? gvm-instr)
(begin (display "jump* " port) 6)
(begin (display "jump " port) 5)))))
(let ((len (+ len
(write-returning-len
(frame-size (gvm-instr-frame gvm-instr))
port))))
(display " " port)
(let ((len (+ len
(+ 1 (write-gvm-opnd (jump-opnd gvm-instr) port)))))
(+ len
(if (jump-nb-args gvm-instr)
(begin
(display " " port)
(+ 1
(write-returning-len (jump-nb-args gvm-instr) port)))
0))))))
(else
(compiler-internal-error
"write-gvm-instr, unknown 'gvm-instr':"
gvm-instr))))
(define (spaces n)
(if (> n 0)
(if (> n 7)
(begin (display " " port) (spaces (- n 8)))
(begin (display " " port) (spaces (- n 1))))))
(let ((len (write-instr gvm-instr)))
(spaces (- 40 len))
(display " " port)
(write-frame (gvm-instr-frame gvm-instr) port))
(let ((x (gvm-instr-comment gvm-instr)))
(if x
(let ((y (comment-get x 'text)))
(if y (begin (display " ; " port) (display y port)))))))
(define (write-frame frame port)
(define (write-var var opnd sep)
(display sep port)
(write-gvm-opnd opnd port)
(if var
(begin
(display "=" port)
(cond ((eq? var closure-env-var)
(write (map (lambda (var) (var-name var))
(frame-closed frame))
port))
((eq? var ret-var) (display "#" port))
((temp-var? var) (display "." port))
(else (write (var-name var) port))))))
(define (live? var)
(let ((live (frame-live frame)))
(or (set-member? var live)
(and (eq? var closure-env-var)
(not (set-empty?
(set-intersection
live
(list->set (frame-closed frame)))))))))
(let loop1 ((i 1) (l (reverse (frame-slots frame))) (sep "; "))
(if (pair? l)
(let ((var (car l)))
(write-var (if (live? var) var #f) (make-stk i) sep)
(loop1 (+ i 1) (cdr l) " "))
(let loop2 ((i 0) (l (frame-regs frame)) (sep sep))
(if (pair? l)
(let ((var (car l)))
(if (live? var)
(begin
(write-var var (make-reg i) sep)
(loop2 (+ i 1) (cdr l) " "))
(loop2 (+ i 1) (cdr l) sep))))))))
(define (write-gvm-opnd gvm-opnd port)
(define (write-opnd)
(cond ((reg? gvm-opnd)
(display "+" port)
(+ 1 (write-returning-len (reg-num gvm-opnd) port)))
((stk? gvm-opnd)
(display "-" port)
(+ 1 (write-returning-len (stk-num gvm-opnd) port)))
((glo? gvm-opnd) (write-returning-len (glo-name gvm-opnd) port))
((clo? gvm-opnd)
(let ((len (write-gvm-opnd (clo-base gvm-opnd) port)))
(display "(" port)
(let ((len (+ len
(+ 1
(write-returning-len
(clo-index gvm-opnd)
port)))))
(display ")" port)
(+ len 1))))
((lbl? gvm-opnd) (write-gvm-lbl (lbl-num gvm-opnd) port))
((obj? gvm-opnd)
(display "'" port)
(+ (write-gvm-obj (obj-val gvm-opnd) port) 1))
(else
(compiler-internal-error
"write-gvm-opnd, unknown 'gvm-opnd':"
gvm-opnd))))
(write-opnd))
(define (write-gvm-lbl lbl port)
(display "#" port)
(+ (write-returning-len lbl port) 1))
(define (write-gvm-obj val port)
(cond ((false-object? val) (display "#f" port) 2)
((undef-object? val) (display "#[undefined]" port) 12)
((proc-obj? val)
(if (proc-obj-primitive? val)
(display "#[primitive " port)
(display "#[procedure " port))
(let ((len (display-returning-len (proc-obj-name val) port)))
(display "]" port)
(+ len 13)))
(else (write-returning-len val port))))
(define (virtual.begin!)
(set! *opnd-table* (make-vector opnd-table-size))
(set! *opnd-table-alloc* 0)
'())
(define (virtual.end!) (set! *opnd-table* '()) '())
(define (make-target version name)
(define current-target-version 4)
(if (not (= version current-target-version))
(compiler-internal-error
"make-target, version of target package is not current"
name))
(let ((x (make-vector 11))) (vector-set! x 1 name) x))
(define (target-name x) (vector-ref x 1))
(define (target-begin! x) (vector-ref x 2))
(define (target-begin!-set! x y) (vector-set! x 2 y))
(define (target-end! x) (vector-ref x 3))
(define (target-end!-set! x y) (vector-set! x 3 y))
(define (target-dump x) (vector-ref x 4))
(define (target-dump-set! x y) (vector-set! x 4 y))
(define (target-nb-regs x) (vector-ref x 5))
(define (target-nb-regs-set! x y) (vector-set! x 5 y))
(define (target-prim-info x) (vector-ref x 6))
(define (target-prim-info-set! x y) (vector-set! x 6 y))
(define (target-label-info x) (vector-ref x 7))
(define (target-label-info-set! x y) (vector-set! x 7 y))
(define (target-jump-info x) (vector-ref x 8))
(define (target-jump-info-set! x y) (vector-set! x 8 y))
(define (target-proc-result x) (vector-ref x 9))
(define (target-proc-result-set! x y) (vector-set! x 9 y))
(define (target-task-return x) (vector-ref x 10))
(define (target-task-return-set! x y) (vector-set! x 10 y))
(define targets-loaded '())
(define (get-target name)
(let ((x (assq name targets-loaded)))
(if x (cdr x) (compiler-error "Target package is not available" name))))
(define (put-target targ)
(let* ((name (target-name targ)) (x (assq name targets-loaded)))
(if x
(set-cdr! x targ)
(set! targets-loaded (cons (cons name targ) targets-loaded)))
'()))
(define (default-target)
(if (null? targets-loaded)
(compiler-error "No target package is available")
(car (car targets-loaded))))
(define (select-target! name info-port)
(set! target (get-target name))
((target-begin! target) info-port)
(set! target.dump (target-dump target))
(set! target.nb-regs (target-nb-regs target))
(set! target.prim-info (target-prim-info target))
(set! target.label-info (target-label-info target))
(set! target.jump-info (target-jump-info target))
(set! target.proc-result (target-proc-result target))
(set! target.task-return (target-task-return target))
(set! **not-proc-obj (target.prim-info **not-sym))
'())
(define (unselect-target!) ((target-end! target)) '())
(define target '())
(define target.dump '())
(define target.nb-regs '())
(define target.prim-info '())
(define target.label-info '())
(define target.jump-info '())
(define target.proc-result '())
(define target.task-return '())
(define **not-proc-obj '())
(define (target.specialized-prim-info* name decl)
(let ((x (target.prim-info* name decl)))
(and x ((proc-obj-specialize x) decl))))
(define (target.prim-info* name decl)
(and (if (standard-procedure name decl)
(standard-binding? name decl)
(extended-binding? name decl))
(target.prim-info name)))
(define generic-sym (string->canonical-symbol "GENERIC"))
(define fixnum-sym (string->canonical-symbol "FIXNUM"))
(define flonum-sym (string->canonical-symbol "FLONUM"))
(define-namable-decl generic-sym 'arith)
(define-namable-decl fixnum-sym 'arith)
(define-namable-decl flonum-sym 'arith)
(define (arith-implementation name decls)
(declaration-value 'arith name generic-sym decls))
(define (cf source target-name . opts)
(let* ((dest (file-root source))
(module-name (file-name dest))
(info-port (if (memq 'verbose opts) (current-output-port) #f))
(result (BENCH-compile-program
(list **include-sym source)
(if target-name target-name (default-target))
opts
module-name
dest
info-port)))
(if (and info-port (not (eq? info-port (current-output-port))))
(close-output-port info-port))
result))
(define (ce source target-name . opts)
(let* ((dest "program")
(module-name "program")
(info-port (if (memq 'verbose opts) (current-output-port) #f))
(result (BENCH-compile-program
source
(if target-name target-name (default-target))
opts
module-name
dest
info-port)))
(if (and info-port (not (eq? info-port (current-output-port))))
(close-output-port info-port))
result))
(define wrap-program #f)
(set! wrap-program (lambda (program) program))
(define (BENCH-compile-program program target-name opts module-name dest info-port)
(define (compiler-body)
(if (not (valid-module-name? module-name))
(compiler-error
"Invalid characters in file name (must be a symbol with no \"#\")")
(begin
(ptree.begin! info-port)
(virtual.begin!)
(select-target! target-name info-port)
(parse-program
(list (expression->source (wrap-program program) #f))
(make-global-environment)
module-name
(lambda (lst env c-intf)
(let ((parsed-program
(map (lambda (x) (normalize-parse-tree (car x) (cdr x)))
lst)))
(if (memq 'expansion opts)
(let ((port (current-output-port)))
(display "Expansion:" port)
(newline port)
(let loop ((l parsed-program))
(if (pair? l)
(let ((ptree (car l)))
(pp-expression
(parse-tree->expression ptree)
port)
(loop (cdr l)))))
(newline port)))
(let ((module-init-proc
(compile-parsed-program
module-name
parsed-program
env
c-intf
info-port)))
(if (memq 'report opts) (generate-report env))
(if (memq 'gvm opts)
(let ((gvm-port
(open-output-file (string-append dest ".gvm"))))
(virtual.dump module-init-proc gvm-port)
(close-output-port gvm-port)))
(target.dump module-init-proc dest c-intf opts)
(dump-c-intf module-init-proc dest c-intf)))))
(unselect-target!)
(virtual.end!)
(ptree.end!)
#t)))
(let ((successful (with-exception-handling compiler-body)))
(if info-port
(if successful
(begin
(display "Compilation finished." info-port)
(newline info-port))
(begin
(display "Compilation terminated abnormally." info-port)
(newline info-port))))
successful))
(define (valid-module-name? module-name)
(define (valid-char? c)
(and (not (memv c
'(#\#
#\;
#\(
#\)
#\space
#\[
#\]
#\{
#\}
#\"
#\'
#\`
#\,)))
(not (char-whitespace? c))))
(let ((n (string-length module-name)))
(and (> n 0)
(not (string=? module-name "."))
(not (string->number module-name 10))
(let loop ((i 0))
(if (< i n)
(if (valid-char? (string-ref module-name i)) (loop (+ i 1)) #f)
#t)))))
(define (dump-c-intf module-init-proc dest c-intf)
(let ((decls (c-intf-decls c-intf))
(procs (c-intf-procs c-intf))
(inits (c-intf-inits c-intf)))
(if (or (not (null? decls)) (not (null? procs)) (not (null? inits)))
(let* ((module-name (proc-obj-name module-init-proc))
(filename (string-append dest ".c"))
(port (open-output-file filename)))
(display "/* File: \"" port)
(display filename port)
(display "\", C-interface file produced by Gambit " port)
(display compiler-version port)
(display " */" port)
(newline port)
(display "#define " port)
(display c-id-prefix port)
(display "MODULE_NAME \"" port)
(display module-name port)
(display "\"" port)
(newline port)
(display "#define " port)
(display c-id-prefix port)
(display "MODULE_LINKER " port)
(display c-id-prefix port)
(display (scheme-id->c-id module-name) port)
(newline port)
(display "#define " port)
(display c-id-prefix port)
(display "VERSION \"" port)
(display compiler-version port)
(display "\"" port)
(newline port)
(if (not (null? procs))
(begin
(display "#define " port)
(display c-id-prefix port)
(display "C_PRC_COUNT " port)
(display (length procs) port)
(newline port)))
(display "#include \"gambit.h\"" port)
(newline port)
(display c-id-prefix port)
(display "BEGIN_MODULE" port)
(newline port)
(for-each
(lambda (x)
(let ((scheme-name (vector-ref x 0)))
(display c-id-prefix port)
(display "SUPPLY_PRM(" port)
(display c-id-prefix port)
(display "P_" port)
(display (scheme-id->c-id scheme-name) port)
(display ")" port)
(newline port)))
procs)
(newline port)
(for-each (lambda (x) (display x port) (newline port)) decls)
(if (not (null? procs))
(begin
(for-each
(lambda (x)
(let ((scheme-name (vector-ref x 0))
(c-name (vector-ref x 1))
(arity (vector-ref x 2))
(def (vector-ref x 3)))
(display c-id-prefix port)
(display "BEGIN_C_COD(" port)
(display c-name port)
(display "," port)
(display c-id-prefix port)
(display "P_" port)
(display (scheme-id->c-id scheme-name) port)
(display "," port)
(display arity port)
(display ")" port)
(newline port)
(display "#undef ___ARG1" port)
(newline port)
(display "#define ___ARG1 ___R1" port)
(newline port)
(display "#undef ___ARG2" port)
(newline port)
(display "#define ___ARG2 ___R2" port)
(newline port)
(display "#undef ___ARG3" port)
(newline port)
(display "#define ___ARG3 ___R3" port)
(newline port)
(display "#undef ___RESULT" port)
(newline port)
(display "#define ___RESULT ___R1" port)
(newline port)
(display def port)
(display c-id-prefix port)
(display "END_C_COD" port)
(newline port)))
procs)
(newline port)
(display c-id-prefix port)
(display "BEGIN_C_PRC" port)
(newline port)
(let loop ((i 0) (lst procs))
(if (not (null? lst))
(let* ((x (car lst))
(scheme-name (vector-ref x 0))
(c-name (vector-ref x 1))
(arity (vector-ref x 2)))
(if (= i 0) (display " " port) (display "," port))
(display c-id-prefix port)
(display "DEF_C_PRC(" port)
(display c-name port)
(display "," port)
(display c-id-prefix port)
(display "P_" port)
(display (scheme-id->c-id scheme-name) port)
(display "," port)
(display arity port)
(display ")" port)
(newline port)
(loop (+ i 1) (cdr lst)))))
(display c-id-prefix port)
(display "END_C_PRC" port)
(newline port)))
(newline port)
(display c-id-prefix port)
(display "BEGIN_PRM" port)
(newline port)
(for-each (lambda (x) (display x port) (newline port)) inits)
(display c-id-prefix port)
(display "END_PRM" port)
(newline port)
(close-output-port port)))))
(define (generate-report env)
(let ((vars (sort-variables (env-global-variables env)))
(decl (env-declarations env)))
(define (report title pred? vars wrote-something?)
(if (pair? vars)
(let ((var (car vars)))
(if (pred? var)
(begin
(if (not wrote-something?)
(begin (display " ") (display title) (newline)))
(let loop1 ((l (var-refs var)) (r? #f) (c? #f))
(if (pair? l)
(let* ((x (car l)) (y (node-parent x)))
(if (and y (app? y) (eq? x (app-oper y)))
(loop1 (cdr l) r? #t)
(loop1 (cdr l) #t c?)))
(let loop2 ((l (var-sets var)) (d? #f) (a? #f))
(if (pair? l)
(if (set? (car l))
(loop2 (cdr l) d? #t)
(loop2 (cdr l) #t a?))
(begin
(display " [")
(if d? (display "D") (display " "))
(if a? (display "A") (display " "))
(if r? (display "R") (display " "))
(if c? (display "C") (display " "))
(display "] ")
(display (var-name var))
(newline))))))
(report title pred? (cdr vars) #t))
(cons (car vars)
(report title pred? (cdr vars) wrote-something?))))
(begin (if wrote-something? (newline)) '())))
(display "Global variable usage:")
(newline)
(newline)
(report "OTHERS"
(lambda (x) #t)
(report "EXTENDED"
(lambda (x) (target.prim-info (var-name x)))
(report "STANDARD"
(lambda (x) (standard-procedure (var-name x) decl))
vars
#f)
#f)
#f)))
(define (compile-parsed-program module-name program env c-intf info-port)
(if info-port (display "Compiling:" info-port))
(set! trace-indentation 0)
(set! *bbs* (make-bbs))
(set! *global-env* env)
(set! proc-queue '())
(set! constant-vars '())
(set! known-procs '())
(restore-context (make-context 0 '() (list ret-var) '() (entry-poll) #f))
(let* ((entry-lbl (bbs-new-lbl! *bbs*))
(body-lbl (bbs-new-lbl! *bbs*))
(frame (current-frame ret-var-set))
(comment (if (null? program) #f (source-comment (car program)))))
(bbs-entry-lbl-num-set! *bbs* entry-lbl)
(set! entry-bb
(make-bb (make-label-entry entry-lbl 0 0 #f #f frame comment) *bbs*))
(bb-put-branch! entry-bb (make-jump (make-lbl body-lbl) #f #f frame #f))
(set! *bb* (make-bb (make-label-simple body-lbl frame comment) *bbs*))
(let loop1 ((l (c-intf-procs c-intf)))
(if (not (null? l))
(let* ((x (car l))
(name (vector-ref x 0))
(sym (string->canonical-symbol name))
(var (env-lookup-global-var *global-env* sym)))
(add-constant-var
var
(make-obj (make-proc-obj name #t #f 0 #t '() '(#f))))
(loop1 (cdr l)))))
(let loop2 ((l program))
(if (not (null? l))
(let ((node (car l)))
(if (def? node)
(let* ((var (def-var node)) (val (global-val var)))
(if (and val (prc? val))
(add-constant-var
var
(make-obj
(make-proc-obj
(symbol->string (var-name var))
#t
#f
(call-pattern val)
#t
'()
'(#f)))))))
(loop2 (cdr l)))))
(let loop3 ((l program))
(if (null? l)
(let ((ret-opnd (var->opnd ret-var)))
(seal-bb #t 'return)
(dealloc-slots nb-slots)
(bb-put-branch!
*bb*
(make-jump ret-opnd #f #f (current-frame (set-empty)) #f)))
(let ((node (car l)))
(if (def? node)
(begin
(gen-define (def-var node) (def-val node) info-port)
(loop3 (cdr l)))
(if (null? (cdr l))
(gen-node node ret-var-set 'tail)
(begin
(gen-node node ret-var-set 'need)
(loop3 (cdr l))))))))
(let loop4 ()
(if (pair? proc-queue)
(let ((x (car proc-queue)))
(set! proc-queue (cdr proc-queue))
(gen-proc (car x) (cadr x) (caddr x) info-port)
(trace-unindent info-port)
(loop4))))
(if info-port (begin (newline info-port) (newline info-port)))
(bbs-purify! *bbs*)
(let ((proc (make-proc-obj
(string-append "#!" module-name)
#t
*bbs*
'(0)
#t
'()
'(#f))))
(set! *bb* '())
(set! *bbs* '())
(set! *global-env* '())
(set! proc-queue '())
(set! constant-vars '())
(set! known-procs '())
(clear-context)
proc)))
(define *bb* '())
(define *bbs* '())
(define *global-env* '())
(define proc-queue '())
(define constant-vars '())
(define known-procs '())
(define trace-indentation '())
(define (trace-indent info-port)
(set! trace-indentation (+ trace-indentation 1))
(if info-port
(begin
(newline info-port)
(let loop ((i trace-indentation))
(if (> i 0) (begin (display " " info-port) (loop (- i 1))))))))
(define (trace-unindent info-port)
(set! trace-indentation (- trace-indentation 1)))
(define (gen-define var node info-port)
(if (prc? node)
(let* ((p-bbs *bbs*)
(p-bb *bb*)
(p-proc-queue proc-queue)
(p-known-procs known-procs)
(p-context (current-context))
(bbs (make-bbs))
(lbl1 (bbs-new-lbl! bbs))
(lbl2 (bbs-new-lbl! bbs))
(context (entry-context node '()))
(frame (context->frame
context
(set-union (free-variables (prc-body node)) ret-var-set)))
(bb1 (make-bb (make-label-entry
lbl1
(length (prc-parms node))
(prc-min node)
(prc-rest node)
#f
frame
(source-comment node))
bbs))
(bb2 (make-bb (make-label-simple lbl2 frame (source-comment node))
bbs)))
(define (do-body)
(gen-proc node bb2 context info-port)
(let loop ()
(if (pair? proc-queue)
(let ((x (car proc-queue)))
(set! proc-queue (cdr proc-queue))
(gen-proc (car x) (cadr x) (caddr x) info-port)
(trace-unindent info-port)
(loop))))
(trace-unindent info-port)
(bbs-purify! *bbs*))
(context-entry-bb-set! context bb1)
(bbs-entry-lbl-num-set! bbs lbl1)
(bb-put-branch! bb1 (make-jump (make-lbl lbl2) #f #f frame #f))
(set! *bbs* bbs)
(set! proc-queue '())
(set! known-procs '())
(if (constant-var? var)
(let-constant-var
var
(make-lbl lbl1)
(lambda () (add-known-proc lbl1 node) (do-body)))
(do-body))
(set! *bbs* p-bbs)
(set! *bb* p-bb)
(set! proc-queue p-proc-queue)
(set! known-procs p-known-procs)
(restore-context p-context)
(let* ((x (assq var constant-vars))
(proc (if x
(let ((p (cdr x)))
(proc-obj-code-set! (obj-val p) bbs)
p)
(make-obj
(make-proc-obj
(symbol->string (var-name var))
#f
bbs
(call-pattern node)
#t
'()
'(#f))))))
(put-copy
proc
(make-glo (var-name var))
#f
ret-var-set
(source-comment node))))
(put-copy
(gen-node node ret-var-set 'need)
(make-glo (var-name var))
#f
ret-var-set
(source-comment node))))
(define (call-pattern node)
(make-pattern (prc-min node) (length (prc-parms node)) (prc-rest node)))
(define (make-context nb-slots slots regs closed poll entry-bb)
(vector nb-slots slots regs closed poll entry-bb))
(define (context-nb-slots x) (vector-ref x 0))
(define (context-slots x) (vector-ref x 1))
(define (context-regs x) (vector-ref x 2))
(define (context-closed x) (vector-ref x 3))
(define (context-poll x) (vector-ref x 4))
(define (context-entry-bb x) (vector-ref x 5))
(define (context-entry-bb-set! x y) (vector-set! x 5 y))
(define nb-slots '())
(define slots '())
(define regs '())
(define closed '())
(define poll '())
(define entry-bb '())
(define (restore-context context)
(set! nb-slots (context-nb-slots context))
(set! slots (context-slots context))
(set! regs (context-regs context))
(set! closed (context-closed context))
(set! poll (context-poll context))
(set! entry-bb (context-entry-bb context)))
(define (clear-context)
(restore-context (make-context '() '() '() '() '() '())))
(define (current-context)
(make-context nb-slots slots regs closed poll entry-bb))
(define (current-frame live) (make-frame nb-slots slots regs closed live))
(define (context->frame context live)
(make-frame
(context-nb-slots context)
(context-slots context)
(context-regs context)
(context-closed context)
live))
(define (make-poll since-entry? delta) (cons since-entry? delta))
(define (poll-since-entry? x) (car x))
(define (poll-delta x) (cdr x))
(define (entry-poll) (make-poll #f (- poll-period poll-head)))
(define (return-poll poll)
(let ((delta (poll-delta poll)))
(make-poll (poll-since-entry? poll) (+ poll-head (max delta poll-tail)))))
(define (poll-merge poll other-poll)
(make-poll
(or (poll-since-entry? poll) (poll-since-entry? other-poll))
(max (poll-delta poll) (poll-delta other-poll))))
(define poll-period #f)
(set! poll-period 90)
(define poll-head #f)
(set! poll-head 15)
(define poll-tail #f)
(set! poll-tail 15)
(define (entry-context proc closed)
(define (empty-vars-list n)
(if (> n 0) (cons empty-var (empty-vars-list (- n 1))) '()))
(let* ((parms (prc-parms proc))
(pc (target.label-info
(prc-min proc)
(length parms)
(prc-rest proc)
(not (null? closed))))
(fs (pcontext-fs pc))
(slots-list (empty-vars-list fs))
(regs-list (empty-vars-list target.nb-regs)))
(define (assign-var-to-loc var loc)
(let ((x (cond ((reg? loc)
(let ((i (reg-num loc)))
(if (<= i target.nb-regs)
(nth-after regs-list i)
(compiler-internal-error
"entry-context, reg out of bound in back-end's pcontext"))))
((stk? loc)
(let ((i (stk-num loc)))
(if (<= i fs)
(nth-after slots-list (- fs i))
(compiler-internal-error
"entry-context, stk out of bound in back-end's pcontext"))))
(else
(compiler-internal-error
"entry-context, loc other than reg or stk in back-end's pcontext")))))
(if (eq? (car x) empty-var)
(set-car! x var)
(compiler-internal-error
"entry-context, duplicate location in back-end's pcontext"))))
(let loop ((l (pcontext-map pc)))
(if (not (null? l))
(let* ((couple (car l)) (name (car couple)) (loc (cdr couple)))
(cond ((eq? name 'return) (assign-var-to-loc ret-var loc))
((eq? name 'closure-env)
(assign-var-to-loc closure-env-var loc))
(else (assign-var-to-loc (list-ref parms (- name 1)) loc)))
(loop (cdr l)))))
(make-context fs slots-list regs-list closed (entry-poll) #f)))
(define (get-var opnd)
(cond ((glo? opnd) (env-lookup-global-var *global-env* (glo-name opnd)))
((reg? opnd) (list-ref regs (reg-num opnd)))
((stk? opnd) (list-ref slots (- nb-slots (stk-num opnd))))
(else
(compiler-internal-error
"get-var, location must be global, register or stack slot"))))
(define (put-var opnd new)
(define (put-v opnd new)
(cond ((reg? opnd) (set! regs (replace-nth regs (reg-num opnd) new)))
((stk? opnd)
(set! slots (replace-nth slots (- nb-slots (stk-num opnd)) new)))
(else
(compiler-internal-error
"put-var, location must be register or stack slot, for var:"
(var-name new)))))
(if (eq? new ret-var)
(let ((x (var->opnd ret-var))) (and x (put-v x empty-var))))
(put-v opnd new))
(define (flush-regs) (set! regs '()))
(define (push-slot)
(set! nb-slots (+ nb-slots 1))
(set! slots (cons empty-var slots)))
(define (dealloc-slots n)
(set! nb-slots (- nb-slots n))
(set! slots (nth-after slots n)))
(define (pop-slot) (dealloc-slots 1))
(define (replace-nth l i v)
(if (null? l)
(if (= i 0) (list v) (cons empty-var (replace-nth l (- i 1) v)))
(if (= i 0)
(cons v (cdr l))
(cons (car l) (replace-nth (cdr l) (- i 1) v)))))
(define (live-vars live)
(if (not (set-empty? (set-intersection live (list->set closed))))
(set-adjoin live closure-env-var)
live))
(define (dead-slots live)
(let ((live-v (live-vars live)))
(define (loop s l i)
(cond ((null? l) (list->set (reverse s)))
((set-member? (car l) live-v) (loop s (cdr l) (- i 1)))
(else (loop (cons i s) (cdr l) (- i 1)))))
(loop '() slots nb-slots)))
(define (live-slots live)
(let ((live-v (live-vars live)))
(define (loop s l i)
(cond ((null? l) (list->set (reverse s)))
((set-member? (car l) live-v) (loop (cons i s) (cdr l) (- i 1)))
(else (loop s (cdr l) (- i 1)))))
(loop '() slots nb-slots)))
(define (dead-regs live)
(let ((live-v (live-vars live)))
(define (loop s l i)
(cond ((>= i target.nb-regs) (list->set (reverse s)))
((null? l) (loop (cons i s) l (+ i 1)))
((and (set-member? (car l) live-v) (not (memq (car l) slots)))
(loop s (cdr l) (+ i 1)))
(else (loop (cons i s) (cdr l) (+ i 1)))))
(loop '() regs 0)))
(define (live-regs live)
(let ((live-v (live-vars live)))
(define (loop s l i)
(cond ((null? l) (list->set (reverse s)))
((and (set-member? (car l) live-v) (not (memq (car l) slots)))
(loop (cons i s) (cdr l) (+ i 1)))
(else (loop s (cdr l) (+ i 1)))))
(loop '() regs 0)))
(define (lowest-dead-slot live)
(make-stk (or (lowest (dead-slots live)) (+ nb-slots 1))))
(define (highest-live-slot live) (make-stk (or (highest (live-slots live)) 0)))
(define (lowest-dead-reg live)
(let ((x (lowest (set-remove (dead-regs live) 0)))) (if x (make-reg x) #f)))
(define (highest-dead-reg live)
(let ((x (highest (dead-regs live)))) (if x (make-reg x) #f)))
(define (highest set) (if (set-empty? set) #f (apply max (set->list set))))
(define (lowest set) (if (set-empty? set) #f (apply min (set->list set))))
(define (above set n) (set-keep (lambda (x) (> x n)) set))
(define (below set n) (set-keep (lambda (x) (< x n)) set))
(define (var->opnd var)
(let ((x (assq var constant-vars)))
(if x
(cdr x)
(if (global? var)
(make-glo (var-name var))
(let ((n (pos-in-list var regs)))
(if n
(make-reg n)
(let ((n (pos-in-list var slots)))
(if n
(make-stk (- nb-slots n))
(let ((n (pos-in-list var closed)))
(if n
(make-clo (var->opnd closure-env-var) (+ n 1))
(compiler-internal-error
"var->opnd, variable is not accessible:"
(var-name var))))))))))))
(define (source-comment node)
(let ((x (make-comment))) (comment-put! x 'source (node-source node)) x))
(define (sort-variables lst)
(sort-list
lst
(lambda (x y)
(string<? (symbol->string (var-name x)) (symbol->string (var-name y))))))
(define (add-constant-var var opnd)
(set! constant-vars (cons (cons var opnd) constant-vars)))
(define (let-constant-var var opnd thunk)
(let* ((x (assq var constant-vars)) (temp (cdr x)))
(set-cdr! x opnd)
(thunk)
(set-cdr! x temp)))
(define (constant-var? var) (assq var constant-vars))
(define (not-constant-var? var) (not (constant-var? var)))
(define (add-known-proc label proc)
(set! known-procs (cons (cons label proc) known-procs)))
(define (gen-proc proc bb context info-port)
(trace-indent info-port)
(if info-port
(if (prc-name proc)
(display (prc-name proc) info-port)
(display "\"unknown\"" info-port)))
(let ((lbl (bb-lbl-num bb))
(live (set-union (free-variables (prc-body proc)) ret-var-set)))
(set! *bb* bb)
(restore-context context)
(gen-node (prc-body proc) ret-var-set 'tail)))
(define (schedule-gen-proc proc closed-list)
(let* ((lbl1 (bbs-new-lbl! *bbs*))
(lbl2 (bbs-new-lbl! *bbs*))
(context (entry-context proc closed-list))
(frame (context->frame
context
(set-union (free-variables (prc-body proc)) ret-var-set)))
(bb1 (make-bb (make-label-entry
lbl1
(length (prc-parms proc))
(prc-min proc)
(prc-rest proc)
(not (null? closed-list))
frame
(source-comment proc))
*bbs*))
(bb2 (make-bb (make-label-simple lbl2 frame (source-comment proc))
*bbs*)))
(context-entry-bb-set! context bb1)
(bb-put-branch! bb1 (make-jump (make-lbl lbl2) #f #f frame #f))
(set! proc-queue (cons (list proc bb2 context) proc-queue))
(make-lbl lbl1)))
(define (gen-node node live why)
(cond ((cst? node) (gen-return (make-obj (cst-val node)) why node))
((ref? node)
(let* ((var (ref-var node)) (name (var-name var)))
(gen-return
(cond ((eq? why 'side) (make-obj undef-object))
((global? var)
(let ((prim (target.prim-info* name (node-decl node))))
(if prim (make-obj prim) (var->opnd var))))
(else (var->opnd var)))
why
node)))
((set? node)
(let* ((src (gen-node
(set-val node)
(set-adjoin live (set-var node))
'keep))
(dst (var->opnd (set-var node))))
(put-copy src dst #f live (source-comment node))
(gen-return (make-obj undef-object) why node)))
((def? node)
(compiler-internal-error
"gen-node, 'def' node not at root of parse tree"))
((tst? node) (gen-tst node live why))
((conj? node) (gen-conj/disj node live why))
((disj? node) (gen-conj/disj node live why))
((prc? node)
(let* ((closed (not-constant-closed-vars node))
(closed-list (sort-variables (set->list closed)))
(proc-lbl (schedule-gen-proc node closed-list)))
(let ((opnd (if (null? closed-list)
(begin
(add-known-proc (lbl-num proc-lbl) node)
proc-lbl)
(begin
(dealloc-slots
(- nb-slots
(stk-num (highest-live-slot
(set-union closed live)))))
(push-slot)
(let ((slot (make-stk nb-slots))
(var (make-temp-var 'closure)))
(put-var slot var)
(bb-put-non-branch!
*bb*
(make-close
(list (make-closure-parms
slot
(lbl-num proc-lbl)
(map var->opnd closed-list)))
(current-frame (set-adjoin live var))
(source-comment node)))
slot)))))
(gen-return opnd why node))))
((app? node) (gen-call node live why))
((fut? node) (gen-fut node live why))
(else
(compiler-internal-error
"gen-node, unknown parse tree node type:"
node))))
(define (gen-return opnd why node)
(cond ((eq? why 'tail)
(let ((var (make-temp-var 'result)))
(put-copy
opnd
target.proc-result
var
ret-var-set
(source-comment node))
(let ((ret-opnd (var->opnd ret-var)))
(seal-bb (intrs-enabled? (node-decl node)) 'return)
(dealloc-slots nb-slots)
(bb-put-branch!
*bb*
(make-jump
ret-opnd
#f
#f
(current-frame (set-singleton var))
#f)))))
(else opnd)))
(define (not-constant-closed-vars val)
(set-keep not-constant-var? (free-variables val)))
(define (predicate node live cont)
(define (cont* true-lbl false-lbl) (cont false-lbl true-lbl))
(define (generic-true-test)
(predicate-test node live **not-proc-obj '0 (list node) cont*))
(cond ((or (conj? node) (disj? node)) (predicate-conj/disj node live cont))
((app? node)
(let ((proc (node->proc (app-oper node))))
(if proc
(let ((spec (specialize-for-call proc (node-decl node))))
(if (and (proc-obj-test spec)
(nb-args-conforms?
(length (app-args node))
(proc-obj-call-pat spec)))
(if (eq? spec **not-proc-obj)
(predicate (car (app-args node)) live cont*)
(predicate-test
node
live
spec
(proc-obj-strict-pat proc)
(app-args node)
cont))
(generic-true-test)))
(generic-true-test))))
(else (generic-true-test))))
(define (predicate-conj/disj node live cont)
(let* ((pre (if (conj? node) (conj-pre node) (disj-pre node)))
(alt (if (conj? node) (conj-alt node) (disj-alt node)))
(alt-live (set-union live (free-variables alt))))
(predicate
pre
alt-live
(lambda (true-lbl false-lbl)
(let ((pre-context (current-context)))
(set! *bb*
(make-bb (make-label-simple
(if (conj? node) true-lbl false-lbl)
(current-frame alt-live)
(source-comment alt))
*bbs*))
(predicate
alt
live
(lambda (true-lbl2 false-lbl2)
(let ((alt-context (current-context)))
(restore-context pre-context)
(set! *bb*
(make-bb (make-label-simple
(if (conj? node) false-lbl true-lbl)
(current-frame live)
(source-comment alt))
*bbs*))
(merge-contexts-and-seal-bb
alt-context
live
(intrs-enabled? (node-decl node))
'internal
(source-comment node))
(bb-put-branch!
*bb*
(make-jump
(make-lbl (if (conj? node) false-lbl2 true-lbl2))
#f
#f
(current-frame live)
#f))
(cont true-lbl2 false-lbl2)))))))))
(define (predicate-test node live test strict-pat args cont)
(let loop ((args* args) (liv live) (vars* '()))
(if (not (null? args*))
(let* ((needed (vals-live-vars liv (cdr args*)))
(var (save-var
(gen-node (car args*) needed 'need)
(make-temp-var 'predicate)
needed
(source-comment (car args*)))))
(loop (cdr args*) (set-adjoin liv var) (cons var vars*)))
(let* ((true-lbl (bbs-new-lbl! *bbs*))
(false-lbl (bbs-new-lbl! *bbs*)))
(seal-bb (intrs-enabled? (node-decl node)) 'internal)
(bb-put-branch!
*bb*
(make-ifjump
test
(map var->opnd (reverse vars*))
true-lbl
false-lbl
#f
(current-frame live)
(source-comment node)))
(cont true-lbl false-lbl)))))
(define (gen-tst node live why)
(let ((pre (tst-pre node)) (con (tst-con node)) (alt (tst-alt node)))
(predicate
pre
(set-union live (free-variables con) (free-variables alt))
(lambda (true-lbl false-lbl)
(let ((pre-context (current-context))
(true-bb (make-bb (make-label-simple
true-lbl
(current-frame
(set-union live (free-variables con)))
(source-comment con))
*bbs*))
(false-bb
(make-bb (make-label-simple
false-lbl
(current-frame (set-union live (free-variables alt)))
(source-comment alt))
*bbs*)))
(set! *bb* true-bb)
(let ((con-opnd (gen-node con live why)))
(if (eq? why 'tail)
(begin
(restore-context pre-context)
(set! *bb* false-bb)
(gen-node alt live why))
(let* ((result-var (make-temp-var 'result))
(live-after (set-adjoin live result-var)))
(save-opnd-to-reg
con-opnd
target.proc-result
result-var
live
(source-comment con))
(let ((con-context (current-context)) (con-bb *bb*))
(restore-context pre-context)
(set! *bb* false-bb)
(save-opnd-to-reg
(gen-node alt live why)
target.proc-result
result-var
live
(source-comment alt))
(let ((next-lbl (bbs-new-lbl! *bbs*)) (alt-bb *bb*))
(if (> (context-nb-slots con-context) nb-slots)
(begin
(seal-bb (intrs-enabled? (node-decl node))
'internal)
(let ((alt-context (current-context)))
(restore-context con-context)
(set! *bb* con-bb)
(merge-contexts-and-seal-bb
alt-context
live-after
(intrs-enabled? (node-decl node))
'internal
(source-comment node))))
(let ((alt-context (current-context)))
(restore-context con-context)
(set! *bb* con-bb)
(seal-bb (intrs-enabled? (node-decl node))
'internal)
(let ((con-context* (current-context)))
(restore-context alt-context)
(set! *bb* alt-bb)
(merge-contexts-and-seal-bb
con-context*
live-after
(intrs-enabled? (node-decl node))
'internal
(source-comment node)))))
(let ((frame (current-frame live-after)))
(bb-put-branch!
con-bb
(make-jump (make-lbl next-lbl) #f #f frame #f))
(bb-put-branch!
alt-bb
(make-jump (make-lbl next-lbl) #f #f frame #f))
(set! *bb*
(make-bb (make-label-simple
next-lbl
frame
(source-comment node))
*bbs*))
target.proc-result)))))))))))
(define (nb-args-conforms? n call-pat) (pattern-member? n call-pat))
(define (merge-contexts-and-seal-bb other-context live poll? where comment)
(let ((live-v (live-vars live))
(other-nb-slots (context-nb-slots other-context))
(other-regs (context-regs other-context))
(other-slots (context-slots other-context))
(other-poll (context-poll other-context))
(other-entry-bb (context-entry-bb other-context)))
(let loop1 ((i (- target.nb-regs 1)))
(if (>= i 0)
(let ((other-var (reg->var other-regs i)) (var (reg->var regs i)))
(if (and (not (eq? var other-var)) (set-member? other-var live-v))
(let ((r (make-reg i)))
(put-var r empty-var)
(if (not (or (not (set-member? var live-v))
(memq var regs)
(memq var slots)))
(let ((top (make-stk (+ nb-slots 1))))
(put-copy r top var live-v comment)))
(put-copy (var->opnd other-var) r other-var live-v comment)))
(loop1 (- i 1)))))
(let loop2 ((i 1))
(if (<= i other-nb-slots)
(let ((other-var (stk->var other-slots i)) (var (stk->var slots i)))
(if (and (not (eq? var other-var)) (set-member? other-var live-v))
(let ((s (make-stk i)))
(if (<= i nb-slots) (put-var s empty-var))
(if (not (or (not (set-member? var live-v))
(memq var regs)
(memq var slots)))
(let ((top (make-stk (+ nb-slots 1))))
(put-copy s top var live-v comment)))
(put-copy (var->opnd other-var) s other-var live-v comment))
(if (> i nb-slots)
(let ((top (make-stk (+ nb-slots 1))))
(put-copy
(make-obj undef-object)
top
empty-var
live-v
comment))))
(loop2 (+ i 1)))))
(dealloc-slots (- nb-slots other-nb-slots))
(let loop3 ((i (- target.nb-regs 1)))
(if (>= i 0)
(let ((other-var (reg->var other-regs i)) (var (reg->var regs i)))
(if (not (eq? var other-var)) (put-var (make-reg i) empty-var))
(loop3 (- i 1)))))
(let loop4 ((i 1))
(if (<= i other-nb-slots)
(let ((other-var (stk->var other-slots i)) (var (stk->var slots i)))
(if (not (eq? var other-var)) (put-var (make-stk i) empty-var))
(loop4 (+ i 1)))))
(seal-bb poll? where)
(set! poll (poll-merge poll other-poll))
(if (not (eq? entry-bb other-entry-bb))
(compiler-internal-error
"merge-contexts-and-seal-bb, entry-bb's do not agree"))))
(define (seal-bb poll? where)
(define (my-last-pair l) (if (pair? (cdr l)) (my-last-pair (cdr l)) l))
(define (poll-at split-point)
(let loop ((i 0) (l1 (bb-non-branch-instrs *bb*)) (l2 '()))
(if (< i split-point)
(loop (+ i 1) (cdr l1) (cons (car l1) l2))
(let* ((label-instr (bb-label-instr *bb*))
(non-branch-instrs1 (reverse l2))
(non-branch-instrs2 l1)
(frame (gvm-instr-frame
(car (my-last-pair
(cons label-instr non-branch-instrs1)))))
(prec-bb (make-bb label-instr *bbs*))
(new-lbl (bbs-new-lbl! *bbs*)))
(bb-non-branch-instrs-set! prec-bb non-branch-instrs1)
(bb-put-branch!
prec-bb
(make-jump (make-lbl new-lbl) #f #t frame #f))
(bb-label-instr-set! *bb* (make-label-simple new-lbl frame #f))
(bb-non-branch-instrs-set! *bb* non-branch-instrs2)
(set! poll (make-poll #t 0))))))
(define (poll-at-end) (poll-at (length (bb-non-branch-instrs *bb*))))
(define (impose-polling-constraints)
(let ((n (+ (length (bb-non-branch-instrs *bb*)) 1))
(delta (poll-delta poll)))
(if (> (+ delta n) poll-period)
(begin
(poll-at (max (- poll-period delta) 0))
(impose-polling-constraints)))))
(if poll? (impose-polling-constraints))
(let* ((n (+ (length (bb-non-branch-instrs *bb*)) 1))
(delta (+ (poll-delta poll) n))
(since-entry? (poll-since-entry? poll)))
(if (and poll?
(case where
((call) (> delta (- poll-period poll-head)))
((tail-call) (> delta poll-tail))
((return) (and since-entry? (> delta (+ poll-head poll-tail))))
((internal) #f)
(else
(compiler-internal-error "seal-bb, unknown 'where':" where))))
(poll-at-end)
(set! poll (make-poll since-entry? delta)))))
(define (reg->var regs i)
(cond ((null? regs) '())
((> i 0) (reg->var (cdr regs) (- i 1)))
(else (car regs))))
(define (stk->var slots i)
(let ((j (- (length slots) i))) (if (< j 0) '() (list-ref slots j))))
(define (gen-conj/disj node live why)
(let ((pre (if (conj? node) (conj-pre node) (disj-pre node)))
(alt (if (conj? node) (conj-alt node) (disj-alt node))))
(let ((needed (set-union live (free-variables alt)))
(bool? (boolean-value? pre))
(predicate-var (make-temp-var 'predicate)))
(define (general-predicate node live cont)
(let* ((con-lbl (bbs-new-lbl! *bbs*)) (alt-lbl (bbs-new-lbl! *bbs*)))
(save-opnd-to-reg
(gen-node pre live 'need)
target.proc-result
predicate-var
live
(source-comment pre))
(seal-bb (intrs-enabled? (node-decl node)) 'internal)
(bb-put-branch!
*bb*
(make-ifjump
**not-proc-obj
(list target.proc-result)
alt-lbl
con-lbl
#f
(current-frame (set-adjoin live predicate-var))
(source-comment node)))
(cont con-lbl alt-lbl)))
(define (alternative con-lbl alt-lbl)
(let* ((pre-context (current-context))
(result-var (make-temp-var 'result))
(con-live (if bool? live (set-adjoin live predicate-var)))
(alt-live (set-union live (free-variables alt)))
(con-bb (make-bb (make-label-simple
con-lbl
(current-frame con-live)
(source-comment alt))
*bbs*))
(alt-bb (make-bb (make-label-simple
alt-lbl
(current-frame alt-live)
(source-comment alt))
*bbs*)))
(if bool?
(begin
(set! *bb* con-bb)
(save-opnd-to-reg
(make-obj (if (conj? node) false-object #t))
target.proc-result
result-var
live
(source-comment node)))
(put-var (var->opnd predicate-var) result-var))
(let ((con-context (current-context)))
(set! *bb* alt-bb)
(restore-context pre-context)
(let ((alt-opnd (gen-node alt live why)))
(if (eq? why 'tail)
(begin
(restore-context con-context)
(set! *bb* con-bb)
(let ((ret-opnd (var->opnd ret-var))
(result-set (set-singleton result-var)))
(seal-bb (intrs-enabled? (node-decl node)) 'return)
(dealloc-slots nb-slots)
(bb-put-branch!
*bb*
(make-jump
ret-opnd
#f
#f
(current-frame result-set)
#f))))
(let ((alt-context* (current-context)) (alt-bb* *bb*))
(restore-context con-context)
(set! *bb* con-bb)
(seal-bb (intrs-enabled? (node-decl node)) 'internal)
(let ((con-context* (current-context))
(next-lbl (bbs-new-lbl! *bbs*)))
(restore-context alt-context*)
(set! *bb* alt-bb*)
(save-opnd-to-reg
alt-opnd
target.proc-result
result-var
live
(source-comment alt))
(merge-contexts-and-seal-bb
con-context*
(set-adjoin live result-var)
(intrs-enabled? (node-decl node))
'internal
(source-comment node))
(let ((frame (current-frame
(set-adjoin live result-var))))
(bb-put-branch!
*bb*
(make-jump (make-lbl next-lbl) #f #f frame #f))
(bb-put-branch!
con-bb
(make-jump (make-lbl next-lbl) #f #f frame #f))
(set! *bb*
(make-bb (make-label-simple
next-lbl
frame
(source-comment node))
*bbs*))
target.proc-result))))))))
((if bool? predicate general-predicate)
pre
needed
(lambda (true-lbl false-lbl)
(if (conj? node)
(alternative false-lbl true-lbl)
(alternative true-lbl false-lbl)))))))
(define (gen-call node live why)
(let* ((oper (app-oper node)) (args (app-args node)) (nb-args (length args)))
(if (and (prc? oper)
(not (prc-rest oper))
(= (length (prc-parms oper)) nb-args))
(gen-let (prc-parms oper) args (prc-body oper) live why)
(if (inlinable-app? node)
(let ((eval-order (arg-eval-order #f args))
(vars (map (lambda (x) (cons x #f)) args)))
(let loop ((l eval-order) (liv live))
(if (not (null? l))
(let* ((needed (vals-live-vars liv (map car (cdr l))))
(arg (car (car l)))
(pos (cdr (car l)))
(var (save-var
(gen-node arg needed 'need)
(make-temp-var pos)
needed
(source-comment arg))))
(set-cdr! (assq arg vars) var)
(loop (cdr l) (set-adjoin liv var)))
(let ((loc (if (eq? why 'side)
(make-reg 0)
(or (lowest-dead-reg live)
(lowest-dead-slot live)))))
(if (and (stk? loc) (> (stk-num loc) nb-slots))
(push-slot))
(let* ((args (map var->opnd (map cdr vars)))
(var (make-temp-var 'result))
(proc (node->proc oper))
(strict-pat (proc-obj-strict-pat proc)))
(if (not (eq? why 'side)) (put-var loc var))
(bb-put-non-branch!
*bb*
(make-apply
(specialize-for-call proc (node-decl node))
args
(if (eq? why 'side) #f loc)
(current-frame
(if (eq? why 'side) live (set-adjoin live var)))
(source-comment node)))
(gen-return loc why node))))))
(let* ((calling-local-proc?
(and (ref? oper)
(let ((opnd (var->opnd (ref-var oper))))
(and (lbl? opnd)
(let ((x (assq (lbl-num opnd) known-procs)))
(and x
(let ((proc (cdr x)))
(and (not (prc-rest proc))
(= (prc-min proc) nb-args)
(= (length (prc-parms proc))
nb-args)
(lbl-num opnd)))))))))
(jstate (get-jump-state
args
(if calling-local-proc?
(target.label-info nb-args nb-args #f #f)
(target.jump-info nb-args))))
(in-stk (jump-state-in-stk jstate))
(in-reg (jump-state-in-reg jstate))
(eval-order
(arg-eval-order (if calling-local-proc? #f oper) in-reg))
(live-after
(if (eq? why 'tail) (set-remove live ret-var) live))
(live-for-regs (args-live-vars live eval-order))
(return-lbl (if (eq? why 'tail) #f (bbs-new-lbl! *bbs*))))
(save-regs
(live-regs live-after)
(stk-live-vars live-for-regs in-stk why)
(source-comment node))
(let ((frame-start (stk-num (highest-live-slot live-after))))
(let loop1 ((l in-stk) (liv live-after) (i (+ frame-start 1)))
(if (not (null? l))
(let ((arg (car l))
(slot (make-stk i))
(needed (set-union
(stk-live-vars liv (cdr l) why)
live-for-regs)))
(if arg
(let ((var (if (and (eq? arg 'return)
(eq? why 'tail))
ret-var
(make-temp-var (- frame-start i)))))
(save-opnd-to-stk
(if (eq? arg 'return)
(if (eq? why 'tail)
(var->opnd ret-var)
(make-lbl return-lbl))
(gen-node arg needed 'need))
slot
var
needed
(source-comment
(if (eq? arg 'return) node arg)))
(loop1 (cdr l) (set-adjoin liv var) (+ i 1)))
(begin
(if (> i nb-slots)
(put-copy
(make-obj undef-object)
slot
empty-var
liv
(source-comment node)))
(loop1 (cdr l) liv (+ i 1)))))
(let loop2 ((l eval-order)
(liv liv)
(reg-map '())
(oper-var '()))
(if (not (null? l))
(let* ((arg (car (car l)))
(pos (cdr (car l)))
(needed (args-live-vars liv (cdr l)))
(var (if (and (eq? arg 'return)
(eq? why 'tail))
ret-var
(make-temp-var pos)))
(opnd (if (eq? arg 'return)
(if (eq? why 'tail)
(var->opnd ret-var)
(make-lbl return-lbl))
(gen-node arg needed 'need))))
(if (eq? pos 'operator)
(if (and (ref? arg)
(not (or (obj? opnd) (lbl? opnd))))
(loop2 (cdr l)
(set-adjoin liv (ref-var arg))
reg-map
(ref-var arg))
(begin
(save-arg
opnd
var
needed
(source-comment
(if (eq? arg 'return) node arg)))
(loop2 (cdr l)
(set-adjoin liv var)
reg-map
var)))
(let ((reg (make-reg pos)))
(if (all-args-trivial? (cdr l))
(save-opnd-to-reg
opnd
reg
var
needed
(source-comment
(if (eq? arg 'return) node arg)))
(save-in-slot
opnd
var
needed
(source-comment
(if (eq? arg 'return) node arg))))
(loop2 (cdr l)
(set-adjoin liv var)
(cons (cons pos var) reg-map)
oper-var))))
(let loop3 ((i (- target.nb-regs 1)))
(if (>= i 0)
(let ((couple (assq i reg-map)))
(if couple
(let ((var (cdr couple)))
(if (not (eq? (reg->var regs i) var))
(save-opnd-to-reg
(var->opnd var)
(make-reg i)
var
liv
(source-comment node)))))
(loop3 (- i 1)))
(let ((opnd (if calling-local-proc?
(make-lbl
(+ calling-local-proc? 1))
(var->opnd oper-var))))
(seal-bb (intrs-enabled? (node-decl node))
(if return-lbl 'call 'tail-call))
(dealloc-slots
(- nb-slots
(+ frame-start (length in-stk))))
(bb-put-branch!
*bb*
(make-jump
opnd
(if calling-local-proc? #f nb-args)
#f
(current-frame liv)
(source-comment node)))
(let ((result-var (make-temp-var 'result)))
(dealloc-slots (- nb-slots frame-start))
(flush-regs)
(put-var target.proc-result result-var)
(if return-lbl
(begin
(set! poll (return-poll poll))
(set! *bb*
(make-bb (make-label-return
return-lbl
(current-frame
(set-adjoin
live
result-var))
(source-comment
node))
*bbs*))))
target.proc-result))))))))))))))
(define (contained-reg/slot opnd)
(cond ((reg? opnd) opnd)
((stk? opnd) opnd)
((clo? opnd) (contained-reg/slot (clo-base opnd)))
(else #f)))
(define (opnd-needed opnd needed)
(let ((x (contained-reg/slot opnd)))
(if x (set-adjoin needed (get-var x)) needed)))
(define (save-opnd opnd live comment)
(let ((slot (lowest-dead-slot live)))
(put-copy opnd slot (get-var opnd) live comment)))
(define (save-regs regs live comment)
(for-each
(lambda (i) (save-opnd (make-reg i) live comment))
(set->list regs)))
(define (save-opnd-to-reg opnd reg var live comment)
(if (set-member? (reg-num reg) (live-regs live))
(save-opnd reg (opnd-needed opnd live) comment))
(put-copy opnd reg var live comment))
(define (save-opnd-to-stk opnd stk var live comment)
(if (set-member? (stk-num stk) (live-slots live))
(save-opnd stk (opnd-needed opnd live) comment))
(put-copy opnd stk var live comment))
(define (all-args-trivial? l)
(if (null? l)
#t
(let ((arg (car (car l))))
(or (eq? arg 'return)
(and (trivial? arg) (all-args-trivial? (cdr l)))))))
(define (every-trivial? l)
(or (null? l) (and (trivial? (car l)) (every-trivial? (cdr l)))))
(define (trivial? node)
(or (cst? node)
(ref? node)
(and (set? node) (trivial? (set-val node)))
(and (inlinable-app? node) (every-trivial? (app-args node)))))
(define (inlinable-app? node)
(if (app? node)
(let ((proc (node->proc (app-oper node))))
(and proc
(let ((spec (specialize-for-call proc (node-decl node))))
(and (proc-obj-inlinable spec)
(nb-args-conforms?
(length (app-args node))
(proc-obj-call-pat spec))))))
#f))
(define (boolean-value? node)
(or (and (conj? node)
(boolean-value? (conj-pre node))
(boolean-value? (conj-alt node)))
(and (disj? node)
(boolean-value? (disj-pre node))
(boolean-value? (disj-alt node)))
(boolean-app? node)))
(define (boolean-app? node)
(if (app? node)
(let ((proc (node->proc (app-oper node))))
(if proc (eq? (type-name (proc-obj-type proc)) 'boolean) #f))
#f))
(define (node->proc node)
(cond ((cst? node) (if (proc-obj? (cst-val node)) (cst-val node) #f))
((ref? node)
(if (global? (ref-var node))
(target.prim-info* (var-name (ref-var node)) (node-decl node))
#f))
(else #f)))
(define (specialize-for-call proc decl) ((proc-obj-specialize proc) decl))
(define (get-jump-state args pc)
(define (empty-node-list n)
(if (> n 0) (cons #f (empty-node-list (- n 1))) '()))
(let* ((fs (pcontext-fs pc))
(slots-list (empty-node-list fs))
(regs-list (empty-node-list target.nb-regs)))
(define (assign-node-to-loc var loc)
(let ((x (cond ((reg? loc)
(let ((i (reg-num loc)))
(if (<= i target.nb-regs)
(nth-after regs-list i)
(compiler-internal-error
"jump-state, reg out of bound in back-end's pcontext"))))
((stk? loc)
(let ((i (stk-num loc)))
(if (<= i fs)
(nth-after slots-list (- i 1))
(compiler-internal-error
"jump-state, stk out of bound in back-end's pcontext"))))
(else
(compiler-internal-error
"jump-state, loc other than reg or stk in back-end's pcontext")))))
(if (not (car x))
(set-car! x var)
(compiler-internal-error
"jump-state, duplicate location in back-end's pcontext"))))
(let loop ((l (pcontext-map pc)))
(if (not (null? l))
(let* ((couple (car l)) (name (car couple)) (loc (cdr couple)))
(cond ((eq? name 'return) (assign-node-to-loc 'return loc))
(else (assign-node-to-loc (list-ref args (- name 1)) loc)))
(loop (cdr l)))))
(vector slots-list regs-list)))
(define (jump-state-in-stk x) (vector-ref x 0))
(define (jump-state-in-reg x) (vector-ref x 1))
(define (arg-eval-order oper nodes)
(define (loop nodes pos part1 part2)
(cond ((null? nodes)
(let ((p1 (reverse part1)) (p2 (free-vars-order part2)))
(cond ((not oper) (append p1 p2))
((trivial? oper)
(append p1 p2 (list (cons oper 'operator))))
(else (append (cons (cons oper 'operator) p1) p2)))))
((not (car nodes)) (loop (cdr nodes) (+ pos 1) part1 part2))
((or (eq? (car nodes) 'return) (trivial? (car nodes)))
(loop (cdr nodes)
(+ pos 1)
part1
(cons (cons (car nodes) pos) part2)))
(else
(loop (cdr nodes)
(+ pos 1)
(cons (cons (car nodes) pos) part1)
part2))))
(loop nodes 0 '() '()))
(define (free-vars-order l)
(let ((bins '()) (ordered-args '()))
(define (free-v x) (if (eq? x 'return) (set-empty) (free-variables x)))
(define (add-to-bin! x)
(let ((y (assq x bins)))
(if y (set-cdr! y (+ (cdr y) 1)) (set! bins (cons (cons x 1) bins)))))
(define (payoff-if-removed node)
(let ((x (free-v node)))
(let loop ((l (set->list x)) (r 0))
(if (null? l)
r
(let ((y (cdr (assq (car l) bins))))
(loop (cdr l) (+ r (quotient 1000 (* y y)))))))))
(define (remove-free-vars! x)
(let loop ((l (set->list x)))
(if (not (null? l))
(let ((y (assq (car l) bins)))
(set-cdr! y (- (cdr y) 1))
(loop (cdr l))))))
(define (find-max-payoff l thunk)
(if (null? l)
(thunk '() -1)
(find-max-payoff
(cdr l)
(lambda (best-arg best-payoff)
(let ((payoff (payoff-if-removed (car (car l)))))
(if (>= payoff best-payoff)
(thunk (car l) payoff)
(thunk best-arg best-payoff)))))))
(define (remove x l)
(cond ((null? l) '())
((eq? x (car l)) (cdr l))
(else (cons (car l) (remove x (cdr l))))))
(for-each
(lambda (x) (for-each add-to-bin! (set->list (free-v (car x)))))
l)
(let loop ((args l) (ordered-args '()))
(if (null? args)
(reverse ordered-args)
(find-max-payoff
args
(lambda (best-arg best-payoff)
(remove-free-vars! (free-v (car best-arg)))
(loop (remove best-arg args) (cons best-arg ordered-args))))))))
(define (args-live-vars live order)
(cond ((null? order) live)
((eq? (car (car order)) 'return)
(args-live-vars (set-adjoin live ret-var) (cdr order)))
(else
(args-live-vars
(set-union live (free-variables (car (car order))))
(cdr order)))))
(define (stk-live-vars live slots why)
(cond ((null? slots) live)
((not (car slots)) (stk-live-vars live (cdr slots) why))
((eq? (car slots) 'return)
(stk-live-vars
(if (eq? why 'tail) (set-adjoin live ret-var) live)
(cdr slots)
why))
(else
(stk-live-vars
(set-union live (free-variables (car slots)))
(cdr slots)
why))))
(define (gen-let vars vals node live why)
(let ((var-val-map (pair-up vars vals))
(var-set (list->set vars))
(all-live
(set-union
live
(free-variables node)
(apply set-union (map free-variables vals)))))
(define (var->val var) (cdr (assq var var-val-map)))
(define (proc-var? var) (prc? (var->val var)))
(define (closed-vars var const-proc-vars)
(set-difference
(not-constant-closed-vars (var->val var))
const-proc-vars))
(define (no-closed-vars? var const-proc-vars)
(set-empty? (closed-vars var const-proc-vars)))
(define (closed-vars? var const-proc-vars)
(not (no-closed-vars? var const-proc-vars)))
(define (compute-const-proc-vars proc-vars)
(let loop1 ((const-proc-vars proc-vars))
(let ((new-const-proc-vars
(set-keep
(lambda (x) (no-closed-vars? x const-proc-vars))
const-proc-vars)))
(if (not (set-equal? new-const-proc-vars const-proc-vars))
(loop1 new-const-proc-vars)
const-proc-vars))))
(let* ((proc-vars (set-keep proc-var? var-set))
(const-proc-vars (compute-const-proc-vars proc-vars))
(clo-vars
(set-keep (lambda (x) (closed-vars? x const-proc-vars)) proc-vars))
(clo-vars-list (set->list clo-vars)))
(for-each
(lambda (proc-var)
(let ((label (schedule-gen-proc (var->val proc-var) '())))
(add-known-proc (lbl-num label) (var->val proc-var))
(add-constant-var proc-var label)))
(set->list const-proc-vars))
(let ((non-clo-vars-list
(set->list
(set-keep
(lambda (var)
(and (not (set-member? var const-proc-vars))
(not (set-member? var clo-vars))))
vars)))
(liv (set-union
live
(apply set-union
(map (lambda (x) (closed-vars x const-proc-vars))
clo-vars-list))
(free-variables node))))
(let loop2 ((vars* non-clo-vars-list))
(if (not (null? vars*))
(let* ((var (car vars*))
(val (var->val var))
(needed (vals-live-vars liv (map var->val (cdr vars*)))))
(if (var-useless? var)
(gen-node val needed 'side)
(save-val
(gen-node val needed 'need)
var
needed
(source-comment val)))
(loop2 (cdr vars*)))))
(if (pair? clo-vars-list)
(begin
(dealloc-slots (- nb-slots (stk-num (highest-live-slot liv))))
(let loop3 ((l clo-vars-list))
(if (not (null? l))
(begin
(push-slot)
(let ((var (car l)) (slot (make-stk nb-slots)))
(put-var slot var)
(loop3 (cdr l))))))
(bb-put-non-branch!
*bb*
(make-close
(map (lambda (var)
(let ((closed-list
(sort-variables
(set->list (closed-vars var const-proc-vars)))))
(if (null? closed-list)
(compiler-internal-error
"gen-let, no closed variables:"
(var-name var))
(make-closure-parms
(var->opnd var)
(lbl-num (schedule-gen-proc
(var->val var)
closed-list))
(map var->opnd closed-list)))))
clo-vars-list)
(current-frame liv)
(source-comment node)))))
(gen-node node live why)))))
(define (save-arg opnd var live comment)
(if (glo? opnd)
(add-constant-var var opnd)
(save-val opnd var live comment)))
(define (save-val opnd var live comment)
(cond ((or (obj? opnd) (lbl? opnd)) (add-constant-var var opnd))
((and (reg? opnd) (not (set-member? (reg-num opnd) (live-regs live))))
(put-var opnd var))
((and (stk? opnd) (not (set-member? (stk-num opnd) (live-slots live))))
(put-var opnd var))
(else (save-in-slot opnd var live comment))))
(define (save-in-slot opnd var live comment)
(let ((slot (lowest-dead-slot live))) (put-copy opnd slot var live comment)))
(define (save-var opnd var live comment)
(cond ((or (obj? opnd) (lbl? opnd)) (add-constant-var var opnd) var)
((or (glo? opnd) (reg? opnd) (stk? opnd)) (get-var opnd))
(else
(let ((dest (or (highest-dead-reg live) (lowest-dead-slot live))))
(put-copy opnd dest var live comment)
var))))
(define (put-copy opnd loc var live comment)
(if (and (stk? loc) (> (stk-num loc) nb-slots)) (push-slot))
(if var (put-var loc var))
(if (not (eq? opnd loc))
(bb-put-non-branch!
*bb*
(make-copy
opnd
loc
(current-frame (if var (set-adjoin live var) live))
comment))))
(define (var-useless? var)
(and (set-empty? (var-refs var)) (set-empty? (var-sets var))))
(define (vals-live-vars live vals)
(if (null? vals)
live
(vals-live-vars
(set-union live (free-variables (car vals)))
(cdr vals))))
(define (gen-fut node live why)
(let* ((val (fut-val node))
(clo-vars (not-constant-closed-vars val))
(clo-vars-list (set->list clo-vars))
(ret-var* (make-temp-var 0))
(live-after live)
(live-starting-task
(set-adjoin (set-union live-after clo-vars) ret-var*))
(task-lbl (bbs-new-lbl! *bbs*))
(return-lbl (bbs-new-lbl! *bbs*)))
(save-regs (live-regs live-after) live-starting-task (source-comment node))
(let ((frame-start (stk-num (highest-live-slot live-after))))
(save-opnd-to-reg
(make-lbl return-lbl)
target.task-return
ret-var*
(set-remove live-starting-task ret-var*)
(source-comment node))
(let loop1 ((l clo-vars-list) (i 0))
(if (null? l)
(dealloc-slots (- nb-slots (+ frame-start i)))
(let ((var (car l)) (rest (cdr l)))
(if (memq var regs)
(loop1 rest i)
(let loop2 ((j (- target.nb-regs 1)))
(if (>= j 0)
(if (or (>= j (length regs))
(not (set-member?
(list-ref regs j)
live-starting-task)))
(let ((reg (make-reg j)))
(put-copy
(var->opnd var)
reg
var
live-starting-task
(source-comment node))
(loop1 rest i))
(loop2 (- j 1)))
(let ((slot (make-stk (+ frame-start (+ i 1))))
(needed (list->set rest)))
(if (and (or (> (stk-num slot) nb-slots)
(not (memq (list-ref
slots
(- nb-slots (stk-num slot)))
regs)))
(set-member?
(stk-num slot)
(live-slots needed)))
(save-opnd
slot
live-starting-task
(source-comment node)))
(put-copy
(var->opnd var)
slot
var
live-starting-task
(source-comment node))
(loop1 rest (+ i 1)))))))))
(seal-bb (intrs-enabled? (node-decl node)) 'call)
(bb-put-branch!
*bb*
(make-jump
(make-lbl task-lbl)
#f
#f
(current-frame live-starting-task)
#f))
(let ((task-context
(make-context
(- nb-slots frame-start)
(reverse (nth-after (reverse slots) frame-start))
(cons ret-var (cdr regs))
'()
poll
entry-bb))
(return-context
(make-context
frame-start
(nth-after slots (- nb-slots frame-start))
'()
closed
(return-poll poll)
entry-bb)))
(restore-context task-context)
(set! *bb*
(make-bb (make-label-task-entry
task-lbl
(current-frame live-starting-task)
(source-comment node))
*bbs*))
(gen-node val ret-var-set 'tail)
(let ((result-var (make-temp-var 'future)))
(restore-context return-context)
(put-var target.proc-result result-var)
(set! *bb*
(make-bb (make-label-task-return
return-lbl
(current-frame (set-adjoin live result-var))
(source-comment node))
*bbs*))
(gen-return target.proc-result why node))))))
(define prim-procs
'(("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)
("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)
("touch" (1) #t 0 #f)
("##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)
("##flonum?" (1) #f () boolean)
("##special?" (1) #f () boolean)
("##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)
("##char?" (1) #f () boolean)
("##closure?" (1) #f () boolean)
("##subprocedure?" (1) #f () boolean)
("##return-dynamic-env-bind?" (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.lsh" (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)
("##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))
("##make-cell" (1) #f () pair)
("##cell-ref" (1) #f () (#f))
("##cell-set!" (2) #t () pair)
("##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)
("##closure-code" (1) #f () #f)
("##closure-ref" (2) #f () (#f))
("##closure-set!" (3) #t () #f)
("##subprocedure-id" (1) #f () #f)
("##subprocedure-parent" (1) #f () #f)
("##return-fs" (1) #f () #f)
("##return-link" (1) #f () #f)
("##procedure-info" (1) #f () #f)
("##pstate" (0) #f () #f)
("##make-placeholder" (1) #f 0 (#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)
("##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)))
(define ofile-version-major 5)
(define ofile-version-minor 0)
(define prim-proc-prefix 1)
(define user-proc-prefix 2)
(define pair-prefix 3)
(define flonum-prefix 4)
(define local-object-bits -524281)
(define symbol-object-bits -393209)
(define prim-proc-object-bits -262137)
(define padding-tag 0)
(define end-of-code-tag 32768)
(define m68020-proc-code-tag 32769)
(define m68881-proc-code-tag 32770)
(define stat-tag 32771)
(define global-var-ref-tag 34816)
(define global-var-set-tag 36864)
(define global-var-ref-jump-tag 38912)
(define prim-proc-ref-tag 40960)
(define local-proc-ref-tag 49152)
(define long-index-mask 16383)
(define word-index-mask 2047)
(define (ofile.begin! filename add-obj)
(set! ofile-add-obj add-obj)
(set! ofile-syms (queue-empty))
; (set! *ofile-port1* (open-output-file (string-append filename ".O")))
(if ofile-asm?
(begin
(set! *ofile-port2*
(asm-open-output-file (string-append filename ".asm")))
(set! *ofile-pos* 0)))
(ofile-word ofile-version-major)
(ofile-word ofile-version-minor)
'())
(define (ofile.end!)
(ofile-line "")
; (close-output-port *ofile-port1*)
(if ofile-asm? (asm-close-output-port *ofile-port2*))
'())
(define asm-output '())
(define asm-line '())
(define (asm-open-output-file filename)
(set! asm-output '())
(set! asm-line '()))
(define (asm-close-output-port asm-port) #f)
(define (asm-newline asm-port) (asm-display char-newline asm-port))
(define (asm-display obj asm-port)
(if (eqv? obj char-newline)
(begin
(set! asm-output
(cons (apply string-append (reverse asm-line)) asm-output))
(set! asm-line '()))
(set! asm-line
(cons (cond ((string? obj) obj)
((char? obj) (if (eqv? obj char-tab) " " (string obj)))
((number? obj) (number->string obj))
(else (compiler-internal-error "asm-display" obj)))
asm-line))))
(define (asm-output-get) (reverse asm-output))
(define *ofile-port1* '())
(define *ofile-port2* '())
(define *ofile-pos* '())
(define ofile-nl char-newline)
(define ofile-tab char-tab)
(define ofile-asm? '())
(set! ofile-asm? '())
(define ofile-asm-bits? '())
(set! ofile-asm-bits? #f)
(define ofile-asm-gvm? '())
(set! ofile-asm-gvm? #f)
(define ofile-stats? '())
(set! ofile-stats? '())
(define ofile-add-obj '())
(set! ofile-add-obj '())
(define ofile-syms '())
(set! ofile-syms '())
(define (ofile-word n)
(let ((n (modulo n 65536)))
(if (and ofile-asm? ofile-asm-bits?)
(let ()
(define (ofile-display x)
(asm-display x *ofile-port2*)
(cond ((eq? x ofile-nl) (set! *ofile-pos* 0))
((eq? x ofile-tab)
(set! *ofile-pos* (* (quotient (+ *ofile-pos* 8) 8) 8)))
(else (set! *ofile-pos* (+ *ofile-pos* (string-length x))))))
(if (> *ofile-pos* 64) (ofile-display ofile-nl))
(if (= *ofile-pos* 0) (ofile-display " .word") (ofile-display ","))
(ofile-display ofile-tab)
(let ((s (make-string 6 #\0)))
(string-set! s 1 #\x)
(let loop ((i 5) (n n))
(if (> n 0)
(begin
(string-set!
s
i
(string-ref "0123456789ABCDEF" (remainder n 16)))
(loop (- i 1) (quotient n 16)))))
(ofile-display s))))
' (write-word n *ofile-port1*)))
(define (ofile-long x) (ofile-word (upper-16bits x)) (ofile-word x))
(define (ofile-string s)
(let ((len (string-length s)))
(define (ref i) (if (>= i len) 0 (character-encoding (string-ref s i))))
(let loop ((i 0))
(if (< i len)
(begin
(ofile-word (+ (* (ref i) 256) (ref (+ i 1))))
(loop (+ i 2)))))
(if (= (remainder len 2) 0) (ofile-word 0))))
(define (ofile-wsym tag name)
(let ((n (string-pos-in-list name (queue->list ofile-syms))))
(if n
(ofile-word (+ tag n))
(let ((m (length (queue->list ofile-syms))))
(queue-put! ofile-syms name)
(ofile-word (+ tag word-index-mask))
(ofile-string name)))))
(define (ofile-lsym tag name)
(let ((n (string-pos-in-list name (queue->list ofile-syms))))
(if n
(ofile-long (+ tag (* n 8)))
(let ((m (length (queue->list ofile-syms))))
(queue-put! ofile-syms name)
(ofile-long (+ tag (* long-index-mask 8)))
(ofile-string name)))))
(define (ofile-ref obj)
(let ((n (obj-encoding obj)))
(if n
(ofile-long n)
(if (symbol-object? obj)
(begin (ofile-lsym symbol-object-bits (symbol->string obj)))
(let ((m (ofile-add-obj obj)))
(if m
(ofile-long (+ local-object-bits (* m 8)))
(begin
(ofile-lsym
prim-proc-object-bits
(proc-obj-name obj)))))))))
(define (ofile-prim-proc s)
(ofile-long prim-proc-prefix)
(ofile-wsym 0 s)
(ofile-comment (list "| #[primitive " s "] =")))
(define (ofile-user-proc) (ofile-long user-proc-prefix))
(define (ofile-line s)
(if ofile-asm?
(begin
(if (> *ofile-pos* 0) (asm-newline *ofile-port2*))
(asm-display s *ofile-port2*)
(asm-newline *ofile-port2*)
(set! *ofile-pos* 0))))
(define (ofile-tabs-to n)
(let loop ()
(if (< *ofile-pos* n)
(begin
(asm-display ofile-tab *ofile-port2*)
(set! *ofile-pos* (* (quotient (+ *ofile-pos* 8) 8) 8))
(loop)))))
(define (ofile-comment l)
(if ofile-asm?
(let ()
(if ofile-asm-bits?
(begin (ofile-tabs-to 32) (asm-display "|" *ofile-port2*)))
(for-each (lambda (x) (asm-display x *ofile-port2*)) l)
(asm-newline *ofile-port2*)
(set! *ofile-pos* 0))))
(define (ofile-gvm-instr code)
(if (and ofile-asm? ofile-asm-gvm?)
(let ((gvm-instr (code-gvm-instr code)) (sn (code-slots-needed code)))
(if (> *ofile-pos* 0)
(begin (asm-newline *ofile-port2*) (set! *ofile-pos* 0)))
(if ofile-asm-bits? (ofile-tabs-to 32))
(asm-display "| GVM: [" *ofile-port2*)
(asm-display sn *ofile-port2*)
(asm-display "] " *ofile-port2*)
(asm-newline *ofile-port2*)
(set! *ofile-pos* 0))))
(define (ofile-stat stat)
(define (obj->string x)
(cond ((string? x) x)
((symbol-object? x) (symbol->string x))
((number? x) (number->string x))
((false-object? x) "#f")
((eq? x #t) "#t")
((null? x) "()")
((pair? x)
(let loop ((l1 (cdr x)) (l2 (list (obj->string (car x)) "(")))
(cond ((pair? l1)
(loop (cdr l1)
(cons (obj->string (car l1)) (cons " " l2))))
((null? l1) (apply string-append (reverse (cons ")" l2))))
(else
(apply string-append
(reverse (cons ")"
(cons (obj->string l1)
(cons " . " l2)))))))))
(else
(compiler-internal-error
"ofile-stat, can't convert to string 'x'"
x))))
(ofile-string (obj->string stat)))
(define (upper-16bits x)
(cond ((>= x 0) (quotient x 65536))
((>= x (- 65536)) -1)
(else (- (quotient (+ x 65537) 65536) 2))))
(define type-fixnum 0)
(define type-flonum 1)
(define type-special 7)
(define type-pair 4)
(define type-placeholder 5)
(define type-subtyped 3)
(define type-procedure 2)
(define subtype-vector 0)
(define subtype-symbol 1)
(define subtype-port 2)
(define subtype-ratnum 3)
(define subtype-cpxnum 4)
(define subtype-string 16)
(define subtype-bignum 17)
(define data-false (- 33686019))
(define data-null (- 67372037))
(define data-true -2)
(define data-undef -3)
(define data-unass -4)
(define data-unbound -5)
(define data-eof -6)
(define data-max-fixnum 268435455)
(define data-min-fixnum (- 268435456))
(define (make-encoding data type) (+ (* data 8) type))
(define (obj-type obj)
(cond ((false-object? obj) 'special)
((undef-object? obj) 'special)
((symbol-object? obj) 'subtyped)
((proc-obj? obj) 'procedure)
((eq? obj #t) 'special)
((null? obj) 'special)
((pair? obj) 'pair)
((number? obj)
(cond ((and (integer? obj)
(exact? obj)
(>= obj data-min-fixnum)
(<= obj data-max-fixnum))
'fixnum)
(
#t
;; (and (inexact? (real-part obj))
;; (zero? (imag-part obj))
;; (exact? (imag-part obj)))
'flonum)
(else 'subtyped)))
((char? obj) 'special)
(else 'subtyped)))
(define (obj-subtype obj)
(cond ((symbol-object? obj) 'symbol)
((number? obj)
(cond ((and (integer? obj) (exact? obj)) 'bignum)
((and (rational? obj) (exact? obj)) 'ratnum)
(else 'cpxnum)))
((vector? obj) 'vector)
((string? obj) 'string)
(else
(compiler-internal-error "obj-subtype, unknown object 'obj'" obj))))
(define (obj-type-tag obj)
(case (obj-type obj)
((fixnum) type-fixnum)
((flonum) type-flonum)
((special) type-special)
((pair) type-pair)
((subtyped) type-subtyped)
((procedure) type-procedure)
(else (compiler-internal-error "obj-type-tag, unknown object 'obj'" obj))))
(define (obj-encoding obj)
(case (obj-type obj)
((fixnum) (make-encoding obj type-fixnum))
((special)
(make-encoding
(cond ((false-object? obj) data-false)
((undef-object? obj) data-undef)
((eq? obj #t) data-true)
((null? obj) data-null)
((char? obj) (character-encoding obj))
(else
(compiler-internal-error
"obj-encoding, unknown SPECIAL object 'obj'"
obj)))
type-special))
(else #f)))
(define bits-false (make-encoding data-false type-special))
(define bits-null (make-encoding data-null type-special))
(define bits-true (make-encoding data-true type-special))
(define bits-unass (make-encoding data-unass type-special))
(define bits-unbound (make-encoding data-unbound type-special))
(define (asm.begin!)
(set! asm-code-queue (queue-empty))
(set! asm-const-queue (queue-empty))
'())
(define (asm.end! debug-info)
(asm-assemble! debug-info)
(set! asm-code-queue '())
(set! asm-const-queue '())
'())
(define asm-code-queue '())
(define asm-const-queue '())
(define (asm-word x) (queue-put! asm-code-queue (modulo x 65536)))
(define (asm-long x) (asm-word (upper-16bits x)) (asm-word x))
(define (asm-label lbl label-descr)
(queue-put! asm-code-queue (cons 'label (cons lbl label-descr))))
(define (asm-comment x) (queue-put! asm-code-queue (cons 'comment x)))
(define (asm-align n offset)
(queue-put! asm-code-queue (cons 'align (cons n offset))))
(define (asm-ref-glob glob)
(queue-put!
asm-code-queue
(cons 'ref-glob (symbol->string (glob-name glob)))))
(define (asm-set-glob glob)
(queue-put!
asm-code-queue
(cons 'set-glob (symbol->string (glob-name glob)))))
(define (asm-ref-glob-jump glob)
(queue-put!
asm-code-queue
(cons 'ref-glob-jump (symbol->string (glob-name glob)))))
(define (asm-proc-ref num offset)
(queue-put! asm-code-queue (cons 'proc-ref (cons num offset))))
(define (asm-prim-ref proc offset)
(queue-put!
asm-code-queue
(cons 'prim-ref (cons (proc-obj-name proc) offset))))
(define (asm-m68020-proc) (queue-put! asm-code-queue '(m68020-proc)))
(define (asm-m68881-proc) (queue-put! asm-code-queue '(m68881-proc)))
(define (asm-stat x) (queue-put! asm-code-queue (cons 'stat x)))
(define (asm-brel type lbl)
(queue-put! asm-code-queue (cons 'brab (cons type lbl))))
(define (asm-wrel lbl offs)
(queue-put! asm-code-queue (cons 'wrel (cons lbl offs))))
(define (asm-lrel lbl offs n)
(queue-put! asm-code-queue (cons 'lrel (cons lbl (cons offs n)))))
(define (asm-assemble! debug-info)
(define header-offset 2)
(define ref-glob-len 2)
(define set-glob-len 10)
(define ref-glob-jump-len 2)
(define proc-ref-len 4)
(define prim-ref-len 4)
(define stat-len 4)
(define (padding loc n offset) (modulo (- offset loc) n))
(queue-put! asm-const-queue debug-info)
(asm-align 4 0)
(emit-label const-lbl)
(let ((code-list (queue->list asm-code-queue))
(const-list (queue->list asm-const-queue)))
(let* ((fix-list
(let loop ((l code-list) (len header-offset) (x '()))
(if (null? l)
(reverse x)
(let ((part (car l)) (rest (cdr l)))
(if (pair? part)
(case (car part)
((label align brab)
(loop rest 0 (cons (cons len part) x)))
((wrel) (loop rest (+ len 2) x))
((lrel) (loop rest (+ len 4) x))
((ref-glob) (loop rest (+ len ref-glob-len) x))
((set-glob) (loop rest (+ len set-glob-len) x))
((ref-glob-jump)
(loop rest (+ len ref-glob-jump-len) x))
((proc-ref) (loop rest (+ len proc-ref-len) x))
((prim-ref) (loop rest (+ len prim-ref-len) x))
((stat) (loop rest (+ len stat-len) x))
((comment m68020-proc m68881-proc) (loop rest len x))
(else
(compiler-internal-error
"asm-assemble!, unknown code list element"
part)))
(loop rest (+ len 2) x))))))
(lbl-list
(let loop ((l fix-list) (x '()))
(if (null? l)
x
(let ((part (cdar l)) (rest (cdr l)))
(if (eq? (car part) 'label)
(loop rest (cons (cons (cadr part) part) x))
(loop rest x)))))))
(define (replace-lbl-refs-by-pointer-to-label)
(let loop ((l code-list))
(if (not (null? l))
(let ((part (car l)) (rest (cdr l)))
(if (pair? part)
(case (car part)
((brab)
(set-cdr! (cdr part) (cdr (assq (cddr part) lbl-list))))
((wrel)
(set-car! (cdr part) (cdr (assq (cadr part) lbl-list))))
((lrel)
(set-car!
(cdr part)
(cdr (assq (cadr part) lbl-list))))))
(loop rest)))))
(define (assign-loc-to-labels)
(let loop ((l fix-list) (loc 0))
(if (not (null? l))
(let* ((first (car l))
(rest (cdr l))
(len (car first))
(cur-loc (+ loc len))
(part (cdr first)))
(case (car part)
((label)
(if (cddr part)
(vector-set!
(cddr part)
0
(quotient (- cur-loc header-offset) 8)))
(set-car! (cdr part) cur-loc)
(loop rest cur-loc))
((align)
(loop rest
(+ cur-loc
(padding cur-loc (cadr part) (cddr part)))))
((brab) (loop rest (+ cur-loc 2)))
((braw) (loop rest (+ cur-loc 4)))
(else
(compiler-internal-error
"assign-loc-to-labels, unknown code list element"
part)))))))
(define (branch-tensioning-pass)
(assign-loc-to-labels)
(let loop ((changed? #f) (l fix-list) (loc 0))
(if (null? l)
(if changed? (branch-tensioning-pass))
(let* ((first (car l))
(rest (cdr l))
(len (car first))
(cur-loc (+ loc len))
(part (cdr first)))
(case (car part)
((label) (loop changed? rest cur-loc))
((align)
(loop changed?
rest
(+ cur-loc
(padding cur-loc (cadr part) (cddr part)))))
((brab)
(let ((dist (- (cadr (cddr part)) (+ cur-loc 2))))
(if (or (< dist -128) (> dist 127) (= dist 0))
(begin
(set-car! part 'braw)
(loop #t rest (+ cur-loc 2)))
(loop changed? rest (+ cur-loc 2)))))
((braw) (loop changed? rest (+ cur-loc 4)))
(else
(compiler-internal-error
"branch-tensioning-pass, unknown code list element"
part)))))))
(define (write-block start-loc end-loc start end)
(if (> end-loc start-loc)
(ofile-word (quotient (- end-loc start-loc) 2)))
(let loop ((loc start-loc) (l start))
(if (not (eq? l end))
(let ((part (car l)) (rest (cdr l)))
(if (pair? part)
(case (car part)
((label) (loop loc rest))
((align)
(let ((n (padding loc (cadr part) (cddr part))))
(let pad ((i 0))
(if (< i n)
(begin (ofile-word 0) (pad (+ i 2)))
(loop (+ loc n) rest)))))
((brab)
(let ((dist (- (cadr (cddr part)) (+ loc 2))))
(ofile-word (+ (cadr part) (modulo dist 256)))
(loop (+ loc 2) rest)))
((braw)
(let ((dist (- (cadr (cddr part)) (+ loc 2))))
(ofile-word (cadr part))
(ofile-word (modulo dist 65536))
(loop (+ loc 4) rest)))
((wrel)
(let ((dist (+ (- (cadr (cadr part)) loc) (cddr part))))
(ofile-word (modulo dist 65536))
(loop (+ loc 2) rest)))
((lrel)
(let ((dist (+ (- (cadr (cadr part)) loc)
(caddr part))))
(ofile-long (+ (* dist 65536) (cdddr part)))
(loop (+ loc 4) rest)))
((comment)
(let ((x (cdr part)))
(if (pair? x) (ofile-comment x) (ofile-gvm-instr x))
(loop loc rest))))
(begin (ofile-word part) (loop (+ loc 2) rest)))))))
(define (write-code)
(let ((proc-len
(+ (cadr (cdr (assq const-lbl lbl-list)))
(* (length const-list) 4))))
(if (>= proc-len 32768)
(compiler-limitation-error
"procedure is too big (32K bytes limit per procedure)"))
(ofile-word (+ 32768 proc-len)))
(let loop1 ((start code-list) (start-loc header-offset))
(let loop2 ((end start) (loc start-loc))
(if (null? end)
(write-block start-loc loc start end)
(let ((part (car end)) (rest (cdr end)))
(if (pair? part)
(case (car part)
((label comment) (loop2 rest loc))
((align)
(loop2 rest
(+ loc (padding loc (cadr part) (cddr part)))))
((brab wrel) (loop2 rest (+ loc 2)))
((braw) (loop2 rest (+ loc 4)))
((lrel) (loop2 rest (+ loc 4)))
(else
(write-block start-loc loc start end)
(case (car part)
((ref-glob)
(ofile-wsym global-var-ref-tag (cdr part))
(loop1 rest (+ loc ref-glob-len)))
((set-glob)
(ofile-wsym global-var-set-tag (cdr part))
(loop1 rest (+ loc set-glob-len)))
((ref-glob-jump)
(ofile-wsym global-var-ref-jump-tag (cdr part))
(loop1 rest (+ loc ref-glob-jump-len)))
((proc-ref)
(ofile-word (+ local-proc-ref-tag (cadr part)))
(ofile-word (cddr part))
(loop1 rest (+ loc proc-ref-len)))
((prim-ref)
(ofile-wsym prim-proc-ref-tag (cadr part))
(ofile-word (cddr part))
(loop1 rest (+ loc prim-ref-len)))
((m68020-proc)
(ofile-word m68020-proc-code-tag)
(loop1 rest loc))
((m68881-proc)
(ofile-word m68881-proc-code-tag)
(loop1 rest loc))
((stat)
(ofile-word stat-tag)
(ofile-stat (cdr part))
(loop1 rest (+ loc stat-len))))))
(loop2 rest (+ loc 2)))))))
(ofile-word end-of-code-tag)
(for-each ofile-ref const-list)
(ofile-long (obj-encoding (+ (length const-list) 1))))
(replace-lbl-refs-by-pointer-to-label)
(branch-tensioning-pass)
(write-code))))
(define const-lbl 0)
(define (identical-opnd68? opnd1 opnd2) (eqv? opnd1 opnd2))
(define (reg68? x) (or (dreg? x) (areg? x)))
(define (make-dreg num) num)
(define (dreg? x) (and (integer? x) (>= x 0) (< x 8)))
(define (dreg-num x) x)
(define (make-areg num) (+ num 8))
(define (areg? x) (and (integer? x) (>= x 8) (< x 16)))
(define (areg-num x) (- x 8))
(define (make-ind areg) (+ areg 8))
(define (ind? x) (and (integer? x) (>= x 16) (< x 24)))
(define (ind-areg x) (- x 8))
(define (make-pinc areg) (+ areg 16))
(define (pinc? x) (and (integer? x) (>= x 24) (< x 32)))
(define (pinc-areg x) (- x 16))
(define (make-pdec areg) (+ areg 24))
(define (pdec? x) (and (integer? x) (>= x 32) (< x 40)))
(define (pdec-areg x) (- x 24))
(define (make-disp areg offset) (+ (+ areg 32) (* (modulo offset 65536) 8)))
(define (disp? x) (and (integer? x) (>= x 40) (< x 524328)))
(define (disp-areg x) (+ (remainder x 8) 8))
(define (disp-offset x)
(- (modulo (+ (quotient (- x 40) 8) 32768) 65536) 32768))
(define (make-disp* areg offset)
(if (= offset 0) (make-ind areg) (make-disp areg offset)))
(define (disp*? x) (or (ind? x) (disp? x)))
(define (disp*-areg x) (if (ind? x) (ind-areg x) (disp-areg x)))
(define (disp*-offset x) (if (ind? x) 0 (disp-offset x)))
(define (make-inx areg ireg offset)
(+ (+ areg 524320) (* ireg 8) (* (modulo offset 256) 128)))
(define (inx? x) (and (integer? x) (>= x 524328) (< x 557096)))
(define (inx-areg x) (+ (remainder (- x 524328) 8) 8))
(define (inx-ireg x) (quotient (remainder (- x 524328) 128) 8))
(define (inx-offset x)
(- (modulo (+ (quotient (- x 524328) 128) 128) 256) 128))
(define (make-freg num) (+ 557096 num))
(define (freg? x) (and (integer? x) (>= x 557096) (< x 557104)))
(define (freg-num x) (- x 557096))
(define (make-pcr lbl offset)
(+ 557104 (+ (modulo offset 65536) (* lbl 65536))))
(define (pcr? x) (and (integer? x) (>= x 557104)))
(define (pcr-lbl x) (quotient (- x 557104) 65536))
(define (pcr-offset x) (- (modulo (- x 524336) 65536) 32768))
(define (make-imm val) (if (< val 0) (* val 2) (- -1 (* val 2))))
(define (imm? x) (and (integer? x) (< x 0)))
(define (imm-val x) (if (even? x) (quotient x 2) (- (quotient x 2))))
(define (make-glob name) name)
(define (glob? x) (symbol? x))
(define (glob-name x) x)
(define (make-frame-base-rel slot) (make-disp sp-reg slot))
(define (frame-base-rel? x)
(and (disp? x) (identical-opnd68? sp-reg (disp-areg x))))
(define (frame-base-rel-slot x) (disp-offset x))
(define (make-reg-list regs) regs)
(define (reg-list? x) (or (pair? x) (null? x)))
(define (reg-list-regs x) x)
(define first-dtemp 0)
(define gvm-reg1 1)
(define poll-timer-reg (make-dreg 5))
(define null-reg (make-dreg 6))
(define placeholder-reg (make-dreg 6))
(define false-reg (make-dreg 7))
(define pair-reg (make-dreg 7))
(define gvm-reg0 0)
(define first-atemp 1)
(define heap-reg (make-areg 3))
(define ltq-tail-reg (make-areg 4))
(define pstate-reg (make-areg 5))
(define table-reg (make-areg 6))
(define sp-reg (make-areg 7))
(define pdec-sp (make-pdec sp-reg))
(define pinc-sp (make-pinc sp-reg))
(define dtemp1 (make-dreg first-dtemp))
(define atemp1 (make-areg first-atemp))
(define atemp2 (make-areg (+ first-atemp 1)))
(define ftemp1 (make-freg 0))
(define arg-count-reg dtemp1)
(define (trap-offset n) (+ 32768 (* (- n 32) 8)))
(define (emit-move.l opnd1 opnd2)
(let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
(asm-word (+ 8192 (+ dst src)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2)
(if ofile-asm?
(emit-asm "movl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
(define (emit-move.w opnd1 opnd2)
(let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
(asm-word (+ 12288 (+ dst src)))
(opnd-ext-rd-word opnd1)
(opnd-ext-wr-word opnd2)
(if ofile-asm?
(emit-asm "movw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
(define (emit-move.b opnd1 opnd2)
(let ((src (opnd->mode/reg opnd1)) (dst (opnd->reg/mode opnd2)))
(asm-word (+ 4096 (+ dst src)))
(opnd-ext-rd-word opnd1)
(opnd-ext-wr-word opnd2)
(if ofile-asm?
(emit-asm "movb" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2)))))
(define (emit-moveq n opnd)
(asm-word (+ 28672 (+ (* (dreg-num opnd) 512) (modulo n 256))))
(if ofile-asm? (emit-asm "moveq" ofile-tab "#" n "," (opnd-str opnd))))
(define (emit-movem.l opnd1 opnd2)
(define (reg-mask reg-list flip-bits?)
(let loop ((i 15) (bit 32768) (mask 0))
(if (>= i 0)
(loop (- i 1)
(quotient bit 2)
(if (memq i reg-list)
(+ mask (if flip-bits? (quotient 32768 bit) bit))
mask))
mask)))
(define (movem op reg-list opnd)
(asm-word (+ op (opnd->mode/reg opnd)))
(asm-word (reg-mask reg-list (pdec? opnd))))
(if (reg-list? opnd1)
(begin (movem 18624 opnd1 opnd2) (opnd-ext-wr-long opnd2))
(begin (movem 19648 opnd2 opnd1) (opnd-ext-rd-long opnd1)))
(if ofile-asm?
(emit-asm "moveml" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-exg opnd1 opnd2)
(define (exg r1 r2)
(let ((mode (if (dreg? r2) 49472 (if (dreg? r1) 49544 49480)))
(num1 (if (dreg? r1) (dreg-num r1) (areg-num r1)))
(num2 (if (dreg? r2) (dreg-num r2) (areg-num r2))))
(asm-word (+ mode (+ (* num1 512) num2)))))
(if (dreg? opnd2) (exg opnd2 opnd1) (exg opnd1 opnd2))
(if ofile-asm?
(emit-asm "exg" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-eor.l opnd1 opnd2)
(cond ((imm? opnd1)
(asm-word (+ 2688 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2))
(else
(asm-word
(+ 45440 (+ (* (dreg-num opnd1) 512) (opnd->mode/reg opnd2))))
(opnd-ext-wr-long opnd2)))
(if ofile-asm?
(emit-asm "eorl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-and.l opnd1 opnd2)
(cond ((imm? opnd1)
(asm-word (+ 640 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2))
(else
(let ((mode (if (dreg? opnd2) 49280 49536))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-long other)
(opnd-ext-wr-long other)))))
(if ofile-asm?
(emit-asm "andl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-and.w opnd1 opnd2)
(cond ((imm? opnd1)
(asm-word (+ 576 (opnd->mode/reg opnd2)))
(opnd-ext-rd-word opnd1)
(opnd-ext-wr-word opnd2))
(else
(let ((mode (if (dreg? opnd2) 49216 49472))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-word other)
(opnd-ext-wr-word other)))))
(if ofile-asm?
(emit-asm "andw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-or.l opnd1 opnd2)
(cond ((imm? opnd1)
(asm-word (+ 128 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2))
(else
(let ((mode (if (dreg? opnd2) 32896 33152))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-long other)
(opnd-ext-wr-long other)))))
(if ofile-asm?
(emit-asm "orl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-addq.l n opnd)
(let ((m (if (= n 8) 0 n)))
(asm-word (+ 20608 (* m 512) (opnd->mode/reg opnd)))
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "addql" ofile-tab "#" n "," (opnd-str opnd)))))
(define (emit-addq.w n opnd)
(let ((m (if (= n 8) 0 n)))
(asm-word (+ 20544 (* m 512) (opnd->mode/reg opnd)))
(opnd-ext-wr-word opnd)
(if ofile-asm? (emit-asm "addqw" ofile-tab "#" n "," (opnd-str opnd)))))
(define (emit-add.l opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 53696 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-long opnd1))
((imm? opnd1)
(asm-word (+ 1664 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2))
(else
(let ((mode (if (dreg? opnd2) 53376 53632))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-long other)
(opnd-ext-wr-long other)))))
(if ofile-asm?
(emit-asm "addl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-add.w opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 53440 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-word opnd1))
((imm? opnd1)
(asm-word (+ 1600 (opnd->mode/reg opnd2)))
(opnd-ext-rd-word opnd1)
(opnd-ext-wr-word opnd2))
(else
(let ((mode (if (dreg? opnd2) 53312 53568))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-word other)
(opnd-ext-wr-word other)))))
(if ofile-asm?
(emit-asm "addw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-addx.w opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 53568 (+ (* (dreg-num opnd2) 512) (dreg-num opnd1))))
(asm-word
(+ 53576
(+ (* (areg-num (pdec-areg opnd2)) 512)
(areg-num (pdec-areg opnd1))))))
(if ofile-asm?
(emit-asm "addxw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-subq.l n opnd)
(let ((m (if (= n 8) 0 n)))
(asm-word (+ 20864 (* m 512) (opnd->mode/reg opnd)))
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "subql" ofile-tab "#" n "," (opnd-str opnd)))))
(define (emit-subq.w n opnd)
(let ((m (if (= n 8) 0 n)))
(asm-word (+ 20800 (* m 512) (opnd->mode/reg opnd)))
(opnd-ext-wr-word opnd)
(if ofile-asm? (emit-asm "subqw" ofile-tab "#" n "," (opnd-str opnd)))))
(define (emit-sub.l opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 37312 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-long opnd1))
((imm? opnd1)
(asm-word (+ 1152 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-wr-long opnd2))
(else
(let ((mode (if (dreg? opnd2) 36992 37248))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-long other)
(opnd-ext-wr-long other)))))
(if ofile-asm?
(emit-asm "subl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-sub.w opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 37056 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-word opnd1))
((imm? opnd1)
(asm-word (+ 1088 (opnd->mode/reg opnd2)))
(opnd-ext-rd-word opnd1)
(opnd-ext-wr-word opnd2))
(else
(let ((mode (if (dreg? opnd2) 36928 37184))
(reg (if (dreg? opnd2) (dreg-num opnd2) (dreg-num opnd1)))
(other (if (dreg? opnd2) opnd1 opnd2)))
(asm-word (+ mode (+ (* reg 512) (opnd->mode/reg other))))
(if (dreg? opnd2)
(opnd-ext-rd-word other)
(opnd-ext-wr-word other)))))
(if ofile-asm?
(emit-asm "subw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-asl.l opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57760 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57728 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "asll" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-asl.w opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57696 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57664 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "aslw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-asr.l opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57504 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57472 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "asrl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-asr.w opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57440 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57408 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "asrw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-lsl.l opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57768 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57736 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "lsll" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-lsr.l opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57512 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57480 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "lsrl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-lsr.w opnd1 opnd2)
(if (dreg? opnd1)
(asm-word (+ 57448 (+ (* (dreg-num opnd1) 512) (dreg-num opnd2))))
(let ((n (imm-val opnd1)))
(asm-word (+ 57416 (+ (* (if (= n 8) 0 n) 512) (dreg-num opnd2))))))
(if ofile-asm?
(emit-asm "lsrw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-clr.l opnd)
(asm-word (+ 17024 (opnd->mode/reg opnd)))
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "clrl" ofile-tab (opnd-str opnd))))
(define (emit-neg.l opnd)
(asm-word (+ 17536 (opnd->mode/reg opnd)))
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "negl" ofile-tab (opnd-str opnd))))
(define (emit-not.l opnd)
(asm-word (+ 18048 (opnd->mode/reg opnd)))
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "notl" ofile-tab (opnd-str opnd))))
(define (emit-ext.l opnd)
(asm-word (+ 18624 (dreg-num opnd)))
(if ofile-asm? (emit-asm "extl" ofile-tab (opnd-str opnd))))
(define (emit-ext.w opnd)
(asm-word (+ 18560 (dreg-num opnd)))
(if ofile-asm? (emit-asm "extw" ofile-tab (opnd-str opnd))))
(define (emit-swap opnd)
(asm-word (+ 18496 (dreg-num opnd)))
(if ofile-asm? (emit-asm "swap" ofile-tab (opnd-str opnd))))
(define (emit-cmp.l opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 45504 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-long opnd1))
((imm? opnd1)
(asm-word (+ 3200 (opnd->mode/reg opnd2)))
(opnd-ext-rd-long opnd1)
(opnd-ext-rd-long opnd2))
(else
(asm-word
(+ 45184 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-long opnd1)))
(if ofile-asm?
(emit-asm "cmpl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-cmp.w opnd1 opnd2)
(cond ((areg? opnd2)
(asm-word
(+ 45248 (+ (* (areg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-word opnd1))
((imm? opnd1)
(asm-word (+ 3136 (opnd->mode/reg opnd2)))
(opnd-ext-rd-word opnd1)
(opnd-ext-rd-word opnd2))
(else
(asm-word
(+ 45120 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-word opnd1)))
(if ofile-asm?
(emit-asm "cmpw" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-cmp.b opnd1 opnd2)
(cond ((imm? opnd1)
(asm-word (+ 3072 (opnd->mode/reg opnd2)))
(opnd-ext-rd-word opnd1)
(opnd-ext-rd-word opnd2))
(else
(asm-word
(+ 45056 (+ (* (dreg-num opnd2) 512) (opnd->mode/reg opnd1))))
(opnd-ext-rd-word opnd1)))
(if ofile-asm?
(emit-asm "cmpb" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-tst.l opnd)
(asm-word (+ 19072 (opnd->mode/reg opnd)))
(opnd-ext-rd-long opnd)
(if ofile-asm? (emit-asm "tstl" ofile-tab (opnd-str opnd))))
(define (emit-tst.w opnd)
(asm-word (+ 19008 (opnd->mode/reg opnd)))
(opnd-ext-rd-word opnd)
(if ofile-asm? (emit-asm "tstw" ofile-tab (opnd-str opnd))))
(define (emit-lea opnd areg)
(asm-word (+ 16832 (+ (* (areg-num areg) 512) (opnd->mode/reg opnd))))
(opnd-ext-rd-long opnd)
(if ofile-asm?
(emit-asm "lea" ofile-tab (opnd-str opnd) "," (opnd-str areg))))
(define (emit-unlk areg)
(asm-word (+ 20056 (areg-num areg)))
(if ofile-asm? (emit-asm "unlk" ofile-tab (opnd-str areg))))
(define (emit-move-proc num opnd)
(let ((dst (opnd->reg/mode opnd)))
(asm-word (+ 8192 (+ dst 60)))
(asm-proc-ref num 0)
(opnd-ext-wr-long opnd)
(if ofile-asm? (emit-asm "MOVE_PROC(" num "," (opnd-str opnd) ")"))))
(define (emit-move-prim val opnd)
(let ((dst (opnd->reg/mode opnd)))
(asm-word (+ 8192 (+ dst 60)))
(asm-prim-ref val 0)
(opnd-ext-wr-long opnd)
(if ofile-asm?
(emit-asm "MOVE_PRIM(" (proc-obj-name val) "," (opnd-str opnd) ")"))))
(define (emit-pea opnd)
(asm-word (+ 18496 (opnd->mode/reg opnd)))
(opnd-ext-rd-long opnd)
(if ofile-asm? (emit-asm "pea" ofile-tab (opnd-str opnd))))
(define (emit-pea* n)
(asm-word 18552)
(asm-word n)
(if ofile-asm? (emit-asm "pea" ofile-tab n)))
(define (emit-btst opnd1 opnd2)
(asm-word (+ 256 (+ (* (dreg-num opnd1) 512) (opnd->mode/reg opnd2))))
(opnd-ext-rd-word opnd2)
(if ofile-asm?
(emit-asm "btst" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-bra lbl)
(asm-brel 24576 lbl)
(if ofile-asm? (emit-asm "bra" ofile-tab "L" lbl)))
(define (emit-bcc lbl)
(asm-brel 25600 lbl)
(if ofile-asm? (emit-asm "bcc" ofile-tab "L" lbl)))
(define (emit-bcs lbl)
(asm-brel 25856 lbl)
(if ofile-asm? (emit-asm "bcs" ofile-tab "L" lbl)))
(define (emit-bhi lbl)
(asm-brel 25088 lbl)
(if ofile-asm? (emit-asm "bhi" ofile-tab "L" lbl)))
(define (emit-bls lbl)
(asm-brel 25344 lbl)
(if ofile-asm? (emit-asm "bls" ofile-tab "L" lbl)))
(define (emit-bmi lbl)
(asm-brel 27392 lbl)
(if ofile-asm? (emit-asm "bmi" ofile-tab "L" lbl)))
(define (emit-bpl lbl)
(asm-brel 27136 lbl)
(if ofile-asm? (emit-asm "bpl" ofile-tab "L" lbl)))
(define (emit-beq lbl)
(asm-brel 26368 lbl)
(if ofile-asm? (emit-asm "beq" ofile-tab "L" lbl)))
(define (emit-bne lbl)
(asm-brel 26112 lbl)
(if ofile-asm? (emit-asm "bne" ofile-tab "L" lbl)))
(define (emit-blt lbl)
(asm-brel 27904 lbl)
(if ofile-asm? (emit-asm "blt" ofile-tab "L" lbl)))
(define (emit-bgt lbl)
(asm-brel 28160 lbl)
(if ofile-asm? (emit-asm "bgt" ofile-tab "L" lbl)))
(define (emit-ble lbl)
(asm-brel 28416 lbl)
(if ofile-asm? (emit-asm "ble" ofile-tab "L" lbl)))
(define (emit-bge lbl)
(asm-brel 27648 lbl)
(if ofile-asm? (emit-asm "bge" ofile-tab "L" lbl)))
(define (emit-dbra dreg lbl)
(asm-word (+ 20936 dreg))
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "dbra" ofile-tab (opnd-str dreg) ",L" lbl)))
(define (emit-trap num)
(asm-word (+ 20032 num))
(if ofile-asm? (emit-asm "trap" ofile-tab "#" num)))
(define (emit-trap1 num args)
(asm-word (+ 20136 (areg-num table-reg)))
(asm-word (trap-offset num))
(let loop ((args args))
(if (not (null? args)) (begin (asm-word (car args)) (loop (cdr args)))))
(if ofile-asm?
(let ()
(define (words l)
(if (null? l) (list ")") (cons "," (cons (car l) (words (cdr l))))))
(apply emit-asm (cons "TRAP1(" (cons num (words args)))))))
(define (emit-trap2 num args)
(asm-word (+ 20136 (areg-num table-reg)))
(asm-word (trap-offset num))
(asm-align 8 (modulo (- 4 (* (length args) 2)) 8))
(let loop ((args args))
(if (not (null? args)) (begin (asm-word (car args)) (loop (cdr args)))))
(if ofile-asm?
(let ()
(define (words l)
(if (null? l) (list ")") (cons "," (cons (car l) (words (cdr l))))))
(apply emit-asm (cons "TRAP2(" (cons num (words args)))))))
(define (emit-trap3 num)
(asm-word (+ 20200 (areg-num table-reg)))
(asm-word (trap-offset num))
(if ofile-asm? (emit-asm "TRAP3(" num ")")))
(define (emit-rts) (asm-word 20085) (if ofile-asm? (emit-asm "rts")))
(define (emit-nop) (asm-word 20081) (if ofile-asm? (emit-asm "nop")))
(define (emit-jmp opnd)
(asm-word (+ 20160 (opnd->mode/reg opnd)))
(opnd-ext-rd-long opnd)
(if ofile-asm? (emit-asm "jmp" ofile-tab (opnd-str opnd))))
(define (emit-jmp-glob glob)
(asm-word 8814)
(asm-ref-glob-jump glob)
(asm-word 20177)
(if ofile-asm? (emit-asm "JMP_GLOB(" (glob-name glob) ")")))
(define (emit-jmp-proc num offset)
(asm-word 20217)
(asm-proc-ref num offset)
(if ofile-asm? (emit-asm "JMP_PROC(" num "," offset ")")))
(define (emit-jmp-prim val offset)
(asm-word 20217)
(asm-prim-ref val offset)
(if ofile-asm? (emit-asm "JMP_PRIM(" (proc-obj-name val) "," offset ")")))
(define (emit-jsr opnd)
(asm-word (+ 20096 (opnd->mode/reg opnd)))
(opnd-ext-rd-long opnd)
(if ofile-asm? (emit-asm "jsr" ofile-tab (opnd-str opnd))))
(define (emit-word n)
(asm-word n)
(if ofile-asm? (emit-asm ".word" ofile-tab n)))
(define (emit-label lbl)
(asm-label lbl #f)
(if ofile-asm? (emit-asm* "L" lbl ":")))
(define (emit-label-subproc lbl parent-lbl label-descr)
(asm-align 8 0)
(asm-wrel parent-lbl (- 32768 type-procedure))
(asm-label lbl label-descr)
(if ofile-asm?
(begin (emit-asm "SUBPROC(L" parent-lbl ")") (emit-asm* "L" lbl ":"))))
(define (emit-label-return lbl parent-lbl fs link label-descr)
(asm-align 8 4)
(asm-word (* fs 4))
(asm-word (* (- fs link) 4))
(asm-wrel parent-lbl (- 32768 type-procedure))
(asm-label lbl label-descr)
(if ofile-asm?
(begin
(emit-asm "RETURN(L" parent-lbl "," fs "," link ")")
(emit-asm* "L" lbl ":"))))
(define (emit-label-task-return lbl parent-lbl fs link label-descr)
(asm-align 8 4)
(asm-word (+ 32768 (* fs 4)))
(asm-word (* (- fs link) 4))
(asm-wrel parent-lbl (- 32768 type-procedure))
(asm-label lbl label-descr)
(if ofile-asm?
(begin
(emit-asm "TASK_RETURN(L" parent-lbl "," fs "," link ")")
(emit-asm* "L" lbl ":"))))
(define (emit-lbl-ptr lbl)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "LBL_PTR(L" lbl ")")))
(define (emit-set-glob glob)
(asm-set-glob glob)
(if ofile-asm? (emit-asm "SET_GLOB(" (glob-name glob) ")")))
(define (emit-const obj)
(let ((n (pos-in-list obj (queue->list asm-const-queue))))
(if n
(make-pcr const-lbl (* n 4))
(let ((m (length (queue->list asm-const-queue))))
(queue-put! asm-const-queue obj)
(make-pcr const-lbl (* m 4))))))
(define (emit-stat stat)
(asm-word 21177)
(asm-stat stat)
(if ofile-asm? (emit-asm "STAT(" stat ")")))
(define (emit-asm . l) (asm-comment (cons ofile-tab l)))
(define (emit-asm* . l) (asm-comment l))
(define (emit-muls.l opnd1 opnd2)
(asm-m68020-proc)
(asm-word (+ 19456 (opnd->mode/reg opnd1)))
(asm-word (+ 2048 (* (dreg-num opnd2) 4096)))
(opnd-ext-rd-long opnd1)
(if ofile-asm?
(emit-asm "mulsl" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-divsl.l opnd1 opnd2 opnd3)
(asm-m68020-proc)
(asm-word (+ 19520 (opnd->mode/reg opnd1)))
(asm-word (+ 2048 (* (dreg-num opnd3) 4096) (dreg-num opnd2)))
(opnd-ext-rd-long opnd1)
(if ofile-asm?
(emit-asm
"divsll"
ofile-tab
(opnd-str opnd1)
","
(opnd-str opnd2)
":"
(opnd-str opnd3))))
(define (emit-fint.dx opnd1 opnd2) (emit-fop.dx "int" 1 opnd1 opnd2))
(define (emit-fsinh.dx opnd1 opnd2) (emit-fop.dx "sinh" 2 opnd1 opnd2))
(define (emit-fintrz.dx opnd1 opnd2) (emit-fop.dx "intrz" 3 opnd1 opnd2))
(define (emit-fsqrt.dx opnd1 opnd2) (emit-fop.dx "sqrt" 4 opnd1 opnd2))
(define (emit-flognp1.dx opnd1 opnd2) (emit-fop.dx "lognp1" 6 opnd1 opnd2))
(define (emit-fetoxm1.dx opnd1 opnd2) (emit-fop.dx "etoxm1" 8 opnd1 opnd2))
(define (emit-ftanh.dx opnd1 opnd2) (emit-fop.dx "tanh" 9 opnd1 opnd2))
(define (emit-fatan.dx opnd1 opnd2) (emit-fop.dx "atan" 10 opnd1 opnd2))
(define (emit-fasin.dx opnd1 opnd2) (emit-fop.dx "asin" 12 opnd1 opnd2))
(define (emit-fatanh.dx opnd1 opnd2) (emit-fop.dx "atanh" 13 opnd1 opnd2))
(define (emit-fsin.dx opnd1 opnd2) (emit-fop.dx "sin" 14 opnd1 opnd2))
(define (emit-ftan.dx opnd1 opnd2) (emit-fop.dx "tan" 15 opnd1 opnd2))
(define (emit-fetox.dx opnd1 opnd2) (emit-fop.dx "etox" 16 opnd1 opnd2))
(define (emit-ftwotox.dx opnd1 opnd2) (emit-fop.dx "twotox" 17 opnd1 opnd2))
(define (emit-ftentox.dx opnd1 opnd2) (emit-fop.dx "tentox" 18 opnd1 opnd2))
(define (emit-flogn.dx opnd1 opnd2) (emit-fop.dx "logn" 20 opnd1 opnd2))
(define (emit-flog10.dx opnd1 opnd2) (emit-fop.dx "log10" 21 opnd1 opnd2))
(define (emit-flog2.dx opnd1 opnd2) (emit-fop.dx "log2" 22 opnd1 opnd2))
(define (emit-fabs.dx opnd1 opnd2) (emit-fop.dx "abs" 24 opnd1 opnd2))
(define (emit-fcosh.dx opnd1 opnd2) (emit-fop.dx "cosh" 25 opnd1 opnd2))
(define (emit-fneg.dx opnd1 opnd2) (emit-fop.dx "neg" 26 opnd1 opnd2))
(define (emit-facos.dx opnd1 opnd2) (emit-fop.dx "acos" 28 opnd1 opnd2))
(define (emit-fcos.dx opnd1 opnd2) (emit-fop.dx "cos" 29 opnd1 opnd2))
(define (emit-fgetexp.dx opnd1 opnd2) (emit-fop.dx "getexp" 30 opnd1 opnd2))
(define (emit-fgetman.dx opnd1 opnd2) (emit-fop.dx "getman" 31 opnd1 opnd2))
(define (emit-fdiv.dx opnd1 opnd2) (emit-fop.dx "div" 32 opnd1 opnd2))
(define (emit-fmod.dx opnd1 opnd2) (emit-fop.dx "mod" 33 opnd1 opnd2))
(define (emit-fadd.dx opnd1 opnd2) (emit-fop.dx "add" 34 opnd1 opnd2))
(define (emit-fmul.dx opnd1 opnd2) (emit-fop.dx "mul" 35 opnd1 opnd2))
(define (emit-fsgldiv.dx opnd1 opnd2) (emit-fop.dx "sgldiv" 36 opnd1 opnd2))
(define (emit-frem.dx opnd1 opnd2) (emit-fop.dx "rem" 37 opnd1 opnd2))
(define (emit-fscale.dx opnd1 opnd2) (emit-fop.dx "scale" 38 opnd1 opnd2))
(define (emit-fsglmul.dx opnd1 opnd2) (emit-fop.dx "sglmul" 39 opnd1 opnd2))
(define (emit-fsub.dx opnd1 opnd2) (emit-fop.dx "sub" 40 opnd1 opnd2))
(define (emit-fcmp.dx opnd1 opnd2) (emit-fop.dx "cmp" 56 opnd1 opnd2))
(define (emit-fop.dx name code opnd1 opnd2)
(asm-m68881-proc)
(asm-word (+ 61952 (opnd->mode/reg opnd1)))
(asm-word
(+ (if (freg? opnd1) (* (freg-num opnd1) 1024) 21504)
(* (freg-num opnd2) 128)
code))
(opnd-ext-rd-long opnd1)
(if ofile-asm?
(emit-asm
"f"
name
(if (freg? opnd1) "x" "d")
ofile-tab
(opnd-str opnd1)
","
(opnd-str opnd2))))
(define (emit-fmov.dx opnd1 opnd2)
(emit-fmov
(if (and (freg? opnd1) (freg? opnd2)) (* (freg-num opnd1) 1024) 21504)
opnd1
opnd2)
(if ofile-asm?
(emit-asm
(if (and (freg? opnd1) (freg? opnd2)) "fmovex" "fmoved")
ofile-tab
(opnd-str opnd1)
","
(opnd-str opnd2))))
(define (emit-fmov.l opnd1 opnd2)
(emit-fmov 16384 opnd1 opnd2)
(if ofile-asm?
(emit-asm "fmovel" ofile-tab (opnd-str opnd1) "," (opnd-str opnd2))))
(define (emit-fmov code opnd1 opnd2)
(define (fmov code opnd1 opnd2)
(asm-m68881-proc)
(asm-word (+ 61952 (opnd->mode/reg opnd1)))
(asm-word (+ (* (freg-num opnd2) 128) code))
(opnd-ext-rd-long opnd1))
(if (freg? opnd2) (fmov code opnd1 opnd2) (fmov (+ code 8192) opnd2 opnd1)))
(define (emit-fbeq lbl)
(asm-m68881-proc)
(asm-word 62081)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fbeq" ofile-tab "L" lbl)))
(define (emit-fbne lbl)
(asm-m68881-proc)
(asm-word 62094)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fbne" ofile-tab "L" lbl)))
(define (emit-fblt lbl)
(asm-m68881-proc)
(asm-word 62100)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fblt" ofile-tab "L" lbl)))
(define (emit-fbgt lbl)
(asm-m68881-proc)
(asm-word 62098)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fbgt" ofile-tab "L" lbl)))
(define (emit-fble lbl)
(asm-m68881-proc)
(asm-word 62101)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fble" ofile-tab "L" lbl)))
(define (emit-fbge lbl)
(asm-m68881-proc)
(asm-word 62099)
(asm-wrel lbl 0)
(if ofile-asm? (emit-asm "fbge" ofile-tab "L" lbl)))
(define (opnd->mode/reg opnd)
(cond ((disp? opnd) (+ 32 (disp-areg opnd)))
((inx? opnd) (+ 40 (inx-areg opnd)))
((pcr? opnd) 58)
((imm? opnd) 60)
((glob? opnd) (+ 32 table-reg))
((freg? opnd) 0)
(else opnd)))
(define (opnd->reg/mode opnd)
(let ((x (opnd->mode/reg opnd)))
(* (+ (* 8 (remainder x 8)) (quotient x 8)) 64)))
(define (opnd-ext-rd-long opnd) (opnd-extension opnd #f #f))
(define (opnd-ext-rd-word opnd) (opnd-extension opnd #f #t))
(define (opnd-ext-wr-long opnd) (opnd-extension opnd #t #f))
(define (opnd-ext-wr-word opnd) (opnd-extension opnd #t #t))
(define (opnd-extension opnd write? word?)
(cond ((disp? opnd) (asm-word (disp-offset opnd)))
((inx? opnd)
(asm-word
(+ (+ (* (inx-ireg opnd) 4096) 2048)
(modulo (inx-offset opnd) 256))))
((pcr? opnd) (asm-wrel (pcr-lbl opnd) (pcr-offset opnd)))
((imm? opnd)
(if word? (asm-word (imm-val opnd)) (asm-long (imm-val opnd))))
((glob? opnd) (if write? (asm-set-glob opnd) (asm-ref-glob opnd)))))
(define (opnd-str opnd)
(cond ((dreg? opnd)
(vector-ref
'#("d0" "d1" "d2" "d3" "d4" "d5" "d6" "d7")
(dreg-num opnd)))
((areg? opnd)
(vector-ref
'#("a0" "a1" "a2" "a3" "a4" "a5" "a6" "sp")
(areg-num opnd)))
((ind? opnd)
(vector-ref
'#("a0@" "a1@" "a2@" "a3@" "a4@" "a5@" "a6@" "sp@")
(areg-num (ind-areg opnd))))
((pinc? opnd)
(vector-ref
'#("a0@+" "a1@+" "a2@+" "a3@+" "a4@+" "a5@+" "a6@+" "sp@+")
(areg-num (pinc-areg opnd))))
((pdec? opnd)
(vector-ref
'#("a0@-" "a1@-" "a2@-" "a3@-" "a4@-" "a5@-" "a6@-" "sp@-")
(areg-num (pdec-areg opnd))))
((disp? opnd)
(string-append
(opnd-str (disp-areg opnd))
"@("
(number->string (disp-offset opnd))
")"))
((inx? opnd)
(string-append
(opnd-str (inx-areg opnd))
"@("
(number->string (inx-offset opnd))
","
(opnd-str (inx-ireg opnd))
":l)"))
((pcr? opnd)
(let ((lbl (pcr-lbl opnd)) (offs (pcr-offset opnd)))
(if (= offs 0)
(string-append "L" (number->string lbl))
(string-append
"L"
(number->string lbl)
"+"
(number->string offs)))))
((imm? opnd) (string-append "#" (number->string (imm-val opnd))))
((glob? opnd)
(string-append "GLOB(" (symbol->string (glob-name opnd)) ")"))
((freg? opnd)
(vector-ref
'#("fp0" "fp1" "fp2" "fp3" "fp4" "fp5" "fp6" "fp7")
(freg-num opnd)))
((reg-list? opnd)
(let loop ((l (reg-list-regs opnd)) (result "[") (sep ""))
(if (pair? l)
(loop (cdr l) (string-append result sep (opnd-str (car l))) "/")
(string-append result "]"))))
(else (compiler-internal-error "opnd-str, unknown 'opnd'" opnd))))
(define (begin! info-port targ)
(set! return-reg (make-reg 0))
(target-end!-set! targ end!)
(target-dump-set! targ dump)
(target-nb-regs-set! targ nb-gvm-regs)
(target-prim-info-set! targ prim-info)
(target-label-info-set! targ label-info)
(target-jump-info-set! targ jump-info)
(target-proc-result-set! targ (make-reg 1))
(target-task-return-set! targ return-reg)
(set! *info-port* info-port)
'())
(define (end!) '())
(define *info-port* '())
(define nb-gvm-regs 5)
(define nb-arg-regs 3)
(define pointer-size 4)
(define prim-proc-table
(map (lambda (x)
(cons (string->canonical-symbol (car x))
(apply make-proc-obj (car x) #t #f (cdr x))))
prim-procs))
(define (prim-info name)
(let ((x (assq name prim-proc-table))) (if x (cdr x) #f)))
(define (get-prim-info name)
(let ((proc (prim-info (string->canonical-symbol name))))
(if proc
proc
(compiler-internal-error "get-prim-info, unknown primitive:" name))))
(define (label-info min-args nb-parms rest? closed?)
(let ((nb-stacked (max 0 (- nb-parms nb-arg-regs))))
(define (location-of-parms i)
(if (> i nb-parms)
'()
(cons (cons i
(if (> i nb-stacked)
(make-reg (- i nb-stacked))
(make-stk i)))
(location-of-parms (+ i 1)))))
(let ((x (cons (cons 'return 0) (location-of-parms 1))))
(make-pcontext
nb-stacked
(if closed?
(cons (cons 'closure-env (make-reg (+ nb-arg-regs 1))) x)
x)))))
(define (jump-info nb-args)
(let ((nb-stacked (max 0 (- nb-args nb-arg-regs))))
(define (location-of-args i)
(if (> i nb-args)
'()
(cons (cons i
(if (> i nb-stacked)
(make-reg (- i nb-stacked))
(make-stk i)))
(location-of-args (+ i 1)))))
(make-pcontext
nb-stacked
(cons (cons 'return (make-reg 0)) (location-of-args 1)))))
(define (closed-var-offset i) (+ (* i pointer-size) 2))
(define (dump proc filename c-intf options)
(if *info-port*
(begin (display "Dumping:" *info-port*) (newline *info-port*)))
(set! ofile-asm? (memq 'asm options))
(set! ofile-stats? (memq 'stats options))
(set! debug-info? (memq 'debug options))
(set! object-queue (queue-empty))
(set! objects-dumped (queue-empty))
(ofile.begin! filename add-object)
(queue-put! object-queue proc)
(queue-put! objects-dumped proc)
(let loop ((index 0))
(if (not (queue-empty? object-queue))
(let ((obj (queue-get! object-queue)))
(dump-object obj index)
(loop (+ index 1)))))
(ofile.end!)
(if *info-port* (newline *info-port*))
(set! object-queue '())
(set! objects-dumped '()))
(define debug-info? '())
(define object-queue '())
(define objects-dumped '())
(define (add-object obj)
(if (and (proc-obj? obj) (not (proc-obj-code obj)))
#f
(let ((n (pos-in-list obj (queue->list objects-dumped))))
(if n
n
(let ((m (length (queue->list objects-dumped))))
(queue-put! objects-dumped obj)
(queue-put! object-queue obj)
m)))))
(define (dump-object obj index)
(ofile-line "|------------------------------------------------------")
(case (obj-type obj)
((pair) (dump-pair obj))
((flonum) (dump-flonum obj))
((subtyped)
(case (obj-subtype obj)
((vector) (dump-vector obj))
((symbol) (dump-symbol obj))
;; ((ratnum) (dump-ratnum obj))
;; ((cpxnum) (dump-cpxnum obj))
((string) (dump-string obj))
((bignum) (dump-bignum obj))
(else
(compiler-internal-error
"dump-object, can't dump object 'obj':"
obj))))
((procedure) (dump-procedure obj))
(else
(compiler-internal-error "dump-object, can't dump object 'obj':" obj))))
(define (dump-pair pair)
(ofile-long pair-prefix)
(ofile-ref (cdr pair))
(ofile-ref (car pair)))
(define (dump-vector v)
(ofile-long (+ (* (vector-length v) 1024) (* subtype-vector 8)))
(let ((len (vector-length v)))
(let loop ((i 0))
(if (< i len) (begin (ofile-ref (vector-ref v i)) (loop (+ i 1)))))))
(define (dump-symbol sym)
(compiler-internal-error "dump-symbol, can't dump SYMBOL type"))
;;(define (dump-ratnum x)
;; (ofile-long (+ (* 2 1024) (* subtype-ratnum 8)))
;; (ofile-ref (numerator x))
;; (ofile-ref (denominator x)))
;;(define (dump-cpxnum x)
;; (ofile-long (+ (* 2 1024) (* subtype-cpxnum 8)))
;; (ofile-ref (real-part x))
;; (ofile-ref (imag-part x)))
(define (dump-string s)
(ofile-long (+ (* (+ (string-length s) 1) 256) (* subtype-string 8)))
(let ((len (string-length s)))
(define (ref i) (if (>= i len) 0 (character-encoding (string-ref s i))))
(let loop ((i 0))
(if (<= i len)
(begin
(ofile-word (+ (* (ref i) 256) (ref (+ i 1))))
(loop (+ i 2)))))))
(define (dump-flonum x)
(let ((bits (flonum->bits x)))
(ofile-long flonum-prefix)
(ofile-long (quotient bits 4294967296))
(ofile-long (modulo bits 4294967296))))
(define (flonum->inexact-exponential-format x)
(define (exp-form-pos x y i)
(let ((i*2 (+ i i)))
(let ((z (if (and (not (< flonum-e-bias i*2)) (not (< x y)))
(exp-form-pos x (* y y) i*2)
(cons x 0))))
(let ((a (car z)) (b (cdr z)))
(let ((i+b (+ i b)))
(if (and (not (< flonum-e-bias i+b)) (not (< a y)))
(begin (set-car! z (/ a y)) (set-cdr! z i+b)))
z)))))
(define (exp-form-neg x y i)
(let ((i*2 (+ i i)))
(let ((z (if (and (< i*2 flonum-e-bias-minus-1) (< x y))
(exp-form-neg x (* y y) i*2)
(cons x 0))))
(let ((a (car z)) (b (cdr z)))
(let ((i+b (+ i b)))
(if (and (< i+b flonum-e-bias-minus-1) (< a y))
(begin (set-car! z (/ a y)) (set-cdr! z i+b)))
z)))))
(define (exp-form x)
(if (< x inexact-+1)
(let ((z (exp-form-neg x inexact-+1/2 1)))
(set-car! z (* inexact-+2 (car z)))
(set-cdr! z (- -1 (cdr z)))
z)
(exp-form-pos x inexact-+2 1)))
(if (negative? x)
(let ((z (exp-form (- inexact-0 x))))
(set-car! z (- inexact-0 (car z)))
z)
(exp-form x)))
(define (flonum->exact-exponential-format x)
(let ((z (flonum->inexact-exponential-format x)))
(let ((y (car z)))
(cond ((not (< y inexact-+2))
(set-car! z flonum-+m-min)
(set-cdr! z flonum-e-bias-plus-1))
((not (< inexact--2 y))
(set-car! z flonum--m-min)
(set-cdr! z flonum-e-bias-plus-1))
(else
(set-car!
z
(truncate (inexact->exact (* (car z) inexact-m-min))))))
(set-cdr! z (- (cdr z) flonum-m-bits))
z)))
(define (flonum->bits x)
(define (bits a b)
(if (< a flonum-+m-min)
a
(+ (- a flonum-+m-min)
(* (+ (+ b flonum-m-bits) flonum-e-bias) flonum-+m-min))))
(let ((z (flonum->exact-exponential-format x)))
(let ((a (car z)) (b (cdr z)))
(if (negative? a) (+ flonum-sign-bit (bits (- 0 a) b)) (bits a b)))))
(define flonum-m-bits 52)
(define flonum-e-bits 11)
(define flonum-sign-bit 9223372036854775808)
(define flonum-+m-min 4503599627370496)
(define flonum--m-min -4503599627370496)
(define flonum-e-bias 1023)
(define flonum-e-bias-plus-1 1024)
(define flonum-e-bias-minus-1 1022)
(define inexact-m-min (exact->inexact flonum-+m-min))
(define inexact-+2 (exact->inexact 2))
(define inexact--2 (exact->inexact -2))
(define inexact-+1 (exact->inexact 1))
(define inexact-+1/2 (/ (exact->inexact 1) (exact->inexact 2)))
(define inexact-0 (exact->inexact 0))
(define (dump-bignum x)
(define radix 16384)
(define (integer->digits n)
(if (= n 0)
'()
(cons (remainder n radix) (integer->digits (quotient n radix)))))
(let ((l (integer->digits (abs x))))
(ofile-long (+ (* (+ (length l) 1) 512) (* subtype-bignum 8)))
(if (< x 0) (ofile-word 0) (ofile-word 1))
(for-each ofile-word l)))
(define (dump-procedure proc)
(let ((bbs (proc-obj-code proc)))
(set! entry-lbl-num (bbs-entry-lbl-num bbs))
(set! label-counter (bbs-lbl-counter bbs))
(set! var-descr-queue (queue-empty))
(set! first-class-label-queue (queue-empty))
(set! deferred-code-queue (queue-empty))
(if *info-port*
(begin
(display " #[" *info-port*)
(if (proc-obj-primitive? proc)
(display "primitive " *info-port*)
(display "procedure " *info-port*))
(display (proc-obj-name proc) *info-port*)
(display "]" *info-port*)))
(if (proc-obj-primitive? proc)
(ofile-prim-proc (proc-obj-name proc))
(ofile-user-proc))
(asm.begin!)
(let loop ((prev-bb #f) (prev-gvm-instr #f) (l (bbs->code-list bbs)))
(if (not (null? l))
(let ((pres-bb (code-bb (car l)))
(pres-gvm-instr (code-gvm-instr (car l)))
(pres-slots-needed (code-slots-needed (car l)))
(next-gvm-instr
(if (null? (cdr l)) #f (code-gvm-instr (cadr l)))))
(if ofile-asm? (asm-comment (car l)))
(gen-gvm-instr
prev-gvm-instr
pres-gvm-instr
next-gvm-instr
pres-slots-needed)
(loop pres-bb pres-gvm-instr (cdr l)))))
(asm.end!
(if debug-info?
(vector (lst->vector (queue->list first-class-label-queue))
(lst->vector (queue->list var-descr-queue)))
#f))
(if *info-port* (newline *info-port*))
(set! var-descr-queue '())
(set! first-class-label-queue '())
(set! deferred-code-queue '())
(set! instr-source '())
(set! entry-frame '())
(set! exit-frame '())))
(define label-counter (lambda () 0))
(define entry-lbl-num '())
(define var-descr-queue '())
(define first-class-label-queue '())
(define deferred-code-queue '())
(define instr-source '())
(define entry-frame '())
(define exit-frame '())
(define (defer-code! thunk) (queue-put! deferred-code-queue thunk))
(define (gen-deferred-code!)
(let loop ()
(if (not (queue-empty? deferred-code-queue))
(let ((thunk (queue-get! deferred-code-queue))) (thunk) (loop)))))
(define (add-var-descr! descr)
(define (index x l)
(let loop ((l l) (i 0))
(cond ((not (pair? l)) #f)
((equal? (car l) x) i)
(else (loop (cdr l) (+ i 1))))))
(let ((n (index descr (queue->list var-descr-queue))))
(if n
n
(let ((m (length (queue->list var-descr-queue))))
(queue-put! var-descr-queue descr)
m))))
(define (add-first-class-label! source slots frame)
(let loop ((i 0) (l1 slots) (l2 '()))
(if (pair? l1)
(let ((var (car l1)))
(let ((x (frame-live? var frame)))
(if (and x (or (pair? x) (not (temp-var? x))))
(let ((descr-index
(add-var-descr!
(if (pair? x)
(map (lambda (y) (add-var-descr! (var-name y))) x)
(var-name x)))))
(loop (+ i 1)
(cdr l1)
(cons (+ (* i 16384) descr-index) l2)))
(loop (+ i 1) (cdr l1) l2))))
(let ((label-descr (lst->vector (cons 0 (cons source l2)))))
(queue-put! first-class-label-queue label-descr)
label-descr))))
(define (gen-gvm-instr prev-gvm-instr gvm-instr next-gvm-instr sn)
(set! instr-source (comment-get (gvm-instr-comment gvm-instr) 'source))
(set! exit-frame (gvm-instr-frame gvm-instr))
(set! entry-frame (and prev-gvm-instr (gvm-instr-frame prev-gvm-instr)))
(case (gvm-instr-type gvm-instr)
((label)
(set! entry-frame exit-frame)
(set! current-fs (frame-size exit-frame))
(case (label-type gvm-instr)
((simple) (gen-label-simple (label-lbl-num gvm-instr) sn))
((entry)
(gen-label-entry
(label-lbl-num gvm-instr)
(label-entry-nb-parms gvm-instr)
(label-entry-min gvm-instr)
(label-entry-rest? gvm-instr)
(label-entry-closed? gvm-instr)
sn))
((return) (gen-label-return (label-lbl-num gvm-instr) sn))
((task-entry) (gen-label-task-entry (label-lbl-num gvm-instr) sn))
((task-return) (gen-label-task-return (label-lbl-num gvm-instr) sn))
(else (compiler-internal-error "gen-gvm-instr, unknown label type"))))
((apply)
(gen-apply
(apply-prim gvm-instr)
(apply-opnds gvm-instr)
(apply-loc gvm-instr)
sn))
((copy) (gen-copy (copy-opnd gvm-instr) (copy-loc gvm-instr) sn))
((close) (gen-close (close-parms gvm-instr) sn))
((ifjump)
(gen-ifjump
(ifjump-test gvm-instr)
(ifjump-opnds gvm-instr)
(ifjump-true gvm-instr)
(ifjump-false gvm-instr)
(ifjump-poll? gvm-instr)
(if (and next-gvm-instr
(memq (label-type next-gvm-instr) '(simple task-entry)))
(label-lbl-num next-gvm-instr)
#f)))
((jump)
(gen-jump
(jump-opnd gvm-instr)
(jump-nb-args gvm-instr)
(jump-poll? gvm-instr)
(if (and next-gvm-instr
(memq (label-type next-gvm-instr) '(simple task-entry)))
(label-lbl-num next-gvm-instr)
#f)))
(else
(compiler-internal-error
"gen-gvm-instr, unknown 'gvm-instr':"
gvm-instr))))
(define (reg-in-opnd68 opnd)
(cond ((dreg? opnd) opnd)
((areg? opnd) opnd)
((ind? opnd) (ind-areg opnd))
((pinc? opnd) (pinc-areg opnd))
((pdec? opnd) (pdec-areg opnd))
((disp? opnd) (disp-areg opnd))
((inx? opnd) (inx-ireg opnd))
(else #f)))
(define (temp-in-opnd68 opnd)
(let ((reg (reg-in-opnd68 opnd)))
(if reg
(cond ((identical-opnd68? reg dtemp1) reg)
((identical-opnd68? reg atemp1) reg)
((identical-opnd68? reg atemp2) reg)
(else #f))
#f)))
(define (pick-atemp keep)
(if (and keep (identical-opnd68? keep atemp1)) atemp2 atemp1))
(define return-reg '())
(define max-nb-args 1024)
(define heap-allocation-fudge (* pointer-size (+ (* 2 max-nb-args) 1024)))
(define intr-flag 0)
(define ltq-tail 1)
(define ltq-head 2)
(define heap-lim 12)
(define closure-lim 17)
(define closure-ptr 18)
(define intr-flag-slot (make-disp* pstate-reg (* pointer-size intr-flag)))
(define ltq-tail-slot (make-disp* pstate-reg (* pointer-size ltq-tail)))
(define ltq-head-slot (make-disp* pstate-reg (* pointer-size ltq-head)))
(define heap-lim-slot (make-disp* pstate-reg (* pointer-size heap-lim)))
(define closure-lim-slot (make-disp* pstate-reg (* pointer-size closure-lim)))
(define closure-ptr-slot (make-disp* pstate-reg (* pointer-size closure-ptr)))
(define touch-trap 1)
(define non-proc-jump-trap 6)
(define rest-params-trap 7)
(define rest-params-closed-trap 8)
(define wrong-nb-arg1-trap 9)
(define wrong-nb-arg1-closed-trap 10)
(define wrong-nb-arg2-trap 11)
(define wrong-nb-arg2-closed-trap 12)
(define heap-alloc1-trap 13)
(define heap-alloc2-trap 14)
(define closure-alloc-trap 15)
(define intr-trap 24)
(define cache-line-length 16)
(define polling-intermittency '())
(set! polling-intermittency 10)
(define (stat-clear!) (set! *stats* (cons 0 '())))
(define (stat-dump!) (emit-stat (cdr *stats*)))
(define (stat-add! bin count)
(define (add! stats bin count)
(set-car! stats (+ (car stats) count))
(if (not (null? bin))
(let ((x (assoc (car bin) (cdr stats))))
(if x
(add! (cdr x) (cdr bin) count)
(begin
(set-cdr! stats (cons (list (car bin) 0) (cdr stats)))
(add! (cdadr stats) (cdr bin) count))))))
(add! *stats* bin count))
(define (fetch-stat-add! gvm-opnd) (opnd-stat-add! 'fetch gvm-opnd))
(define (store-stat-add! gvm-opnd) (opnd-stat-add! 'store gvm-opnd))
(define (jump-stat-add! gvm-opnd) (opnd-stat-add! 'jump gvm-opnd))
(define (opnd-stat-add! type opnd)
(cond ((reg? opnd) (stat-add! (list 'gvm-opnd 'reg type (reg-num opnd)) 1))
((stk? opnd) (stat-add! (list 'gvm-opnd 'stk type) 1))
((glo? opnd) (stat-add! (list 'gvm-opnd 'glo type (glo-name opnd)) 1))
((clo? opnd)
(stat-add! (list 'gvm-opnd 'clo type) 1)
(fetch-stat-add! (clo-base opnd)))
((lbl? opnd) (stat-add! (list 'gvm-opnd 'lbl type) 1))
((obj? opnd)
(let ((val (obj-val opnd)))
(if (number? val)
(stat-add! (list 'gvm-opnd 'obj type val) 1)
(stat-add! (list 'gvm-opnd 'obj type (obj-type val)) 1))))
(else
(compiler-internal-error "opnd-stat-add!, unknown 'opnd':" opnd))))
(define (opnd-stat opnd)
(cond ((reg? opnd) 'reg)
((stk? opnd) 'stk)
((glo? opnd) 'glo)
((clo? opnd) 'clo)
((lbl? opnd) 'lbl)
((obj? opnd) 'obj)
(else (compiler-internal-error "opnd-stat, unknown 'opnd':" opnd))))
(define *stats* '())
(define (move-opnd68-to-loc68 opnd loc)
(if (not (identical-opnd68? opnd loc))
(if (imm? opnd)
(move-n-to-loc68 (imm-val opnd) loc)
(emit-move.l opnd loc))))
(define (move-obj-to-loc68 obj loc)
(let ((n (obj-encoding obj)))
(if n (move-n-to-loc68 n loc) (emit-move.l (emit-const obj) loc))))
(define (move-n-to-loc68 n loc)
(cond ((= n bits-null) (emit-move.l null-reg loc))
((= n bits-false) (emit-move.l false-reg loc))
((and (dreg? loc) (>= n -128) (<= n 127)) (emit-moveq n loc))
((and (areg? loc) (>= n -32768) (<= n 32767))
(emit-move.w (make-imm n) loc))
((and (identical-opnd68? loc pdec-sp) (>= n -32768) (<= n 32767))
(emit-pea* n))
((= n 0) (emit-clr.l loc))
((and (not (and (inx? loc) (= (inx-ireg loc) dtemp1)))
(>= n -128)
(<= n 127))
(emit-moveq n dtemp1)
(emit-move.l dtemp1 loc))
(else (emit-move.l (make-imm n) loc))))
(define (add-n-to-loc68 n loc)
(if (not (= n 0))
(cond ((and (>= n -8) (<= n 8))
(if (> n 0) (emit-addq.l n loc) (emit-subq.l (- n) loc)))
((and (areg? loc) (>= n -32768) (<= n 32767))
(emit-lea (make-disp loc n) loc))
((and (not (identical-opnd68? loc dtemp1)) (>= n -128) (<= n 128))
(emit-moveq (- (abs n)) dtemp1)
(if (> n 0) (emit-sub.l dtemp1 loc) (emit-add.l dtemp1 loc)))
(else (emit-add.l (make-imm n) loc)))))
(define (power-of-2 n)
(let loop ((i 0) (k 1))
(cond ((= k n) i) ((> k n) #f) (else (loop (+ i 1) (* k 2))))))
(define (mul-n-to-reg68 n reg)
(if (= n 0)
(emit-moveq 0 reg)
(let ((abs-n (abs n)))
(if (= abs-n 1)
(if (< n 0) (emit-neg.l reg))
(let ((shift (power-of-2 abs-n)))
(if shift
(let ((m (min shift 32)))
(if (or (<= m 8) (identical-opnd68? reg dtemp1))
(let loop ((i m))
(if (> i 0)
(begin
(emit-asl.l (make-imm (min i 8)) reg)
(loop (- i 8)))))
(begin (emit-moveq m dtemp1) (emit-asl.l dtemp1 reg)))
(if (< n 0) (emit-neg.l reg)))
(emit-muls.l (make-imm n) reg)))))))
(define (div-n-to-reg68 n reg)
(let ((abs-n (abs n)))
(if (= abs-n 1)
(if (< n 0) (emit-neg.l reg))
(let ((shift (power-of-2 abs-n)))
(if shift
(let ((m (min shift 32)) (lbl (new-lbl!)))
(emit-move.l reg reg)
(emit-bpl lbl)
(add-n-to-loc68 (* (- abs-n 1) 8) reg)
(emit-label lbl)
(if (or (<= m 8) (identical-opnd68? reg dtemp1))
(let loop ((i m))
(if (> i 0)
(begin
(emit-asr.l (make-imm (min i 8)) reg)
(loop (- i 8)))))
(begin (emit-moveq m dtemp1) (emit-asr.l dtemp1 reg)))
(if (< n 0) (emit-neg.l reg)))
(emit-divsl.l (make-imm n) reg reg))))))
(define (cmp-n-to-opnd68 n opnd)
(cond ((= n bits-null) (emit-cmp.l opnd null-reg) #f)
((= n bits-false) (emit-cmp.l opnd false-reg) #f)
((or (pcr? opnd) (imm? opnd))
(if (= n 0)
(begin (emit-move.l opnd dtemp1) #t)
(begin
(move-opnd68-to-loc68 opnd atemp1)
(if (and (>= n -32768) (<= n 32767))
(emit-cmp.w (make-imm n) atemp1)
(emit-cmp.l (make-imm n) atemp1))
#t)))
((= n 0) (emit-move.l opnd dtemp1) #t)
((and (>= n -128) (<= n 127) (not (identical-opnd68? opnd dtemp1)))
(emit-moveq n dtemp1)
(emit-cmp.l opnd dtemp1)
#f)
(else (emit-cmp.l (make-imm n) opnd) #t)))
(define current-fs '())
(define (adjust-current-fs n) (set! current-fs (+ current-fs n)))
(define (new-lbl!) (label-counter))
(define (needed? loc sn) (and loc (if (stk? loc) (<= (stk-num loc) sn) #t)))
(define (sn-opnd opnd sn)
(cond ((stk? opnd) (max (stk-num opnd) sn))
((clo? opnd) (sn-opnd (clo-base opnd) sn))
(else sn)))
(define (sn-opnds opnds sn)
(if (null? opnds) sn (sn-opnd (car opnds) (sn-opnds (cdr opnds) sn))))
(define (sn-opnd68 opnd sn)
(cond ((and (disp*? opnd) (identical-opnd68? (disp*-areg opnd) sp-reg))
(max (disp*-offset opnd) sn))
((identical-opnd68? opnd pdec-sp) (max (+ current-fs 1) sn))
((identical-opnd68? opnd pinc-sp) (max current-fs sn))
(else sn)))
(define (resize-frame n)
(let ((x (- n current-fs)))
(adjust-current-fs x)
(add-n-to-loc68 (* (- pointer-size) x) sp-reg)))
(define (shrink-frame n)
(cond ((< n current-fs) (resize-frame n))
((> n current-fs)
(compiler-internal-error "shrink-frame, can't increase frame size"))))
(define (make-top-of-frame n sn)
(if (and (< n current-fs) (>= n sn)) (resize-frame n)))
(define (make-top-of-frame-if-stk-opnd68 opnd sn)
(if (frame-base-rel? opnd)
(make-top-of-frame (frame-base-rel-slot opnd) sn)))
(define (make-top-of-frame-if-stk-opnds68 opnd1 opnd2 sn)
(if (frame-base-rel? opnd1)
(let ((slot1 (frame-base-rel-slot opnd1)))
(if (frame-base-rel? opnd2)
(make-top-of-frame (max (frame-base-rel-slot opnd2) slot1) sn)
(make-top-of-frame slot1 sn)))
(if (frame-base-rel? opnd2)
(make-top-of-frame (frame-base-rel-slot opnd2) sn))))
(define (opnd68->true-opnd68 opnd sn)
(if (frame-base-rel? opnd)
(let ((slot (frame-base-rel-slot opnd)))
(cond ((> slot current-fs) (adjust-current-fs 1) pdec-sp)
((and (= slot current-fs) (< sn current-fs))
(adjust-current-fs -1)
pinc-sp)
(else (make-disp* sp-reg (* pointer-size (- current-fs slot))))))
opnd))
(define (move-opnd68-to-any-areg opnd keep sn)
(if (areg? opnd)
opnd
(let ((areg (pick-atemp keep)))
(make-top-of-frame-if-stk-opnd68 opnd sn)
(move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) areg)
areg)))
(define (clo->opnd68 opnd keep sn)
(let ((base (clo-base opnd)) (offs (closed-var-offset (clo-index opnd))))
(if (lbl? base) (make-pcr (lbl-num base) offs) (clo->loc68 opnd keep sn))))
(define (clo->loc68 opnd keep sn)
(let ((base (clo-base opnd)) (offs (closed-var-offset (clo-index opnd))))
(cond ((eq? base return-reg) (make-disp* (reg->reg68 base) offs))
((obj? base)
(let ((areg (pick-atemp keep)))
(move-obj-to-loc68 (obj-val base) areg)
(make-disp* areg offs)))
(else
(let ((areg (pick-atemp keep)))
(move-opnd-to-loc68 base areg sn)
(make-disp* areg offs))))))
(define (reg->reg68 reg) (reg-num->reg68 (reg-num reg)))
(define (reg-num->reg68 num)
(if (= num 0) (make-areg gvm-reg0) (make-dreg (+ (- num 1) gvm-reg1))))
(define (opnd->opnd68 opnd keep sn)
(cond ((lbl? opnd)
(let ((areg (pick-atemp keep)))
(emit-lea (make-pcr (lbl-num opnd) 0) areg)
areg))
((obj? opnd)
(let ((val (obj-val opnd)))
(if (proc-obj? val)
(let ((num (add-object val)) (areg (pick-atemp keep)))
(if num (emit-move-proc num areg) (emit-move-prim val areg))
areg)
(let ((n (obj-encoding val)))
(if n (make-imm n) (emit-const val))))))
((clo? opnd) (clo->opnd68 opnd keep sn))
(else (loc->loc68 opnd keep sn))))
(define (loc->loc68 loc keep sn)
(cond ((reg? loc) (reg->reg68 loc))
((stk? loc) (make-frame-base-rel (stk-num loc)))
((glo? loc) (make-glob (glo-name loc)))
((clo? loc) (clo->loc68 loc keep sn))
(else (compiler-internal-error "loc->loc68, unknown 'loc':" loc))))
(define (move-opnd68-to-loc opnd loc sn)
(cond ((reg? loc)
(make-top-of-frame-if-stk-opnd68 opnd sn)
(move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) (reg->reg68 loc)))
((stk? loc)
(let* ((loc-slot (stk-num loc))
(sn-after-opnd1 (if (< loc-slot sn) sn (- loc-slot 1))))
(if (> current-fs loc-slot)
(make-top-of-frame
(if (frame-base-rel? opnd)
(let ((opnd-slot (frame-base-rel-slot opnd)))
(if (>= opnd-slot (- loc-slot 1)) opnd-slot loc-slot))
loc-slot)
sn-after-opnd1))
(let* ((opnd1 (opnd68->true-opnd68 opnd sn-after-opnd1))
(opnd2 (opnd68->true-opnd68
(make-frame-base-rel loc-slot)
sn)))
(move-opnd68-to-loc68 opnd1 opnd2))))
((glo? loc)
(make-top-of-frame-if-stk-opnd68 opnd sn)
(move-opnd68-to-loc68
(opnd68->true-opnd68 opnd sn)
(make-glob (glo-name loc))))
((clo? loc)
(let ((clo (clo->loc68
loc
(temp-in-opnd68 opnd)
(sn-opnd68 opnd sn))))
(make-top-of-frame-if-stk-opnd68 opnd sn)
(move-opnd68-to-loc68 (opnd68->true-opnd68 opnd sn) clo)))
(else
(compiler-internal-error "move-opnd68-to-loc, unknown 'loc':" loc))))
(define (move-opnd-to-loc68 opnd loc68 sn)
(if (and (lbl? opnd) (areg? loc68))
(emit-lea (make-pcr (lbl-num opnd) 0) loc68)
(let* ((sn-after-opnd68 (sn-opnd68 loc68 sn))
(opnd68 (opnd->opnd68
opnd
(temp-in-opnd68 loc68)
sn-after-opnd68)))
(make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn)
(let* ((opnd68* (opnd68->true-opnd68 opnd68 sn-after-opnd68))
(loc68* (opnd68->true-opnd68 loc68 sn)))
(move-opnd68-to-loc68 opnd68* loc68*)))))
(define (copy-opnd-to-loc opnd loc sn)
(if (and (lbl? opnd) (eq? loc return-reg))
(emit-lea (make-pcr (lbl-num opnd) 0) (reg->reg68 loc))
(move-opnd68-to-loc (opnd->opnd68 opnd #f (sn-opnd loc sn)) loc sn)))
(define (touch-reg68-to-reg68 src dst)
(define (trap-to-touch-handler dreg lbl)
(if ofile-stats?
(emit-stat
'((touch 0
(determined-placeholder -1)
(undetermined-placeholder 1)))))
(gen-trap
instr-source
entry-frame
#t
dreg
(+ touch-trap (dreg-num dreg))
lbl))
(define (touch-dreg-to-reg src dst)
(let ((lbl1 (new-lbl!)))
(emit-btst src placeholder-reg)
(emit-bne lbl1)
(if ofile-stats?
(emit-stat
'((touch 0 (non-placeholder -1) (determined-placeholder 1)))))
(trap-to-touch-handler src lbl1)
(move-opnd68-to-loc68 src dst)))
(define (touch-areg-to-dreg src dst)
(let ((lbl1 (new-lbl!)))
(emit-move.l src dst)
(emit-btst dst placeholder-reg)
(emit-bne lbl1)
(if ofile-stats?
(emit-stat
'((touch 0 (non-placeholder -1) (determined-placeholder 1)))))
(trap-to-touch-handler dst lbl1)))
(if ofile-stats? (emit-stat '((touch 1 (non-placeholder 1)))))
(cond ((dreg? src) (touch-dreg-to-reg src dst))
((dreg? dst) (touch-areg-to-dreg src dst))
(else (emit-move.l src dtemp1) (touch-dreg-to-reg dtemp1 dst))))
(define (touch-opnd-to-any-reg68 opnd sn)
(if (reg? opnd)
(let ((reg (reg->reg68 opnd))) (touch-reg68-to-reg68 reg reg) reg)
(let ((opnd68 (opnd->opnd68 opnd #f sn)))
(make-top-of-frame-if-stk-opnd68 opnd68 sn)
(move-opnd68-to-loc68 (opnd68->true-opnd68 opnd68 sn) dtemp1)
(touch-reg68-to-reg68 dtemp1 dtemp1)
dtemp1)))
(define (touch-opnd-to-loc opnd loc sn)
(if (reg? opnd)
(let ((reg68 (reg->reg68 opnd)))
(if (reg? loc)
(touch-reg68-to-reg68 reg68 (reg->reg68 loc))
(begin
(touch-reg68-to-reg68 reg68 reg68)
(move-opnd68-to-loc reg68 loc sn))))
(if (reg? loc)
(let ((reg68 (reg->reg68 loc)))
(move-opnd-to-loc68 opnd reg68 sn)
(touch-reg68-to-reg68 reg68 reg68))
(let ((reg68 (touch-opnd-to-any-reg68 opnd sn)))
(move-opnd68-to-loc reg68 loc sn)))))
(define (gen-trap source frame save-live? not-save-reg num lbl)
(define (adjust-slots l n)
(cond ((= n 0) (append l '()))
((< n 0) (adjust-slots (cdr l) (+ n 1)))
(else (adjust-slots (cons empty-var l) (- n 1)))))
(define (set-slot! slots i x)
(let loop ((l slots) (n (- (length slots) i)))
(if (> n 0) (loop (cdr l) (- n 1)) (set-car! l x))))
(let ((ret-slot (frame-first-empty-slot frame)))
(let loop1 ((save1 '()) (save2 #f) (regs (frame-regs frame)) (i 0))
(if (pair? regs)
(let ((var (car regs)))
(if (eq? var ret-var)
(let ((x (cons (reg->reg68 (make-reg i)) var)))
(if (> ret-slot current-fs)
(loop1 (cons x save1) save2 (cdr regs) (+ i 1))
(loop1 save1 x (cdr regs) (+ i 1))))
(if (and save-live?
(frame-live? var frame)
(not (eqv? not-save-reg (reg->reg68 (make-reg i)))))
(loop1 (cons (cons (reg->reg68 (make-reg i)) var) save1)
save2
(cdr regs)
(+ i 1))
(loop1 save1 save2 (cdr regs) (+ i 1)))))
(let ((order (sort-list save1 (lambda (x y) (< (car x) (car y))))))
(let ((slots (append (map cdr order)
(adjust-slots
(frame-slots frame)
(- current-fs (frame-size frame)))))
(reg-list (map car order))
(nb-regs (length order)))
(define (trap)
(emit-trap2 num '())
(gen-label-return*
(new-lbl!)
(add-first-class-label! source slots frame)
slots
0))
(if save2
(begin
(emit-move.l
(car save2)
(make-disp*
sp-reg
(* pointer-size (- current-fs ret-slot))))
(set-slot! slots ret-slot (cdr save2))))
(if (> (length order) 2)
(begin
(emit-movem.l reg-list pdec-sp)
(trap)
(emit-movem.l pinc-sp reg-list))
(let loop2 ((l (reverse reg-list)))
(if (pair? l)
(let ((reg (car l)))
(emit-move.l reg pdec-sp)
(loop2 (cdr l))
(emit-move.l pinc-sp reg))
(trap))))
(if save2
(emit-move.l
(make-disp* sp-reg (* pointer-size (- current-fs ret-slot)))
(car save2)))
(emit-label lbl)))))))
(define (gen-label-simple lbl sn)
(if ofile-stats?
(begin (stat-clear!) (stat-add! '(gvm-instr label simple) 1)))
(set! pointers-allocated 0)
(emit-label lbl))
(define (gen-label-entry lbl nb-parms min rest? closed? sn)
(if ofile-stats?
(begin
(stat-clear!)
(stat-add!
(list 'gvm-instr
'label
'entry
nb-parms
min
(if rest? 'rest 'not-rest)
(if closed? 'closed 'not-closed))
1)))
(set! pointers-allocated 0)
(let ((label-descr (add-first-class-label! instr-source '() exit-frame)))
(if (= lbl entry-lbl-num)
(emit-label lbl)
(emit-label-subproc lbl entry-lbl-num label-descr)))
(let* ((nb-parms* (if rest? (- nb-parms 1) nb-parms))
(dispatch-lbls (make-vector (+ (- nb-parms min) 1)))
(optional-lbls (make-vector (+ (- nb-parms min) 1))))
(let loop ((i min))
(if (<= i nb-parms)
(let ((lbl (new-lbl!)))
(vector-set! optional-lbls (- nb-parms i) lbl)
(vector-set!
dispatch-lbls
(- nb-parms i)
(if (or (>= i nb-parms) (<= nb-parms nb-arg-regs))
lbl
(new-lbl!)))
(loop (+ i 1)))))
(if closed?
(let ((closure-reg (reg-num->reg68 (+ nb-arg-regs 1))))
(emit-move.l pinc-sp closure-reg)
(emit-subq.l 6 closure-reg)
(if (or (and (<= min 1) (<= 1 nb-parms*))
(and (<= min 2) (<= 2 nb-parms*)))
(emit-move.w dtemp1 dtemp1))))
(if (and (<= min 2) (<= 2 nb-parms*))
(emit-beq (vector-ref dispatch-lbls (- nb-parms 2))))
(if (and (<= min 1) (<= 1 nb-parms*))
(emit-bmi (vector-ref dispatch-lbls (- nb-parms 1))))
(let loop ((i min))
(if (<= i nb-parms*)
(begin
(if (not (or (= i 1) (= i 2)))
(begin
(emit-cmp.w (make-imm (encode-arg-count i)) arg-count-reg)
(emit-beq (vector-ref dispatch-lbls (- nb-parms i)))))
(loop (+ i 1)))))
(cond (rest?
(emit-trap1
(if closed? rest-params-closed-trap rest-params-trap)
(list min nb-parms*))
(if (not closed?) (emit-lbl-ptr lbl))
(set! pointers-allocated 1)
(gen-guarantee-fudge)
(emit-bra (vector-ref optional-lbls 0)))
((= min nb-parms*)
(emit-trap1
(if closed? wrong-nb-arg1-closed-trap wrong-nb-arg1-trap)
(list nb-parms*))
(if (not closed?) (emit-lbl-ptr lbl)))
(else
(emit-trap1
(if closed? wrong-nb-arg2-closed-trap wrong-nb-arg2-trap)
(list min nb-parms*))
(if (not closed?) (emit-lbl-ptr lbl))))
(if (> nb-parms nb-arg-regs)
(let loop1 ((i (- nb-parms 1)))
(if (>= i min)
(let ((nb-stacked (if (<= i nb-arg-regs) 0 (- i nb-arg-regs))))
(emit-label (vector-ref dispatch-lbls (- nb-parms i)))
(let loop2 ((j 1))
(if (and (<= j nb-arg-regs)
(<= j i)
(<= j (- (- nb-parms nb-arg-regs) nb-stacked)))
(begin
(emit-move.l (reg-num->reg68 j) pdec-sp)
(loop2 (+ j 1)))
(let loop3 ((k j))
(if (and (<= k nb-arg-regs) (<= k i))
(begin
(emit-move.l
(reg-num->reg68 k)
(reg-num->reg68 (+ (- k j) 1)))
(loop3 (+ k 1)))))))
(if (> i min)
(emit-bra (vector-ref optional-lbls (- nb-parms i))))
(loop1 (- i 1))))))
(let loop ((i min))
(if (<= i nb-parms)
(let ((val (if (= i nb-parms*) bits-null bits-unass)))
(emit-label (vector-ref optional-lbls (- nb-parms i)))
(cond ((> (- nb-parms i) nb-arg-regs)
(move-n-to-loc68 val pdec-sp))
((< i nb-parms)
(move-n-to-loc68
val
(reg-num->reg68 (parm->reg-num (+ i 1) nb-parms)))))
(loop (+ i 1)))))))
(define (encode-arg-count n) (cond ((= n 1) -1) ((= n 2) 0) (else (+ n 1))))
(define (parm->reg-num i nb-parms)
(if (<= nb-parms nb-arg-regs) i (+ i (- nb-arg-regs nb-parms))))
(define (no-arg-check-entry-offset proc nb-args)
(let ((x (proc-obj-call-pat proc)))
(if (and (pair? x) (null? (cdr x)))
(let ((arg-count (car x)))
(if (= arg-count nb-args)
(if (or (= arg-count 1) (= arg-count 2)) 10 14)
0))
0)))
(define (gen-label-return lbl sn)
(if ofile-stats?
(begin (stat-clear!) (stat-add! '(gvm-instr label return) 1)))
(set! pointers-allocated 0)
(let ((slots (frame-slots exit-frame)))
(gen-label-return*
lbl
(add-first-class-label! instr-source slots exit-frame)
slots
0)))
(define (gen-label-return* lbl label-descr slots extra)
(let ((i (pos-in-list ret-var slots)))
(if i
(let* ((fs (length slots)) (link (- fs i)))
(emit-label-return lbl entry-lbl-num (+ fs extra) link label-descr))
(compiler-internal-error
"gen-label-return*, no return address in frame"))))
(define (gen-label-task-entry lbl sn)
(if ofile-stats?
(begin (stat-clear!) (stat-add! '(gvm-instr label task-entry) 1)))
(set! pointers-allocated 0)
(emit-label lbl)
(if (= current-fs 0)
(begin
(emit-move.l (reg->reg68 return-reg) pdec-sp)
(emit-move.l sp-reg (make-pinc ltq-tail-reg)))
(begin
(emit-move.l sp-reg atemp1)
(emit-move.l (make-pinc atemp1) pdec-sp)
(let loop ((i (- current-fs 1)))
(if (> i 0)
(begin
(emit-move.l (make-pinc atemp1) (make-disp atemp1 -8))
(loop (- i 1)))))
(emit-move.l (reg->reg68 return-reg) (make-pdec atemp1))
(emit-move.l atemp1 (make-pinc ltq-tail-reg))))
(emit-move.l ltq-tail-reg ltq-tail-slot))
(define (gen-label-task-return lbl sn)
(if ofile-stats?
(begin (stat-clear!) (stat-add! '(gvm-instr label task-return) 1)))
(set! pointers-allocated 0)
(let ((slots (frame-slots exit-frame)))
(set! current-fs (+ current-fs 1))
(let ((dummy-lbl (new-lbl!)) (skip-lbl (new-lbl!)))
(gen-label-return*
dummy-lbl
(add-first-class-label! instr-source slots exit-frame)
slots
1)
(emit-bra skip-lbl)
(gen-label-task-return*
lbl
(add-first-class-label! instr-source slots exit-frame)
slots
1)
(emit-subq.l pointer-size ltq-tail-reg)
(emit-label skip-lbl))))
(define (gen-label-task-return* lbl label-descr slots extra)
(let ((i (pos-in-list ret-var slots)))
(if i
(let* ((fs (length slots)) (link (- fs i)))
(emit-label-task-return
lbl
entry-lbl-num
(+ fs extra)
link
label-descr))
(compiler-internal-error
"gen-label-task-return*, no return address in frame"))))
(define (gen-apply prim opnds loc sn)
(if ofile-stats?
(begin
(stat-add!
(list 'gvm-instr
'apply
(string->canonical-symbol (proc-obj-name prim))
(map opnd-stat opnds)
(if loc (opnd-stat loc) #f))
1)
(for-each fetch-stat-add! opnds)
(if loc (store-stat-add! loc))))
(let ((x (proc-obj-inlinable prim)))
(if (not x)
(compiler-internal-error "gen-APPLY, unknown 'prim':" prim)
(if (or (needed? loc sn) (car x)) ((cdr x) opnds loc sn)))))
(define (define-apply name side-effects? proc)
(let ((prim (get-prim-info name)))
(proc-obj-inlinable-set! prim (cons side-effects? proc))))
(define (gen-copy opnd loc sn)
(if ofile-stats?
(begin
(stat-add! (list 'gvm-instr 'copy (opnd-stat opnd) (opnd-stat loc)) 1)
(fetch-stat-add! opnd)
(store-stat-add! loc)))
(if (needed? loc sn) (copy-opnd-to-loc opnd loc sn)))
(define (gen-close parms sn)
(define (size->bytes size)
(* (quotient
(+ (* (+ size 2) pointer-size) (- cache-line-length 1))
cache-line-length)
cache-line-length))
(define (parms->bytes parms)
(if (null? parms)
0
(+ (size->bytes (length (closure-parms-opnds (car parms))))
(parms->bytes (cdr parms)))))
(if ofile-stats?
(begin
(for-each
(lambda (x)
(stat-add!
(list 'gvm-instr
'close
(opnd-stat (closure-parms-loc x))
(map opnd-stat (closure-parms-opnds x)))
1)
(store-stat-add! (closure-parms-loc x))
(fetch-stat-add! (make-lbl (closure-parms-lbl x)))
(for-each fetch-stat-add! (closure-parms-opnds x)))
parms)))
(let ((total-space-needed (parms->bytes parms)) (lbl1 (new-lbl!)))
(emit-move.l closure-ptr-slot atemp2)
(move-n-to-loc68 total-space-needed dtemp1)
(emit-sub.l dtemp1 atemp2)
(emit-cmp.l closure-lim-slot atemp2)
(emit-bcc lbl1)
(gen-trap instr-source entry-frame #f #f closure-alloc-trap lbl1)
(emit-move.l atemp2 closure-ptr-slot)
(let* ((opnds* (apply append (map closure-parms-opnds parms)))
(sn* (sn-opnds opnds* sn)))
(let loop1 ((parms parms))
(let ((loc (closure-parms-loc (car parms)))
(size (length (closure-parms-opnds (car parms))))
(rest (cdr parms)))
(if (= size 1)
(emit-addq.l type-procedure atemp2)
(emit-move.w
(make-imm (+ 32768 (* (+ size 1) 4)))
(make-pinc atemp2)))
(move-opnd68-to-loc
atemp2
loc
(sn-opnds (map closure-parms-loc rest) sn*))
(if (null? rest)
(add-n-to-loc68
(+ (- (size->bytes size) total-space-needed) 2)
atemp2)
(begin
(add-n-to-loc68 (- (size->bytes size) type-procedure) atemp2)
(loop1 rest)))))
(let loop2 ((parms parms))
(let* ((opnds (closure-parms-opnds (car parms)))
(lbl (closure-parms-lbl (car parms)))
(size (length opnds))
(rest (cdr parms)))
(emit-lea (make-pcr lbl 0) atemp1)
(emit-move.l atemp1 (make-pinc atemp2))
(let loop3 ((opnds opnds))
(if (not (null? opnds))
(let ((sn** (sn-opnds
(apply append (map closure-parms-opnds rest))
sn)))
(move-opnd-to-loc68
(car opnds)
(make-pinc atemp2)
(sn-opnds (cdr opnds) sn**))
(loop3 (cdr opnds)))))
(if (not (null? rest))
(begin
(add-n-to-loc68
(- (size->bytes size) (* (+ size 1) pointer-size))
atemp2)
(loop2 rest))))))))
(define (gen-ifjump test opnds true-lbl false-lbl poll? next-lbl)
(if ofile-stats?
(begin
(stat-add!
(list 'gvm-instr
'ifjump
(string->canonical-symbol (proc-obj-name test))
(map opnd-stat opnds)
(if poll? 'poll 'not-poll))
1)
(for-each fetch-stat-add! opnds)
(stat-dump!)))
(let ((proc (proc-obj-test test)))
(if proc
(gen-ifjump* proc opnds true-lbl false-lbl poll? next-lbl)
(compiler-internal-error "gen-IFJUMP, unknown 'test':" test))))
(define (gen-ifjump* proc opnds true-lbl false-lbl poll? next-lbl)
(let ((fs (frame-size exit-frame)))
(define (double-branch)
(proc #t opnds false-lbl fs)
(if ofile-stats?
(emit-stat
'((gvm-instr.ifjump.fall-through 1)
(gvm-instr.ifjump.double-branch 1))))
(emit-bra true-lbl)
(gen-deferred-code!))
(gen-guarantee-fudge)
(if poll? (gen-poll))
(if next-lbl
(cond ((= true-lbl next-lbl)
(proc #t opnds false-lbl fs)
(if ofile-stats?
(emit-stat '((gvm-instr.ifjump.fall-through 1)))))
((= false-lbl next-lbl)
(proc #f opnds true-lbl fs)
(if ofile-stats?
(emit-stat '((gvm-instr.ifjump.fall-through 1)))))
(else (double-branch)))
(double-branch))))
(define (define-ifjump name proc)
(define-apply
name
#f
(lambda (opnds loc sn)
(let ((true-lbl (new-lbl!))
(cont-lbl (new-lbl!))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(proc #f opnds true-lbl current-fs)
(move-n-to-loc68 bits-false reg68)
(emit-bra cont-lbl)
(emit-label true-lbl)
(move-n-to-loc68 bits-true reg68)
(emit-label cont-lbl)
(move-opnd68-to-loc reg68 loc sn))))
(proc-obj-test-set! (get-prim-info name) proc))
(define (gen-jump opnd nb-args poll? next-lbl)
(let ((fs (frame-size exit-frame)))
(if ofile-stats?
(begin
(stat-add!
(list 'gvm-instr
'jump
(opnd-stat opnd)
nb-args
(if poll? 'poll 'not-poll))
1)
(jump-stat-add! opnd)
(if (and (lbl? opnd) next-lbl (= next-lbl (lbl-num opnd)))
(stat-add! '(gvm-instr.jump.fall-through) 1))
(stat-dump!)))
(gen-guarantee-fudge)
(cond ((glo? opnd)
(if poll? (gen-poll))
(setup-jump fs nb-args)
(emit-jmp-glob (make-glob (glo-name opnd)))
(gen-deferred-code!))
((and (stk? opnd) (= (stk-num opnd) (+ fs 1)) (not nb-args))
(if poll? (gen-poll))
(setup-jump (+ fs 1) nb-args)
(emit-rts)
(gen-deferred-code!))
((lbl? opnd)
(if (and poll?
(= fs current-fs)
(not nb-args)
(not (and next-lbl (= next-lbl (lbl-num opnd)))))
(gen-poll-branch (lbl-num opnd))
(begin
(if poll? (gen-poll))
(setup-jump fs nb-args)
(if (not (and next-lbl (= next-lbl (lbl-num opnd))))
(emit-bra (lbl-num opnd))))))
((obj? opnd)
(if poll? (gen-poll))
(let ((val (obj-val opnd)))
(if (proc-obj? val)
(let ((num (add-object val))
(offset (no-arg-check-entry-offset val nb-args)))
(setup-jump fs (if (<= offset 0) nb-args #f))
(if num
(emit-jmp-proc num offset)
(emit-jmp-prim val offset))
(gen-deferred-code!))
(gen-jump* (opnd->opnd68 opnd #f fs) fs nb-args))))
(else
(if poll? (gen-poll))
(gen-jump* (opnd->opnd68 opnd #f fs) fs nb-args)))))
(define (gen-jump* opnd fs nb-args)
(if nb-args
(let ((lbl (new-lbl!)))
(make-top-of-frame-if-stk-opnd68 opnd fs)
(move-opnd68-to-loc68 (opnd68->true-opnd68 opnd fs) atemp1)
(shrink-frame fs)
(emit-move.l atemp1 dtemp1)
(emit-addq.w (modulo (- type-pair type-procedure) 8) dtemp1)
(emit-btst dtemp1 pair-reg)
(emit-beq lbl)
(move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)
(emit-trap3 non-proc-jump-trap)
(emit-label lbl)
(move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)
(emit-jmp (make-ind atemp1)))
(let ((areg (move-opnd68-to-any-areg opnd #f fs)))
(setup-jump fs nb-args)
(emit-jmp (make-ind areg))))
(gen-deferred-code!))
(define (setup-jump fs nb-args)
(shrink-frame fs)
(if nb-args (move-n-to-loc68 (encode-arg-count nb-args) arg-count-reg)))
(define (gen-poll)
(let ((lbl (new-lbl!)))
(emit-dbra poll-timer-reg lbl)
(emit-moveq (- polling-intermittency 1) poll-timer-reg)
(emit-cmp.l intr-flag-slot sp-reg)
(emit-bcc lbl)
(gen-trap instr-source entry-frame #f #f intr-trap lbl)))
(define (gen-poll-branch lbl)
(emit-dbra poll-timer-reg lbl)
(emit-moveq (- polling-intermittency 1) poll-timer-reg)
(emit-cmp.l intr-flag-slot sp-reg)
(emit-bcc lbl)
(gen-trap instr-source entry-frame #f #f intr-trap (new-lbl!))
(emit-bra lbl))
(define (make-gen-slot-ref slot type)
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(move-opnd68-to-loc
(make-disp* atemp1 (- (* slot pointer-size) type))
loc
sn))))
(define (make-gen-slot-set! slot type)
(lambda (opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let* ((first-opnd (car opnds))
(second-opnd (cadr opnds))
(sn-second-opnd (sn-opnd second-opnd sn-loc)))
(move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
(move-opnd-to-loc68
second-opnd
(make-disp* atemp1 (- (* slot pointer-size) type))
sn-loc)
(if loc
(if (not (eq? first-opnd loc))
(move-opnd68-to-loc atemp1 loc sn)))))))
(define (gen-cons opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
(gen-guarantee-space 2)
(if (contains-opnd? loc second-opnd)
(let ((sn-second-opnd (sn-opnd second-opnd sn-loc)))
(move-opnd-to-loc68 first-opnd (make-pdec heap-reg) sn-second-opnd)
(move-opnd68-to-loc68 heap-reg atemp2)
(move-opnd-to-loc68 second-opnd (make-pdec heap-reg) sn-loc)
(move-opnd68-to-loc atemp2 loc sn))
(let* ((sn-second-opnd (sn-opnd second-opnd sn))
(sn-loc (sn-opnd loc sn-second-opnd)))
(move-opnd-to-loc68 first-opnd (make-pdec heap-reg) sn-loc)
(move-opnd68-to-loc heap-reg loc sn-second-opnd)
(move-opnd-to-loc68 second-opnd (make-pdec heap-reg) sn))))))
(define (make-gen-apply-c...r pattern)
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(let loop ((pattern pattern))
(if (<= pattern 3)
(if (= pattern 3)
(move-opnd68-to-loc (make-pdec atemp1) loc sn)
(move-opnd68-to-loc (make-ind atemp1) loc sn))
(begin
(if (odd? pattern)
(emit-move.l (make-pdec atemp1) atemp1)
(emit-move.l (make-ind atemp1) atemp1))
(loop (quotient pattern 2))))))))
(define (gen-set-car! opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let* ((first-opnd (car opnds))
(second-opnd (cadr opnds))
(sn-second-opnd (sn-opnd second-opnd sn-loc)))
(move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
(move-opnd-to-loc68 second-opnd (make-ind atemp1) sn-loc)
(if (and loc (not (eq? first-opnd loc)))
(move-opnd68-to-loc atemp1 loc sn)))))
(define (gen-set-cdr! opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let* ((first-opnd (car opnds))
(second-opnd (cadr opnds))
(sn-second-opnd (sn-opnd second-opnd sn-loc)))
(move-opnd-to-loc68 first-opnd atemp1 sn-second-opnd)
(if (and loc (not (eq? first-opnd loc)))
(move-opnd-to-loc68
second-opnd
(make-disp atemp1 (- pointer-size))
sn-loc)
(move-opnd-to-loc68 second-opnd (make-pdec atemp1) sn-loc))
(if (and loc (not (eq? first-opnd loc)))
(move-opnd68-to-loc atemp1 loc sn)))))
(define (commut-oper gen opnds loc sn self? accum-self accum-other)
(if (null? opnds)
(gen (reverse accum-self) (reverse accum-other) loc sn self?)
(let ((opnd (car opnds)) (rest (cdr opnds)))
(cond ((and (not self?) (eq? opnd loc))
(commut-oper gen rest loc sn #t accum-self accum-other))
((contains-opnd? loc opnd)
(commut-oper
gen
rest
loc
sn
self?
(cons opnd accum-self)
accum-other))
(else
(commut-oper
gen
rest
loc
sn
self?
accum-self
(cons opnd accum-other)))))))
(define (gen-add-in-place opnds loc68 sn)
(if (not (null? opnds))
(let* ((first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
(opnd68 (opnd->opnd68
first-opnd
(temp-in-opnd68 loc68)
(sn-opnd68 loc68 sn))))
(make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
(if (imm? opnd68)
(add-n-to-loc68
(imm-val opnd68)
(opnd68->true-opnd68 loc68 sn-other-opnds))
(let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
(if (or (dreg? opnd68) (reg68? loc68))
(emit-add.l
opnd68*
(opnd68->true-opnd68 loc68 sn-other-opnds))
(begin
(move-opnd68-to-loc68 opnd68* dtemp1)
(emit-add.l
dtemp1
(opnd68->true-opnd68 loc68 sn-other-opnds))))))
(gen-add-in-place other-opnds loc68 sn))))
(define (gen-add self-opnds other-opnds loc sn self?)
(let* ((opnds (append self-opnds other-opnds))
(first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
(if (<= (length self-opnds) 1)
(let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
(if self?
(gen-add-in-place opnds loc68 sn)
(begin
(move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
(gen-add-in-place other-opnds loc68 sn))))
(begin
(move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
(gen-add-in-place other-opnds dtemp1 (sn-opnd loc sn))
(if self?
(let ((loc68 (loc->loc68 loc dtemp1 sn)))
(make-top-of-frame-if-stk-opnd68 loc68 sn)
(emit-add.l dtemp1 (opnd68->true-opnd68 loc68 sn)))
(move-opnd68-to-loc dtemp1 loc sn))))))
(define (gen-sub-in-place opnds loc68 sn)
(if (not (null? opnds))
(let* ((first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
(opnd68 (opnd->opnd68
first-opnd
(temp-in-opnd68 loc68)
(sn-opnd68 loc68 sn))))
(make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
(if (imm? opnd68)
(add-n-to-loc68
(- (imm-val opnd68))
(opnd68->true-opnd68 loc68 sn-other-opnds))
(let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
(if (or (dreg? opnd68) (reg68? loc68))
(emit-sub.l
opnd68*
(opnd68->true-opnd68 loc68 sn-other-opnds))
(begin
(move-opnd68-to-loc68 opnd68* dtemp1)
(emit-sub.l
dtemp1
(opnd68->true-opnd68 loc68 sn-other-opnds))))))
(gen-sub-in-place other-opnds loc68 sn))))
(define (gen-sub first-opnd other-opnds loc sn self-opnds?)
(if (null? other-opnds)
(if (and (or (reg? loc) (stk? loc)) (not (eq? loc return-reg)))
(begin
(copy-opnd-to-loc first-opnd loc (sn-opnd loc sn))
(let ((loc68 (loc->loc68 loc #f sn)))
(make-top-of-frame-if-stk-opnd68 loc68 sn)
(emit-neg.l (opnd68->true-opnd68 loc68 sn))))
(begin
(move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn))
(emit-neg.l dtemp1)
(move-opnd68-to-loc dtemp1 loc sn)))
(let* ((sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
(if (and (not self-opnds?) (or (reg? loc) (stk? loc)))
(let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
(if (not (eq? first-opnd loc))
(move-opnd-to-loc68 first-opnd loc68 sn-other-opnds))
(gen-sub-in-place other-opnds loc68 sn))
(begin
(move-opnd-to-loc68
first-opnd
dtemp1
(sn-opnd loc sn-other-opnds))
(gen-sub-in-place other-opnds dtemp1 (sn-opnd loc sn))
(move-opnd68-to-loc dtemp1 loc sn))))))
(define (gen-mul-in-place opnds reg68 sn)
(if (not (null? opnds))
(let* ((first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(opnd68 (opnd->opnd68 first-opnd (temp-in-opnd68 reg68) sn)))
(make-top-of-frame-if-stk-opnd68 opnd68 sn-other-opnds)
(if (imm? opnd68)
(mul-n-to-reg68 (quotient (imm-val opnd68) 8) reg68)
(begin
(emit-asr.l (make-imm 3) reg68)
(emit-muls.l (opnd68->true-opnd68 opnd68 sn-other-opnds) reg68)))
(gen-mul-in-place other-opnds reg68 sn))))
(define (gen-mul self-opnds other-opnds loc sn self?)
(let* ((opnds (append self-opnds other-opnds))
(first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
(if (null? self-opnds)
(let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
(if self?
(gen-mul-in-place opnds loc68 sn)
(begin
(move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
(gen-mul-in-place other-opnds loc68 sn))))
(begin
(move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
(gen-mul-in-place other-opnds dtemp1 (sn-opnd loc sn))
(if self?
(let ((loc68 (loc->loc68 loc dtemp1 sn)))
(make-top-of-frame-if-stk-opnd68 loc68 sn)
(emit-asr.l (make-imm 3) dtemp1)
(emit-muls.l dtemp1 (opnd68->true-opnd68 loc68 sn)))
(move-opnd68-to-loc dtemp1 loc sn))))))
(define (gen-div-in-place opnds reg68 sn)
(if (not (null? opnds))
(let* ((first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
(opnd68 (opnd->opnd68 first-opnd (temp-in-opnd68 reg68) sn)))
(make-top-of-frame-if-stk-opnd68 opnd68 sn-other-opnds)
(if (imm? opnd68)
(let ((n (quotient (imm-val opnd68) 8)))
(div-n-to-reg68 n reg68)
(if (> (abs n) 1) (emit-and.w (make-imm -8) reg68)))
(let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
(emit-divsl.l opnd68* reg68 reg68)
(emit-asl.l (make-imm 3) reg68)))
(gen-div-in-place other-opnds reg68 sn))))
(define (gen-div first-opnd other-opnds loc sn self-opnds?)
(if (null? other-opnds)
(begin
(move-opnd-to-loc68 first-opnd pdec-sp (sn-opnd loc sn))
(emit-moveq 8 dtemp1)
(emit-divsl.l pinc-sp dtemp1 dtemp1)
(emit-asl.l (make-imm 3) dtemp1)
(emit-and.w (make-imm -8) dtemp1)
(move-opnd68-to-loc dtemp1 loc sn))
(let* ((sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
(if (and (reg? loc) (not self-opnds?) (not (eq? loc return-reg)))
(let ((reg68 (reg->reg68 loc)))
(if (not (eq? first-opnd loc))
(move-opnd-to-loc68 first-opnd reg68 sn-other-opnds))
(gen-div-in-place other-opnds reg68 sn))
(begin
(move-opnd-to-loc68
first-opnd
dtemp1
(sn-opnd loc sn-other-opnds))
(gen-div-in-place other-opnds dtemp1 (sn-opnd loc sn))
(move-opnd68-to-loc dtemp1 loc sn))))))
(define (gen-rem first-opnd second-opnd loc sn)
(let* ((sn-loc (sn-opnd loc sn))
(sn-second-opnd (sn-opnd second-opnd sn-loc)))
(move-opnd-to-loc68 first-opnd dtemp1 sn-second-opnd)
(let ((opnd68 (opnd->opnd68 second-opnd #f sn-loc))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
false-reg)))
(make-top-of-frame-if-stk-opnd68 opnd68 sn-loc)
(let ((opnd68* (if (areg? opnd68)
(begin (emit-move.l opnd68 reg68) reg68)
(opnd68->true-opnd68 opnd68 sn-loc))))
(emit-divsl.l opnd68* reg68 dtemp1))
(move-opnd68-to-loc reg68 loc sn)
(if (not (and (reg? loc) (not (eq? loc return-reg))))
(emit-move.l (make-imm bits-false) false-reg)))))
(define (gen-mod first-opnd second-opnd loc sn)
(let* ((sn-loc (sn-opnd loc sn))
(sn-first-opnd (sn-opnd first-opnd sn-loc))
(sn-second-opnd (sn-opnd second-opnd sn-first-opnd))
(opnd68 (opnd->opnd68 second-opnd #f sn-second-opnd)))
(define (general-case)
(let ((lbl1 (new-lbl!))
(lbl2 (new-lbl!))
(lbl3 (new-lbl!))
(opnd68** (opnd68->true-opnd68 opnd68 sn-second-opnd))
(opnd68* (opnd68->true-opnd68
(opnd->opnd68 first-opnd #f sn-second-opnd)
sn-second-opnd)))
(move-opnd68-to-loc68 opnd68* dtemp1)
(move-opnd68-to-loc68 opnd68** false-reg)
(emit-divsl.l false-reg false-reg dtemp1)
(emit-move.l false-reg false-reg)
(emit-beq lbl3)
(move-opnd68-to-loc68 opnd68* dtemp1)
(emit-bmi lbl1)
(move-opnd68-to-loc68 opnd68** dtemp1)
(emit-bpl lbl3)
(emit-bra lbl2)
(emit-label lbl1)
(move-opnd68-to-loc68 opnd68** dtemp1)
(emit-bmi lbl3)
(emit-label lbl2)
(emit-add.l dtemp1 false-reg)
(emit-label lbl3)
(move-opnd68-to-loc false-reg loc sn)
(emit-move.l (make-imm bits-false) false-reg)))
(make-top-of-frame-if-stk-opnd68 opnd68 sn-first-opnd)
(if (imm? opnd68)
(let ((n (quotient (imm-val opnd68) 8)))
(if (> n 0)
(let ((shift (power-of-2 n)))
(if shift
(let ((reg68 (if (and (reg? loc)
(not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(move-opnd-to-loc68 first-opnd reg68 sn-loc)
(emit-and.l (make-imm (* (- n 1) 8)) reg68)
(move-opnd68-to-loc reg68 loc sn))
(general-case)))
(general-case)))
(general-case))))
(define (gen-op emit-op dst-ok?)
(define (gen-op-in-place opnds loc68 sn)
(if (not (null? opnds))
(let* ((first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds))
(opnd68 (opnd->opnd68
first-opnd
(temp-in-opnd68 loc68)
(sn-opnd68 loc68 sn))))
(make-top-of-frame-if-stk-opnds68 opnd68 loc68 sn-other-opnds)
(if (imm? opnd68)
(emit-op opnd68 (opnd68->true-opnd68 loc68 sn-other-opnds))
(let ((opnd68* (opnd68->true-opnd68 opnd68 sn-other-opnds)))
(if (or (dreg? opnd68) (dst-ok? loc68))
(emit-op opnd68*
(opnd68->true-opnd68 loc68 sn-other-opnds))
(begin
(move-opnd68-to-loc68 opnd68* dtemp1)
(emit-op dtemp1
(opnd68->true-opnd68 loc68 sn-other-opnds))))))
(gen-op-in-place other-opnds loc68 sn))))
(lambda (self-opnds other-opnds loc sn self?)
(let* ((opnds (append self-opnds other-opnds))
(first-opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn))
(sn-first-opnd (sn-opnd first-opnd sn-other-opnds)))
(if (<= (length self-opnds) 1)
(let ((loc68 (loc->loc68 loc #f sn-first-opnd)))
(if self?
(gen-op-in-place opnds loc68 sn)
(begin
(move-opnd-to-loc68 first-opnd loc68 sn-other-opnds)
(gen-op-in-place other-opnds loc68 sn))))
(begin
(move-opnd-to-loc68 first-opnd dtemp1 (sn-opnd loc sn-other-opnds))
(gen-op-in-place other-opnds dtemp1 (sn-opnd loc sn))
(if self?
(let ((loc68 (loc->loc68 loc dtemp1 sn)))
(make-top-of-frame-if-stk-opnd68 loc68 sn)
(emit-op dtemp1 (opnd68->true-opnd68 loc68 sn)))
(move-opnd68-to-loc dtemp1 loc sn)))))))
(define gen-logior (gen-op emit-or.l dreg?))
(define gen-logxor (gen-op emit-eor.l (lambda (x) #f)))
(define gen-logand (gen-op emit-and.l dreg?))
(define (gen-shift right-shift)
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(let* ((opnd1 (car opnds))
(opnd2 (cadr opnds))
(sn-opnd1 (sn-opnd opnd1 sn-loc))
(o2 (opnd->opnd68 opnd2 #f sn-opnd1)))
(make-top-of-frame-if-stk-opnd68 o2 sn-opnd1)
(if (imm? o2)
(let* ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1))
(n (quotient (imm-val o2) 8))
(emit-shft (if (> n 0) emit-lsl.l right-shift)))
(move-opnd-to-loc68 opnd1 reg68 sn-loc)
(let loop ((i (min (abs n) 29)))
(if (> i 0)
(begin
(emit-shft (make-imm (min i 8)) reg68)
(loop (- i 8)))))
(if (< n 0) (emit-and.w (make-imm -8) reg68))
(move-opnd68-to-loc reg68 loc sn))
(let* ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1))
(reg68* (if (and (reg? loc) (not (eq? loc return-reg)))
dtemp1
false-reg))
(lbl1 (new-lbl!))
(lbl2 (new-lbl!)))
(emit-move.l (opnd68->true-opnd68 o2 sn-opnd1) reg68*)
(move-opnd-to-loc68 opnd1 reg68 sn-loc)
(emit-asr.l (make-imm 3) reg68*)
(emit-bmi lbl1)
(emit-lsl.l reg68* reg68)
(emit-bra lbl2)
(emit-label lbl1)
(emit-neg.l reg68*)
(right-shift reg68* reg68)
(emit-and.w (make-imm -8) reg68)
(emit-label lbl2)
(move-opnd68-to-loc reg68 loc sn)
(if (not (and (reg? loc) (not (eq? loc return-reg))))
(emit-move.l (make-imm bits-false) false-reg))))))))
(define (flo-oper oper1 oper2 opnds loc sn)
(gen-guarantee-space 2)
(move-opnd-to-loc68
(car opnds)
atemp1
(sn-opnds (cdr opnds) (sn-opnd loc sn)))
(oper1 (make-disp* atemp1 (- type-flonum)) ftemp1)
(let loop ((opnds (cdr opnds)))
(if (not (null? opnds))
(let* ((opnd (car opnds))
(other-opnds (cdr opnds))
(sn-other-opnds (sn-opnds other-opnds sn)))
(move-opnd-to-loc68 opnd atemp1 sn-other-opnds)
(oper2 (make-disp* atemp1 (- type-flonum)) ftemp1)
(loop (cdr opnds)))))
(add-n-to-loc68 (* -2 pointer-size) heap-reg)
(emit-fmov.dx ftemp1 (make-ind heap-reg))
(let ((reg68 (if (reg? loc) (reg->reg68 loc) atemp1)))
(emit-move.l heap-reg reg68)
(emit-addq.l type-flonum reg68))
(if (not (reg? loc)) (move-opnd68-to-loc atemp1 loc sn)))
(define (gen-make-placeholder opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(let ((opnd (car opnds)))
(gen-guarantee-space 4)
(emit-clr.l (make-pdec heap-reg))
(move-opnd-to-loc68 opnd (make-pdec heap-reg) sn-loc)
(emit-move.l null-reg (make-pdec heap-reg))
(move-opnd68-to-loc68 heap-reg atemp2)
(emit-addq.l (modulo (- type-placeholder type-pair) 8) atemp2)
(emit-move.l atemp2 (make-pdec heap-reg))
(move-opnd68-to-loc atemp2 loc sn))))
(define (gen-subprocedure-id opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(move-n-to-loc68 32768 reg68)
(emit-sub.w (make-disp* atemp1 -2) reg68)
(move-opnd68-to-loc reg68 loc sn)))
(define (gen-subprocedure-parent opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(emit-add.w (make-disp* atemp1 -2) atemp1)
(add-n-to-loc68 -32768 atemp1)
(move-opnd68-to-loc atemp1 loc sn)))
(define (gen-return-fs opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1))
(lbl (new-lbl!)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(emit-moveq 0 reg68)
(emit-move.w (make-disp* atemp1 -6) reg68)
(emit-beq lbl)
(emit-and.w (make-imm 32767) reg68)
(emit-subq.l 8 reg68)
(emit-label lbl)
(emit-addq.l 8 reg68)
(emit-asl.l (make-imm 1) reg68)
(move-opnd68-to-loc reg68 loc sn)))
(define (gen-return-link opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1))
(lbl (new-lbl!)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(emit-moveq 0 reg68)
(emit-move.w (make-disp* atemp1 -6) reg68)
(emit-beq lbl)
(emit-and.w (make-imm 32767) reg68)
(emit-subq.l 8 reg68)
(emit-label lbl)
(emit-addq.l 8 reg68)
(emit-sub.w (make-disp* atemp1 -4) reg68)
(emit-asl.l (make-imm 1) reg68)
(move-opnd68-to-loc reg68 loc sn)))
(define (gen-procedure-info opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(emit-add.w (make-disp* atemp1 -2) atemp1)
(move-opnd68-to-loc (make-disp* atemp1 (- 32768 6)) loc sn)))
(define (gen-guarantee-space n)
(set! pointers-allocated (+ pointers-allocated n))
(if (> pointers-allocated heap-allocation-fudge)
(begin (gen-guarantee-fudge) (set! pointers-allocated n))))
(define (gen-guarantee-fudge)
(if (> pointers-allocated 0)
(let ((lbl (new-lbl!)))
(emit-cmp.l heap-lim-slot heap-reg)
(emit-bcc lbl)
(gen-trap instr-source entry-frame #f #f heap-alloc1-trap lbl)
(set! pointers-allocated 0))))
(define pointers-allocated '())
(define (gen-type opnds loc sn)
(let* ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(move-opnd-to-loc68 opnd reg68 sn-loc)
(emit-and.l (make-imm 7) reg68)
(emit-asl.l (make-imm 3) reg68)
(move-opnd68-to-loc reg68 loc sn)))
(define (gen-type-cast opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
(let* ((sn-loc (if (and loc (not (eq? first-opnd loc))) sn-loc sn))
(o1 (opnd->opnd68 first-opnd #f (sn-opnd second-opnd sn-loc)))
(o2 (opnd->opnd68 second-opnd (temp-in-opnd68 o1) sn-loc))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 (sn-opnd68 o2 sn-loc))
reg68)
(emit-and.w (make-imm -8) reg68)
(if (imm? o2)
(let ((n (quotient (imm-val o2) 8)))
(if (> n 0) (emit-addq.w n reg68)))
(begin
(move-opnd68-to-loc68 (opnd68->true-opnd68 o2 sn-loc) atemp1)
(emit-exg atemp1 reg68)
(emit-asr.l (make-imm 3) reg68)
(emit-add.l atemp1 reg68)))
(move-opnd68-to-loc reg68 loc sn)))))
(define (gen-subtype opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(emit-moveq 0 reg68)
(emit-move.b (make-ind atemp1) reg68)
(move-opnd68-to-loc reg68 loc sn)))
(define (gen-subtype-set! opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
(let* ((sn-loc (if (and loc (not (eq? first-opnd loc))) sn-loc sn))
(o1 (opnd->opnd68 first-opnd #f (sn-opnd second-opnd sn-loc)))
(o2 (opnd->opnd68 second-opnd (temp-in-opnd68 o1) sn-loc)))
(make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 (sn-opnd68 o2 sn-loc))
atemp1)
(if (imm? o2)
(emit-move.b (make-imm (imm-val o2)) (make-ind atemp1))
(begin
(move-opnd68-to-loc68 (opnd68->true-opnd68 o2 sn-loc) dtemp1)
(emit-move.b dtemp1 (make-ind atemp1))))
(if (and loc (not (eq? first-opnd loc)))
(move-opnd68-to-loc atemp1 loc sn))))))
(define (vector-select kind vector string vector8 vector16)
(case kind
((string) string)
((vector8) vector8)
((vector16) vector16)
(else vector)))
(define (obj-vector? kind) (vector-select kind #t #f #f #f))
(define (make-gen-vector kind)
(lambda (opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let* ((n (length opnds))
(bytes (+ pointer-size
(* (vector-select kind 4 1 1 2)
(+ n (if (eq? kind 'string) 1 0)))))
(adjust (modulo (- bytes) 8)))
(gen-guarantee-space
(quotient (* (quotient (+ bytes (- 8 1)) 8) 8) pointer-size))
(if (not (= adjust 0)) (emit-subq.l adjust heap-reg))
(if (eq? kind 'string) (emit-move.b (make-imm 0) (make-pdec heap-reg)))
(let loop ((opnds (reverse opnds)))
(if (pair? opnds)
(let* ((o (car opnds)) (sn-o (sn-opnds (cdr opnds) sn-loc)))
(if (eq? kind 'vector)
(move-opnd-to-loc68 o (make-pdec heap-reg) sn-o)
(begin
(move-opnd-to-loc68 o dtemp1 sn-o)
(emit-asr.l (make-imm 3) dtemp1)
(if (eq? kind 'vector16)
(emit-move.w dtemp1 (make-pdec heap-reg))
(emit-move.b dtemp1 (make-pdec heap-reg)))))
(loop (cdr opnds)))))
(emit-move.l
(make-imm
(+ (* 256 (- bytes pointer-size))
(* 8 (if (eq? kind 'vector) subtype-vector subtype-string))))
(make-pdec heap-reg))
(if loc
(begin
(emit-lea (make-disp* heap-reg type-subtyped) atemp2)
(move-opnd68-to-loc atemp2 loc sn)))))))
(define (make-gen-vector-length kind)
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))
(opnd (car opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(move-opnd-to-loc68 opnd atemp1 sn-loc)
(move-opnd68-to-loc68 (make-disp* atemp1 (- type-subtyped)) reg68)
(emit-lsr.l (make-imm (vector-select kind 7 5 5 6)) reg68)
(if (not (eq? kind 'vector))
(begin
(emit-and.w (make-imm -8) reg68)
(if (eq? kind 'string) (emit-subq.l 8 reg68))))
(move-opnd68-to-loc reg68 loc sn))))
(define (make-gen-vector-ref kind)
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(let ((first-opnd (car opnds))
(second-opnd (cadr opnds))
(reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(let* ((o2 (opnd->opnd68 second-opnd #f (sn-opnd first-opnd sn-loc)))
(o1 (opnd->opnd68 first-opnd (temp-in-opnd68 o2) sn-loc)))
(make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
(let* ((offset (if (eq? kind 'closure)
(- pointer-size type-procedure)
(- pointer-size type-subtyped)))
(loc68 (if (imm? o2)
(begin
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 sn-loc)
atemp1)
(make-disp*
atemp1
(+ (quotient
(imm-val o2)
(vector-select kind 2 8 8 4))
offset)))
(begin
(move-opnd68-to-loc68
(opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
dtemp1)
(emit-asr.l
(make-imm (vector-select kind 1 3 3 2))
dtemp1)
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 sn-loc)
atemp1)
(if (and (identical-opnd68? reg68 dtemp1)
(not (obj-vector? kind)))
(begin
(emit-move.l dtemp1 atemp2)
(make-inx atemp1 atemp2 offset))
(make-inx atemp1 dtemp1 offset))))))
(if (not (obj-vector? kind)) (emit-moveq 0 reg68))
(case kind
((string vector8) (emit-move.b loc68 reg68))
((vector16) (emit-move.w loc68 reg68))
(else (emit-move.l loc68 reg68)))
(if (not (obj-vector? kind))
(begin
(emit-asl.l (make-imm 3) reg68)
(if (eq? kind 'string) (emit-addq.w type-special reg68))))
(move-opnd68-to-loc reg68 loc sn)))))))
(define (make-gen-vector-set! kind)
(lambda (opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let ((first-opnd (car opnds))
(second-opnd (cadr opnds))
(third-opnd (caddr opnds)))
(let* ((sn-loc (if (and loc (not (eq? first-opnd loc)))
(sn-opnd first-opnd sn-loc)
sn))
(sn-third-opnd (sn-opnd third-opnd sn-loc))
(o2 (opnd->opnd68
second-opnd
#f
(sn-opnd first-opnd sn-third-opnd)))
(o1 (opnd->opnd68
first-opnd
(temp-in-opnd68 o2)
sn-third-opnd)))
(make-top-of-frame-if-stk-opnds68 o1 o2 sn-third-opnd)
(let* ((offset (if (eq? kind 'closure)
(- pointer-size type-procedure)
(- pointer-size type-subtyped)))
(loc68 (if (imm? o2)
(begin
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 sn-third-opnd)
atemp1)
(make-disp*
atemp1
(+ (quotient
(imm-val o2)
(vector-select kind 2 8 8 4))
offset)))
(begin
(move-opnd68-to-loc68
(opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
dtemp1)
(emit-asr.l
(make-imm (vector-select kind 1 3 3 2))
dtemp1)
(move-opnd68-to-loc68
(opnd68->true-opnd68 o1 sn-loc)
atemp1)
(if (obj-vector? kind)
(make-inx atemp1 dtemp1 offset)
(begin
(emit-move.l dtemp1 atemp2)
(make-inx atemp1 atemp2 offset)))))))
(if (obj-vector? kind)
(move-opnd-to-loc68 third-opnd loc68 sn-loc)
(begin
(move-opnd-to-loc68 third-opnd dtemp1 sn-loc)
(emit-asr.l (make-imm 3) dtemp1)
(if (eq? kind 'vector16)
(emit-move.w dtemp1 loc68)
(emit-move.b dtemp1 loc68))))
(if (and loc (not (eq? first-opnd loc)))
(copy-opnd-to-loc first-opnd loc sn))))))))
(define (make-gen-vector-shrink! kind)
(lambda (opnds loc sn)
(let ((sn-loc (if loc (sn-opnd loc sn) sn)))
(let ((first-opnd (car opnds)) (second-opnd (cadr opnds)))
(let* ((sn-loc (if (and loc (not (eq? first-opnd loc)))
(sn-opnd first-opnd sn-loc)
sn))
(o2 (opnd->opnd68 second-opnd #f (sn-opnd first-opnd sn-loc)))
(o1 (opnd->opnd68 first-opnd (temp-in-opnd68 o2) sn-loc)))
(make-top-of-frame-if-stk-opnds68 o1 o2 sn-loc)
(move-opnd68-to-loc68
(opnd68->true-opnd68 o2 (sn-opnd68 o1 sn-loc))
dtemp1)
(emit-move.l (opnd68->true-opnd68 o1 sn-loc) atemp1)
(if (eq? kind 'string)
(begin
(emit-asr.l (make-imm 3) dtemp1)
(emit-move.b
(make-imm 0)
(make-inx atemp1 dtemp1 (- pointer-size type-subtyped)))
(emit-addq.l 1 dtemp1)
(emit-asl.l (make-imm 8) dtemp1))
(emit-asl.l (make-imm (vector-select kind 7 5 5 6)) dtemp1))
(emit-move.b (make-ind atemp1) dtemp1)
(emit-move.l dtemp1 (make-disp* atemp1 (- type-subtyped)))
(if (and loc (not (eq? first-opnd loc)))
(move-opnd68-to-loc atemp1 loc sn)))))))
(define (gen-eq-test bits not? opnds lbl fs)
(gen-compare* (opnd->opnd68 (car opnds) #f fs) (make-imm bits) fs)
(if not? (emit-bne lbl) (emit-beq lbl)))
(define (gen-compare opnd1 opnd2 fs)
(let* ((o1 (opnd->opnd68 opnd1 #f (sn-opnd opnd2 fs)))
(o2 (opnd->opnd68 opnd2 (temp-in-opnd68 o1) fs)))
(gen-compare* o1 o2 fs)))
(define (gen-compare* o1 o2 fs)
(make-top-of-frame-if-stk-opnds68 o1 o2 fs)
(let ((order-1-2
(cond ((imm? o1)
(cmp-n-to-opnd68 (imm-val o1) (opnd68->true-opnd68 o2 fs)))
((imm? o2)
(not (cmp-n-to-opnd68
(imm-val o2)
(opnd68->true-opnd68 o1 fs))))
((reg68? o1) (emit-cmp.l (opnd68->true-opnd68 o2 fs) o1) #f)
((reg68? o2) (emit-cmp.l (opnd68->true-opnd68 o1 fs) o2) #t)
(else
(emit-move.l (opnd68->true-opnd68 o1 (sn-opnd68 o2 fs)) dtemp1)
(emit-cmp.l (opnd68->true-opnd68 o2 fs) dtemp1)
#f))))
(shrink-frame fs)
order-1-2))
(define (gen-compares branch< branch>= branch> branch<= not? opnds lbl fs)
(gen-compares*
gen-compare
branch<
branch>=
branch>
branch<=
not?
opnds
lbl
fs))
(define (gen-compares*
gen-comp
branch<
branch>=
branch>
branch<=
not?
opnds
lbl
fs)
(define (gen-compare-sequence opnd1 opnd2 rest)
(if (null? rest)
(if (gen-comp opnd1 opnd2 fs)
(if not? (branch<= lbl) (branch> lbl))
(if not? (branch>= lbl) (branch< lbl)))
(let ((order-1-2
(gen-comp opnd1 opnd2 (sn-opnd opnd2 (sn-opnds rest fs)))))
(if (= current-fs fs)
(if not?
(begin
(if order-1-2 (branch<= lbl) (branch>= lbl))
(gen-compare-sequence opnd2 (car rest) (cdr rest)))
(let ((exit-lbl (new-lbl!)))
(if order-1-2 (branch<= exit-lbl) (branch>= exit-lbl))
(gen-compare-sequence opnd2 (car rest) (cdr rest))
(emit-label exit-lbl)))
(if not?
(let ((next-lbl (new-lbl!)))
(if order-1-2 (branch> next-lbl) (branch< next-lbl))
(shrink-frame fs)
(emit-bra lbl)
(emit-label next-lbl)
(gen-compare-sequence opnd2 (car rest) (cdr rest)))
(let* ((next-lbl (new-lbl!)) (exit-lbl (new-lbl!)))
(if order-1-2 (branch> next-lbl) (branch< next-lbl))
(shrink-frame fs)
(emit-bra exit-lbl)
(emit-label next-lbl)
(gen-compare-sequence opnd2 (car rest) (cdr rest))
(emit-label exit-lbl)))))))
(if (or (null? opnds) (null? (cdr opnds)))
(begin (shrink-frame fs) (if (not not?) (emit-bra lbl)))
(gen-compare-sequence (car opnds) (cadr opnds) (cddr opnds))))
(define (gen-compare-flo opnd1 opnd2 fs)
(let* ((o1 (opnd->opnd68 opnd1 #f (sn-opnd opnd2 fs)))
(o2 (opnd->opnd68 opnd2 (temp-in-opnd68 o1) fs)))
(make-top-of-frame-if-stk-opnds68 o1 o2 fs)
(emit-move.l (opnd68->true-opnd68 o1 (sn-opnd68 o2 fs)) atemp1)
(emit-move.l (opnd68->true-opnd68 o2 fs) atemp2)
(emit-fmov.dx (make-disp* atemp2 (- type-flonum)) ftemp1)
(emit-fcmp.dx (make-disp* atemp1 (- type-flonum)) ftemp1)
#t))
(define (gen-compares-flo branch< branch>= branch> branch<= not? opnds lbl fs)
(gen-compares*
gen-compare-flo
branch<
branch>=
branch>
branch<=
not?
opnds
lbl
fs))
(define (gen-type-test tag not? opnds lbl fs)
(let ((opnd (car opnds)))
(let ((o (opnd->opnd68 opnd #f fs)))
(define (mask-test set-reg correction)
(emit-btst
(if (= correction 0)
(if (dreg? o)
o
(begin
(emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
dtemp1))
(begin
(if (not (eq? o dtemp1))
(emit-move.l (opnd68->true-opnd68 o fs) dtemp1))
(emit-addq.w correction dtemp1)
dtemp1))
set-reg))
(make-top-of-frame-if-stk-opnd68 o fs)
(cond ((= tag 0)
(if (eq? o dtemp1)
(emit-and.w (make-imm 7) dtemp1)
(begin
(emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
(emit-and.w (make-imm 7) dtemp1))))
((= tag type-placeholder) (mask-test placeholder-reg 0))
(else (mask-test pair-reg (modulo (- type-pair tag) 8))))
(shrink-frame fs)
(if not? (emit-bne lbl) (emit-beq lbl)))))
(define (gen-subtype-test type not? opnds lbl fs)
(let ((opnd (car opnds)))
(let ((o (opnd->opnd68 opnd #f fs)) (cont-lbl (new-lbl!)))
(make-top-of-frame-if-stk-opnd68 o fs)
(if (not (eq? o dtemp1)) (emit-move.l (opnd68->true-opnd68 o fs) dtemp1))
(emit-move.l dtemp1 atemp1)
(emit-addq.w (modulo (- type-pair type-subtyped) 8) dtemp1)
(emit-btst dtemp1 pair-reg)
(shrink-frame fs)
(if not? (emit-bne lbl) (emit-bne cont-lbl))
(emit-cmp.b (make-imm (* type 8)) (make-ind atemp1))
(if not? (emit-bne lbl) (emit-beq lbl))
(emit-label cont-lbl))))
(define (gen-even-test not? opnds lbl fs)
(move-opnd-to-loc68 (car opnds) dtemp1 fs)
(emit-and.w (make-imm 8) dtemp1)
(shrink-frame fs)
(if not? (emit-bne lbl) (emit-beq lbl)))
(define (def-spec name specializer-maker)
(let ((proc-name (string->canonical-symbol name)))
(let ((proc (prim-info proc-name)))
(if proc
(proc-obj-specialize-set! proc (specializer-maker proc proc-name))
(compiler-internal-error "def-spec, unknown primitive:" name)))))
(define (safe name)
(lambda (proc proc-name)
(let ((spec (get-prim-info name))) (lambda (decls) spec))))
(define (unsafe name)
(lambda (proc proc-name)
(let ((spec (get-prim-info name)))
(lambda (decls) (if (not (safe? decls)) spec proc)))))
(define (safe-arith fix-name flo-name) (arith #t fix-name flo-name))
(define (unsafe-arith fix-name flo-name) (arith #f fix-name flo-name))
(define (arith fix-safe? fix-name flo-name)
(lambda (proc proc-name)
(let ((fix-spec (if fix-name (get-prim-info fix-name) proc))
(flo-spec (if flo-name (get-prim-info flo-name) proc)))
(lambda (decls)
(let ((arith (arith-implementation proc-name decls)))
(cond ((eq? arith fixnum-sym)
(if (or fix-safe? (not (safe? decls))) fix-spec proc))
((eq? arith flonum-sym) (if (not (safe? decls)) flo-spec proc))
(else proc)))))))
(define-apply "##TYPE" #f (lambda (opnds loc sn) (gen-type opnds loc sn)))
(define-apply
"##TYPE-CAST"
#f
(lambda (opnds loc sn) (gen-type-cast opnds loc sn)))
(define-apply
"##SUBTYPE"
#f
(lambda (opnds loc sn) (gen-subtype opnds loc sn)))
(define-apply
"##SUBTYPE-SET!"
#t
(lambda (opnds loc sn) (gen-subtype-set! opnds loc sn)))
(define-ifjump
"##NOT"
(lambda (not? opnds lbl fs) (gen-eq-test bits-false not? opnds lbl fs)))
(define-ifjump
"##NULL?"
(lambda (not? opnds lbl fs) (gen-eq-test bits-null not? opnds lbl fs)))
(define-ifjump
"##UNASSIGNED?"
(lambda (not? opnds lbl fs) (gen-eq-test bits-unass not? opnds lbl fs)))
(define-ifjump
"##UNBOUND?"
(lambda (not? opnds lbl fs) (gen-eq-test bits-unbound not? opnds lbl fs)))
(define-ifjump
"##EQ?"
(lambda (not? opnds lbl fs)
(gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
(define-ifjump
"##FIXNUM?"
(lambda (not? opnds lbl fs) (gen-type-test type-fixnum not? opnds lbl fs)))
(define-ifjump
"##FLONUM?"
(lambda (not? opnds lbl fs) (gen-type-test type-flonum not? opnds lbl fs)))
(define-ifjump
"##SPECIAL?"
(lambda (not? opnds lbl fs) (gen-type-test type-special not? opnds lbl fs)))
(define-ifjump
"##PAIR?"
(lambda (not? opnds lbl fs) (gen-type-test type-pair not? opnds lbl fs)))
(define-ifjump
"##SUBTYPED?"
(lambda (not? opnds lbl fs) (gen-type-test type-subtyped not? opnds lbl fs)))
(define-ifjump
"##PROCEDURE?"
(lambda (not? opnds lbl fs) (gen-type-test type-procedure not? opnds lbl fs)))
(define-ifjump
"##PLACEHOLDER?"
(lambda (not? opnds lbl fs)
(gen-type-test type-placeholder not? opnds lbl fs)))
(define-ifjump
"##VECTOR?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-vector not? opnds lbl fs)))
(define-ifjump
"##SYMBOL?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-symbol not? opnds lbl fs)))
(define-ifjump
"##RATNUM?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-ratnum not? opnds lbl fs)))
(define-ifjump
"##CPXNUM?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-cpxnum not? opnds lbl fs)))
(define-ifjump
"##STRING?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-string not? opnds lbl fs)))
(define-ifjump
"##BIGNUM?"
(lambda (not? opnds lbl fs)
(gen-subtype-test subtype-bignum not? opnds lbl fs)))
(define-ifjump
"##CHAR?"
(lambda (not? opnds lbl fs)
(let ((opnd (car opnds)))
(let ((o (opnd->opnd68 opnd #f fs)) (cont-lbl (new-lbl!)))
(make-top-of-frame-if-stk-opnd68 o fs)
(emit-move.l (opnd68->true-opnd68 o fs) dtemp1)
(if not? (emit-bmi lbl) (emit-bmi cont-lbl))
(emit-addq.w (modulo (- type-pair type-special) 8) dtemp1)
(emit-btst dtemp1 pair-reg)
(shrink-frame fs)
(if not? (emit-bne lbl) (emit-beq lbl))
(emit-label cont-lbl)))))
(define-ifjump
"##CLOSURE?"
(lambda (not? opnds lbl fs)
(move-opnd-to-loc68 (car opnds) atemp1 fs)
(shrink-frame fs)
(emit-cmp.w (make-imm 20153) (make-ind atemp1))
(if not? (emit-bne lbl) (emit-beq lbl))))
(define-ifjump
"##SUBPROCEDURE?"
(lambda (not? opnds lbl fs)
(move-opnd-to-loc68 (car opnds) atemp1 fs)
(shrink-frame fs)
(emit-move.w (make-pdec atemp1) dtemp1)
(if not? (emit-bmi lbl) (emit-bpl lbl))))
(define-ifjump
"##RETURN-DYNAMIC-ENV-BIND?"
(lambda (not? opnds lbl fs)
(move-opnd-to-loc68 (car opnds) atemp1 fs)
(shrink-frame fs)
(emit-move.w (make-disp* atemp1 -6) dtemp1)
(if not? (emit-bne lbl) (emit-beq lbl))))
(define-apply
"##FIXNUM.+"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
((or (reg? loc) (stk? loc))
(commut-oper gen-add opnds loc sn #f '() '()))
(else (gen-add opnds '() loc sn #f))))))
(define-apply
"##FIXNUM.-"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(gen-sub (car opnds)
(cdr opnds)
loc
sn
(any-contains-opnd? loc (cdr opnds))))))
(define-apply
"##FIXNUM.*"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj '1) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
((and (reg? loc) (not (eq? loc return-reg)))
(commut-oper gen-mul opnds loc sn #f '() '()))
(else (gen-mul opnds '() loc sn #f))))))
(define-apply
"##FIXNUM.QUOTIENT"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(gen-div (car opnds)
(cdr opnds)
loc
sn
(any-contains-opnd? loc (cdr opnds))))))
(define-apply
"##FIXNUM.REMAINDER"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(gen-rem (car opnds) (cadr opnds) loc sn))))
(define-apply
"##FIXNUM.MODULO"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(gen-mod (car opnds) (cadr opnds) loc sn))))
(define-apply
"##FIXNUM.LOGIOR"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
((or (reg? loc) (stk? loc))
(commut-oper gen-logior opnds loc sn #f '() '()))
(else (gen-logior opnds '() loc sn #f))))))
(define-apply
"##FIXNUM.LOGXOR"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj '0) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
((or (reg? loc) (stk? loc))
(commut-oper gen-logxor opnds loc sn #f '() '()))
(else (gen-logxor opnds '() loc sn #f))))))
(define-apply
"##FIXNUM.LOGAND"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj '-1) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
((or (reg? loc) (stk? loc))
(commut-oper gen-logand opnds loc sn #f '() '()))
(else (gen-logand opnds '() loc sn #f))))))
(define-apply
"##FIXNUM.LOGNOT"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)) (opnd (car opnds)))
(if (and (or (reg? loc) (stk? loc)) (not (eq? loc return-reg)))
(begin
(copy-opnd-to-loc opnd loc sn-loc)
(let ((loc68 (loc->loc68 loc #f sn)))
(make-top-of-frame-if-stk-opnd68 loc68 sn)
(emit-not.l (opnd68->true-opnd68 loc68 sn))
(emit-and.w (make-imm -8) (opnd68->true-opnd68 loc68 sn))))
(begin
(move-opnd-to-loc68 opnd dtemp1 (sn-opnd loc sn))
(emit-not.l dtemp1)
(emit-and.w (make-imm -8) dtemp1)
(move-opnd68-to-loc dtemp1 loc sn))))))
(define-apply "##FIXNUM.ASH" #f (gen-shift emit-asr.l))
(define-apply "##FIXNUM.LSH" #f (gen-shift emit-lsr.l))
(define-ifjump
"##FIXNUM.ZERO?"
(lambda (not? opnds lbl fs) (gen-eq-test 0 not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.POSITIVE?"
(lambda (not? opnds lbl fs)
(gen-compares
emit-bgt
emit-ble
emit-blt
emit-bge
not?
(list (car opnds) (make-obj '0))
lbl
fs)))
(define-ifjump
"##FIXNUM.NEGATIVE?"
(lambda (not? opnds lbl fs)
(gen-compares
emit-blt
emit-bge
emit-bgt
emit-ble
not?
(list (car opnds) (make-obj '0))
lbl
fs)))
(define-ifjump
"##FIXNUM.ODD?"
(lambda (not? opnds lbl fs) (gen-even-test (not not?) opnds lbl fs)))
(define-ifjump
"##FIXNUM.EVEN?"
(lambda (not? opnds lbl fs) (gen-even-test not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.="
(lambda (not? opnds lbl fs)
(gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.<"
(lambda (not? opnds lbl fs)
(gen-compares emit-blt emit-bge emit-bgt emit-ble not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.>"
(lambda (not? opnds lbl fs)
(gen-compares emit-bgt emit-ble emit-blt emit-bge not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.<="
(lambda (not? opnds lbl fs)
(gen-compares emit-ble emit-bgt emit-bge emit-blt not? opnds lbl fs)))
(define-ifjump
"##FIXNUM.>="
(lambda (not? opnds lbl fs)
(gen-compares emit-bge emit-blt emit-ble emit-bgt not? opnds lbl fs)))
(define-apply
"##FLONUM.->FIXNUM"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(move-opnd-to-loc68 (car opnds) atemp1 sn-loc)
(let ((reg68 (if (and (reg? loc) (not (eq? loc return-reg)))
(reg->reg68 loc)
dtemp1)))
(emit-fmov.dx (make-disp* atemp1 (- type-flonum)) ftemp1)
(emit-fmov.l ftemp1 reg68)
(emit-asl.l (make-imm 3) reg68)
(if (not (and (reg? loc) (not (eq? loc return-reg))))
(move-opnd68-to-loc reg68 loc sn))))))
(define-apply
"##FLONUM.<-FIXNUM"
#f
(lambda (opnds loc sn)
(gen-guarantee-space 2)
(move-opnd-to-loc68
(car opnds)
dtemp1
(sn-opnds (cdr opnds) (sn-opnd loc sn)))
(emit-asr.l (make-imm 3) dtemp1)
(emit-fmov.l dtemp1 ftemp1)
(add-n-to-loc68 (* -2 pointer-size) heap-reg)
(emit-fmov.dx ftemp1 (make-ind heap-reg))
(let ((reg68 (if (reg? loc) (reg->reg68 loc) atemp1)))
(emit-move.l heap-reg reg68)
(emit-addq.l type-flonum reg68))
(if (not (reg? loc)) (move-opnd68-to-loc atemp1 loc sn))))
(define-apply
"##FLONUM.+"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj inexact-0) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
(else (flo-oper emit-fmov.dx emit-fadd.dx opnds loc sn))))))
(define-apply
"##FLONUM.*"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(cond ((null? opnds) (copy-opnd-to-loc (make-obj inexact-+1) loc sn))
((null? (cdr opnds)) (copy-opnd-to-loc (car opnds) loc sn))
(else (flo-oper emit-fmov.dx emit-fmul.dx opnds loc sn))))))
(define-apply
"##FLONUM.-"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(if (null? (cdr opnds))
(flo-oper emit-fneg.dx #f opnds loc sn)
(flo-oper emit-fmov.dx emit-fsub.dx opnds loc sn)))))
(define-apply
"##FLONUM./"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(if (null? (cdr opnds))
(flo-oper
emit-fmov.dx
emit-fdiv.dx
(cons (make-obj inexact-+1) opnds)
loc
sn)
(flo-oper emit-fmov.dx emit-fdiv.dx opnds loc sn)))))
(define-apply
"##FLONUM.ABS"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fabs.dx #f opnds loc sn))))
(define-apply
"##FLONUM.TRUNCATE"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn)))
(flo-oper emit-fintrz.dx #f opnds loc sn))))
(define-apply
"##FLONUM.ROUND"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fint.dx #f opnds loc sn))))
(define-apply
"##FLONUM.EXP"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fetox.dx #f opnds loc sn))))
(define-apply
"##FLONUM.LOG"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-flogn.dx #f opnds loc sn))))
(define-apply
"##FLONUM.SIN"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fsin.dx #f opnds loc sn))))
(define-apply
"##FLONUM.COS"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fcos.dx #f opnds loc sn))))
(define-apply
"##FLONUM.TAN"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-ftan.dx #f opnds loc sn))))
(define-apply
"##FLONUM.ASIN"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fasin.dx #f opnds loc sn))))
(define-apply
"##FLONUM.ACOS"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-facos.dx #f opnds loc sn))))
(define-apply
"##FLONUM.ATAN"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fatan.dx #f opnds loc sn))))
(define-apply
"##FLONUM.SQRT"
#f
(lambda (opnds loc sn)
(let ((sn-loc (sn-opnd loc sn))) (flo-oper emit-fsqrt.dx #f opnds loc sn))))
(define-ifjump
"##FLONUM.ZERO?"
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fbeq
emit-fbne
emit-fbeq
emit-fbne
not?
(list (car opnds) (make-obj inexact-0))
lbl
fs)))
(define-ifjump
"##FLONUM.NEGATIVE?"
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fblt
emit-fbge
emit-fbgt
emit-fble
not?
(list (car opnds) (make-obj inexact-0))
lbl
fs)))
(define-ifjump
"##FLONUM.POSITIVE?"
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fbgt
emit-fble
emit-fblt
emit-fbge
not?
(list (car opnds) (make-obj inexact-0))
lbl
fs)))
(define-ifjump
"##FLONUM.="
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fbeq
emit-fbne
emit-fbeq
emit-fbne
not?
opnds
lbl
fs)))
(define-ifjump
"##FLONUM.<"
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fblt
emit-fbge
emit-fbgt
emit-fble
not?
opnds
lbl
fs)))
(define-ifjump
"##FLONUM.>"
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fbgt
emit-fble
emit-fblt
emit-fbge
not?
opnds
lbl
fs)))
(define-ifjump
"##FLONUM.<="
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fble
emit-fbgt
emit-fbge
emit-fblt
not?
opnds
lbl
fs)))
(define-ifjump
"##FLONUM.>="
(lambda (not? opnds lbl fs)
(gen-compares-flo
emit-fbge
emit-fblt
emit-fble
emit-fbgt
not?
opnds
lbl
fs)))
(define-ifjump
"##CHAR=?"
(lambda (not? opnds lbl fs)
(gen-compares emit-beq emit-bne emit-beq emit-bne not? opnds lbl fs)))
(define-ifjump
"##CHAR<?"
(lambda (not? opnds lbl fs)
(gen-compares emit-blt emit-bge emit-bgt emit-ble not? opnds lbl fs)))
(define-ifjump
"##CHAR>?"
(lambda (not? opnds lbl fs)
(gen-compares emit-bgt emit-ble emit-blt emit-bge not? opnds lbl fs)))
(define-ifjump
"##CHAR<=?"
(lambda (not? opnds lbl fs)
(gen-compares emit-ble emit-bgt emit-bge emit-blt not? opnds lbl fs)))
(define-ifjump
"##CHAR>=?"
(lambda (not? opnds lbl fs)
(gen-compares emit-bge emit-blt emit-ble emit-bgt not? opnds lbl fs)))
(define-apply "##CONS" #f (lambda (opnds loc sn) (gen-cons opnds loc sn)))
(define-apply
"##SET-CAR!"
#t
(lambda (opnds loc sn) (gen-set-car! opnds loc sn)))
(define-apply
"##SET-CDR!"
#t
(lambda (opnds loc sn) (gen-set-cdr! opnds loc sn)))
(define-apply "##CAR" #f (make-gen-apply-c...r 2))
(define-apply "##CDR" #f (make-gen-apply-c...r 3))
(define-apply "##CAAR" #f (make-gen-apply-c...r 4))
(define-apply "##CADR" #f (make-gen-apply-c...r 5))
(define-apply "##CDAR" #f (make-gen-apply-c...r 6))
(define-apply "##CDDR" #f (make-gen-apply-c...r 7))
(define-apply "##CAAAR" #f (make-gen-apply-c...r 8))
(define-apply "##CAADR" #f (make-gen-apply-c...r 9))
(define-apply "##CADAR" #f (make-gen-apply-c...r 10))
(define-apply "##CADDR" #f (make-gen-apply-c...r 11))
(define-apply "##CDAAR" #f (make-gen-apply-c...r 12))
(define-apply "##CDADR" #f (make-gen-apply-c...r 13))
(define-apply "##CDDAR" #f (make-gen-apply-c...r 14))
(define-apply "##CDDDR" #f (make-gen-apply-c...r 15))
(define-apply "##CAAAAR" #f (make-gen-apply-c...r 16))
(define-apply "##CAAADR" #f (make-gen-apply-c...r 17))
(define-apply "##CAADAR" #f (make-gen-apply-c...r 18))
(define-apply "##CAADDR" #f (make-gen-apply-c...r 19))
(define-apply "##CADAAR" #f (make-gen-apply-c...r 20))
(define-apply "##CADADR" #f (make-gen-apply-c...r 21))
(define-apply "##CADDAR" #f (make-gen-apply-c...r 22))
(define-apply "##CADDDR" #f (make-gen-apply-c...r 23))
(define-apply "##CDAAAR" #f (make-gen-apply-c...r 24))
(define-apply "##CDAADR" #f (make-gen-apply-c...r 25))
(define-apply "##CDADAR" #f (make-gen-apply-c...r 26))
(define-apply "##CDADDR" #f (make-gen-apply-c...r 27))
(define-apply "##CDDAAR" #f (make-gen-apply-c...r 28))
(define-apply "##CDDADR" #f (make-gen-apply-c...r 29))
(define-apply "##CDDDAR" #f (make-gen-apply-c...r 30))
(define-apply "##CDDDDR" #f (make-gen-apply-c...r 31))
(define-apply
"##MAKE-CELL"
#f
(lambda (opnds loc sn) (gen-cons (list (car opnds) (make-obj '())) loc sn)))
(define-apply "##CELL-REF" #f (make-gen-apply-c...r 2))
(define-apply
"##CELL-SET!"
#t
(lambda (opnds loc sn) (gen-set-car! opnds loc sn)))
(define-apply "##VECTOR" #f (make-gen-vector 'vector))
(define-apply "##VECTOR-LENGTH" #f (make-gen-vector-length 'vector))
(define-apply "##VECTOR-REF" #f (make-gen-vector-ref 'vector))
(define-apply "##VECTOR-SET!" #t (make-gen-vector-set! 'vector))
(define-apply "##VECTOR-SHRINK!" #t (make-gen-vector-shrink! 'vector))
(define-apply "##STRING" #f (make-gen-vector 'string))
(define-apply "##STRING-LENGTH" #f (make-gen-vector-length 'string))
(define-apply "##STRING-REF" #f (make-gen-vector-ref 'string))
(define-apply "##STRING-SET!" #t (make-gen-vector-set! 'string))
(define-apply "##STRING-SHRINK!" #t (make-gen-vector-shrink! 'string))
(define-apply "##VECTOR8" #f (make-gen-vector 'vector8))
(define-apply "##VECTOR8-LENGTH" #f (make-gen-vector-length 'vector8))
(define-apply "##VECTOR8-REF" #f (make-gen-vector-ref 'vector8))
(define-apply "##VECTOR8-SET!" #t (make-gen-vector-set! 'vector8))
(define-apply "##VECTOR8-SHRINK!" #t (make-gen-vector-shrink! 'vector8))
(define-apply "##VECTOR16" #f (make-gen-vector 'vector16))
(define-apply "##VECTOR16-LENGTH" #f (make-gen-vector-length 'vector16))
(define-apply "##VECTOR16-REF" #f (make-gen-vector-ref 'vector16))
(define-apply "##VECTOR16-SET!" #t (make-gen-vector-set! 'vector16))
(define-apply "##VECTOR16-SHRINK!" #t (make-gen-vector-shrink! 'vector16))
(define-apply "##CLOSURE-CODE" #f (make-gen-slot-ref 1 type-procedure))
(define-apply "##CLOSURE-REF" #f (make-gen-vector-ref 'closure))
(define-apply "##CLOSURE-SET!" #t (make-gen-vector-set! 'closure))
(define-apply
"##SUBPROCEDURE-ID"
#f
(lambda (opnds loc sn) (gen-subprocedure-id opnds loc sn)))
(define-apply
"##SUBPROCEDURE-PARENT"
#f
(lambda (opnds loc sn) (gen-subprocedure-parent opnds loc sn)))
(define-apply
"##RETURN-FS"
#f
(lambda (opnds loc sn) (gen-return-fs opnds loc sn)))
(define-apply
"##RETURN-LINK"
#f
(lambda (opnds loc sn) (gen-return-link opnds loc sn)))
(define-apply
"##PROCEDURE-INFO"
#f
(lambda (opnds loc sn) (gen-procedure-info opnds loc sn)))
(define-apply
"##PSTATE"
#f
(lambda (opnds loc sn) (move-opnd68-to-loc pstate-reg loc sn)))
(define-apply
"##MAKE-PLACEHOLDER"
#f
(lambda (opnds loc sn) (gen-make-placeholder opnds loc sn)))
(define-apply
"##TOUCH"
#t
(lambda (opnds loc sn)
(let ((opnd (car opnds)))
(if loc
(touch-opnd-to-loc opnd loc sn)
(touch-opnd-to-any-reg68 opnd sn)))))
(def-spec "NOT" (safe "##NOT"))
(def-spec "NULL?" (safe "##NULL?"))
(def-spec "EQ?" (safe "##EQ?"))
(def-spec "PAIR?" (safe "##PAIR?"))
(def-spec "PROCEDURE?" (safe "##PROCEDURE?"))
(def-spec "VECTOR?" (safe "##VECTOR?"))
(def-spec "SYMBOL?" (safe "##SYMBOL?"))
(def-spec "STRING?" (safe "##STRING?"))
(def-spec "CHAR?" (safe "##CHAR?"))
(def-spec "ZERO?" (safe-arith "##FIXNUM.ZERO?" "##FLONUM.ZERO?"))
(def-spec "POSITIVE?" (safe-arith "##FIXNUM.POSITIVE?" "##FLONUM.POSITIVE?"))
(def-spec "NEGATIVE?" (safe-arith "##FIXNUM.NEGATIVE?" "##FLONUM.NEGATIVE?"))
(def-spec "ODD?" (safe-arith "##FIXNUM.ODD?" #f))
(def-spec "EVEN?" (safe-arith "##FIXNUM.EVEN?" #f))
(def-spec "+" (unsafe-arith "##FIXNUM.+" "##FLONUM.+"))
(def-spec "*" (unsafe-arith "##FIXNUM.*" "##FLONUM.*"))
(def-spec "-" (unsafe-arith "##FIXNUM.-" "##FLONUM.-"))
(def-spec "/" (unsafe-arith #f "##FLONUM./"))
(def-spec "QUOTIENT" (unsafe-arith "##FIXNUM.QUOTIENT" #f))
(def-spec "REMAINDER" (unsafe-arith "##FIXNUM.REMAINDER" #f))
(def-spec "MODULO" (unsafe-arith "##FIXNUM.MODULO" #f))
(def-spec "=" (safe-arith "##FIXNUM.=" "##FLONUM.="))
(def-spec "<" (safe-arith "##FIXNUM.<" "##FLONUM.<"))
(def-spec ">" (safe-arith "##FIXNUM.>" "##FLONUM.>"))
(def-spec "<=" (safe-arith "##FIXNUM.<=" "##FLONUM.<="))
(def-spec ">=" (safe-arith "##FIXNUM.>=" "##FLONUM.>="))
(def-spec "ABS" (unsafe-arith #f "##FLONUM.ABS"))
(def-spec "TRUNCATE" (unsafe-arith #f "##FLONUM.TRUNCATE"))
(def-spec "EXP" (unsafe-arith #f "##FLONUM.EXP"))
(def-spec "LOG" (unsafe-arith #f "##FLONUM.LOG"))
(def-spec "SIN" (unsafe-arith #f "##FLONUM.SIN"))
(def-spec "COS" (unsafe-arith #f "##FLONUM.COS"))
(def-spec "TAN" (unsafe-arith #f "##FLONUM.TAN"))
(def-spec "ASIN" (unsafe-arith #f "##FLONUM.ASIN"))
(def-spec "ACOS" (unsafe-arith #f "##FLONUM.ACOS"))
(def-spec "ATAN" (unsafe-arith #f "##FLONUM.ATAN"))
(def-spec "SQRT" (unsafe-arith #f "##FLONUM.SQRT"))
(def-spec "CHAR=?" (safe "##CHAR=?"))
(def-spec "CHAR<?" (safe "##CHAR<?"))
(def-spec "CHAR>?" (safe "##CHAR>?"))
(def-spec "CHAR<=?" (safe "##CHAR<=?"))
(def-spec "CHAR>=?" (safe "##CHAR>=?"))
(def-spec "CONS" (safe "##CONS"))
(def-spec "SET-CAR!" (unsafe "##SET-CAR!"))
(def-spec "SET-CDR!" (unsafe "##SET-CDR!"))
(def-spec "CAR" (unsafe "##CAR"))
(def-spec "CDR" (unsafe "##CDR"))
(def-spec "CAAR" (unsafe "##CAAR"))
(def-spec "CADR" (unsafe "##CADR"))
(def-spec "CDAR" (unsafe "##CDAR"))
(def-spec "CDDR" (unsafe "##CDDR"))
(def-spec "CAAAR" (unsafe "##CAAAR"))
(def-spec "CAADR" (unsafe "##CAADR"))
(def-spec "CADAR" (unsafe "##CADAR"))
(def-spec "CADDR" (unsafe "##CADDR"))
(def-spec "CDAAR" (unsafe "##CDAAR"))
(def-spec "CDADR" (unsafe "##CDADR"))
(def-spec "CDDAR" (unsafe "##CDDAR"))
(def-spec "CDDDR" (unsafe "##CDDDR"))
(def-spec "CAAAAR" (unsafe "##CAAAAR"))
(def-spec "CAAADR" (unsafe "##CAAADR"))
(def-spec "CAADAR" (unsafe "##CAADAR"))
(def-spec "CAADDR" (unsafe "##CAADDR"))
(def-spec "CADAAR" (unsafe "##CADAAR"))
(def-spec "CADADR" (unsafe "##CADADR"))
(def-spec "CADDAR" (unsafe "##CADDAR"))
(def-spec "CADDDR" (unsafe "##CADDDR"))
(def-spec "CDAAAR" (unsafe "##CDAAAR"))
(def-spec "CDAADR" (unsafe "##CDAADR"))
(def-spec "CDADAR" (unsafe "##CDADAR"))
(def-spec "CDADDR" (unsafe "##CDADDR"))
(def-spec "CDDAAR" (unsafe "##CDDAAR"))
(def-spec "CDDADR" (unsafe "##CDDADR"))
(def-spec "CDDDAR" (unsafe "##CDDDAR"))
(def-spec "CDDDDR" (unsafe "##CDDDDR"))
(def-spec "VECTOR" (safe "##VECTOR"))
(def-spec "VECTOR-LENGTH" (unsafe "##VECTOR-LENGTH"))
(def-spec "VECTOR-REF" (unsafe "##VECTOR-REF"))
(def-spec "VECTOR-SET!" (unsafe "##VECTOR-SET!"))
(def-spec "STRING" (safe "##STRING"))
(def-spec "STRING-LENGTH" (unsafe "##STRING-LENGTH"))
(def-spec "STRING-REF" (unsafe "##STRING-REF"))
(def-spec "STRING-SET!" (unsafe "##STRING-SET!"))
(def-spec "TOUCH" (safe "##TOUCH"))
(let ((targ (make-target 4 'm68000)))
(target-begin!-set! targ (lambda (info-port) (begin! info-port targ)))
(put-target targ))
(define input-source-code '
(begin
(declare (standard-bindings) (fixnum) (not safe) (block))
(define (fib n)
(if (< n 2)
n
(+ (fib (- n 1))
(fib (- n 2)))))
(define (tak x y z)
(if (not (< y x))
z
(tak (tak (- x 1) y z)
(tak (- y 1) z x)
(tak (- z 1) x y))))
(define (ack m n)
(cond ((= m 0) (+ n 1))
((= n 0) (ack (- m 1) 1))
(else (ack (- m 1) (ack m (- n 1))))))
(define (create-x n)
(define result (make-vector n))
(do ((i 0 (+ i 1)))
((>= i n) result)
(vector-set! result i i)))
(define (create-y x)
(let* ((n (vector-length x))
(result (make-vector n)))
(do ((i (- n 1) (- i 1)))
((< i 0) result)
(vector-set! result i (vector-ref x i)))))
(define (my-try n)
(vector-length (create-y (create-x n))))
(define (go n)
(let loop ((repeat 100)
(result 0))
(if (> repeat 0)
(loop (- repeat 1) (my-try n))
result)))
(+ (fib 20)
(tak 18 12 6)
(ack 3 9)
(go 200000))
))
(define output-expected '(
"|------------------------------------------------------"
"| #[primitive #!program] ="
"L1:"
" cmpw #1,d0"
" beq L1000"
" TRAP1(9,0)"
" LBL_PTR(L1)"
"L1000:"
" MOVE_PROC(1,a1)"
" movl a1,GLOB(fib)"
" MOVE_PROC(2,a1)"
" movl a1,GLOB(tak)"
" MOVE_PROC(3,a1)"
" movl a1,GLOB(ack)"
" MOVE_PROC(4,a1)"
" movl a1,GLOB(create-x)"
" MOVE_PROC(5,a1)"
" movl a1,GLOB(create-y)"
" MOVE_PROC(6,a1)"
" movl a1,GLOB(my-try)"
" MOVE_PROC(7,a1)"
" movl a1,GLOB(go)"
" movl a0,sp@-"
" movl #160,d1"
" lea L2,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1002:"
"L1001:"
" JMP_PROC(1,10)"
" RETURN(L1,1,1)"
"L2:"
" movl d1,sp@-"
" moveq #48,d3"
" moveq #96,d2"
" movl #144,d1"
" lea L3,a0"
" JMP_PROC(2,14)"
" RETURN(L1,2,1)"
"L3:"
" movl d1,sp@-"
" moveq #72,d2"
" moveq #24,d1"
" lea L4,a0"
" JMP_PROC(3,10)"
" RETURN(L1,3,1)"
"L4:"
" movl d1,sp@-"
" movl #1600000,d1"
" lea L5,a0"
" JMP_PROC(7,10)"
" RETURN(L1,4,1)"
"L5:"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" TRAP2(24)"
" RETURN(L1,4,1)"
"L1004:"
"L1003:"
"L6:"
" addl sp@(8),d1"
" addl sp@(4),d1"
" addl sp@+,d1"
" addql #8,sp"
" rts"
"L0:"
"|------------------------------------------------------"
"| #[primitive fib] ="
"L1:"
" bmi L1000"
" TRAP1(9,1)"
" LBL_PTR(L1)"
"L1000:"
" moveq #16,d0"
" cmpl d1,d0"
" ble L3"
" bra L4"
" RETURN(L1,2,1)"
"L2:"
" movl d1,sp@-"
" movl sp@(4),d1"
" moveq #-16,d0"
" addl d0,d1"
" lea L5,a0"
" moveq #16,d0"
" cmpl d1,d0"
" bgt L4"
"L3:"
" movl a0,sp@-"
" movl d1,sp@-"
" subql #8,d1"
" lea L2,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" TRAP2(24)"
" RETURN(L1,2,1)"
"L1002:"
"L1001:"
" moveq #16,d0"
" cmpl d1,d0"
" ble L3"
"L4:"
" jmp a0@"
" RETURN(L1,3,1)"
"L5:"
" addl sp@+,d1"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" TRAP2(24)"
" RETURN(L1,2,1)"
"L1004:"
"L1003:"
" addql #4,sp"
" rts"
"L0:"
"|------------------------------------------------------"
"| #[primitive tak] ="
"L1:"
" cmpw #4,d0"
" beq L1000"
" TRAP1(9,3)"
" LBL_PTR(L1)"
"L1000:"
" cmpl d1,d2"
" bge L4"
" bra L3"
" RETURN(L1,6,1)"
"L2:"
" movl d1,d3"
" movl sp@(20),a0"
" movl sp@+,d2"
" movl sp@+,d1"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" movl a0,sp@(12)"
" TRAP2(24)"
" RETURN(L1,4,1)"
"L1002:"
" movl sp@(12),a0"
"L1001:"
" cmpl d1,d2"
" lea sp@(16),sp"
" bge L4"
"L3:"
" movl a0,sp@-"
" movl d1,sp@-"
" movl d2,sp@-"
" movl d3,sp@-"
" subql #8,d1"
" lea L5,a0"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" TRAP2(24)"
" RETURN(L1,4,1)"
"L1004:"
"L1003:"
" cmpl d1,d2"
" blt L3"
"L4:"
" movl d3,d1"
" jmp a0@"
" RETURN(L1,4,1)"
"L5:"
" movl d1,sp@-"
" movl sp@(12),d3"
" movl sp@(4),d2"
" movl sp@(8),d1"
" subql #8,d1"
" lea L6,a0"
" cmpl d1,d2"
" bge L4"
" bra L3"
" RETURN(L1,5,1)"
"L6:"
" movl d1,sp@-"
" movl sp@(12),d3"
" movl sp@(16),d2"
" movl sp@(8),d1"
" subql #8,d1"
" lea L2,a0"
" cmpl d1,d2"
" bge L4"
" bra L3"
"L0:"
"|------------------------------------------------------"
"| #[primitive ack] ="
"L1:"
" beq L1000"
" TRAP1(9,2)"
" LBL_PTR(L1)"
"L1000:"
" movl d1,d0"
" bne L3"
" bra L5"
" RETURN(L1,2,1)"
"L2:"
" movl d1,d2"
" movl sp@+,d1"
" subql #8,d1"
" movl sp@+,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1002:"
" movl sp@+,a0"
"L1001:"
" movl d1,d0"
" beq L5"
"L3:"
" movl d2,d0"
" bne L6"
"L4:"
" subql #8,d1"
" moveq #8,d2"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1004:"
" movl sp@+,a0"
"L1003:"
" movl d1,d0"
" bne L3"
"L5:"
" movl d2,d1"
" addql #8,d1"
" jmp a0@"
"L6:"
" movl a0,sp@-"
" movl d1,sp@-"
" movl d2,d1"
" subql #8,d1"
" movl d1,d2"
" movl sp@,d1"
" lea L2,a0"
" dbra d5,L1005"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1005"
" TRAP2(24)"
" RETURN(L1,2,1)"
"L1006:"
"L1005:"
" movl d1,d0"
" bne L3"
" bra L5"
"L0:"
"|------------------------------------------------------"
"| #[primitive create-x] ="
"L1:"
" bmi L1000"
" TRAP1(9,1)"
" LBL_PTR(L1)"
"L1000:"
" movl a0,sp@-"
" movl d1,sp@-"
" lea L2,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" TRAP2(24)"
" RETURN(L1,2,1)"
"L1002:"
"L1001:"
" moveq #-1,d0"
" JMP_PRIM(make-vector,0)"
" RETURN(L1,2,1)"
"L2:"
" movl d1,d2"
" movl sp@+,d1"
" moveq #0,d3"
" movl sp@+,a0"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1004:"
" movl sp@+,a0"
"L1003:"
" cmpl d1,d3"
" bge L4"
"L3:"
" movl d3,d0"
" asrl #1,d0"
" movl d2,a1"
" movl d3,a1@(1,d0:l)"
" addql #8,d3"
" dbra d5,L1005"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1005"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1006:"
" movl sp@+,a0"
"L1005:"
" cmpl d1,d3"
" blt L3"
"L4:"
" movl d2,d1"
" jmp a0@"
"L0:"
"|------------------------------------------------------"
"| #[primitive create-y] ="
"L1:"
" bmi L1000"
" TRAP1(9,1)"
" LBL_PTR(L1)"
"L1000:"
" movl d1,a1"
" movl a1@(-3),d2"
" lsrl #7,d2"
" movl a0,sp@-"
" movl d1,sp@-"
" movl d2,sp@-"
" movl d2,d1"
" lea L2,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" TRAP2(24)"
" RETURN(L1,3,1)"
"L1002:"
"L1001:"
" moveq #-1,d0"
" JMP_PRIM(make-vector,0)"
" RETURN(L1,3,1)"
"L2:"
" movl sp@+,d2"
" subql #8,d2"
" movl d2,d3"
" movl d1,d2"
" movl sp@+,d1"
" movl sp@+,a0"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1004:"
" movl sp@+,a0"
"L1003:"
" movl d3,d0"
" blt L4"
"L3:"
" movl d3,d0"
" asrl #1,d0"
" movl d1,a1"
" movl a1@(1,d0:l),d4"
" movl d3,d0"
" asrl #1,d0"
" movl d2,a1"
" movl d4,a1@(1,d0:l)"
" subql #8,d3"
" dbra d5,L1005"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1005"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1006:"
" movl sp@+,a0"
"L1005:"
" movl d3,d0"
" bge L3"
"L4:"
" movl d2,d1"
" jmp a0@"
"L0:"
"|------------------------------------------------------"
"| #[primitive my-try] ="
"L1:"
" bmi L1000"
" TRAP1(9,1)"
" LBL_PTR(L1)"
"L1000:"
" movl a0,sp@-"
" lea L2,a0"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1002:"
"L1001:"
" JMP_PROC(4,10)"
" RETURN(L1,1,1)"
"L2:"
" lea L3,a0"
" JMP_PROC(5,10)"
" RETURN(L1,1,1)"
"L3:"
" movl d1,a1"
" movl a1@(-3),d1"
" lsrl #7,d1"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1004:"
"L1003:"
" rts"
"L0:"
"|------------------------------------------------------"
"| #[primitive go] ="
"L1:"
" bmi L1000"
" TRAP1(9,1)"
" LBL_PTR(L1)"
"L1000:"
" moveq #0,d3"
" movl #800,d2"
" dbra d5,L1001"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1001"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1002:"
" movl sp@+,a0"
"L1001:"
" movl d2,d0"
" ble L4"
" bra L3"
" RETURN(L1,3,1)"
"L2:"
" movl d1,d3"
" movl sp@+,d1"
" subql #8,d1"
" movl d1,d2"
" movl sp@+,d1"
" movl sp@+,a0"
" dbra d5,L1003"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1003"
" movl a0,sp@-"
" TRAP2(24)"
" RETURN(L1,1,1)"
"L1004:"
" movl sp@+,a0"
"L1003:"
" movl d2,d0"
" ble L4"
"L3:"
" movl a0,sp@-"
" movl d1,sp@-"
" movl d2,sp@-"
" lea L2,a0"
" dbra d5,L1005"
" moveq #9,d5"
" cmpl a5@,sp"
" bcc L1005"
" TRAP2(24)"
" RETURN(L1,3,1)"
"L1006:"
"L1005:"
" JMP_PROC(6,10)"
"L4:"
" movl d3,d1"
" jmp a0@"
"L0:"
""))
(define (main . args)
(run-benchmark
"compiler"
compiler-iters
(lambda (result)
(equal? result output-expected))
(lambda (expr target opt) (lambda () (ce expr target opt) (asm-output-get)))
input-source-code
'm68000
'asm))
| false |
a5f4511dc8b44b9c242bbd808d9ebd5b76c0e438
|
f4aeaa0812ac15d5a8d2cb6da75ac335c3cf5cf4
|
/miruKanren/mk-diseq.sld
|
354068fdec4cc212d9f62a22125aa462cb4cd299
|
[
"MIT"
] |
permissive
|
orchid-hybrid/microKanren-sagittarius
|
13f7916f8ef7c946cefeb87e9e52d6d4a5dfe6c9
|
9e740bbf94ed2930f88bbcf32636d3480934cfbb
|
refs/heads/master
| 2021-01-13T01:54:20.589391 | 2015-06-13T12:40:14 | 2015-06-13T12:40:14 | 29,868,626 | 12 | 4 | null | 2015-02-12T07:11:25 | 2015-01-26T16:01:10 |
Scheme
|
UTF-8
|
Scheme
| false | false | 196 |
sld
|
mk-diseq.sld
|
(define-library (miruKanren mk-diseq)
(import (miruKanren mini)
(miruKanren run)
(miruKanren eqeq-diseq))
(export == =/=
fresh conde
run^ run* runi))
| false |
d597a789539823046cd4a42feb184b738818ace4
|
9c8c0fb8f206ea8b1871df102737c1cb51b7c516
|
/tests/version/version.scm
|
e2fd1c916baf4137e86f720e1997b1144746bb98
|
[
"MIT"
] |
permissive
|
massimo-nocentini/chicken-zmq
|
3c4ca6cbed51e2fbcdcc0b5287b7d05194f039b5
|
b62a1dc8c66c84134770a41802f927d36a7e0f81
|
refs/heads/master
| 2020-04-20T02:32:32.536355 | 2019-04-11T09:00:23 | 2019-04-11T09:00:23 | 168,574,171 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 435 |
scm
|
version.scm
|
(import scheme
(chicken base)
(chicken foreign)
(chicken process-context)
(chicken format)
(chicken memory))
(import srfi-1 srfi-13)
(import zmq)
(define version
(lambda ()
(let-location ((major int) (minor int) (patch int))
(zmq_version (location major) (location minor) (location patch))
(print* `(Current ∅MQ version is ,(list major minor patch)) "\n"))))
(version) ; entry point
| false |
0420275205b89103fd1dbd4dc92dbb4db457eabb
|
7bb9eb9fd4b5bec0061d641b5431824ae75d5c7a
|
/examples/quicksort.scm
|
c99e9420986845586dc3110679917743756f2b7f
|
[] |
permissive
|
0x0f0f0f/yasih
|
aac90fc96cac0b6e1c66409eaeefd580feabb038
|
d7cedc4e5b4ea5c6c59d2799bbd37524969f2467
|
refs/heads/master
| 2020-06-22T23:49:21.402474 | 2019-12-21T11:07:40 | 2019-12-21T11:07:40 | 198,434,591 | 21 | 1 |
BSD-3-Clause
| 2019-10-02T20:29:59 | 2019-07-23T13:18:36 |
Haskell
|
UTF-8
|
Scheme
| false | false | 413 |
scm
|
quicksort.scm
|
(define (qsort l)
(let ((lesser '()) (greater '()))
(cond
((null? l) '())
(else (map (lambda (el)
(if (> (car l) el)
(set! lesser (cons el lesser))
(set! greater! (cons el greater))))
(cdr l))
(append (qsort lesser) (cons (car l) (qsort greater)))))))
| false |
346f251dd212a713b2c60e94009a2a61b48e0e2f
|
120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193
|
/packages/surfage/s99/records/procedural.sls
|
535bc8ff30272bdd37e5bcab1c703acc755e5a90
|
[
"MIT",
"X11-distribute-modifications-variant"
] |
permissive
|
evilbinary/scheme-lib
|
a6d42c7c4f37e684c123bff574816544132cb957
|
690352c118748413f9730838b001a03be9a6f18e
|
refs/heads/master
| 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 |
MIT
| 2022-06-16T05:54:55 | 2016-12-13T06:27:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 5,163 |
sls
|
procedural.sls
|
;; Copyright (C) William D Clinger 2008. All Rights Reserved.
;;
;; Permission is hereby granted, free of charge, to any person obtaining a copy
;; of this software and associated documentation files (the "Software"), to deal
;; in the Software without restriction, including without limitation the rights
;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;; copies of the Software, and to permit persons to whom the Software is
;; furnished to do so, subject to the following conditions:
;;
;; The above copyright notice and this permission notice shall be included in
;; all copies or substantial portions of the Software.
;;
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. REMEMBER, THERE IS NO
;; SCHEME UNDERGROUND. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
;; CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; ERR5RS Records.
;
; This is a quick-and-dirty reference implementation that favors
; simplicity over quality error messages and performance. It is
; implemented using the R6RS procedural and inspection layers,
; with which it interoperates nicely.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#!r6rs
(library (surfage s99 records procedural)
(export make-rtd rtd? rtd-constructor
rtd-predicate rtd-accessor rtd-mutator)
(import (rnrs base)
(rnrs lists)
(rnrs records procedural)
(surfage s99 records inspection))
; Note: the options are permitted by ERR5RS,
; but are not part of ERR5RS.
(define (make-rtd name fieldspecs . rest)
(let* ((parent (if (null? rest) #f (car rest)))
(options (if (null? rest) '() (cdr rest)))
(sealed? (and (memq 'sealed options) #t))
(opaque? (and (memq 'opaque options) #t))
(uid (let ((probe (memq 'uid options)))
(if (and probe (not (null? (cdr probe))))
(cadr probe)
#f))))
(make-record-type-descriptor
name
parent
uid
sealed?
opaque?
(vector-map (lambda (fieldspec)
(if (symbol? fieldspec)
(list 'mutable fieldspec)
fieldspec))
fieldspecs))))
(define rtd? record-type-descriptor?)
(define (rtd-constructor rtd . rest)
; Computes permutation and allocates permutation buffer
; when the constructor is created, not when the constructor
; is called. More error checking is recommended.
(define (make-constructor fieldspecs allnames maker)
(let* ((k (length fieldspecs))
(n (length allnames))
(buffer (make-vector n))
(reverse-all-names (reverse allnames)))
(define (position fieldname)
(let ((names (memq fieldname reverse-all-names)))
(assert names)
(- (length names) 1)))
(let ((indexes (map position fieldspecs)))
; The following can be made quite efficient by
; hand-coding it in some lower-level language,
; e.g. Larceny's mal. Even case-lambda would
; be good enough in most systems.
(lambda args
(assert (= (length args) k))
(for-each (lambda (arg posn)
(vector-set! buffer posn arg))
args indexes)
(apply maker (vector->list buffer))))))
(if (null? rest)
(record-constructor
(make-record-constructor-descriptor rtd #f #f))
(begin (assert (null? (cdr rest)))
(make-constructor
(vector->list (car rest))
(vector->list (rtd-all-field-names rtd))
(record-constructor
(make-record-constructor-descriptor rtd #f #f))))))
(define rtd-predicate record-predicate)
(define (rtd-accessor rtd0 fieldname)
(define (loop rtd)
(if (rtd? rtd)
(let* ((names (vector->list (rtd-field-names rtd)))
(probe (memq fieldname names)))
(if probe
(record-accessor rtd (- (length names) (length probe)))
(loop (rtd-parent rtd))))
(assertion-violation 'rtd-accessor
"illegal argument" rtd0 fieldname)))
(loop rtd0))
(define (rtd-mutator rtd0 fieldname)
(define (loop rtd)
(if (rtd? rtd)
(let* ((names (vector->list (rtd-field-names rtd)))
(probe (memq fieldname names)))
(if probe
(record-mutator rtd (- (length names) (length probe)))
(loop (rtd-parent rtd))))
(assertion-violation 'rtd-mutator
"illegal argument" rtd0 fieldname)))
(loop rtd0))
)
| false |
ce4e26c602387bdca44669c710646f247bff6758
|
92b8d8f6274941543cf41c19bc40d0a41be44fe6
|
/testsuite/numeric-tests.scm
|
65a899e3b9564045326cf68e05f26b3300ba1031
|
[
"MIT"
] |
permissive
|
spurious/kawa-mirror
|
02a869242ae6a4379a3298f10a7a8e610cf78529
|
6abc1995da0a01f724b823a64c846088059cd82a
|
refs/heads/master
| 2020-04-04T06:23:40.471010 | 2017-01-16T16:54:58 | 2017-01-16T16:54:58 | 51,633,398 | 6 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 7,973 |
scm
|
numeric-tests.scm
|
;; Modified from chibi/tests/numeric-tests.scm
;; these tests are only valid if chibi-scheme is compiled with full
;; numeric support (USE_BIGNUMS, USE_FLONUMS and USE_MATH)
(cond-expand
(kawa
(define-syntax test
(syntax-rules ()
((test expected expression)
(test-equal expected expression)))))
(modules (import (only (chibi test) test-begin test test-end)))
(else #f))
(test-begin "numbers")
(define (integer-neighborhoods x)
(list x (+ 1 x) (+ -1 x) (- x) (- 1 x) (- -1 x)))
(test '(536870912 536870913 536870911 -536870912 -536870911 -536870913)
(integer-neighborhoods (expt 2 29)))
(test '(1073741824 1073741825 1073741823 -1073741824 -1073741823 -1073741825)
(integer-neighborhoods (expt 2 30)))
(test '(2147483648 2147483649 2147483647 -2147483648 -2147483647 -2147483649)
(integer-neighborhoods (expt 2 31)))
(test '(4294967296 4294967297 4294967295 -4294967296 -4294967295 -4294967297)
(integer-neighborhoods (expt 2 32)))
(test '(4611686018427387904 4611686018427387905 4611686018427387903
-4611686018427387904 -4611686018427387903 -4611686018427387905)
(integer-neighborhoods (expt 2 62)))
(test '(9223372036854775808 9223372036854775809 9223372036854775807
-9223372036854775808 -9223372036854775807 -9223372036854775809)
(integer-neighborhoods (expt 2 63)))
(test '(18446744073709551616 18446744073709551617 18446744073709551615
-18446744073709551616 -18446744073709551615 -18446744073709551617)
(integer-neighborhoods (expt 2 64)))
(test '(85070591730234615865843651857942052864
85070591730234615865843651857942052865
85070591730234615865843651857942052863
-85070591730234615865843651857942052864
-85070591730234615865843651857942052863
-85070591730234615865843651857942052865)
(integer-neighborhoods (expt 2 126)))
(test '(170141183460469231731687303715884105728
170141183460469231731687303715884105729
170141183460469231731687303715884105727
-170141183460469231731687303715884105728
-170141183460469231731687303715884105727
-170141183460469231731687303715884105729)
(integer-neighborhoods (expt 2 127)))
(test '(340282366920938463463374607431768211456
340282366920938463463374607431768211457
340282366920938463463374607431768211455
-340282366920938463463374607431768211456
-340282366920938463463374607431768211455
-340282366920938463463374607431768211457)
(integer-neighborhoods (expt 2 128)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (integer-arithmetic-combinations a b)
(list (+ a b) (- a b) (* a b) (quotient a b) (remainder a b)))
(define (sign-combinations a b)
(list (integer-arithmetic-combinations a b)
(integer-arithmetic-combinations (- a) b)
(integer-arithmetic-combinations a (- b))
(integer-arithmetic-combinations (- a) (- b))))
;; fix x fix
(test '((1 -1 0 0 0) (1 -1 0 0 0) (-1 1 0 0 0) (-1 1 0 0 0))
(sign-combinations 0 1))
(test '((2 0 1 1 0) (0 -2 -1 -1 0) (0 2 -1 -1 0) (-2 0 1 1 0))
(sign-combinations 1 1))
(test '((59 25 714 2 8) (-25 -59 -714 -2 -8)
(25 59 -714 -2 8) (-59 -25 714 2 -8))
(sign-combinations 42 17))
;; fix x big
(test '((4294967338 -4294967254 180388626432 0 42)
(4294967254 -4294967338 -180388626432 0 -42)
(-4294967254 4294967338 -180388626432 0 42)
(-4294967338 4294967254 180388626432 0 -42))
(sign-combinations 42 (expt 2 32)))
;; big x fix
(test '((4294967338 4294967254 180388626432 102261126 4)
(-4294967254 -4294967338 -180388626432 -102261126 -4)
(4294967254 4294967338 -180388626432 -102261126 4)
(-4294967338 -4294967254 180388626432 102261126 -4))
(sign-combinations (expt 2 32) 42))
;; big x bigger
(test '((12884901889 -4294967297 36893488151714070528 0 4294967296)
(4294967297 -12884901889 -36893488151714070528 0 -4294967296)
(-4294967297 12884901889 -36893488151714070528 0 4294967296)
(-12884901889 4294967297 36893488151714070528 0 -4294967296))
(sign-combinations (expt 2 32) (+ 1 (expt 2 33))))
(test '((18446744078004518913 -18446744069414584321 79228162514264337597838917632 0 4294967296)
(18446744069414584321 -18446744078004518913 -79228162514264337597838917632 0 -4294967296)
(-18446744069414584321 18446744078004518913 -79228162514264337597838917632 0 4294967296)
(-18446744078004518913 18446744069414584321 79228162514264337597838917632 0 -4294967296))
(sign-combinations (expt 2 32) (+ 1 (expt 2 64))))
;; bigger x big
(test '((12884901889 4294967297 36893488151714070528 2 1)
(-4294967297 -12884901889 -36893488151714070528 -2 -1)
(4294967297 12884901889 -36893488151714070528 -2 1)
(-12884901889 -4294967297 36893488151714070528 2 -1))
(sign-combinations (+ 1 (expt 2 33)) (expt 2 32)))
(test '((18446744078004518913 18446744069414584321 79228162514264337597838917632 4294967296 1)
(-18446744069414584321 -18446744078004518913 -79228162514264337597838917632 -4294967296 -1)
(18446744069414584321 18446744078004518913 -79228162514264337597838917632 -4294967296 1)
(-18446744078004518913 -18446744069414584321 79228162514264337597838917632 4294967296 -1))
(sign-combinations (+ 1 (expt 2 64)) (expt 2 32)))
(define M7 (- (expt 2 127) 1))
(test '((170141183460469231750134047789593657344
170141183460469231713240559642174554110
3138550867693340382088035895064302439764418281874191810559
9223372036854775807
9223372036854775808)
(-170141183460469231713240559642174554110
-170141183460469231750134047789593657344
-3138550867693340382088035895064302439764418281874191810559
-9223372036854775807
-9223372036854775808)
(170141183460469231713240559642174554110
170141183460469231750134047789593657344
-3138550867693340382088035895064302439764418281874191810559
-9223372036854775807
9223372036854775808)
(-170141183460469231750134047789593657344
-170141183460469231713240559642174554110
3138550867693340382088035895064302439764418281874191810559
9223372036854775807
-9223372036854775808))
(sign-combinations M7 (+ 1 (expt 2 64))))
(test #f (< +nan.0 +nan.0))
(test #f (<= +nan.0 +nan.0))
(test #f (= +nan.0 +nan.0))
(test #f (>= +nan.0 +nan.0))
(test #f (> +nan.0 +nan.0))
(test #f (< +inf.0 +inf.0))
(test #t (<= +inf.0 +inf.0))
(test #t (= +inf.0 +inf.0))
(test #t (>= +inf.0 +inf.0))
(test #f (> +inf.0 +inf.0))
(test #f (< -inf.0 -inf.0))
(test #t (<= -inf.0 -inf.0))
(test #t (= -inf.0 -inf.0))
(test #t (>= -inf.0 -inf.0))
(test #f (> -inf.0 -inf.0))
(test #t (< -inf.0 +inf.0))
(test #t (<= -inf.0 +inf.0))
(test #f (= -inf.0 +inf.0))
(test #f (>= -inf.0 +inf.0))
(test #f (> -inf.0 +inf.0))
(test 88962710306127702866241727433142015
(string->number "#x00112233445566778899aabbccddeeff"))
(test (inexact (expt 10 154)) (inexact (sqrt (expt 10 308))))
(test 36893488147419103231
(- 340282366920938463463374607431768211456
340282366920938463426481119284349108225))
(cond-expand
(ratios
(test #t (< 1/2 1.0))
(test #t (< 1.0 3/2))
(test #t (< 1/2 1.5))
(test #t (< 1/2 2.0))
(test 1.0 (max 1/2 1.0))
(test 18446744073709551617 (numerator (/ 18446744073709551617 2)))
(test "18446744073709551617/2" (number->string (/ 18446744073709551617 2)))
(let ((a 1000000000000000000000000000000000000000)
(b 31622776601683794000))
(test 31622776601683792639 (quotient a b))
(test 30922992657207634000 (remainder a b)))
(let ((g 18446744073709551616/6148914691236517205))
(test 36893488147419103231/113427455640312821148309287786019553280
(- g (/ 9 g))))
(let ((r (/ (expt 2 61) 3)))
(test 0 (- r r))
(test 2305843009213693952/3 r)))
(else
#f))
(test-end)
| true |
adf6a77b6ceed98242cc3c21b4ca3ebc457bf6eb
|
ab05b79ab17619f548d9762a46199dc9eed6b3e9
|
/sitelib/ypsilon/gtk/fixed.scm
|
493b37a977b12e63a8269f3a1028913da96e9827
|
[
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] |
permissive
|
lambdaconservatory/ypsilon
|
2dce9ff4b5a50453937340bc757697b9b4839dee
|
f154436db2b3c0629623eb2a53154ad3c50270a1
|
refs/heads/master
| 2021-02-28T17:44:05.571304 | 2017-12-17T12:29:00 | 2020-03-08T12:57:52 | 245,719,032 | 1 | 0 |
NOASSERTION
| 2020-03-07T23:08:26 | 2020-03-07T23:08:25 | null |
UTF-8
|
Scheme
| false | false | 1,890 |
scm
|
fixed.scm
|
#!nobacktrace
;;; Ypsilon Scheme System
;;; Copyright (c) 2004-2009 Y.FUJITA / LittleWing Company Limited.
;;; See license.txt for terms and conditions of use.
(library (ypsilon gtk fixed)
(export gtk_fixed_get_has_window
gtk_fixed_get_type
gtk_fixed_move
gtk_fixed_new
gtk_fixed_put
gtk_fixed_set_has_window)
(import (rnrs) (ypsilon ffi))
(define lib-name
(cond (on-linux "libgtk-x11-2.0.so.0")
(on-sunos "libgtk-x11-2.0.so.0")
(on-freebsd "libgtk-x11-2.0.so.0")
(on-openbsd "libgtk-x11-2.0.so.0")
(on-darwin "Gtk.framework/Gtk")
(on-windows "libgtk-win32-2.0-0.dll")
(else
(assertion-violation #f "can not locate GTK library, unknown operating system"))))
(define lib (load-shared-object lib-name))
(define-syntax define-function
(syntax-rules ()
((_ ret name args)
(define name (c-function lib lib-name ret name args)))))
(define-syntax define-function/va_list
(syntax-rules ()
((_ ret name args)
(define name (lambda x (assertion-violation 'name "va_list argument not supported"))))))
;; gboolean gtk_fixed_get_has_window (GtkFixed* fixed)
(define-function int gtk_fixed_get_has_window (void*))
;; GType gtk_fixed_get_type (void)
(define-function unsigned-long gtk_fixed_get_type ())
;; void gtk_fixed_move (GtkFixed* fixed, GtkWidget* widget, gint x, gint y)
(define-function void gtk_fixed_move (void* void* int int))
;; GtkWidget* gtk_fixed_new (void)
(define-function void* gtk_fixed_new ())
;; void gtk_fixed_put (GtkFixed* fixed, GtkWidget* widget, gint x, gint y)
(define-function void gtk_fixed_put (void* void* int int))
;; void gtk_fixed_set_has_window (GtkFixed* fixed, gboolean has_window)
(define-function void gtk_fixed_set_has_window (void* int))
) ;[end]
| true |
cacf655f662cb4dfab5b54f24dbe2b102f7b13b1
|
92b8d8f6274941543cf41c19bc40d0a41be44fe6
|
/testsuite/knucleotide-2.scm
|
cb37a99755c4612239309f670a892a954ea2200a
|
[
"MIT"
] |
permissive
|
spurious/kawa-mirror
|
02a869242ae6a4379a3298f10a7a8e610cf78529
|
6abc1995da0a01f724b823a64c846088059cd82a
|
refs/heads/master
| 2020-04-04T06:23:40.471010 | 2017-01-16T16:54:58 | 2017-01-16T16:54:58 | 51,633,398 | 6 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,899 |
scm
|
knucleotide-2.scm
|
;; The Computer Language Shootout
;; http://shootout.alioth.debian.org/
;; This is a Kawa implementation of the knucelotide benchmark.
;; This is is fairly low-level - it by-passes the Scheme APIs
;; to use pure Java libraries. It does make use of
;; gnu.kawa.util.AbstractHashTable, but it sort-of cheats by getting
;; down into implementation internals.
;;
;; Original Kawa version based on mzscheme version,
;; with some bits based on Java version contributed by James McIlree.
(define-simple-class StrIntNode (java.util.Map$Entry)
(next ::StrIntNode)
(hash :: int)
(key ::java.lang.String)
(count ::int)
((getKey) key)
((getValue) ::object count))
(define (make-node key::string hash::int count::int) ::StrIntNode
(let ((n (StrIntNode)))
(set! n:key key)
(set! n:hash hash)
(set! n:count count)
n))
(define-simple-class StrIntHashTable (gnu.kawa.util.AbstractHashTable)
((getEntryHashCode entry) (as StrIntNode entry):hash)
((getEntryNext entry) (as StrIntNode entry):next)
((setEntryNext entry next) (set! (as StrIntNode entry):next next))
((allocEntries n) (StrIntNode[] size: n))
((makeEntry key hash value) (make-node key hash value))
;; FIXME this code should be made into library code.
((toNodeArray) ::StrIntNode[]
(let* ((arr ::StrIntNode[] table)
(length arr:length)
(n ::int ((this):size))
(result (StrIntNode[] length: n))
(j ::int 0))
(do ((i ::int (- length 1) (- i 1)))
((< i 0) result)
(do ((node ::StrIntNode (table i)
node:next))
((eq? node #!null) #!void)
(set! (result j) node)
(set! j (+ j 1)))))))
(define (all-counts (len :: int) (dna :: java.lang.String))
(let ((table (StrIntHashTable)))
(let loop ((s :: int (- (string-length dna) len)))
(let* ((key (dna:substring s (+ s len)))
(node ::StrIntNode (table:getNode key)))
(if (eq? node #!null)
;; Non-optimal - requires recalculating hashCode.
(table:put key (key:hashCode) 1)
(set! node:count (+ node:count 1))))
(if (> s 0)
(loop (- s 1))))
table))
(define node-comparator ::java.util.Comparator
(object (java.util.Comparator)
((compare o1 o2) ::int
(let ((v1 ::int (as StrIntNode o1):count)
(v2 ::int (as StrIntNode o2):count))
(cond ((> v1 v2) -1)
((< v1 v2) 1)
(else 0))))
((equals o)::boolean (eq? o (this)))))
(define (write-freqs table::StrIntHashTable) ::void
(let* ((content (table:toNodeArray))
(size content:length)
(total ::double
(let ((sum ::int 0))
(do ((i ::int 0 (+ i 1)))
((>= i size) sum)
(set! sum (+ sum (content i):count)))
sum)))
(java.util.Arrays:sort content node-comparator)
(do ((i ::int 0 (+ i 1)))
((>= i size))
(let ((a (content i)))
(format #t "~a ~,3f~%"
a:key
(* 100 (/ (as double a:count) total)))))))
(define (write-one-freq table::StrIntHashTable key::string)
(let* ((node ::StrIntNode (table:getNode key))
(cnt (if (eq? node #!null) 0 node:count)))
(format #t "~a\t~a~%" cnt key)))
(define dna
(let ((in :: input-port (current-input-port))
(sb (java.lang.StringBuilder)))
;; Skip to ">THREE ..."
(do ()
((let ((line (in:readLine)))
(or (eq? line #!null) (line:startsWith ">THREE")))))
(let loop ()
(let ((line (in:readLine)))
(cond (line
(sb:append line)
(loop)))))
((sb:toString):toUpperCase)))
;; 1-nucleotide counts:
(write-freqs (all-counts 1 dna))
(newline)
;; 2-nucleotide counts:
(write-freqs (all-counts 2 dna))
(newline)
;; Specific sequences:
(for-each (lambda (seq)
(write-one-freq (all-counts (string-length seq) dna)
seq))
'("GGT" "GGTA" "GGTATT" "GGTATTTTAATT" "GGTATTTTAATTTATAGT"))
| false |
113c826e43dae1e0b84ea1d86de67de8c358c580
|
e431ffc80b17660454f48a2e507ff170912e944a
|
/test/scheme/tests-1.5-req.scm
|
c9f7a4bad5e1581648285491818458620f19aa0d
|
[
"MIT"
] |
permissive
|
toroidal-code/propellisp
|
42b0520d5e409b494b989fe0ac48738dd8232770
|
fac0e21583c3451e216a53f40d8b16c65afc5d47
|
refs/heads/master
| 2016-09-15T21:49:23.009711 | 2013-07-21T22:59:45 | 2013-07-21T22:59:45 | 10,539,499 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 8,423 |
scm
|
tests-1.5-req.scm
|
(add-tests-with-string-output "fx+"
[(fx+ 1 2) => "3\n"]
[(fx+ 1 -2) => "-1\n"]
[(fx+ -1 2) => "1\n"]
[(fx+ -1 -2) => "-3\n"]
[(fx+ 536870911 -1) => "536870910\n"]
[(fx+ 536870910 1) => "536870911\n"]
[(fx+ -536870912 1) => "-536870911\n"]
[(fx+ -536870911 -1) => "-536870912\n"]
[(fx+ 536870911 -536870912) => "-1\n"]
[(fx+ 1 (fx+ 2 3)) => "6\n"]
[(fx+ 1 (fx+ 2 -3)) => "0\n"]
[(fx+ 1 (fx+ -2 3)) => "2\n"]
[(fx+ 1 (fx+ -2 -3)) => "-4\n"]
[(fx+ -1 (fx+ 2 3)) => "4\n"]
[(fx+ -1 (fx+ 2 -3)) => "-2\n"]
[(fx+ -1 (fx+ -2 3)) => "0\n"]
[(fx+ -1 (fx+ -2 -3)) => "-6\n"]
[(fx+ (fx+ 1 2) 3) => "6\n"]
[(fx+ (fx+ 1 2) -3) => "0\n"]
[(fx+ (fx+ 1 -2) 3) => "2\n"]
[(fx+ (fx+ 1 -2) -3) => "-4\n"]
[(fx+ (fx+ -1 2) 3) => "4\n"]
[(fx+ (fx+ -1 2) -3) => "-2\n"]
[(fx+ (fx+ -1 -2) 3) => "0\n"]
[(fx+ (fx+ -1 -2) -3) => "-6\n"]
[(fx+ (fx+ -1 -2) (fx+ 3 4)) => "4\n"]
[(fx+ (fx+ -1 -2) (fx+ 3 -4)) => "-4\n"]
[(fx+ (fx+ -1 -2) (fx+ -3 4)) => "-2\n"]
[(fx+ (fx+ -1 -2) (fx+ -3 -4)) => "-10\n"]
[(fx+ (fx+ (fx+ (fx+ (fx+ (fx+ (fx+ (fx+ 1 2) 3) 4) 5) 6) 7) 8) 9) => "45\n"]
[(fx+ (fx+ (fx+ (fx+ (fx+ (fx+ (fx+ (fx+ 1 2) 3) 4) 5) 6) 7) 8) 9) => "45\n"]
[(fx+ 1 (fx+ 2 (fx+ 3 (fx+ 4 (fx+ 5 (fx+ 6 (fx+ 7 (fx+ 8 9)))))))) => "45\n"]
; [(fx+ (fx+ (fx+ (fx+ 1 2) (fx+ 3 4)) (fx+ (fx+ 5 6) (fx+ 7 8)))
; (fx+ (fx+ (fx+ 9 10) (fx+ 11 12)) (fx+ (fx+ 13 14) (fx+ 15 16))))
; => "136\n"]
)
(add-tests-with-string-output "fx-"
[(fx- 1 2) => "-1\n"]
[(fx- 1 -2) => "3\n"]
[(fx- -1 2) => "-3\n"]
[(fx- -1 -2) => "1\n"]
[(fx- 536870910 -1) => "536870911\n"]
[(fx- 536870911 1) => "536870910\n"]
[(fx- -536870911 1) => "-536870912\n"]
[(fx- -536870912 -1) => "-536870911\n"]
[(fx- 1 536870911) => "-536870910\n"]
[(fx- -1 536870911) => "-536870912\n"]
[(fx- 1 -536870910) => "536870911\n"]
[(fx- -1 -536870912) => "536870911\n"]
[(fx- 536870911 536870911) => "0\n"]
;[(fx- 536870911 -536870912) => "-1\n"]
[(fx- -536870911 -536870912) => "1\n"]
[(fx- 1 (fx- 2 3)) => "2\n"]
[(fx- 1 (fx- 2 -3)) => "-4\n"]
[(fx- 1 (fx- -2 3)) => "6\n"]
[(fx- 1 (fx- -2 -3)) => "0\n"]
[(fx- -1 (fx- 2 3)) => "0\n"]
[(fx- -1 (fx- 2 -3)) => "-6\n"]
[(fx- -1 (fx- -2 3)) => "4\n"]
[(fx- -1 (fx- -2 -3)) => "-2\n"]
[(fx- 0 (fx- -2 -3)) => "-1\n"]
[(fx- (fx- 1 2) 3) => "-4\n"]
[(fx- (fx- 1 2) -3) => "2\n"]
[(fx- (fx- 1 -2) 3) => "0\n"]
[(fx- (fx- 1 -2) -3) => "6\n"]
[(fx- (fx- -1 2) 3) => "-6\n"]
[(fx- (fx- -1 2) -3) => "0\n"]
[(fx- (fx- -1 -2) 3) => "-2\n"]
[(fx- (fx- -1 -2) -3) => "4\n"]
[(fx- (fx- (fx- (fx- (fx- (fx- (fx- (fx- 1 2) 3) 4) 5) 6) 7) 8) 9) => "-43\n"]
[(fx- 1 (fx- 2 (fx- 3 (fx- 4 (fx- 5 (fx- 6 (fx- 7 (fx- 8 9)))))))) => "5\n"]
[(fx- (fx- 1 2) (fx- 3 4)) => "0\n"]
[(fx- (fx- 1 2) (fx- 3 -4)) => "-8\n"]
[(fx- (fx- 1 2) (fx- -3 4)) => "6\n"]
[(fx- (fx- 1 2) (fx- -3 -4)) => "-2\n"]
[(fx- (fx- 1 -2) (fx- 3 4)) => "4\n"]
[(fx- (fx- 1 -2) (fx- 3 -4)) => "-4\n"]
[(fx- (fx- 1 -2) (fx- -3 4)) => "10\n"]
[(fx- (fx- 1 -2) (fx- -3 -4)) => "2\n"]
[(fx- (fx- -1 2) (fx- 3 4)) => "-2\n"]
[(fx- (fx- -1 2) (fx- 3 -4)) => "-10\n"]
[(fx- (fx- -1 2) (fx- -3 4)) => "4\n"]
[(fx- (fx- -1 2) (fx- -3 -4)) => "-4\n"]
[(fx- (fx- -1 -2) (fx- 3 4)) => "2\n"]
[(fx- (fx- -1 -2) (fx- 3 -4)) => "-6\n"]
[(fx- (fx- -1 -2) (fx- -3 4)) => "8\n"]
[(fx- (fx- -1 -2) (fx- -3 -4)) => "0\n"]
[(fx- (fx- (fx- (fx- (fx- (fx- (fx- (fx- 1 2) 3) 4) 5) 6) 7) 8) 9) => "-43\n"]
[(fx- 1 (fx- 2 (fx- 3 (fx- 4 (fx- 5 (fx- 6 (fx- 7 (fx- 8 9)))))))) => "5\n"]
; [(fx- (fx- (fx- (fx- 1 2) (fx- 3 4)) (fx- (fx- 5 6) (fx- 7 8)))
; (fx- (fx- (fx- 9 10) (fx- 11 12)) (fx- (fx- 13 14) (fx- 15 16))))
; => "0\n"]
)
(add-tests-with-string-output "fx*"
[(fx* 2 3) => "6\n"]
[(fx* 2 -3) => "-6\n"]
[(fx* -2 3) => "-6\n"]
[(fx* -2 -3) => "6\n"]
[(fx* 536870911 1) => "536870911\n"]
[(fx* 536870911 -1) => "-536870911\n"]
[(fx* -536870912 1) => "-536870912\n"]
[(fx* -536870911 -1) => "536870911\n"]
[(fx* 2 (fx* 3 4)) => "24\n"]
[(fx* (fx* 2 3) 4) => "24\n"]
;[(fx* (fx* (fx* (fx* (fx* 2 3) 4) 5) 6) 7) => "5040\n"] ;; multiplication is too expensive an operation
;[(fx* 2 (fx* 3 (fx* 4 (fx* 5 (fx* 6 7))))) => "5040\n"] ;; to perform these tests with cog memory
; [(fx* (fx* (fx* (fx* 2 3) (fx* 4 5)) (fx* (fx* 6 7) (fx* 8 9)))
; (fx* (fx* (fx* 2 3) (fx* 2 3)) (fx* (fx* 2 3) (fx* 2 3))))
; => "470292480\n"]
)
(add-tests-with-string-output "fxlognot"
[(fxlognot -7) => "6\n"]
[(fxlognot (fxlogor (fxlognot 7) 1)) => "6\n"]
[(fxlognot (fxlogor (fxlognot 7) (fxlognot 2))) => "2\n"]
[(fxlogand (fxlognot (fxlognot 12)) (fxlognot (fxlognot 12))) => "12\n"]
)
(add-tests-with-string-output "fxlogand and fxlogor"
[(fxlogor 3 16) => "19\n"]
[(fxlogor 3 5) => "7\n"]
[(fxlogor 3 7) => "7\n"]
[(fxlognot (fxlogor (fxlognot 7) 1)) => "6\n"]
[(fxlognot (fxlogor 1 (fxlognot 7))) => "6\n"]
[(fxlogand 3 7) => "3\n"]
[(fxlogand 3 5) => "1\n"]
[(fxlogand 2346 (fxlognot 2346)) => "0\n"]
[(fxlogand (fxlognot 2346) 2346) => "0\n"]
[(fxlogand 2376 2376) => "2376\n"]
[(fxlognot (fxlogor (fxlognot 7) 1)) => "6\n"]
[(fxlognot (fxlogor (fxlognot 7) (fxlognot 2))) => "2\n"]
[(fxlogand (fxlognot (fxlognot 12)) (fxlognot (fxlognot 12))) => "12\n"]
)
(add-tests-with-string-output "fx="
[(fx= 12 13) => "#f\n"]
[(fx= 12 12) => "#t\n"]
[(fx= 16 (fx+ 13 3)) => "#t\n"]
[(fx= 16 (fx+ 13 13)) => "#f\n"]
[(fx= (fx+ 13 3) 16) => "#t\n"]
[(fx= (fx+ 13 13) 16) => "#f\n"]
[(fx= (fx+ 13 3) (fx+ 10 6)) => "#t\n"]
[(fx= (fx+ 13 0) (fx+ 10 6)) => "#f\n"]
[(fx= (fx+ 12 1) (fx+ -12 -1)) => "#f\n"]
)
(add-tests-with-string-output "fx<"
[(fx< 12 13) => "#t\n"]
[(fx< 12 12) => "#f\n"]
[(fx< 13 12) => "#f\n"]
[(fx< 16 (fx+ 13 1)) => "#f\n"]
[(fx< 16 (fx+ 13 3)) => "#f\n"]
[(fx< 16 (fx+ 13 13)) => "#t\n"]
[(fx< (fx+ 13 1) 16) => "#t\n"]
[(fx< (fx+ 13 3) 16) => "#f\n"]
[(fx< (fx+ 13 13) 16) => "#f\n"]
[(fx< (fx+ 10 6) (fx+ 13 1)) => "#f\n"]
[(fx< (fx+ 10 6) (fx+ 13 3)) => "#f\n"]
[(fx< (fx+ 10 6) (fx+ 13 31)) => "#t\n"]
[(fx< (fx+ 12 1) (fx+ -12 -1)) => "#f\n"]
[(fx< (fx+ -12 -1) (fx+ 12 1)) => "#t\n"]
)
(add-tests-with-string-output "fx<="
[(fx<= 12 13) => "#t\n"]
[(fx<= 12 12) => "#t\n"]
[(fx<= 13 12) => "#f\n"]
[(fx<= 16 (fx+ 13 1)) => "#f\n"]
[(fx<= 16 (fx+ 13 3)) => "#t\n"]
[(fx<= 16 (fx+ 13 13)) => "#t\n"]
[(fx<= (fx+ 13 1) 16) => "#t\n"]
[(fx<= (fx+ 13 3) 16) => "#t\n"]
[(fx<= (fx+ 13 13) 16) => "#f\n"]
)
(add-tests-with-string-output "fx>"
[(fx> 12 13) => "#f\n"]
[(fx> 12 12) => "#f\n"]
[(fx> 13 12) => "#t\n"]
[(fx> 16 (fx+ 13 1)) => "#t\n"]
[(fx> 16 (fx+ 13 3)) => "#f\n"]
[(fx> 16 (fx+ 13 13)) => "#f\n"]
[(fx> (fx+ 13 1) 16) => "#f\n"]
[(fx> (fx+ 13 3) 16) => "#f\n"]
[(fx> (fx+ 13 13) 16) => "#t\n"]
[(fx> (fx+ 10 6) (fx+ 13 1)) => "#t\n"]
[(fx> (fx+ 10 6) (fx+ 13 3)) => "#f\n"]
[(fx> (fx+ 10 6) (fx+ 13 31)) => "#f\n"]
[(fx> (fx+ 12 1) (fx+ -12 -1)) => "#t\n"]
[(fx> (fx+ -12 -1) (fx+ 12 1)) => "#f\n"]
)
(add-tests-with-string-output "fx>="
[(fx>= 12 13) => "#f\n"]
[(fx>= 12 12) => "#t\n"]
[(fx>= 13 12) => "#t\n"]
[(fx>= 16 (fx+ 13 1)) => "#t\n"]
[(fx>= 16 (fx+ 13 3)) => "#t\n"]
[(fx>= 16 (fx+ 13 13)) => "#f\n"]
[(fx>= (fx+ 13 1) 16) => "#f\n"]
[(fx>= (fx+ 13 3) 16) => "#t\n"]
[(fx>= (fx+ 13 13) 16) => "#t\n"]
[(fx<= (fx+ 10 6) (fx+ 13 1)) => "#f\n"]
[(fx<= (fx+ 10 6) (fx+ 13 3)) => "#t\n"]
[(fx<= (fx+ 10 6) (fx+ 13 31)) => "#t\n"]
[(fx<= (fx+ 12 1) (fx+ -12 -1)) => "#f\n"]
[(fx<= (fx+ -12 -1) (fx+ 12 1)) => "#t\n"]
[(fx>= (fx+ 10 6) (fx+ 13 1)) => "#t\n"]
[(fx>= (fx+ 10 6) (fx+ 13 3)) => "#t\n"]
[(fx>= (fx+ 10 6) (fx+ 13 31)) => "#f\n"]
[(fx>= (fx+ 12 1) (fx+ -12 -1)) => "#t\n"]
[(fx>= (fx+ -12 -1) (fx+ 12 1)) => "#f\n"]
)
(add-tests-with-string-output "if"
[(if (fx= 12 13) 12 13) => "13\n"]
[(if (fx= 12 12) 13 14) => "13\n"]
[(if (fx< 12 13) 12 13) => "12\n"]
[(if (fx< 12 12) 13 14) => "14\n"]
[(if (fx< 13 12) 13 14) => "14\n"]
[(if (fx<= 12 13) 12 13) => "12\n"]
[(if (fx<= 12 12) 12 13) => "12\n"]
[(if (fx<= 13 12) 13 14) => "14\n"]
[(if (fx> 12 13) 12 13) => "13\n"]
[(if (fx> 12 12) 12 13) => "13\n"]
[(if (fx> 13 12) 13 14) => "13\n"]
[(if (fx>= 12 13) 12 13) => "13\n"]
[(if (fx>= 12 12) 12 13) => "12\n"]
[(if (fx>= 13 12) 13 14) => "13\n"]
)
| false |
c65853d9007bd1703f4c86b8b5bb4e7e9ba577c0
|
80c8c43dd7956bb78a0c586ea193e3114de31046
|
/practice-1.scm
|
88356833717fcf00e8e77a92969323ef2905fdb7
|
[] |
no_license
|
UeharaYou/Learning-SICP
|
78b9d29e6a84a0890ec9788073160c3f7fd8a231
|
3a6cf413a313d7249e121bdd1515e374d2a369ea
|
refs/heads/master
| 2021-04-05T14:00:36.752016 | 2020-03-19T17:27:39 | 2020-03-19T17:27:39 | 248,564,129 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,830 |
scm
|
practice-1.scm
|
;; SICP Practice: 1
(define self-cons
(lambda (x y)
(lambda (z) (z x y))))
(define self-cdr
(lambda (z)
(z (lambda (p q) q))))
(self-cdr (self-cons 1 2))
;; Step of eval/apply:
;; => e0 <TOP> : cons car apply eval bind
;; (eval '(cdr (cons 1 2) e0))
;; (apply (eval 'cdr e0)
;; (ev-list '((cons 1 2)) e0))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list (eval '(cons 1 2) e0)))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list (apply (eval 'cons e0)
;; (ev-list '((1 2)) e0))))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list (apply (eval 'cons e0)
;; '(1 2))))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list (apply '(closure ((x y) (lambda (z) (z x y))) e0)
;; '(1 2))))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list (eval '(lambda (z) (z x y)) (bind '((x 1) (y 2)) e0))))
;; => e1 <e0> : x = 1; y = 2
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; (list '(closure ((z) (z x y)) e1)))
;; (apply '(closure ((z) (z (lambda (p q) q))) e0)
;; '((closure ((z) (z x y)) e1)))
;; (eval '(z (lambda (p q) q)) (bind '((z (closure ((z) (z x y)) e1))) e0))
;; => e2 <e0> : z = (closure ((z) (z x y)) e1)
;; (apply (eval 'z e2)
;; (ev-list '((lambda (p q) q)) e2))
;; (apply '(closure ((z) (z x y)) e1)
;; (eval '(lambda (p q) q) e2))
;; (apply '(closure ((z) (z x y)) e1)
;; '(closure ((p q) q) e2))
;; (eval '(z x y) (bind '((z (closure ((p q) q) e2))) e1))
;; => e3 <e1> : z = (closure ((p q) q) e2)
;; (apply (eval 'z e3)
;; (ev-list '(x y) e3))
;; (apply '(closure ((p q) q) e2)
;; '(1 2))
;; (eval 'q (bind '((p 1) (q 2)) e2))
;; => e4 <e2> : p = 1; q = 2
;; 2
| false |
02db824c209207c8f52f9c4eae1bcb8626c6a9fc
|
120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193
|
/apps/event-test.ss
|
591016dc9aa83dc088d6534bd6e30a8ae30b6617
|
[
"MIT"
] |
permissive
|
evilbinary/scheme-lib
|
a6d42c7c4f37e684c123bff574816544132cb957
|
690352c118748413f9730838b001a03be9a6f18e
|
refs/heads/master
| 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 |
MIT
| 2022-06-16T05:54:55 | 2016-12-13T06:27:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,060 |
ss
|
event-test.ss
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Copyright 2016-2080 evilbinary.
;author:evilbinary on 12/24/16.
;email:[email protected]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (net socket-ffi) (cffi cffi) (net event2-ffi) )
;;(cffi-log #t)
(define base (cffi-alloc 4))
(define listener (cffi-alloc 4))
(set! base (event-base-new))
(define sockaddr (make-sockaddr-in AF_INET INADDR_ANY 8080 ))
(def-function-callback
make-listener-cb
(void* int void* int void*) void)
(def-function-callback
make-write-cb
(void* void*) void)
(def-function-callback
make-read-cb
(void* void*) void)
(def-function-callback
make-conn-cb
(void* int void*) void)
(define read-cb (make-read-cb
(lambda (bev user-data)
(let ((input (bufferevent-get-input bev))
(len 0))
(set! len (evbuffer-get-length input))
(display (format "inputlen ~a\n" len))
(display (format "~s\n" (cffi-string (evbuffer-pullup input len) ))) ))))
(define write-cb (make-write-cb
(lambda (bev user-data)
(let ((output (bufferevent-get-output bev)))
(if (= 0 (evbuffer-get-length output))
(display "replay\n")
(bufferevent-free bev))) )))
(define conn-cb (make-write-cb
(lambda (bev event user-data)
(display (format "event=~a\n" event))
(bufferevent-free bev)
)))
(define listener-cb (make-listener-cb
(lambda (listener-ptr fd sockaddr-ptr socklen ptr)
(let ((bev (bufferevent-socket-new base fd 1)))
(bufferevent-setcb bev read-cb write-cb conn-cb 0)
(bufferevent-enable bev 4)
(bufferevent-enable bev 2)
(bufferevent-write bev "hello" 5)
(display "listener\n")))))
(set! listener (evconnlistener-new-bind base listener-cb base 10 -1 sockaddr 16))
(if (= 0 listener )
(display (format "erro Could not create a listener!\n")))
;;(define signal-event (evsignal-new base SIGINT signal-cb base ))
(event-base-dispatch base)
(evconnlistener-free listener)
(event-base-free base)
| false |
174501f9144e3a2e76779068f0151ccf64e71d5f
|
47457420b9a1eddf69e2b2f426570567258f3afd
|
/1/22.scm
|
43d429b384176fc7ae563981bd3f86a08df2990e
|
[] |
no_license
|
adromaryn/sicp
|
797496916620e85b8d85760dc3f5739c4cc63437
|
342b56d233cc309ffb59dd13b2d3cf9cd22af6c9
|
refs/heads/master
| 2021-08-30T06:55:04.560128 | 2021-08-29T12:47:28 | 2021-08-29T12:47:28 | 162,965,433 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,444 |
scm
|
22.scm
|
#lang sicp
(define (smallest-divisor n)
(find-divisor n 2))
(define (find-divisor n test-divisor)
(cond ((> (square test-divisor) n) n )
((divides? test-divisor n) test-divisor)
(else (find-divisor n (+ test-divisor 1)))))
(define (divides? a b)
(= (remainder b a) 0))
(define (square x) (* x x))
(define (prime? n)
(= n (smallest-divisor n)))
(define (timed-prime-test n)
(newline)
(display n)
(start-prime-test n (runtime)))
(define (start-prime-test n start-time)
(if (prime? n)
(report-prime (- (runtime) start-time))))
(define (report-prime elapsed-time)
(display " *** ")
(display elapsed-time))
(define (great-odd n)
(if (even? n)
(+ n 1)
n))
(define (less-odd n)
(if (even? n)
(- n 1)
n))
(define (search-for-primes a b)
(define (search-iter a b)
(timed-prime-test a)
(if (= a b)
(display "")
(search-iter (great-odd (+ a 2)) (less-odd b))))
(search-iter (great-odd a) (less-odd b)))
(search-for-primes 1000 1019)
(search-for-primes 10000 10037)
(search-for-primes 100000 100043)
(search-for-primes 1000000 1000037)
(timed-prime-test 1009)
(timed-prime-test 1013)
(timed-prime-test 1019)
(timed-prime-test 10007)
(timed-prime-test 10009)
(timed-prime-test 10037)
(timed-prime-test 100003)
(timed-prime-test 100019)
(timed-prime-test 100043)
(timed-prime-test 1000003)
(timed-prime-test 1000033)
(timed-prime-test 1000037)
| false |
f803c3c2c4105e4b60cc786f0bd0302041161dff
|
a66514d577470329b9f0bf39e5c3a32a6d01a70d
|
/json.sls
|
8f7d7b660ffe72f046374835ee44de4ca05b6ebe
|
[
"Apache-2.0"
] |
permissive
|
ovenpasta/thunderchez
|
2557819a41114423a4e664ead7c521608e7b6b42
|
268d0d7da87fdeb5f25bdcd5e62217398d958d59
|
refs/heads/trunk
| 2022-08-31T15:01:37.734079 | 2021-07-25T14:59:53 | 2022-08-18T09:33:35 | 62,828,147 | 149 | 29 | null | 2022-08-18T09:33:37 | 2016-07-07T18:07:23 |
Common Lisp
|
UTF-8
|
Scheme
| false | false | 8,339 |
sls
|
json.sls
|
;;
;; Copyright 2016 Aldo Nicolas Bruno
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
#!chezscheme
(library
(json)
(export parse-json-str read-file let-json-object string->json json->string)
(import (srfi s14 char-sets)
(scheme)
(only (data-structures) string-intersperse string-translate*))
(include "lalr/associators.ss")
(include "lalr/lalr.ss")
(define (parse-json-str pos data escaping out)
(cond
[(>= pos (string-length data))
(error 'parse-json-str "error unexpected end of string")]
[(and (char=? (string-ref data pos) #\") (not escaping))
(values (list->string (reverse out)) pos)]
[else
(let ([char (string-ref data pos)])
(cond
[escaping
(let* ([special '((#\/ . #\/) (#\b . #\backspace) (#\n . #\newline)
(#\r . #\return) (#\t . #\tab) (#\\ . #\\) (#\" . #\"))]
[q (assq char special)])
(cond
[q (parse-json-str (+ 1 pos) data #f (cons (cdr q) out))]
[(char=? char #\\) (parse-json-str (+ 1 pos) data #f (cons #\\ out))]
[(char=? char #\u)
(if (< (+ 4 pos) (string-length data))
(let ([num (string->number (substring data (+ pos 1) (+ pos 5)) 16)])
(if num
(parse-json-str (+ 5 pos) data #f (cons (integer->char num) out))
(error 'parse-json-str "invalid unicode sequence at" pos)))
(error 'parse-json-str "unexpected end of string in unicode sequence"))]
[else
(error 'parse-json-str "parse error" escaping char)]))]
[(char=? char #\\)
(parse-json-str (+ 1 pos) data (cons #\\ (+ 1 pos)) out)]
[(char-set-contains? char-set:iso-control char)
(error 'parse-json-str "parse error: special character in string literal" char )]
[else
(parse-json-str (+ 1 pos) data escaping (cons char out))]))]))
(define (parse-literal pos data out)
(cond
[(or (>= pos (string-length data))
(not (char-set-contains? char-set:letter (string-ref data pos))))
(values (list->string (reverse out)) pos)]
[else
(parse-literal (+ 1 pos) data (cons (string-ref data pos) out))]))
;; TODO WRITE MORE TESTS LIKE THIS
;; WRITE A MACRO THAT SIMPLIFIES TESTING
;(eval-when (compile eval)
; (unless (equal? (parse-json "a b c") '((char . #\a) (char . #\b) (char . #\c)))
; (error 'parse-json-test "a b c assertion failed")))
(define (identity expr) expr)
(define expr-grammar
`(;(expr --> expr expr-op term ,binary-apply) ;;; change ` to '
(main --> object ,identity)
(main --> array ,identity)
(main --> pair ,identity)
(main --> value ,identity)
(object --> lbracket rbracket ,(lambda (l r) '()))
(object --> lbracket members rbracket ,(lambda (l m r) m))
(members --> pair ,(lambda (p) (list p)))
(members --> pair comma members ,(lambda (p c m) (append (list p) m)))
(pair --> string colon value ,(lambda (s c v) `(,(string->symbol s) . ,v)))
(array --> lsquare rsquare ,(lambda (l r) '#()))
(array --> lsquare elements rsquare ,(lambda (l e r) `#(,@e)))
(elements --> value ,(lambda (v) (list v)))
(elements --> value comma elements ,(lambda (v c e) (append (list v) e)))
(value --> string ,identity)
(value --> number ,(lambda (n) (string->number n)))
(value --> object ,identity)
(value --> array ,identity)
(value --> true ,(lambda (x) #t))
(value --> false ,(lambda (x) #f))
(value --> null ,(lambda (x) '()))
(int --> digits ,identity)
(int --> minus digits ,(lambda (m d) (string-append "-" d )))
(frac --> dot digits ,(lambda (p d) (string-append "." d)))
(exp --> ex digits ,(lambda (e d) (string-append (if (eq? e 'minus-e) "e-" "e") d)))
(ex --> e ,identity)
(ex --> e plus ,(lambda (e p) 'plus-e))
(ex --> e minus ,(lambda (e p) 'minus-e))
(number --> int ,identity)
(number --> int frac ,(lambda (i f) (string-append i f)))
(number --> int exp ,(lambda (i e) (string-append i e)))
(number --> int frac exp ,(lambda (i f e) (string-append i f e)))
(digit -> digit-1-9 ,(lambda (n) (number->string n)))
(digit -> zero ,(lambda (n) "0"))
;; I COULDN'T FORCE THE digit-1-9 start stuff. is it really needed??
(digits --> digit digits ,(lambda (d n) (string-append d n)))
; (digits --> digit-1-9 ,(lambda (n) (number->string n)))
; (digits --> d ,(lambda (n) (number->string n)))
(digits --> digit ,identity)
))
(define expr-terminals '(string literal digit-1-9 zero char lbracket rbracket lsquare rsquare e dot minus plus colon comma true false null ) )
(define table (lalr-table expr-grammar expr-terminals #f))
(define (string->json data)
(import (srfi s14 char-sets))
(let ((pos 0))
(define lexical-analyser
(lambda ()
(if (>= pos (string-length data)) #f
(begin
(let ([char (string-ref data pos)])
(cond
[(char=? char #\")
(let-values ([(str pos*) (parse-json-str (+ 1 pos) data #f '())])
;;(parse (+ 1 pos*) data (cons (cons 'str str) out)))]
(set! pos (+ 1 pos*))
`(string . ,str))]
[(char-set-contains? char-set:whitespace char)
(set! pos (+ 1 pos))
(lexical-analyser)]
[(char-set-contains? char-set:letter char) ;; literals
(let-values ([(str pos*) (parse-literal pos data '())])
(set! pos pos*)
(let ([sym (string->symbol str)])
(case sym
[(true) `(true . #t)]
[(false) `(false . #f)]
[(null) `(null . '())]
[(e E) `(e . #f)]
[else
`(literal ,(string->symbol str))])))]
[(char-set-contains? (string->char-set "123456789") char)
(set! pos (+ 1 pos))
`(digit-1-9 . ,(- (char->integer char) (char->integer #\0)))]
[(char=? #\0 char)
(set! pos (+ 1 pos))
`(zero . 0)]
[else
(set! pos (+ 1 pos))
(case char
((#\{) '(lbracket . #f))
((#\}) '(rbracket . #f))
((#\[) '(lsquare . #f))
((#\]) '(rsquare . #f))
; ((#\e #\E) '(e . #f))
((#\.) '(dot . #f))
((#\-) '(minus . #f))
((#\+) '(plus . #f))
((#\:) '(colon . #f))
((#\,) '(comma . #f))
[else
`(char . ,char)])]))))))
(define (parse-error)
(display "Error somewhere in ")
(write (substring data (max 0 (- pos -100)) pos))
(newline))
(lalr-parser table lexical-analyser parse-error)))
(define (read-file filename)
(with-input-from-file filename
(lambda ()
(let loop ([x (read-char)] [acc '()])
(if (eof-object? x) (apply string (reverse acc))
(loop (read-char) (cons x acc)))))))
(define-syntax let-json-object
(lambda (x)
(syntax-case x ()
[(_ object (tag ...) body ...)
#`(let #,(map (lambda (t) #`(#,t
(let ([v (assq (quote #,t) object)])
(if v (cdr v) v))))#'(tag ...))
body ...)])))
(define (json->string json)
(define special '((#\backspace . #\b) (#\newline . #\n) (#\alarm . #\a)
(#\return . #\r) (#\tab #\t) (#\\ . #\\) (#\" . #\")))
(cond [(and (pair? json) (eq? (car json) '@))
(string-append
"{\n"
(string-intersperse
(map (lambda (pair)
(let ([k (car pair)]
[v (cdr pair)])
(string-append " " (json->string k)
" : " (json->string v))))
(cdr json))
",\n")
"\n}\n")]
[(list? json)
(string-append "["
(string-intersperse (map json->string json) ",")
"]\n")]
[(number? json)
(number->string json)]
[(string? json)
(string-append "\""
(list->string (fold-right
(lambda (x acc)
(let ([q (assq x special)])
(if q (cons #\\ (cons (cdr q) acc))
(cons x acc))))
'()
(string->list json)))
"\"" )]
[(bytevector? json)
(utf8->string json)]
[(symbol? json)
(json->string (symbol->string json))]
[else
(json->string "")]))
)
;;#!eof
| true |
4cdf9145c405f054443d4cb885e89c1af887cef5
|
51d30de9d65cc3d5079f050de33d574584183039
|
/http/duct-internal.scm
|
b1316356825701bcfd8914733d624e1ef9c5635f
|
[
"BSD-2-Clause",
"BSD-3-Clause"
] |
permissive
|
langmartin/ykk
|
30feb00265d603ef765b5c664d2f759be34b7b89
|
dd6e441dddd5b6363ee9adbbdd0f346c1522ffcf
|
refs/heads/master
| 2016-09-05T20:01:19.353224 | 2009-12-10T16:25:55 | 2009-12-10T16:25:55 | 408,478 | 0 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,801 |
scm
|
duct-internal.scm
|
(define (e-unimplemented . args)
(error "duct: unimplemented" args))
(define (read-byte . maybe-in)
(let ((x (apply read-char maybe-in)))
(if (eof-object? x) x
(char->ascii x))))
(define (write-byte b . maybe-out)
(apply write-char (ascii->char b) maybe-out))
(define-record-type duct
(make-duct parent attr)
duct?
(parent duct-parent)
(attr duct-attr duct-set-attr!))
(define-record-discloser duct
(lambda (duct)
`(duct ,(duct-get-property duct 'name))))
(define (port-duct-default-attr port)
`((reader . ,(lambda () (read-byte port)))
(peeker . ,(lambda () (peek-byte port)))
(writer . ,(lambda (b) (write-byte b port)))
(closer . ,(lambda () #t)) ; leave the port open by default
(name . "port/fundamental")))
(define (port->duct port . attr)
(let ((attr (list->alist attr)))
(set-port-text-codec! port us-ascii-codec)
(make-duct
port
(update-force-alist
attr
(port-duct-default-attr port)))))
(define (duct-get-local-property duct tag)
(cond ((assv tag (duct-attr duct)) => cdr)
(else #f)))
(define (duct-get-property duct tag)
(if (not (duct? duct))
(e-unimplemented tag)
(or (duct-get-local-property duct tag)
(duct-get-property (duct-parent duct) tag))))
(define (duct-set-property! duct tag value)
(duct-set-attr!
(update-force-alist
(duct-attr duct)
(list (cons tag value)))))
(define (read-proc duct)
(duct-get-property duct 'reader))
(define (duct-read duct)
((read-proc duct)))
(define (peek-proc duct)
(duct-get-property duct 'peeker))
(define (duct-peek duct)
((peek-proc duct)))
(define (write-proc duct)
(duct-get-property duct 'writer))
(define (duct-write duct)
((write-proc duct)))
(define (duct-close duct)
((duct-get-property duct 'closer)))
(define-syntax duct-extend*
(syntax-rules ()
((_ parent (tag val) ...)
(make-duct parent
(let-foldr* cons-alist '() (tag val) ...)))))
#;
(define (duct->input-port duct)
(make-buffered-input-port
(make-buffered-input-port-handler
(lambda (duct)
`(input-port ,duct)) ; discloser
(lambda (duct)
(duct-close duct)) ; closer
(lambda (port wait?)
(duct-read (port-data port))
(maybe-commit)) ; buffer-filler
e-unimplemented ; ready?
)
duct
(make-byte-vector 4096 0)
0
4096))
(define (duct-read-all duct)
(let lp ()
(let ((datum (duct-read duct)))
(if (eof-object? datum)
'()
(cons datum (lp))))))
(define (duct-foldr proc nil duct)
(let lp ()
(let ((datum (duct-read duct)))
(if (eof-object? datum)
nil
(proc datum (lp))))))
(define (duct-for-each proc duct)
(let ((datum (duct-read duct)))
(or (eof-object? datum)
(begin
(proc datum)
(duct-for-each proc duct)))))
(define (duct->string duct)
(with-string-output-port
(lambda ()
(duct-for-each display duct))))
(assert
(duct->string
(port->duct (make-string-input-port "test"))) => "116101115116")
;;; this should use duct-peek, and work symetrically to next-chunk
(define (duct-next-chunk-for-each pred? display duct keep-delimiter)
(next-chunk-primitive
(lambda () (duct-peek duct))
(lambda () (duct-read duct))
pred?
display
keep-delimiter))
(define (duct-next-chunk delims/proc duct . keep-delimiter)
(let-optionals* keep-delimiter ((keep-delimiter #f))
(let-string-output-port
(duct-next-chunk-for-each
(string-or-chars->predicate delims/proc)
display
duct
keep-delimiter))))
(define (match ch) (= ch 115))
(assert
(duct-next-chunk match (port->duct (make-string-input-port "test")))
=> "116101")
| true |
1929c7e3021b40d087516358b6b85baa6a702836
|
00466b7744f0fa2fb42e76658d04387f3aa839d8
|
/sicp/chapter2/2.5/generic-ops/complex-numbers.scm
|
8dbb5ce2bb2c41432413b74ec6506c4d0a1ffeb2
|
[
"WTFPL"
] |
permissive
|
najeex/stolzen
|
961da2b408bcead7850c922f675888b480f2df9d
|
bb13d0a7deea53b65253bb4b61aaf2abe4467f0d
|
refs/heads/master
| 2020-09-11T11:00:28.072686 | 2015-10-22T21:35:29 | 2015-10-22T21:35:29 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,130 |
scm
|
complex-numbers.scm
|
#lang scheme
(require "container.scm")
(require "tags.scm")
(require "generic-operations.scm")
(define (square x)
(mul x x)
)
(define (install-rectangular-package)
(define RECTANGULAR 'rectangular)
(define (real-part z)
(car z)
)
(define (imag-part z)
(cdr z)
)
(define (magnitude z)
(sqroot (add (square (real-part z))
(square (imag-part z))))
)
(define (angle z)
(artangent2 (imag-part z) (real-part z))
)
(define (negate-rectangular z)
(make-from-real-imag (negate (real-part z)) (negate (imag-part z)))
)
(define (make-from-real-imag x y)
(cons x y)
)
(define (make-from-mag-ang r a)
(cons (mul r (cosine a)) (mul r (sine a)))
)
;; interface
(define (tag x)
(attach-tag RECTANGULAR x)
)
(put 'real-part RECTANGULAR real-part)
(put 'imag-part RECTANGULAR imag-part)
(put 'magnitude RECTANGULAR magnitude)
(put 'angle RECTANGULAR angle)
(put 'negate RECTANGULAR (lambda (x) (tag (negate-rectangular x))))
(put 'make-from-real-imag RECTANGULAR
(lambda (x y) (tag (make-from-real-imag x y)))
)
(put 'make-from-mag-ang RECTANGULAR
(lambda (r a) (tag (make-from-mag-ang r a)))
)
(void)
)
(define (install-polar-package)
(define POLAR 'polar)
(define (real-part-polar z)
(mul (magnitude z) (cosine (angle z)))
)
(define (imag-part z)
(mul (magnitude z) (sine (angle z)))
)
(define (magnitude z)
(car z)
)
(define (angle z)
(cdr z)
)
(define (rotate180 a)
(let
((res (+ a (/ pi 2))))
(if (> res pi)
(- res pi)
res
)
)
)
(define (negate-polar z)
(make-from-mag-ang (magnitude z) (rotate180 (angle z)))
)
(define (make-from-real-imag x y)
(cons
(sqroot (add (square x) (square y)))
(artangent2 y x)
)
)
(define (make-from-mag-ang r a)
(cons r a)
)
;; interface
(define (tag x)
(attach-tag POLAR x)
)
(put 'real-part POLAR real-part-polar)
(put 'imag-part POLAR imag-part)
(put 'magnitude POLAR magnitude)
(put 'angle POLAR angle)
(put 'negate POLAR (lambda (x) (tag (negate-polar x))))
(put 'make-from-real-imag POLAR
(lambda (x y) (tag (make-from-real-imag x y)))
)
(put 'make-from-mag-ang POLAR
(lambda (r a) (tag (make-from-mag-ang r a)))
)
(void)
)
(define (install-complex-package)
(install-rectangular-package)
(install-polar-package)
;; imported procedures from rectangular and polar packages
(define make-from-real-imag (get 'make-from-real-imag 'rectangular))
(define make-from-mag-ang (get 'make-from-mag-ang 'polar))
(define (get-op name z)
(get name (type-tag z))
)
(define (operation name z)
((get-op name z) (contents z))
)
(define (real-part z)
(operation 'real-part z)
)
(define (imag-part z)
(operation 'imag-part z)
)
(define (magnitude z)
(operation 'magnitude z)
)
(define (angle z)
(operation 'angle z)
)
;; internal procedures
(define (add-complex z1 z2)
(make-from-real-imag (add (real-part z1) (real-part z2))
(add (imag-part z1) (imag-part z2)))
)
(define (sub-complex z1 z2)
(make-from-real-imag (sub (real-part z1) (real-part z2))
(sub (imag-part z1) (imag-part z2)))
)
(define (negate-complex z)
(operation 'negate z)
)
(define (mul-complex z1 z2)
(make-from-mag-ang (mul (magnitude z1) (magnitude z2))
(add (angle z1) (angle z2)))
)
(define (div-complex z1 z2)
(make-from-mag-ang (div (magnitude z1) (magnitude z2))
(sub (angle z1) (angle z2)))
)
;; interface to rest of the system
(define (tag z) (attach-tag 'complex z))
(put 'real-part 'complex (lambda (z) (real-part (contents z))))
(put 'imag-part 'complex (lambda (z) (imag-part (contents z))))
(put 'magnitude 'complex (lambda (z) (magnitude (contents z))))
(put 'angle 'complex (lambda (z) (angle (contents z))))
(put 'add '(complex complex)
(lambda (z1 z2) (tag (add-complex (contents z1) (contents z2))))
)
(put 'negate '(complex)
(lambda (z) (tag (negate-complex (contents z))))
)
(put 'sub '(complex complex)
(lambda (z1 z2) (tag (sub-complex (contents z1) (contents z2))))
)
(put 'mul '(complex complex)
(lambda (z1 z2) (tag (mul-complex (contents z1) (contents z2))))
)
(put 'div '(complex complex)
(lambda (z1 z2) (tag (div-complex (contents z1) (contents z2))))
)
(put 'make-from-real-imag 'complex
(lambda (x y) (tag (make-from-real-imag x y)))
)
(put 'make-from-mag-ang 'complex
(lambda (r a) (tag (make-from-mag-ang r a)))
)
(define (zero? z)
(and (=zero? (real-part z)) (=zero? (imag-part z)))
)
(put '=zero? '(complex)
(lambda (a) (zero? (contents a)))
)
(define (drop a)
(if (=zero? (imag-part a))
(real-part a)
false
)
)
(put 'drop 'complex
(lambda (a) (drop (contents a)))
)
(void)
)
(define (make-complex-from-real-imag x y)
((get 'make-from-real-imag 'complex) x y)
)
(define (make-complex-from-mag-ang r a)
((get 'make-from-mag-ang 'complex) r a)
)
(define (rational->complex x)
(make-complex-from-real-imag x 0)
)
(put 'raise 'rational rational->complex)
(provide (all-defined-out))
| false |
b25134c7ffa0492a137aad5559d82cad16992ee4
|
f4cf5bf3fb3c06b127dda5b5d479c74cecec9ce9
|
/Sources/LispKit/Resources/Tests/SRFI-174.scm
|
ff8df66b7d8ff699fd1cd54bcec9f05f8b72bb38
|
[
"Apache-2.0"
] |
permissive
|
objecthub/swift-lispkit
|
62b907d35fe4f20ecbe022da70075b70a1d86881
|
90d78a4de3a20447db7fc33bdbeb544efea05dda
|
refs/heads/master
| 2023-08-16T21:09:24.735239 | 2023-08-12T21:37:39 | 2023-08-12T21:37:39 | 57,930,217 | 356 | 17 |
Apache-2.0
| 2023-06-04T12:11:51 | 2016-05-03T00:37:22 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,306 |
scm
|
SRFI-174.scm
|
;;; SRFI 174 REGRESSION TEST SUITE
;;;
;;; This is the test suite for SRFI 174.
;;;
;;; Copyright © 2019 John Cowan. All rights reserved.
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without restriction,
;;; including without limitation the rights to use, copy, modify, merge,
;;; publish, distribute, sublicense, and/or sell copies of the Software,
;;; and to permit persons to whom the Software is furnished to do so,
;;; subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
;;;
;;; LispKit Port:
;;; Copyright © 2019 Matthias Zenger. All rights reserved.
(import (lispkit base)
(lispkit test)
(lispkit comparator)
(srfi 174))
(test-begin "SRFI 174: POSIX Timespecs")
(define ts1 (timespec 1 2))
(define ts2 (timespec 1 2))
(define ts3 (timespec 1 3))
(define ts4 (timespec 2 2))
(define ts-odd (timespec 1 (- 1000000001 2))) ; nano second too big (fixed test)
(define ts-neg (timespec -1 2))
(test-assert "timespec?" (timespec? ts1))
(test-assert "not timespec?" (not (timespec? #f)))
(test "seconds" 1 (timespec-seconds ts1))
(test "nanos" 2 (timespec-nanoseconds ts1))
(test-assert "equal" (=? timespec-comparator ts1 ts2))
(test-assert "less nanos" (<? timespec-comparator ts1 ts3))
(test-assert "less seconds" (<? timespec-comparator ts1 ts3))
(test-assert "odd" (<? timespec-comparator ts1 ts-odd))
(test-assert "integer hash" (exact-integer? (comparator-hash timespec-comparator ts-neg)))
; LispKit hash functions might return negative values (replaced positive? with
; exact-integer?)
(test-end)
| false |
1a7a27276a3a6502295bc9ca6b5a62c038d8e4aa
|
ffb05b145989e01da075e2a607fb291955251f46
|
/pypers/oxford/latebinding.scm
|
27858ec70813a82aa3bca69d6933effd78f3f70f
|
[] |
no_license
|
micheles/papers
|
a5e7f2fa0cf305cd3f8face7c7ecc0db70ce7cc7
|
be9070f8b7e8192b84a102444b1238266bdc55a0
|
refs/heads/master
| 2023-06-07T16:46:46.306040 | 2018-07-14T04:17:51 | 2018-07-14T04:17:51 | 32,264,461 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 97 |
scm
|
latebinding.scm
|
(define (toplevel)
(define a 1)
(define (f)
(display a))
(set! a 2)
(f))
(toplevel)
| false |
9acd606eba4db93a47c37b3b4a20338fa61b9113
|
b9eb119317d72a6742dce6db5be8c1f78c7275ad
|
/random-scheme-stuff/normals.ss
|
dbf4f770e94a4545f977ab4337019c333aa186c2
|
[] |
no_license
|
offby1/doodles
|
be811b1004b262f69365d645a9ae837d87d7f707
|
316c4a0dedb8e4fde2da351a8de98a5725367901
|
refs/heads/master
| 2023-02-21T05:07:52.295903 | 2022-05-15T18:08:58 | 2022-05-15T18:08:58 | 512,608 | 2 | 1 | null | 2023-02-14T22:19:40 | 2010-02-11T04:24:52 |
Scheme
|
UTF-8
|
Scheme
| false | false | 1,245 |
ss
|
normals.ss
|
(module normals mzscheme
(provide one-unit-normal)
;; Note that this is obviated by
;; (require (planet "random.ss" ("schematics" "random.plt")))
;; http://en.wikipedia.org/wiki/Box-Muller_transform
(define (pair-of-unit-normals)
(let loop ((x (random))
(y (random)))
(let ((sum-of-squares (+ (* x x)
(* y y))))
(if (or (zero? sum-of-squares)
(< 1 sum-of-squares))
(loop (random)
(random))
(let ((hmph (sqrt (/ (* -2 (log sum-of-squares))
sum-of-squares))))
(list (* x hmph)
(* y hmph)))))))
;; TODO -- find a nifty way to write this, without using assignment,
;; and without just throwing away one of the two return values from
;; pair-of-unit-normals
;; see http://schemewiki.org/view/Cookbook/NumberRecipeBiasedRands for
;; inspiration. Executive summary: return a thunk, not a number; the
;; thunk itself returns your random number, and keeps its own little
;; cache.
(define one-unit-normal
(let ((buffer '()))
(lambda ()
(when (null? buffer)
(set! buffer (pair-of-unit-normals)))
(begin0
(car buffer)
(set! buffer (cdr buffer))))))
)
| false |
d4f34b24452fbbf4d25511517d1d372a1defa275
|
ac2a3544b88444eabf12b68a9bce08941cd62581
|
/tests/unit-tests/11-network/udp_io.scm
|
434915e38d8ba15faaa60feb2ede9b52b7f53935
|
[
"Apache-2.0",
"LGPL-2.1-only"
] |
permissive
|
tomelam/gambit
|
2fd664cf6ea68859d4549fdda62d31a25b2d6c6f
|
d60fdeb136b2ed89b75da5bfa8011aa334b29020
|
refs/heads/master
| 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 |
Apache-2.0
| 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null |
UTF-8
|
Scheme
| false | false | 4,014 |
scm
|
udp_io.scm
|
(include "#.scm")
(define p
(exit0-when-unimplemented-operation-os-exception
(lambda ()
(open-udp))))
(check-eq? (write '#u8() p) (void))
(check-eq? (write '#u8(11) p) (void))
(check-eq? (write '#u8(22 33) p) (void))
(check-eq? (write '#u8(44 55 66) p) (void))
(check-equal? (read p) '#u8())
(check-equal? (read p) '#u8(11))
(check-equal? (read p) '#u8(22 33))
(check-equal? (read p) '#u8(44 55 66))
(check-eq? (udp-write-u8vector '#u8() p) (void))
(check-eq? (udp-write-u8vector '#u8(11) p) (void))
(check-eq? (udp-write-u8vector '#u8(22 33) p) (void))
(check-eq? (udp-write-u8vector '#u8(44 55 66) p) (void))
(check-equal? (udp-read-u8vector p) '#u8())
(check-equal? (udp-read-u8vector p) '#u8(11))
(check-equal? (udp-read-u8vector p) '#u8(22 33))
(check-equal? (udp-read-u8vector p) '#u8(44 55 66))
(parameterize ((current-output-port p))
(check-eq? (write '#u8()) (void))
(check-eq? (write '#u8(11)) (void))
(check-eq? (write '#u8(22 33)) (void))
(check-eq? (write '#u8(44 55 66)) (void)))
(parameterize ((current-input-port p))
(check-equal? (read) '#u8())
(check-equal? (read) '#u8(11))
(check-equal? (read) '#u8(22 33))
(check-equal? (read) '#u8(44 55 66)))
(parameterize ((current-output-port p))
(check-eq? (udp-write-u8vector '#u8()) (void))
(check-eq? (udp-write-u8vector '#u8(11)) (void))
(check-eq? (udp-write-u8vector '#u8(22 33)) (void))
(check-eq? (udp-write-u8vector '#u8(44 55 66)) (void)))
(parameterize ((current-input-port p))
(check-equal? (udp-read-u8vector) '#u8())
(check-equal? (udp-read-u8vector) '#u8(11))
(check-equal? (udp-read-u8vector) '#u8(22 33))
(check-equal? (udp-read-u8vector) '#u8(44 55 66)))
(check-eq? (udp-write-subu8vector '#u8(1 2 3 4 5) 1 3 p) (void))
(check-eq? (udp-write-subu8vector '#u8(1 2 3 4 5) 0 5 p) (void))
(define buf (make-u8vector 10 0))
(check-= (udp-read-subu8vector buf 0 10 p) 2)
(check-equal? buf '#u8(2 3 0 0 0 0 0 0 0 0))
(check-= (udp-read-subu8vector buf 0 10 p) 5)
(check-equal? buf '#u8(1 2 3 4 5 0 0 0 0 0))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-u8vector)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-u8vector 1 2 3)))
(check-tail-exn type-exception? (lambda () (udp-write-u8vector 1)))
(check-tail-exn type-exception? (lambda () (udp-write-u8vector 1 p)))
(check-tail-exn type-exception? (lambda () (udp-write-u8vector buf #f)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-read-u8vector 1 2)))
(check-tail-exn type-exception? (lambda () (udp-read-u8vector 1)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-subu8vector)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-subu8vector 1)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-subu8vector 1 2)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-write-subu8vector 1 2 3 4 5)))
(check-tail-exn type-exception? (lambda () (udp-write-subu8vector 1 0 1)))
(check-tail-exn type-exception? (lambda () (udp-write-subu8vector buf #f 1)))
(check-tail-exn type-exception? (lambda () (udp-write-subu8vector buf 0 #f)))
(check-tail-exn type-exception? (lambda () (udp-write-subu8vector buf 0 1 #f)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-read-subu8vector)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-read-subu8vector 1)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-read-subu8vector 1 2)))
(check-tail-exn wrong-number-of-arguments-exception? (lambda () (udp-read-subu8vector 1 2 3 4 5)))
(check-tail-exn type-exception? (lambda () (udp-read-subu8vector 1 0 1)))
(check-tail-exn type-exception? (lambda () (udp-read-subu8vector buf #f 1)))
(check-tail-exn type-exception? (lambda () (udp-read-subu8vector buf 0 #f)))
(check-tail-exn type-exception? (lambda () (udp-read-subu8vector buf 0 1 #f)))
(check-tail-exn type-exception? (lambda () (write #f p)))
| false |
50f05f5127ff47060ad310260adf8a7040f25e47
|
ca39b0bad8cf2fb9bc5699720c1ef86a34ab096a
|
/bench/dynamic.scm
|
e551c968d69a6f67568227aa7ad65c00e00041a8
|
[
"MIT"
] |
permissive
|
janm31415/skiwi
|
9f40c2120f14dd895cd875087ee941ec6a155b2d
|
8234d18fd95a971e947f28477b6173c3c7ef30da
|
refs/heads/master
| 2022-09-23T23:52:09.637174 | 2022-08-31T21:34:50 | 2022-08-31T21:34:50 | 252,686,866 | 4 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 53 |
scm
|
dynamic.scm
|
(load "run-benchmark.scm")
(load "dynamic.src.scm")
| false |
deb39a4c69e8782ccf545f826bc72daf5d24ab6b
|
fba55a7038615b7967256306ee800f2a055df92f
|
/vvalkyrie/2.1/ex-2-11.scm
|
d64e7679f5322a19da9c46e6296da541c1f7348f
|
[] |
no_license
|
lisp-korea/sicp2014
|
7e8ccc17fc85b64a1c66154b440acd133544c0dc
|
9e60f70cb84ad2ad5987a71aebe1069db288b680
|
refs/heads/master
| 2016-09-07T19:09:28.818346 | 2015-10-17T01:41:13 | 2015-10-17T01:41:13 | 26,661,049 | 2 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,284 |
scm
|
ex-2-11.scm
|
;; Alyssa P. Hacker's code.
(define (make-interval a b) (cons a b))
(define (lower-bound x) (car x))
(define (upper-bound x) (cdr x))
(define (mul-interval x y)
(let ((p1 (* (lower-bound x) (lower-bound y)))
(p2 (* (lower-bound x) (upper-bound y)))
(p3 (* (upper-bound x) (lower-bound y)))
(p4 (* (upper-bound x) (upper-bound y))))
(make-interval (min p1 p2 p3 p4)
(max p1 p2 p3 p4))))
;; Ben Bitdiddle's advice.
;; (a b) x (a' b')
;; ----------------
;; (+ +) x (+ +) -> (aa', bb')
;; (- -) x (- -) -> (bb', aa')
;; (- +) x (+ +) -> (ab', bb')
;; (+ +) x (- +) -> (a'b, bb')
;; (- -) x (+ +) -> (ab', a'b)
;; (+ +) x (- -) -> (a'b, ab')
;; (- +) x (- -) -> (a'b, aa')
;; (- -) x (- +) -> (ab', aa')
;; (- +) x (- +) -> (ab', bb') or (a'b, bb')
;;
;; (0이 있는 경우, 예전 mul-interval 함수를 사용하는 것으로 처리함)
(define (mul-interval-1 x y)
(if (or (= 0 (lower-bound x)) (= 0 (lower-bound y))
(= 0 (upper-bound x)) (= 0 (upper-bound y)))
(mul-interval x y) ;; use original func
(mul-interval-non0 x y)))
(define (mul-interval-non0 x y)
(let ((lx (lower-bound x))
(ux (upper-bound x))
(ly (lower-bound y))
(uy (upper-bound y)))
(cond ((and (> lx 0) (> ux 0) (> ly 0) (> uy 0))
(make-interval (* lx ly) (* ux uy)))
((and (< lx 0) (< ux 0) (< ly 0) (< uy 0))
(make-interval (* ux uy) (* lx ly)))
((and (< lx 0) (> ux 0) (> ly 0) (> uy 0))
(make-interval (* lx uy) (* ux uy)))
((and (> lx 0) (> ux 0) (< ly 0) (> uy 0))
(make-interval (* ly ux) (* ux uy)))
((and (< lx 0) (< ux 0) (> ly 0) (> uy 0))
(make-interval (* lx uy) (* ly ux)))
((and (> lx 0) (> ux 0) (< ly 0) (< uy 0))
(make-interval (* ly ux) (* lx uy)))
((and (< lx 0) (> ux 0) (< ly 0) (< uy 0))
(make-interval (* ly ux) (* lx ly)))
((and (< lx 0) (< ux 0) (< ly 0) (> uy 0))
(make-interval (* lx uy) (* lx ly)))
((and (< lx 0) (> ux 0) (< ly 0) (> uy 0))
(make-interval (min (* lx uy) (* ly ux)) (* ux uy))))))
;; test
(mul-interval-1 (make-interval 1 2) (make-interval 3 4))
(mul-interval (make-interval 1 2) (make-interval 3 4))
(mul-interval-1 (make-interval -2 -1) (make-interval -4 -3))
(mul-interval (make-interval -2 -1) (make-interval -4 -3))
(mul-interval-1 (make-interval -1 2) (make-interval 3 4))
(mul-interval (make-interval -1 2) (make-interval 3 4))
(mul-interval-1 (make-interval 1 2) (make-interval -3 4))
(mul-interval (make-interval 1 2) (make-interval -3 4))
(mul-interval-1 (make-interval -2 -1) (make-interval 3 4))
(mul-interval (make-interval -2 -1) (make-interval 3 4))
(mul-interval-1 (make-interval 1 2) (make-interval -4 -3))
(mul-interval (make-interval 1 2) (make-interval -4 -3))
(mul-interval-1 (make-interval -1 2) (make-interval -4 -3))
(mul-interval (make-interval -1 2) (make-interval -4 -3))
(mul-interval-1 (make-interval -2 -1) (make-interval -3 4))
(mul-interval (make-interval -2 -1) (make-interval -3 4))
(mul-interval-1 (make-interval -1 2) (make-interval -3 4))
(mul-interval (make-interval -1 2) (make-interval -3 4))
| false |
298d9a3db2b6a2767560aa970fd5414bbf619b96
|
d2fc383d46303bc47223f4e4d59ed925e9b446ce
|
/courses/2008/fall/330/notes/15.ss
|
0f8d36926e1ea31df7c3453dc648f45ea92898ba
|
[] |
no_license
|
jeapostrophe/jeapostrophe.github.com
|
ce0507abc0bf3de1c513955f234e8f39b60e4d05
|
48ae350248f33f6ce27be3ce24473e2bd225f6b5
|
refs/heads/master
| 2022-09-29T07:38:27.529951 | 2022-09-22T10:12:04 | 2022-09-22T10:12:04 | 3,734,650 | 14 | 5 | null | 2022-03-25T14:33:29 | 2012-03-16T01:13:09 |
HTML
|
UTF-8
|
Scheme
| false | false | 471 |
ss
|
15.ss
|
#lang plai
; Testing Web Transformations
(define the-receiver (box 'dummy))
(define receiver-prompt (box 'dummy))
(define (web-display n)
(printf "Web output: ~a~n" n))
(define (web-read/k p k)
(begin (set-box! receiver-prompt p)
(set-box! the-receiver k)
(error 'web-read/k "Run (resume) to enter number and simulate clicking Submit")))
(define (resume)
(begin (display (unbox receiver-prompt))
((unbox the-receiver) (read))))
| false |
f109392b686de9d1216a682a08fcd52d943719a3
|
404799b4b2d5f83ee5304392826a69defc25da77
|
/ex2-68.scm
|
1cb05354b1dd1490aa0597fa9fc8e6432c9e9631
|
[] |
no_license
|
WuzhangFang/SICP-exercise
|
38ae650c63e74bb7c6639bf984285e06743db925
|
d9977009ec3e32a74edb13b4f13f6ebbbc44ab32
|
refs/heads/master
| 2020-04-16T16:01:18.058287 | 2019-10-01T21:52:40 | 2019-10-01T21:52:40 | 165,722,260 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 850 |
scm
|
ex2-68.scm
|
;;; Exercise 2.68
(load "huffman-tree.scm")
(define (encode message tree)
(if (null? message)
'()
(append
(encode-symbol (car message) tree)
(encode (cdr message) tree))))
(define (encode-symbol symbol tree)
(cond ((leaf? tree) '())
((symbol-in-tree? symbol (left-branch tree))
(cons 0 (encode-symbol symbol (left-branch tree))))
((symbol-in-tree? symbol (right-branch tree))
(cons 1 (encode-symbol symbol (right-branch tree))))
(else (error "This symbol is not in the tree: " symbol))))
(define (symbol-in-tree? symbol tree)
(member symbol (symbols tree)))
(load "huffman-tree.scm")
(define sample-tree
(make-code-tree (make-leaf 'A 4)
(make-code-tree (make-leaf 'B 2)
(make-code-tree
(make-leaf 'D 1)
(make-leaf 'C 1)))))
(symbols sample-tree)
(encode '(a b c d) sample-tree)
| false |
1fbca3fbabdce3a1eccab04b415139c7d77e41a0
|
2bcf33718a53f5a938fd82bd0d484a423ff308d3
|
/programming/sicp/ch2/ex-2.69.scm
|
78f32f89c0947a2161d1f0d0e2d2fdde6daf0d94
|
[] |
no_license
|
prurph/teach-yourself-cs
|
50e598a0c781d79ff294434db0430f7f2c12ff53
|
4ce98ebab5a905ea1808b8785949ecb52eee0736
|
refs/heads/main
| 2023-08-30T06:28:22.247659 | 2021-10-17T18:27:26 | 2021-10-17T18:27:26 | 345,412,092 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 683 |
scm
|
ex-2.69.scm
|
#lang scheme
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-16.html#%_thm_2.69
(require "huffman.scm")
;; Write successive-merge for an ordered set of leaves for use in the provided
;; `generate-huffman-tree` below.
(define (successive-merge leaf-set)
(let ((l (car leaf-set))
(r (cdr leaf-set)))
(if (null? r)
l
(successive-merge (adjoin-set (make-code-tree (car leaf-set)
(cadr leaf-set))
(cddr leaf-set))))))
(define (generate-huffman-tree pairs)
(successive-merge (make-leaf-set pairs)))
(provide generate-huffman-tree)
| false |
6a9b9a4f2c8575d98ec7bf84f727d0872e1119e1
|
d8bdd07d7fff442a028ca9edbb4d66660621442d
|
/scam/tests/10-scheme/00-base/let/new-env.scm
|
729824135c86551a3f4fd82744ca333c0b7b3ff9
|
[] |
no_license
|
xprime480/scam
|
0257dc2eae4aede8594b3a3adf0a109e230aae7d
|
a567d7a3a981979d929be53fce0a5fb5669ab294
|
refs/heads/master
| 2020-03-31T23:03:19.143250 | 2020-02-10T20:58:59 | 2020-02-10T20:58:59 | 152,641,151 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 207 |
scm
|
new-env.scm
|
(import (only (scheme base) /)
(test let-suite)
(test narc))
(narc-label "Let Env")
(define x 2)
(define y 0)
(let-suite-expect 2.0 ((y 1.0)) (/ x y))
(narc-expect
(0 y))
(narc-report)
| false |
07d63896b0a82a8510e47a8ccb40b4a7cc1202e2
|
5355071004ad420028a218457c14cb8f7aa52fe4
|
/5.5/e-5.36.scm
|
4df5ed94f992e8080868e2ade934bd31d825daae
|
[] |
no_license
|
ivanjovanovic/sicp
|
edc8f114f9269a13298a76a544219d0188e3ad43
|
2694f5666c6a47300dadece631a9a21e6bc57496
|
refs/heads/master
| 2022-02-13T22:38:38.595205 | 2022-02-11T22:11:18 | 2022-02-11T22:11:18 | 2,471,121 | 376 | 90 | null | 2022-02-11T22:11:19 | 2011-09-27T22:11:25 |
Scheme
|
UTF-8
|
Scheme
| false | false | 991 |
scm
|
e-5.36.scm
|
; Exercise 5.36. What order of evaluation does our compiler produce for
; operands of a combination? Is it left-to-right, right-to-left, or some other
; order? Where in the compiler is this order determined? Modify the compiler so
; that it produces some other order of evaluation. (See the discussion of order
; of evaluation for the explicit-control evaluator in section 5.4.1.) How does
; changing the order of operand evaluation affect the efficiency of the code
; that constructs the argument list?
; ------------------------------------------------------------
; Evaluation is done from right to left, because the way we use argument list is that we
; cons on top of it the arguments so in order to preserve correct order we do it backwards.
; It is defined in couple of places. First in way machine uses it, and second in the place where we
; generate code for computation of the arguments.
;
; I guess efficiency depends on the way we write code, as we saw it could be either way.
| false |
db677dc97064325d8d45df5bec2fe94f72cbf3c8
|
382706a62fae6f24855ab689b8b2d87c6a059fb6
|
/0.2/src/print.scm
|
ddd49b154b17b5fb774a453ba77f3c7f5dc4bd8a
|
[
"Apache-2.0"
] |
permissive
|
mstram/bard
|
ddb1e72a78059617403bea1842840bb9e979198e
|
340d6919603a30c7944fb66e04df0562180bc0bb
|
refs/heads/master
| 2021-01-21T00:12:27.174597 | 2014-07-10T13:20:39 | 2014-07-10T13:20:39 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,508 |
scm
|
print.scm
|
;;;; ***********************************************************************
;;;; FILE IDENTIFICATION
;;;;
;;;; Name: print.scm
;;;; Project: Bard
;;;; Purpose: printing Bard values
;;;; Author: mikel evins
;;;; Copyright: 2012 by mikel evins
;;;;
;;;; ***********************************************************************
(define $bard-printers (make-table test: eqv?))
(define (%defprinter type printfn)
(table-set! $bard-printers type printfn))
(%defprinter <undefined> (constantly "undefined"))
(%defprinter <null> (constantly "nothing"))
(%defprinter <boolean> (lambda (b)(if b "true" "false")))
(%defprinter <character> object->string)
(%defprinter <fixnum> object->string)
(%defprinter <bignum> object->string)
(%defprinter <flonum> object->string)
(%defprinter <ratnum> object->string)
(%defprinter <string> object->string)
(%defprinter <symbol> object->string)
(%defprinter <keyword> object->string)
(%defprinter <primitive-procedure>
(lambda (x)
(string-append "#<primitive-procedure "
(object->string (object->serial-number x))
">")))
(%defprinter <frame>
(lambda (fr)
(with-output-to-string '()
(lambda ()
(display "{")
(let* ((space (lambda ()(display " ")))
(item (lambda (x)
(display (%as-string x))
(space)
(display (%as-string (%frame-get fr x)))))
(keys (%frame-keys fr)))
(if (not (%null? keys))
(begin
(item (%car keys))
(let loop ((keys (%cdr keys)))
(if (not (%null? keys))
(begin
(space)
(item (%car keys))
(loop (%cdr keys))))))))
(display "}")))))
(%defprinter <list>
(lambda (ls)
(with-output-to-string '()
(lambda ()
(display "(")
(let ((space (lambda ()(display " ")))
(item (lambda (x)(display (%as-string x)))))
(if (not (%null? ls))
(begin
(item (%car ls))
(let loop ((items (%cdr ls)))
(if (not (%null? items))
(begin
(space)
(item (%car items))
(loop (%cdr items))))))))
(display ")")))))
(%defprinter <foreign-value>
(lambda (x)
(string-append "#<foreign value "
(object->string (object->serial-number x))
">")))
(%defprinter <iostream> object->string)
(%defprinter Type
(lambda (x)
(if (%singleton? x)
(string-append "(singleton " (%as-string (%singleton-value x)) ")")
(object->string (%type-name x)))))
(%defprinter <function>
(lambda (x)
(let ((nm (%function-name x)))
(if nm
(string-append "#<function " (object->string nm) ">")
(string-append "#<anonymous function " (object->string (object->serial-number x)) ">")))))
(%defprinter <generator>
(lambda (x)
(string-append "#<generator " (object->string (object->serial-number x)) ">")))
(%defprinter <primitive-method>
(lambda (x)
(let ((nm (%method-name x)))
(if nm
(string-append "#<primitive-method " (object->string nm) ">")
(string-append "#<anonymous primitive method " (object->string (object->serial-number x)) ">")))))
(%defprinter <interpreted-method>
(lambda (x)
(let ((nm (or (and (%method-name x)
(%as-string (%method-name x)))
""))
(formals (%method-formals x))
(body (%method-body x)))
(with-output-to-string '()
(lambda ()
(display "(method ")
(display nm)
(if (> (string-length nm) 0) (display " "))
(display (interpose " " (%bard-list->cons formals)))
(if (> (%length body) 0) (display " "))
(display (%as-string body))
(display ")"))))))
(define (%as-string x)
(let ((printer (table-ref $bard-printers (%object->bard-type x) #f)))
(if printer
(printer x)
(error (string-append "No Bard printer defined for value: " (object->string x))))))
(define (show x)
(newline)
(display (%as-string x))
(newline))
(define (bard:print x #!optional (port (current-output-port)))
(display (%as-string x) port)
x)
;;; (show 4)
;;; (show (%undefined))
;;; (show '())
;;; (show #\C)
;;; (show (%true))
;;; (show (%false))
;;; (show 'Foo)
;;; (show FooBar:)
;;; (show +)
;;; (show *)
;;; (show (current-input-port))
;;; (show (current-output-port))
;;; (show (%make-frame '()))
;;; (show (%make-frame '(name: "Fred" age: 101)))
;;; (show <frame>)
;;; (show Anything)
;;; (show (%singleton 5))
| false |
8fd97628c790f6915ff28e22b246c44b1ac489e8
|
eeb788f85765d6ea5a495e1ece590f912bc8c657
|
/profj/tests/beginner-tests.ss
|
b575399c55604b605a6b0878e45fcce0fed42e21
|
[] |
no_license
|
mflatt/profj
|
f645aaae2b147a84b385e42f681de29535e13dd4
|
bc30ab369ac92ef3859d57be5c13c9562948bb8a
|
refs/heads/master
| 2023-08-28T14:13:17.153358 | 2023-08-08T13:08:04 | 2023-08-08T13:08:04 | 10,001,564 | 10 | 4 | null | 2020-12-01T18:41:00 | 2013-05-11T15:54:54 |
Scheme
|
UTF-8
|
Scheme
| false | false | 13,906 |
ss
|
beginner-tests.ss
|
(module beginner-tests mzscheme
(require "profj-testing.ss")
(require mzlib/class
profj/libs/java/lang/Object
profj/libs/java/lang/String)
(prepare-for-tests "Beginner")
(define language 'beginner)
;;Execution tests that should pass
(execute-test
"class MyClass {
Object field;
MyClass( Object f ) { this.field = f; }
MyClass method() { return this; }
}
class CorrectChecks {
boolean t;
boolean t2 = check 1 expect 3;
boolean t3 = (check 1 expect 3) || (check 2 expect 3);
boolean t4 = (check 1 expect 1) && (check 3 expect 3);
boolean t5 = check \"Hi\" expect \"\";
boolean t6 = check 1.5 expect 2 within .4;
boolean t7 = check true expect false;
boolean t8 = check new MyClass(\"\") expect new MyClass(\"\");
boolean t9 = check new MyClass(\"\").field expect \"\";
boolean t10 = check new MyClass(\"\").method() expect new MyClass(\"\");
CorrectChecks(boolean t) { this.t= t; }
}" language #f "Class with many different style of checks within it")
(execute-test
"interface A {
boolean s( B b);
}
class B implements A {
B() { }
boolean s( B b ) { return true; }
}"
language #f "Interface and class with cyclic reference")
(execute-test
"class Simple {
Simple() { }
}
class Simple2 {
Simple s;
Simple2( Simple s ) {
this.s = s;
}
}
class Simple3 {
Simple2 s;
Simple3( Simple2 s ) {
this.s = s;
}
boolean happy() {
return true;
}
}"
language
#f
"Simple classes, with fields and methods")
(execute-test
"interface F {
int fo();
}"
'beginner #f "Interface with method")
(execute-test
"interface F {
int foo();
}
class FP implements F {
int x;
FP(int x) {
this.x = x;
}
int foo() { return this.x; }
}"
language
#f
"Simple implementation of interface")
(execute-test
"interface F {
int lessThan( int x );
}
class Fp implements F {
int x;
Fp( int x ) {
this.x = x;
}
int lessThan( int y) {
if (y < this.x) {
return -1;
} else {
return 1;
}
}
}" language #f "Class & interface, containing if statement")
(execute-test
"class A {
int a;
double b;
boolean c;
char d;
String e;
Object f;
A(int a, double b, boolean c, char d, String e, Object f) {
this.a = a;
this.b = b; this.c =c; this.d = d; this.e = e; this.f = f;
}
}" language #f "Class with variables of many primitive types")
(execute-test
"class A {
B var;
A(B var) { this.var = var; }
}
class B {
A var;
B( A var) { this.var = var; }
}" language #f "Two classes with cycles: cannot be instantiated")
(execute-test
"interface X { }
class O {
O() { }
String happy( X x ) {
return x.toString();
}
}" language #f "Test that interface types have Object methods")
;;Execution tests that should produce errors
(execute-test
"class UseNoSet {
Object x;
Object y = this.x;
UseNoSet(Object x) { this.x = x; }
}" language #t "using fields before setting them")
(execute-test
"class DoubleSet {
int x;
DoubleSet(int x, int y) {
this.x = x;
this.x = y;
}
}" language #t "Setting a field twice, in the constructor")
(execute-test
"class DoubleSet2 {
int x = 3;
DoubleSet2(int x) {
this.x = x;
}
}" language #t "Setting a field twice, init and ctor")
(execute-test
"class CorrectChecks {
boolean t;
boolean t2 = check 1 expect 3;
boolean t3 = (check 1 expect 3) || (check 2 expect 3);
boolean t4 = (check 1 expect 1) && (check 3 expect 3);
boolean t5 = check \"Hi\" expect \"\";
boolean t6 = check 1.5 expect 2 within .4;
boolean t7 = check true expect false;
boolean t8 = check new MyClass(\"\") expect new MyClass(\"\");
boolean t9 = check new MyClass(\"\").field expect \"\";
boolean t10 = check new MyClass(\"\").method() expect new MyClass(\"\");
()
CorrectChecks(boolean t) { this.t= t; }
}" language #t "Correct checks, followed by a parse error: should mention (")
(execute-test
"class X {
int x = this.y;
int y = 3;
X() { }
}" language #t "Should be forward field error")
(execute-test
"interface Z {
int x();
}
class A {
int z = 3;
Z y;
A(int z) {
this.z = z;
this.y = y;//new B();
}
}
class B implements Z {
B() { }
int x() { return 3; }
int oX() { if (this.x() == 3) { return 5; } else { return 6; } }
}
foo"
language #t "Parse-error test, mentioning foo")
(execute-test
"class X {
X() { super(); }
}"
language #t "Parse-error test, indicating that super not allowed")
(execute-test
"class X {
X() { }
int x() { return super.x(); }
}"
language #t "Parse-error test, indicating that super.x() not allowed")
(execute-test
"interface A {
int x;
}"
language #t "Interface with a field")
(execute-test
"interface A {
int x();
boolean x();
}" language
#t "Two methods in an interface with the same name, and different return types")
(execute-test
"interface A {
int x();
int x(int y);
}" language
#t "Two methods in an interface with different arguments")
(execute-test
"public class B { B() { } }"
language #t "Use of public")
(execute-test
"interface A {
A foo();
}
class B implements A {
B() { }
A foo( String s) { return new B(); }
}"
'beginner #t "Method not implemented test, overload error")
(execute-test
"class F { }"
'beginner #t "No constructor error")
(execute-test
"class F {
F() { }
int x;
int x() { return 3; }
}" 'beginner #t "Method and field name share names error")
(execute-test
"class badCtor {
badCtor() c{
}
}" 'beginner #t "Error message bug")
(execute-test
"class IncorrectField {
int myField;
IncorrectField(int x) {
this.myField = myField;
}
}"
'beginner #t "Field access without this")
(execute-test
"class IncorrectMethodCall {
IncorrectMethodCall() { }
int returner() { return 4; }
int adder( int x ) {
return returner() + x;
}
}"
'beginner #t "Method access without this")
(execute-test
"class F1 {
F1(int x) {
x = x;
}
}"
'beginner #t "Set non-field")
(execute-test
"class F2 {
int f;
F2() {
this.f = f;
}
}"
'beginner #t "Set with field")
(execute-test
"interface A {
A foo();
}
class B implements A {
B() { }
B foo() { return new B(); }
}"
'beginner #t "Incorrect overriding")
(execute-test
"abstract class A { }"
language #t "Use of abstract class")
(execute-test
"class B extends A { }"
language #t "Use of extends")
(execute-test
"class A { A() { } }
class B implements A { B () { } }"
language #t "Implementing a class")
(execute-test
"import java.util.Random;
class Random { }"
language #t "Renaming an imported class")
(execute-test
"import geometry.*;
class Posn { }"
language #t "Renaming an imported class with a star")
;;Interaction tests: Mix of pass and fail
(interact-test
language
'("1 + 2 * 3 / 4" "new Object()" "\"Hello World\"" "true" "true && false" "true || false")
(list 2 (make-object Object) (make-java-string "Hello World") #t #f #t)
"Tests of simple expressions")
(interact-test
"class Book {
String title;
int numPages;
Book( String title, int numPages ) {
this.title = title;
this.numPages = numPages;
}
}"
language
(list "Book b = new Book(\"HP\", 33);" "b.title" "new Book(\"HP\",33).numPages" "new Book()" "new Book(\"\",0).numPages()")
(list (void) (make-java-string "HP") 33 'error 'error)
"Tests instantiating a class")
(interact-test
"class Book2 {
int numPages;
Book2( int numPages ) {
this.numPages = numPages;
}
String level() {
if ( this.numPages < 10 ) {
return \"Apprentice\";
} else {
if (this.numPages < 100) {
return \"Journeyman\";
} else {
return \"Master\";
}
}
}
}
"
language
(list "new Book2(9).level()" "new Book2(10).level()" "new Book2(100).level()" "new Book2(99).level")
(list (make-java-string "Apprentice") (make-java-string "Journeyman") (make-java-string "Master") 'error)
"Tests of an if in a method")
(interact-test
"interface AShape { }
class CartPt {
int x;
int y;
CartPt(int x, int y) {
this.x = x;
this.y = y;
}
}
class Dot implements AShape {
CartPt loc;
Dot(CartPt loc) {
this.loc = loc;
}
}
class Square implements AShape {
CartPt loc;
int size;
Square(CartPt loc, int size) {
this.loc = loc;
this.size = size;
}
}
class Circle implements AShape {
CartPt loc;
int radius;
Circle(CartPt loc, int radius) {
this.loc = loc;
this.radius = radius;
}
}"
language
(list "new Object()" "new AShape()" "new Square(new CartPt(77,22), 300).size" "new CartPt(21,1+21)")
(list `(make-object Object) 'error 300 `(let ((obj (make-object CartPt)))
(send obj CartPt-constructor-int-int 21 22)
obj))
"Book Test: AShape")
(interact-test
"class Coffee {
String kind;
int price;
int weight;
Coffee(String kind, int price, int weight) {
this.kind = kind;
this.price = price;
this.weight = weight;
}
// to compute the total cost of this coffee purchase
int cost() { return this.price * this.weight; }
// to determine whether this coffee costs less than the given amount
boolean costsLess(int amt) { return this.price < amt; }
// to determine whether this coffee is cheaper than the given coffee
boolean cheaperThan(Coffee that) { return this.price < that.price; }
}"
'beginner
(list "new Coffee(\"Kona\", 1595, 100).cost()"
"new Coffee(\"Ethiopian\", 800, 1000).cost()"
"new Coffee(\"Colombian\", 950, 20).cost()"
"new Coffee(\"Kona\", 1595, 100).costsLess(200)"
"new Coffee(\"Columbian\", 950, 200).costsLess(1000)"
"new Coffee(\"Ethiopian\", 800, 1000).cheaperThan(new Coffee(\"Columbian\", 950, 200))"
"new Coffee(\"Kona\", 1595, 100).cheaperThan(new Coffee(\"Columbian\", 950, 200))")
(list 159500 800000 19000 #f #t #t #f)
"Book Test Coffee")
(interact-test 'beginner
(list "Math.abs(-1)")
(list 1)
"Library availability test")
(execute-test
"// Exercise 3.1.1
// Exercise 5.1.2
interface ALoH{}
class MTLoH implements ALoH{
MTLoH(){}
}
class ConsHouse implements ALoH{
House fst;
ALoH rst;
ConsHouse(House f, ALoH r) {
this.fst = f;
this.rst = r;
}
}
class Address {
int no;
String street;
String city;
Address(int no, String street, String city) {
this.no = no;
this.street = street;
this.city = city;
}
}
class House {
String kind;
int rooms;
Address address;
int price;
House(String kind, int rooms, Address address, int price) {
this.kind = kind;
this.rooms = rooms;
this.address = address;
this.price = price;
}
// determine if this house has more rooms (is bigger) than that given house
boolean isBigger(House that) { return this.rooms > that.rooms; }
// actual: h1.isBigger(h2), expected: false
// actual: h2.isBigger(h3), expected: true
//determine if this house's city as the same as a given city
boolean thisCity(String city) { return this.city.equals(city); }
// h1.thisCity(\"Brookline)\"--true
// h2.thisCity(\"Brookline\")--false
}
/*
Address a1 = new Address(23, \"Maple Street\", \"Brookline\");
Address a2 = new Address(5, \"Joye Road\", \"Newton\");
Address a3 = new Address(83, \"Winslow Street\", \"Waltham\");
House h1 = new House(\"Ranch\", 7, a1, 375000);
House h2 = new House(\"Colonial\", 9, a2, 450000);
House h3 = new House(\"Cape\", 6, a3, 235000);
ALoH mtlist = new MTLoH();
ALoH list1 = new ConsHouse(h1, mtlist);
ALoH list2 = new ConsHouse(h3, list1);
*/"
'beginner #t "Error message bug")
(interact-test
"interface A { }"
language
(list "new A()")
(list 'error)
"Trying to create an instance of an interface")
(interact-test
"class X { X() { } double f() { return 2; } }"
language
(list "double x = 1;" "x" "new X().f()")
(list '(void) 1.0 2.0)
"Converting ints into doubles appropriately")
(interact-test
language
(list "check true expect true"
"check true expect 1"
"check true expect true within 1"
"check new Object() expect \"hi\""
"check \"hi\" expect new Object()"
"check 1.4 expect 1"
"check 1.4 expect 1 within .5"
"check 1.4 expect 1 within true")
(list #t 'error #t #f 'error 'error #t 'error)
"Calling check in many ways")
(report-test-results))
| false |
86c67b51adfd3982c065d7027791577e31884856
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System/system/text/regular-expressions/rx-link-ref.sls
|
5c1ebaa5fc0ce97a399a78aa9fb997a9e251e217
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,263 |
sls
|
rx-link-ref.sls
|
(library (system text regular-expressions rx-link-ref)
(export new
is?
rx-link-ref?
push-instruction-base
push-offset-position
offsets-get
offsets-set!
offsets-update!
current-get
current-set!
current-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Text.RegularExpressions.RxLinkRef a ...)))))
(define (is? a) (clr-is System.Text.RegularExpressions.RxLinkRef a))
(define (rx-link-ref? a)
(clr-is System.Text.RegularExpressions.RxLinkRef a))
(define-method-port
push-instruction-base
System.Text.RegularExpressions.RxLinkRef
PushInstructionBase
(System.Void System.Int32))
(define-method-port
push-offset-position
System.Text.RegularExpressions.RxLinkRef
PushOffsetPosition
(System.Void System.Int32))
(define-field-port
offsets-get
offsets-set!
offsets-update!
()
System.Text.RegularExpressions.RxLinkRef
offsets
System.Int32[])
(define-field-port
current-get
current-set!
current-update!
()
System.Text.RegularExpressions.RxLinkRef
current
System.Int32))
| true |
64cd4e021b7ff660daf04724b1859400c0697384
|
72f761ae4ce62922cc5b6003afbd785a554c7705
|
/lib/control-operators/threading.sls
|
fc44f5c2d5130fac64e3badaabe2b80dbb4792fc
|
[] |
no_license
|
pre-srfi/control-operators
|
66ee281fd834ee14a0469e4d653004bf24a1bfb5
|
f17333ec535bd4a8732a256423a4a304dd414b19
|
refs/heads/master
| 2023-07-02T18:36:59.879377 | 2021-08-08T08:34:36 | 2021-08-08T08:34:36 | 378,713,951 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,855 |
sls
|
threading.sls
|
#!r6rs
;; Copyright (C) Marc Nieper-Wißkirchen (2021). All Rights Reserved.
;; Permission is hereby granted, free of charge, to any person
;; obtaining a copy of this software and associated documentation
;; files (the "Software"), to deal in the Software without
;; restriction, including without limitation the rights to use, copy,
;; modify, merge, publish, distribute, sublicense, and/or sell copies
;; of the Software, and to permit persons to whom the Software is
;; furnished to do so, subject to the following conditions:
;; The above copyright notice and this permission notice shall be
;; included in all copies or substantial portions of the Software.
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;; SOFTWARE.
(library (control-operators threading)
(export %current-dynamic-environment
%current-thread %thread? %thread-start! %thread-yield! %thread-terminate!
%thread-join!
make-%mutex %mutex-lock! %mutex-unlock!
make-%condition-variable %condition-variable-broadcast!
%run)
(import (rnrs (6))
(control-operators primitives)
(control-operators timer))
(define *exit-continuation*)
(define *current-thread*)
(define *lock* #f)
(define lock!
(lambda ()
;(display "Lock!\n")
(assert (not (locked?)))
(set! *lock* #t)))
(define unlock!
(lambda ()
;(display "Unlock!\n")
(assert (locked?))
(set! *lock* #f)))
(define locked?
(lambda ()
*lock*))
(define-record-type %mutex
(nongenerative) (sealed #t) (opaque #t)
(fields (mutable locked?))
(protocol
(lambda (p)
(lambda ()
(p #f)))))
(define %mutex-unlock!
(case-lambda
[(mtx)
(assert (%mutex? mtx))
(%mutex-locked?-set! mtx #f)]
[(mtx cv)
(assert (%mutex? mtx))
(assert (%condition-variable? cv))
(lock!)
(%mutex-locked?-set! mtx #f)
(%condition-variable-waiting-threads-set!
cv
(cons (%current-thread)
(%condition-variable-waiting-threads cv)))
(let f ()
(unlock!)
(%thread-yield!)
(lock!)
(when (memq (%current-thread) (%condition-variable-waiting-threads cv))
(f)))
(unlock!)]))
(define %mutex-lock!
(lambda (mtx)
(assert (%mutex? mtx))
(let f ()
(lock!)
(if (%mutex-locked? mtx)
(begin
(unlock!)
(%thread-yield!)
(f))
(begin
(%mutex-locked?-set! mtx #t)
(unlock!))))))
(define-record-type %condition-variable
(nongenerative) (sealed #t) (opaque #t)
(fields (mutable waiting-threads))
(protocol
(lambda (p)
(lambda ()
(p '())))))
(define %condition-variable-broadcast!
(lambda (cv)
(assert (%condition-variable? cv))
(%condition-variable-waiting-threads-set! cv '())))
(define interrupt-handler
(lambda ()
(%set-timer! #t)
(unless (locked?)
(%thread-yield!))))
(define-record-type %thread
(nongenerative) (opaque #t)
(fields (mutable continuation)
(mutable terminated?))
(protocol
(lambda (p)
(lambda (thunk)
(assert (procedure? thunk))
(p thunk #f)))))
(define-record-type %primordial-thread
(parent %thread)
(nongenerative) (sealed #t) (opaque #t)
(protocol
(lambda (n)
(lambda ()
((n (lambda () (assert #f))))))))
(define %current-thread
(lambda ()
*current-thread*))
(define current-threads
(let ([threads '()])
(case-lambda
[() threads]
[(t) (set! threads t)])))
(define %current-dynamic-environment
(let ([environment #f])
(case-lambda
[() environment]
[(env) (set! environment env)])))
(define %run
(lambda (thunk)
(lock!)
(let-values
([val*
(%call-with-current-continuation
(lambda (k)
(%call-with-interrupt-handler
interrupt-handler
(lambda ()
(set! *exit-continuation* k)
(set! *current-thread* (make-%primordial-thread))
(current-threads
(list *current-thread*))
(unlock!)
(thunk)))))])
(current-threads '())
(apply values val*))))
(define %thread-start!
(lambda (thunk)
(assert (procedure? thunk))
(lock!)
(letrec ([thread
(make-%thread
(lambda ()
(unlock!)
(thunk)
(%thread-terminate! thread)))])
(current-threads (append (current-threads) (list thread)))
(unlock!)
thread)))
(define %thread-yield!
(lambda ()
(lock!)
(let* ([t* (current-threads)]
[ot (car t*)]
[t* (append (cdr t*) (list ot))]
[nt (car t*)])
(if (eq? ot nt)
(unlock!)
(let ([env (%current-dynamic-environment)])
(%call-with-current-continuation
(lambda (k)
(%thread-continuation-set! ot k)
(current-threads t*)
(abort-to-thread nt)))
(%current-dynamic-environment env)
(unlock!))))))
(define %thread-terminate!
(lambda (thread)
(lock!)
(when (%primordial-thread? thread)
(*exit-continuation*))
(%thread-terminated?-set! thread #t)
(let ([t* (remq thread (current-threads))])
(current-threads t*)
(if (eq? (%current-thread) (car t*))
(unlock!)
(abort-to-thread (car t*))))))
(define %thread-join!
(lambda (thread)
(do ()
((%thread-terminated? thread))
(%thread-yield!))))
(define abort-to-thread
(lambda (thread)
(set! *current-thread* thread)
((%thread-continuation thread)))))
;; Local Variables:
;; mode: scheme
;; End:
| false |
cafc6da1cca38772f819c435768ce58a793fe245
|
98fd12cbf428dda4c673987ff64ace5e558874c4
|
/sicp/v1/chapter-2.2/ndpar-2.2.scm
|
946d40c32d4a905a1f13b80701ddd6d3e81893b5
|
[
"Unlicense"
] |
permissive
|
CompSciCabal/SMRTYPRTY
|
397645d909ff1c3d1517b44a1bb0173195b0616e
|
a8e2c5049199635fecce7b7f70a2225cda6558d8
|
refs/heads/master
| 2021-12-30T04:50:30.599471 | 2021-12-27T23:50:16 | 2021-12-27T23:50:16 | 13,666,108 | 66 | 11 |
Unlicense
| 2019-05-13T03:45:42 | 2013-10-18T01:26:44 |
Racket
|
UTF-8
|
Scheme
| false | false | 12,939 |
scm
|
ndpar-2.2.scm
|
#lang racket
(define (inc n) (+ n 1))
(define (dec n) (- n 1))
(define id identity)
(define (apply1 p a) (p a))
(define (not-in item seq)
(not (member item seq)))
(define (square x) (* x x))
;; Exercise 2.17, p.103
;; Last element of the list
(define (last-pair lst)
(cond ((null? lst) null)
((null? (cdr lst)) (car lst))
(else (last-pair (cdr lst)))))
;(= 34 (last-pair (list 23 72 149 34)))
;(= 34 (last-pair (list 34)))
;(null? (last-pair null))
;; Exercise 2.18, p.103
;; Reversing list
(define (my-reverse lst)
(define (iter li acc)
(if (null? li)
acc
(iter (cdr li) (cons (car li) acc))))
(iter lst null))
;; Tests
;(let ((lst (list 25 16 9 4 1)))
; (equal? (reverse lst) (my-reverse lst)))
;; Exercise 2.19, p.103
;; Counting change (see also ndpar-1.2.tex)
(define (cc amount coin-values)
(cond ((= amount 0) 1)
((or (< amount 0) (no-more? coin-values)) 0)
(else
(+ (cc amount
(except-first-denomination coin-values))
(cc (- amount
(first-denomination coin-values))
coin-values)))))
(define no-more? null?)
(define except-first-denomination cdr)
(define first-denomination car)
(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))
;; Order of the coins does NOT affect the answer.
;(= 292 (cc 100 us-coins) (cc 100 (reverse us-coins)))
;; Exercise 2.20, p.104
;; Varargs: dotted-tail notation
(define (same-parity x . y)
(define (filter li acc)
(cond ((null? li) (reverse acc))
((even? (- x (car li))) (filter (cdr li)
(cons (car li) acc)))
(else (filter (cdr li) acc))))
(filter y (list x)))
;(equal? (same-parity 1 2 3 4 5 6 7) (list 1 3 5 7))
;(equal? (same-parity 2 3 4 5 6 7) (list 2 4 6))
;; Exercise 2.21, p.106
;; Map function
(define (square-list items)
(map square items))
(define (square-list-2 items)
(if (null? items)
null
(cons (square (car items))
(square-list-2 (cdr items)))))
;(equal? (list 1 4 9 16)
; (square-list (list 1 2 3 4)))
;(equal? (list 1 4 9 16)
; (square-list-2 (list 1 2 3 4)))
;; Exercise 2.22, p.106
;; Iterative map
(define (square-list-3 items)
(define (iter li acc)
(if (null? li)
(flatten acc) ; otherwise it's deeply unproper list
(iter (cdr li)
(cons acc (square (car li))))))
(iter items null))
;(equal? (list 1 4 9 16)
; (square-list-3 (list 1 2 3 4)))
;; Exercise 2.23, p.107
;; Iterating for side effects
(define (for-each p items)
(cond ((null? items) #t)
(else
(p (car items))
(for-each p (cdr items)))))
;(for-each (lambda (x) (newline) (display x))
; (list 57 321 88))
;; Exercise 2.25, p.110
(define (cadaddr x)
(car (cdaddr x)))
(define (cadadadadadadr x)
(cadadr (cadadr (cadadr x))))
;(cadaddr '(1 3 (5 7) 9))
;(caar '((7)))
;(cadadadadadadr '(1 (2 (3 (4 (5 (6 7)))))))
;; Exercise 2.26, p.110
;(define x (list 1 2 3))
;(define y (list 4 5 6))
;(append x y)
;(cons x y)
;(list x y)
;; Exercise 2.27, p.110
;; Reversing trees
(define (deep-reverse-2 tree)
(define (iter li acc)
(cond ((null? li) acc)
((pair? (car li))
(iter (cdr li)
(cons (deep-reverse-2 (car li)) acc)))
(else (iter (cdr li)
(cons (car li) acc)))))
(iter tree null))
(define (deep-reverse tree)
(define (iter li acc)
(if (null? li)
acc
(iter (cdr li)
(cons (deep-reverse (car li))
acc))))
(if (pair? tree)
(iter tree null)
tree))
;(equal? '((4 3) (2 1))
; (deep-reverse '((1 2) (3 4))))
;; Exercise 2.28, p.111
(define (fringe tree)
(cond ((null? tree) null)
((not (pair? tree)) (list tree))
(else (append (fringe (car tree))
(fringe (cdr tree))))))
;(define x '((1 2) (3 4)))
;(equal? '(1 2 3 4) (fringe x))
;(equal? '(1 2 3 4 1 2 3 4)
; (fringe (list x x)))
;(equal? '(1 2 3 4 1 2 3 4)
; (fringe '((1 ((2 ((3 (4 1)) 2)) 3)) 4)))
;; Exercise 2.29, p.111
(define (make-mobile left right)
(list left right))
(define left-branch car)
(define right-branch cadr)
(define (total-weight mobile)
(+ (branch-weight (left-branch mobile))
(branch-weight (right-branch mobile))))
;; structure is either number (weight)
;; or another mobile
(define (make-branch length structure)
(list length structure))
(define mobile-structure? pair?)
(define branch-length car)
(define branch-structure cadr)
(define (branch-weight branch)
(let ((struct (branch-structure branch)))
(if (mobile-structure? struct)
(total-weight struct)
struct)))
(define (torque branch)
(* (branch-length branch)
(branch-weight branch)))
(define (branch-balanced? branch)
(let ((struct (branch-structure branch)))
(if (mobile-structure? struct)
(balanced? struct)
#t)))
;; Mobile is balanced iff
;; 1) left and right torques are equal
;; 2) all sbumobiles are balanced
(define (balanced? mobile)
(let ((lbranch (left-branch mobile))
(rbranch (right-branch mobile)))
(and (= (torque lbranch) (torque rbranch))
(branch-balanced? lbranch)
(branch-balanced? rbranch))))
;; Alternative representation
;(define (make-mobile left right)
; (cons left right))
;(define right-branch cdr) ; cadr -> cdr
;(define (make-branch length structure)
; (cons length structure))
;(define branch-structure cdr) ; cadr -> cdr
;; Tests
;(define mobile (make-mobile (make-branch 10 3)
; (make-branch 5 (make-mobile (make-branch 1 4)
; (make-branch 2 2)))))
;(= 9 (total-weight mobile))
;(balanced? mobile)
;; Exercise 2.30, p.112
;; Squaring trees
(define (square-tree-1 tree)
(map (lambda (x)
(if (pair? x)
(square-tree-1 x)
(square x)))
tree))
(define (square-tree-2 tree)
(cond ((null? tree) null)
((not (pair? tree)) (square tree))
(else (cons (square-tree-2 (car tree))
(square-tree-2 (cdr tree))))))
;; Exercise 2.31, p.113
;; Mapping over trees
(define (tree-map f tree)
(map (lambda (x)
(if (pair? x)
(tree-map f x)
(f x)))
tree))
(define (square-tree tree)
(tree-map square tree))
;; Tests
(let ((tree '(1 (2 (3 4) 5) (6 7)))
(result '(1 (4 (9 16) 25) (36 49))))
(and (equal? result (square-tree tree))
(equal? result (square-tree-1 tree))
(equal? result (square-tree-2 tree))))
;; Exercise 2.32, p.113
;; Set of all subsets
(define (subsets s)
(if (null? s)
(list null)
(let ((rst (subsets (cdr s))))
(append rst (map (lambda (x) (cons (car s) x))
rst)))))
;; Tests
(equal? '(() (3) (2) (2 3) (1) (1 3) (1 2) (1 2 3))
(subsets '(1 2 3)))
;; Exercise 2.33, p.119
;; Accumulate (right fold) as a fundametal operation of FP
(define (accumulate op initial seq)
(if (null? seq)
initial
(op (car seq)
(accumulate op initial (cdr seq)))))
(define fold-right accumulate)
(define (map-2 p seq)
(accumulate (lambda (x y) (cons (p x) y)) null seq))
(define (append-2 seq1 seq2)
(accumulate cons seq2 seq1))
(define (length-2 seq)
(accumulate (lambda (_ n) (inc n)) 0 seq))
;; Tests
(equal? '(1 4 9 16) (map-2 square '(1 2 3 4)))
(equal? '(1 2 3 4) (append-2 '(1 2) '(3 4)))
(= 4 (length-2 '(1 2 3 4)))
;; Exercise 2.34, p.119
;; Horner's rule
(define (horner-eval x coefficients)
(accumulate (lambda (coeff higher-terms)
(+ (* higher-terms x) coeff))
0
coefficients))
;; Tests
(= 79 (horner-eval 2 '(1 3 0 5 0 1)))
;; Exercise 2.35, p.120
(define (count-leaves tree)
(accumulate + 0 (map (lambda (t)
(if (pair? t)
(count-leaves t)
1))
tree)))
;; Tests
(let ((x '((1 2) (3 4))))
(= 8 (count-leaves (list x x))))
;; Exercise 2.36, p.120
(define (accumulate-n op init seqs)
(if (null? (car seqs))
null
(cons (accumulate op init (map car seqs))
(accumulate-n op init (map cdr seqs)))))
;; Tests
(equal? (accumulate-n + 0 '(( 1 2 3)
( 4 5 6)
( 7 8 9)
(10 11 12)))
'(22 26 30))
;; Exercise 2.37, p.120
;; Vector algebra
(define (dot-product v w)
(accumulate + 0 (map * v w)))
(define (matrix-*-vector m v)
(map (lambda (x) (dot-product v x)) m))
(define (transpose m)
(accumulate-n cons null m))
(define (matrix-*-matrix m n)
(let ((cols (transpose n)))
(map (lambda (x) (matrix-*-vector cols x)) m)))
;; Tests
(define a '((1 2 3 4)
(4 5 6 6)
(6 7 8 9)))
(define b '(( 1 2 0)
( 2 1 -1)
(-1 1 2)
( 0 -1 1)))
(define v '(1 0 -1 2))
(equal? (matrix-*-vector a v)
'(6 10 16))
(equal? (transpose a)
'((1 4 6)
(2 5 7)
(3 6 8)
(4 6 9)))
(equal? (matrix-*-matrix a b)
'(( 2 3 8)
( 8 13 13)
(12 18 18)))
;; Exercise 2.38, p.121
(define (fold-left op initial seq)
(define (iter acc rest)
(if (null? rest)
acc
(iter (op acc (car rest))
(cdr rest))))
(iter initial seq))
;; Tests
(= 3/2 (fold-right / 1 '(1 2 3)))
(= 1/6 (fold-left / 1 '(1 2 3)))
(equal? (fold-right list null '(1 2 3))
'(1 (2 (3 ()))))
(equal? (fold-left list null '(1 2 3))
'(((() 1) 2) 3))
;; For commutative operations left fold
;; yields the same result as right fold
(equal? (fold-right * 1 '(1 2 3))
(fold-left * 1 '(1 2 3)))
;; Exercise 2.39, p.122
;; Reverse through fold
(define (reverse-right seq)
(fold-right (lambda (x acc) (append acc (list x)))
null
seq))
(define (reverse-left seq)
(fold-left (lambda (acc x) (cons x acc))
null
seq))
;; Tests
(let ((lst (list 25 16 9 4 1)))
(and (equal? (reverse lst) (reverse-right lst))
(equal? (reverse lst) (reverse-left lst))))
;; Flatmap
(define (flatmap f seq)
(fold-right append null (map f seq)))
;; Exercise 2.40, p.124
;; { (i,j) : 1 ≤ j < i ≤ n }
(define (unique-pairs n)
(flatmap (lambda (i)
(map (lambda (j) (list i j))
(range 1 i)))
(range 2 (inc n))))
;; Tests
(equal? '((2 1) (3 1) (3 2) (4 1) (4 2) (4 3) (5 1) (5 2) (5 3) (5 4))
(unique-pairs 5))
;; Exercise 2.41, p.124
(define (exercise-2.41 s n)
(filter-sum s (unique-triples n)))
(define (filter-sum s seq)
(filter (lambda (c) (= s (sum c)))
seq))
(define (sum seq) (fold-left + 0 seq))
(define (unique-triples n)
(flatmap (lambda (pair)
(map (lambda (k) (cons k pair))
(range (inc (car pair)) (inc n))))
(unique-pairs (dec n))))
;; Tests
(equal? '((5 2 1) (4 3 1))
(exercise-2.41 8 5))
;; Exercise 2.42, p.124
;; Eight-queens puzzle
(define (queens board-size)
(define (queen-cols k)
(if (= k 0)
(list empty-board)
(filter
(lambda (positions) (safe? k positions))
(flatmap
(lambda (rest-of-queens)
(map (lambda (new-row)
(adjoin-position new-row k rest-of-queens))
(range 1 (inc board-size))))
(queen-cols (dec k))))))
(queen-cols board-size))
;; NB: In the following procedures K is not used!
;; What data structure requires K?
(define empty-board null)
(define (adjoin-position new-row _ rest-of-queens)
(cons new-row rest-of-queens))
(define (safe? _ positions)
; queen checks horizontally and diagonally
(define (next-checked-positions positions)
(map apply1 (list dec id inc) positions))
(define (safe-positions? checked-positions positions)
(if (null? positions)
#t
(and (not-in (car positions) checked-positions)
(safe-positions? (next-checked-positions checked-positions)
(cdr positions)))))
(let ((pos (car positions)))
(safe-positions? (next-checked-positions (list pos pos pos))
(cdr positions))))
;; Tests
(= (length (queens 0)) 1)
(= (length (queens 1)) 1)
(= (length (queens 2)) 0)
(= (length (queens 3)) 0)
(= (length (queens 4)) 2)
(= (length (queens 5)) 10)
(= (length (queens 6)) 4)
(= (length (queens 7)) 40)
(= (length (queens 8)) 92)
;(member '(6 2 7 1 4 8 5 3) (queens 8))
(equal? '((5 3 1 6 4 2) (4 1 5 2 6 3) (3 6 2 5 1 4) (2 4 6 1 3 5))
(queens 6))
;; Exercise 2.43, p.126
;; It seems that Luois' time is O(n^n),
;; while the original time is O(n^2).
;; I don't have formal proof yet.
| false |
f5cb54457e0d37d6fe081d2746e1b68deae19232
|
190af72b5df9ab2da787f7e44b3d3830f3df902b
|
/unlib-build.ss
|
be88e143d27d356d05438167b81654115c75b5a4
|
[] |
no_license
|
noelwelsh/build-tools
|
3704a590f516448d7f8c2c30d5b05d4998400f4d
|
a83587cfeb96ed3685f680787a165302bfb1a995
|
refs/heads/master
| 2019-01-02T04:42:42.267258 | 2009-01-10T20:56:15 | 2009-01-10T20:56:15 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,130 |
ss
|
unlib-build.ss
|
#lang scheme/base
(require web-server/templates
(planet schematics/sake:1)
"build/info.ss"
(prefix-in action: "build/licence.ss")
(prefix-in action: "build/stage.ss"))
; package-info
(define info
(make-package-info (current-directory)))
; (U 'plain 'scheme) -> string
(define make-licence
(action:licence-maker info "COPYING-template"))
; path
(define build-dir
(build-path (current-directory) "sake-build"))
; Sake tasks -------------------------------------
(define-task compile
()
(action:compile "all-tests.ss")
(action:compile "main.ss"))
(define-task recreate-licence-file
()
(action:recreate-licence-file
(build-path (current-directory) (package-info-licence-file info))
(make-licence 'plain)))
(define-task stage-to-build-dir
(compile recreate-licence-file)
(action:stage-to-build-dir build-dir)
(action:licence-scheme-files build-dir (make-licence 'scheme)))
(define-task test
(stage-to-build-dir)
(action:test
(build-path build-dir (package-info-test-file info))
(package-info-test-suite info)))
(define-task default
(test)
(void))
| false |
5708ffc7a06810723eac6d7e44d85d0dde28378f
|
6488db22a3d849f94d56797297b2469a61ad22bf
|
/test/test.scm
|
718e976312ae19e95eb3c8e57abd4dc82b6935a3
|
[] |
no_license
|
bazurbat/chicken-eggs
|
34d8707cecbbd4975a84ed9a0d7addb6e48899da
|
8e741148d6e0cd67a969513ce2a7fe23241df648
|
refs/heads/master
| 2020-05-18T05:06:02.090313 | 2015-11-18T16:07:12 | 2015-11-18T16:07:12 | 22,037,751 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,289 |
scm
|
test.scm
|
;;;; test.scm -- simple friendly test suite
;;
;; Copyright (c) 2007-2008 Alex Shinn. All rights reserved.
;; BSD-style license: http://synthcode.com/license.txt
(module test
(test test-error test-assert
test-group test-group-inc! current-test-group
test-begin test-end test-syntax-error test-info
test-vars test-run test-exit
current-test-verbosity current-test-epsilon current-test-comparator
current-test-applier current-test-handler current-test-skipper
current-test-group-reporter test-failure-count test-total-count)
(import scheme chicken)
(include "test-support.scm")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; test interface
(define-syntax test
(syntax-rules ()
((test expect expr)
(test #f expect expr))
((test name expect (expr ...))
(test-info name expect (expr ...) ()))
((test name (expect ...) expr)
(test-syntax-error
'test
"the test expression should come last "
(test name (expect ...) expr)))
((test name expect expr)
(test-info name expect expr ()))
((test a ...)
(test-syntax-error 'test "2 or 3 arguments required"
(test a ...)))
))
(define-syntax test-assert
(syntax-rules ()
((_ expr)
(test-assert #f expr))
((_ name expr)
(test-info name #f expr ((assertion . #t))))
((test a ...)
(test-syntax-error 'test-assert "1 or 2 arguments required"
(test a ...)))
))
(define-syntax test-error
(syntax-rules ()
((_ expr)
(test-error #f expr))
((_ name expr)
(test-info name #f expr ((expect-error . #t))))
((test a ...)
(test-syntax-error 'test-error "1 or 2 arguments required"
(test a ...)))
))
;; (define-syntax test-error*
;; (syntax-rules ()
;; ((_ ?msg (?error-type ...) ?expr)
;; (let-syntax ((expression:
;; (syntax-rules ()
;; ((_ ?expr)
;; (condition-case (begin ?expr "<no error thrown>")
;; ((?error-type ...) '(?error-type ...))
;; (exn () (##sys#slot exn 1)))))))
;; (test ?msg '(?error-type ...) (expression: ?expr))))
;; ((_ ?msg ?error-type ?expr)
;; (test-error* ?msg (?error-type) ?expr))
;; ((_ ?error-type ?expr)
;; (test-error* (sprintf "~S" '?expr) ?error-type ?expr))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; group interface
(define-syntax test-group
(syntax-rules ()
((_ name-expr body ...)
(let ((name name-expr)
(old-group (current-test-group)))
(if (not (string? name))
(syntax-error 'test-group "a name is required, got " 'name-expr name))
(test-begin name)
(condition-case (begin body ...)
(e ()
(warning "error in group outside of tests")
(print-error-message e)
(test-group-inc! (current-test-group) 'count)
(test-group-inc! (current-test-group) 'ERROR)))
(test-end name)
(current-test-group old-group)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; utilities
(define-syntax test-syntax-error
(syntax-rules ()
((_) (syntax-error "invalid use of test-syntax-error"))))
(define-syntax test-info
(syntax-rules ()
((test-info name expect expr info)
(test-vars () name expect expr ((source . expr) . info)))))
(define-syntax test-vars
(syntax-rules ()
;; Consider trying to determine "interesting" variables as in
;; Oleg's ASSERT macro (which unfortunately requires code walking
;; to detect lambda's, a point Oleg ignores). We could hack it by
;; not walking into let/lambda's and/or wrapping the value binding
;; in error handlers.
((_ (vars ...) n expect expr ((key . val) ...))
(test-run (lambda () expect)
(lambda () expr)
(cons (cons 'name n)
'((source . expr)
;;(var-names . (vars ...))
;;(var-values . ,(list vars))
(key . val) ...)))))))
| true |
b0073cd7ec4ea9cdeb167f8c55fccb3b9c0b7457
|
08b21a94e7d29f08ca6452b148fcc873d71e2bae
|
/src/scheme/read.sld
|
2ef638274c427a455ee0d4d3b88cce996feeb52c
|
[
"MIT"
] |
permissive
|
rickbutton/loki
|
cbdd7ad13b27e275bb6e160e7380847d7fcf3b3a
|
7addd2985de5cee206010043aaf112c77e21f475
|
refs/heads/master
| 2021-12-23T09:05:06.552835 | 2021-06-13T08:38:23 | 2021-06-13T08:38:23 | 200,152,485 | 21 | 1 |
NOASSERTION
| 2020-07-16T06:51:33 | 2019-08-02T02:42:39 |
Scheme
|
UTF-8
|
Scheme
| false | false | 374 |
sld
|
read.sld
|
(define-library (scheme read)
(import (loki core primitives))
(import (only (loki core reader) make-reader read-datum))
(import (loki core io))
(import (loki core case-lambda))
(export read)
(begin
(define read
(case-lambda
(() (read-datum (make-reader (current-input-port) "<read>")))
((port) (read-datum (make-reader port "<read>")))))))
| false |
6f0c409b82e574fccc4a9ba7abdb22a8bfcdcc76
|
4b480cab3426c89e3e49554d05d1b36aad8aeef4
|
/chapter-04/ex4.58-dgoon.scm
|
b4304adebab57b71cfdfdac2c56546dffe04e9ef
|
[] |
no_license
|
tuestudy/study-sicp
|
a5dc423719ca30a30ae685e1686534a2c9183b31
|
a2d5d65e711ac5fee3914e45be7d5c2a62bfc20f
|
refs/heads/master
| 2021-01-12T13:37:56.874455 | 2016-10-04T12:26:45 | 2016-10-04T12:26:45 | 69,962,129 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 600 |
scm
|
ex4.58-dgoon.scm
|
; ex4.58-dgoon.scm
; mzscheme -f ch4-query.scm < ex4.58-dgoon.scm
(rule (big shot ?person)
(and (job ?person (?division . ?r1))
(or (not (supervisor ?person ?anybody))
(and (supervisor ?person ?s-person)
(job ?s-person (?s-division . ?r2))
(not (same ?division ?s-division))))))
(rule (supervisor in same division ?person)
(and (job ?person (?d . ?x))
(job ?s-person (?d . ?y))
(supervisor ?person ?s-person)))
(rule (big shot2 ?who)
(and (job ?who ?j)
(not (supervisor in same division ?who))))
(big shot ?who)
(big shot2 ?who)
| false |
01f4da8917d2d1341b5b36fadc573a5f783a59ae
|
15b3f9425594407e43dd57411a458daae76d56f6
|
/bin/test/load2.scm
|
b7da96d89d57d165d62b8040533d4acd61adb757
|
[] |
no_license
|
aa10000/scheme
|
ecc2d50b9d5500257ace9ebbbae44dfcc0a16917
|
47633d7fc4d82d739a62ceec75c111f6549b1650
|
refs/heads/master
| 2021-05-30T06:06:32.004446 | 2015-02-12T23:42:25 | 2015-02-12T23:42:25 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 156 |
scm
|
load2.scm
|
(display "start load scm/load2.scm")
(newline)
(display (current-input-port))
(newline)
(load "scm/load3.scm")
(display "end load scm/load2.scm")
(newline)
| false |
abd006e54a8caf35842f78f461fe8a6179961f36
|
120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193
|
/packages/surfage/s23/error.sls
|
4cec7b3d00a5ec960b78d81a2fffb150cdd94135
|
[
"X11-distribute-modifications-variant",
"MIT"
] |
permissive
|
evilbinary/scheme-lib
|
a6d42c7c4f37e684c123bff574816544132cb957
|
690352c118748413f9730838b001a03be9a6f18e
|
refs/heads/master
| 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 |
MIT
| 2022-06-16T05:54:55 | 2016-12-13T06:27:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 483 |
sls
|
error.sls
|
#!r6rs
;; Copyright (c) 2009 Derick Eddington. All rights reserved.
;; Licensed under an MIT-style license. My license is in the file
;; named LICENSE from the original collection this file is distributed
;; with. If this file is redistributed with some other collection, my
;; license must also be included.
(library (surfage s23 error)
(export
error)
(import
(rename (rnrs base) (error rnrs:error)))
(define (error . args)
(apply rnrs:error #F args))
)
| false |
d7ec04d205b03ff09045f49909eb48e96c87cf58
|
370ebaf71b077579ebfc4d97309ce879f97335f7
|
/sicp-old/TestTree.sld
|
669f56de3453797977139e7e142b954b42f2237a
|
[] |
no_license
|
jgonis/sicp
|
7f14beb5b65890a86892a05ba9e7c59fc8bceb80
|
fd46c80b98c408e3fd18589072f02ba444d35f53
|
refs/heads/master
| 2023-08-17T11:52:23.344606 | 2023-08-13T22:20:42 | 2023-08-13T22:20:42 | 376,708,557 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 189 |
sld
|
TestTree.sld
|
(include "tree.sld")
(define-library (sicp test-binary-tree)
(export test-all)
(import (scheme base)
(srfi 78)
(sicp tree-lib))
(begin
(define (test-all) 1)))
| false |
270fb25b6651ed5faccf294bfa923c7b9dc304d9
|
378e5f5664461f1cc3031c54d243576300925b40
|
/rsauex/home/services/rofi.scm
|
5bd6bb2a83bfd4d6add72f5cf107f6883cf7e8b4
|
[] |
no_license
|
rsauex/dotfiles
|
7a787f003a768699048ffd068f7d2b53ff673e39
|
77e405cda4277e282725108528874b6d9ebee968
|
refs/heads/master
| 2023-08-07T17:07:40.074456 | 2023-07-30T12:59:48 | 2023-07-30T12:59:48 | 97,400,340 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,552 |
scm
|
rofi.scm
|
(define-module (rsauex home services rofi)
#:use-module ((gnu home services))
#:use-module ((gnu packages xdisorg) #:prefix xdisorg:)
#:use-module ((gnu services configuration))
#:use-module ((gnu services))
#:use-module ((guix gexp))
#:use-module ((guix packages))
#:use-module ((ice-9 match))
#:export (rofi-configuration
rofi-configuration-package
rofi-configuration-config
rofi-configuration-theme
rofi-service-type))
(define (rofi-serialize-config field-name val)
#~(begin
(use-modules (ice-9 string-fun))
(let ((serialize-value
(lambda (value)
(cond
((string? value)
(string-append "\"" (string-replace-substring value "\"" "\\\"") "\""))
((number? value)
(number->string value))
(#t
(raise "Only string and number values are supported currently"))))))
(string-append
"configuration {\n"
#$@(map (match-lambda
((key . value)
#~(string-append #$key ": " (serialize-value #$value) ";\n")))
val)
"}\n"))))
(define (rofi-serialize-theme field-name val)
#~(let ((val #$val))
(if (unspecified? val)
""
(string-append "@theme \"" #$val "\"\n"))))
(define-maybe file-like)
(define-configuration rofi-configuration
(package
(package xdisorg:rofi)
"The Rofi package to use.")
(config
(alist '())
"Association list of configuration options."
(serializer rofi-serialize-config))
(theme
(maybe-file-like)
"File-like with theme."
(serializer rofi-serialize-theme)))
(define (add-rofi-configuration config)
`(("rofi/config.rasi"
,(mixed-text-file
"config_rasi"
(rofi-serialize-config 'config (rofi-configuration-config config))
(rofi-serialize-theme 'theme (rofi-configuration-theme config))))))
(define (add-rofi-package config)
(list (rofi-configuration-package config)))
(define rofi-service-type
(service-type (name 'rofi)
(extensions
(list (service-extension
home-xdg-configuration-files-service-type
add-rofi-configuration)
(service-extension
home-profile-service-type
add-rofi-package)))
(default-value (rofi-configuration))
(description "Install and configure Rofi.")))
| false |
c05ebfd79319e53cc62ee7e259cf2fa67bedbbab
|
e8e2b3f22c7e1921e99f44593fc0ba5e5e44eebb
|
/PortableApps/GnuCashPortable/App/GnuCash/share/gnucash/scm/gnucash/report/standard-reports/register.scm
|
da9bd8e58408145f29aa86db97848bc7c0204954
|
[] |
no_license
|
314pi/PortableOffice
|
da262df5eaca240a00921e8348d366efa426ae57
|
08a5e828b35ff3cade7c56d101d7f6712b19a308
|
refs/heads/master
| 2022-11-25T19:20:33.942725 | 2018-05-11T07:49:35 | 2018-05-11T07:49:35 | 132,839,264 | 1 | 2 | null | 2022-11-02T22:19:00 | 2018-05-10T02:42:46 |
Python
|
UTF-8
|
Scheme
| false | false | 36,328 |
scm
|
register.scm
|
;; -*-scheme-*-
;; register.scm
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2 of
;; the License, or (at your option) any later version.
;;
;; 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, contact:
;;
;; Free Software Foundation Voice: +1-617-542-5942
;; 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652
;; Boston, MA 02110-1301, USA [email protected]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-module (gnucash report standard-reports register))
(use-modules (gnucash main)) ;; FIXME: delete after we finish modularizing.
(use-modules (srfi srfi-1))
(use-modules (gnucash gnc-module))
(use-modules (gnucash gettext))
(gnc:module-load "gnucash/report/report-system" 0)
(define-macro (addto! alist element)
`(set! ,alist (cons ,element ,alist)))
(define (set-last-row-style! table tag . rest)
(let ((arg-list
(cons table
(cons (- (gnc:html-table-num-rows table) 1)
(cons tag rest)))))
(apply gnc:html-table-set-row-style! arg-list)))
(define (date-col columns-used)
(vector-ref columns-used 0))
(define (num-col columns-used)
(vector-ref columns-used 1))
(define (description-col columns-used)
(vector-ref columns-used 2))
(define (memo-col columns-used)
(vector-ref columns-used 3))
(define (account-col columns-used)
(vector-ref columns-used 4))
(define (shares-col columns-used)
(vector-ref columns-used 5))
(define (price-col columns-used)
(vector-ref columns-used 6))
(define (amount-single-col columns-used)
(vector-ref columns-used 7))
(define (debit-col columns-used)
(vector-ref columns-used 8))
(define (credit-col columns-used)
(vector-ref columns-used 9))
(define (balance-col columns-used)
(vector-ref columns-used 10))
(define (value-single-col columns-used)
(vector-ref columns-used 11))
(define (value-debit-col columns-used)
(vector-ref columns-used 12))
(define (value-credit-col columns-used)
(vector-ref columns-used 13))
(define (lot-col columns-used)
(vector-ref columns-used 14))
(define columns-used-size 15)
(define (num-columns-required columns-used)
(do ((i 0 (+ i 1))
(col-req 0 col-req))
((>= i columns-used-size) col-req)
(if (vector-ref columns-used i)
(set! col-req (+ col-req 1)))))
(define (build-column-used options)
(define (opt-val section name)
(gnc:option-value
(gnc:lookup-option options section name)))
(define (make-set-col col-vector)
(let ((col 0))
(lambda (used? index)
(if used?
(begin
(vector-set! col-vector index col)
(set! col (+ col 1)))
(vector-set! col-vector index #f)))))
(let* ((col-vector (make-vector columns-used-size #f))
(set-col (make-set-col col-vector)))
(set-col (opt-val "Display" "Date") 0)
(set-col (if (gnc:lookup-option options "Display" "Num")
(opt-val "Display" "Num")
(opt-val "Display" "Num/Action")) 1)
(set-col
(if (opt-val "__reg" "journal")
(or (opt-val "Display" "Memo") (opt-val "Display" "Description") (opt-val "__reg" "double") )
(opt-val "Display" "Description")
)
2)
(set-col
(if (opt-val "__reg" "journal")
#f
(opt-val "Display" "Memo")
)
3)
(set-col (opt-val "Display" "Account") 4)
(set-col (opt-val "Display" "Shares") 5)
(set-col (opt-val "Display" "Lot") 14)
(set-col (opt-val "Display" "Price") 6)
(let ((invoice? #f)
(amount-setting (opt-val "Display" "Amount")))
(if (or invoice? (eq? amount-setting 'single))
(set-col #t 7)
(begin
(set-col #t 8)
(set-col #t 9))))
(if (opt-val "Display" "Value")
(if (amount-single-col col-vector)
(set-col #t 11)
(begin
(set-col #t 12)
(set-col #t 13))))
(set-col (opt-val "Display" "Running Balance") 10)
col-vector))
(define (make-heading-list column-vector
debit-string credit-string amount-string
multi-rows? action-for-num? ledger-type?)
(let ((heading-list '()))
(gnc:debug "Column-vector" column-vector)
(if (date-col column-vector)
(addto! heading-list (_ "Date")))
(if (num-col column-vector)
(addto! heading-list (if action-for-num?
(if ledger-type?
(_ "T-Num")
(_ "Num/Action"))
(_ "Num"))))
(if (description-col column-vector)
(addto! heading-list (_ "Description")))
(if (memo-col column-vector)
(addto! heading-list (_ "Memo")))
(if (account-col column-vector)
(addto! heading-list (if multi-rows?
(_ "Account")
(_ "Transfer"))))
(if (shares-col column-vector)
(addto! heading-list (_ "Shares")))
(if (lot-col column-vector)
(addto! heading-list (_ "Lot")))
(if (price-col column-vector)
(addto! heading-list (_ "Price")))
(if (amount-single-col column-vector)
(addto! heading-list amount-string))
(if (debit-col column-vector)
(addto! heading-list debit-string))
(if (credit-col column-vector)
(addto! heading-list credit-string))
(if (value-single-col column-vector)
(addto! heading-list (_ "Value")))
(if (value-debit-col column-vector)
(addto! heading-list (_ "Debit Value")))
(if (value-credit-col column-vector)
(addto! heading-list (_ "Credit Value")))
(if (balance-col column-vector)
(addto! heading-list (_ "Balance")))
(reverse heading-list)))
(define (gnc:split-get-balance-display split-info? split)
(let* ((account (xaccSplitGetAccount split))
(balance
(if split-info?
(xaccSplitGetBalance split)
(xaccTransGetAccountBalance
(xaccSplitGetParent split) account))))
(if (and (not (null? account)) (gnc-reverse-balance account))
(gnc-numeric-neg balance)
balance)))
(define (add-split-row table split column-vector row-style transaction-info?
split-info? action-for-num? ledger-type? double? memo?
description? total-collector)
(let* ((row-contents '())
(parent (xaccSplitGetParent split))
(account (xaccSplitGetAccount split))
(currency (if (not (null? account))
(xaccAccountGetCommodity account)
(gnc-default-currency)))
(trans-currency (xaccTransGetCurrency parent))
(damount (xaccSplitGetAmount split))
(split-value (gnc:make-gnc-monetary currency damount)))
(if (date-col column-vector)
(addto! row-contents
(if transaction-info?
(gnc:make-html-table-cell/markup
"date-cell"
(gnc-print-date
(gnc-transaction-get-date-posted parent)))
" ")))
(if (num-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if transaction-info?
(if (and action-for-num? ledger-type?)
(gnc-get-num-action parent #f)
(gnc-get-num-action parent split))
(if split-info?
(gnc-get-action-num #f split)
" ")))))
(if (description-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if transaction-info?
(if description?
(xaccTransGetDescription parent)
" " )
(if split-info?
(if memo?
(xaccSplitGetMemo split)
" ")
" ")))))
(if (memo-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if transaction-info?
(xaccSplitGetMemo split)
" "))))
(if (account-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if split-info?
(if transaction-info?
(let ((other-split
(xaccSplitGetOtherSplit split)))
(if (not (null? other-split))
(gnc-account-get-full-name
(xaccSplitGetAccount other-split))
(_ "-- Split Transaction --")))
(gnc-account-get-full-name account))
" "))))
(if (shares-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if split-info?
(xaccSplitGetAmount split)
" "))))
(if (lot-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if split-info?
(gnc-lot-get-title (xaccSplitGetLot split))
" "))))
(if (price-col column-vector)
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if split-info?
(gnc:make-gnc-monetary
currency (xaccSplitGetSharePrice split))
" "))))
(if (amount-single-col column-vector)
(addto! row-contents
(if split-info?
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:html-split-anchor split split-value))
" ")))
(if (debit-col column-vector)
(if (gnc-numeric-positive-p (gnc:gnc-monetary-amount split-value))
(addto! row-contents
(if split-info?
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:html-split-anchor split split-value))
" "))
(addto! row-contents " ")))
(if (credit-col column-vector)
(if (gnc-numeric-negative-p (gnc:gnc-monetary-amount split-value))
(addto! row-contents
(if split-info?
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:html-split-anchor
split (gnc:monetary-neg split-value)))
" "))
(addto! row-contents " ")))
(if (value-single-col column-vector)
(addto! row-contents
(if split-info?
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:make-gnc-monetary trans-currency
(xaccSplitGetValue split)))
" ")))
(if (value-debit-col column-vector)
(addto! row-contents
(if (and split-info? (gnc-numeric-positive-p (xaccSplitGetValue split)))
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:make-gnc-monetary trans-currency
(xaccSplitGetValue split)))
" ")))
(if (value-credit-col column-vector)
(addto! row-contents
(if (and split-info? (gnc-numeric-negative-p (xaccSplitGetValue split)))
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:make-gnc-monetary trans-currency
(gnc-numeric-neg (xaccSplitGetValue split))))
" ")))
; For single account registers, use the split's cached balance to remain
; consistent with the balances shown in the register itself
; For others, use the cumulated balance from the totals-collector
(if (balance-col column-vector)
(addto! row-contents
(if transaction-info?
(gnc:make-html-table-cell/markup
"number-cell"
(gnc:html-split-anchor
split
(gnc:make-gnc-monetary
currency
(if ledger-type?
(cadr (total-collector 'getpair currency #f))
(xaccSplitGetBalance split)))))
" ")))
(gnc:html-table-append-row/markup! table row-style
(reverse row-contents))
(if (and double? transaction-info?)
(if (or (num-col column-vector) (description-col column-vector))
(begin
(let ((count 0))
(set! row-contents '())
(if (date-col column-vector)
(begin
(set! count (+ count 1))
(addto! row-contents " ")))
(if (and (num-col column-vector) (description-col column-vector))
(begin
(set! count (+ count 1))
(addto! row-contents
(gnc:make-html-table-cell/markup
"text-cell"
(if (and action-for-num? (not ledger-type?))
(gnc-get-num-action parent #f)
" ")))))
(if (description-col column-vector)
(addto! row-contents ;;
(gnc:make-html-table-cell/size
1 (- (num-columns-required column-vector) count)
(xaccTransGetNotes parent)))
(gnc:make-html-table-cell/size
1 (- (num-columns-required column-vector) (- count 1))
(if (and action-for-num? (not ledger-type?))
(gnc-get-num-action parent #f)
" ")))
(gnc:html-table-append-row/markup! table row-style
(reverse row-contents))))))
split-value))
(define (lookup-sort-key sort-option)
(vector-ref (cdr (assq sort-option comp-funcs-assoc-list)) 0))
(define (lookup-subtotal-pred sort-option)
(vector-ref (cdr (assq sort-option comp-funcs-assoc-list)) 1))
(define (options-generator)
(define gnc:*report-options* (gnc:new-options))
(define (gnc:register-reg-option new-option)
(gnc:register-option gnc:*report-options* new-option))
(gnc:register-reg-option
(gnc:make-query-option "__reg" "query" '()))
(gnc:register-reg-option
(gnc:make-internal-option "__reg" "journal" #f))
(gnc:register-reg-option
(gnc:make-internal-option "__reg" "ledger-type" #f))
(gnc:register-reg-option
(gnc:make-internal-option "__reg" "double" #f))
(gnc:register-reg-option
(gnc:make-internal-option "__reg" "debit-string" (_ "Debit")))
(gnc:register-reg-option
(gnc:make-internal-option "__reg" "credit-string" (_ "Credit")))
(gnc:register-reg-option
(gnc:make-string-option
(N_ "General") (N_ "Title")
"a" (N_ "The title of the report.")
(N_ "Register Report")))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Date")
"b" (N_ "Display the date?") #t))
(if (qof-book-use-split-action-for-num-field (gnc-get-current-book))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Num/Action")
"c" (N_ "Display the check number/action?") #t))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Num")
"c" (N_ "Display the check number?") #t)))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Description")
"d" (N_ "Display the description?") #t))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Memo")
"e" (N_ "Display the memo?") #t))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Account")
"g" (N_ "Display the account?") #t))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Shares")
"ha" (N_ "Display the number of shares?") #f))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Lot")
"hb" (N_ "Display the name of lot the shares are in?") #f))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Price")
"hc" (N_ "Display the shares price?") #f))
(gnc:register-reg-option
(gnc:make-multichoice-option
(N_ "Display") (N_ "Amount")
"ia" (N_ "Display the amount?")
'double
(list
(vector 'single (N_ "Single") (N_ "Single Column Display."))
(vector 'double (N_ "Double") (N_ "Two Column Display.")))))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Value")
"ib" (N_ "Display the value in transaction currency?") #f))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Running Balance")
"k" (N_ "Display a running balance?") #t))
(gnc:register-reg-option
(gnc:make-simple-boolean-option
(N_ "Display") (N_ "Totals")
"l" (N_ "Display the totals?") #t))
(gnc:options-set-default-section gnc:*report-options* "General")
gnc:*report-options*)
;; -----------------------------------------------------------------
;; create the report result
;; -----------------------------------------------------------------
(define (make-split-table splits options
debit-string credit-string amount-string)
;; ----------------------------------
;; local helper
;; ----------------------------------
(define (opt-val section name)
(gnc:option-value (gnc:lookup-option options section name)))
(define (reg-report-journal?)
(opt-val "__reg" "journal"))
(define (reg-report-ledger-type?)
(opt-val "__reg" "ledger-type"))
(define (reg-report-double?)
(opt-val "__reg" "double"))
(define (reg-report-invoice?)
#f)
(define (reg-report-show-totals?)
(opt-val "Display" "Totals"))
(define (add-subtotal-row label leader table used-columns
subtotal-collector subtotal-style
value?)
(let ((currency-totals (subtotal-collector
'format gnc:make-gnc-monetary #f))
(single-col (if value?
(value-single-col used-columns)
(amount-single-col used-columns)))
(credit-col (if value?
(value-credit-col used-columns)
(credit-col used-columns)))
(debit-col (if value?
(value-debit-col used-columns)
(debit-col used-columns))))
(define (colspan monetary)
(cond
(single-col single-col)
((gnc-numeric-negative-p (gnc:gnc-monetary-amount monetary)) credit-col)
(else debit-col)))
(define (display-subtotal monetary)
(if single-col
(if (and (not (null? leader)) (gnc-reverse-balance leader))
(gnc:monetary-neg monetary)
monetary)
(if (gnc-numeric-negative-p (gnc:gnc-monetary-amount monetary))
(gnc:monetary-neg monetary)
monetary)))
(if (or single-col credit-col debit-col)
(begin
(if (not (reg-report-invoice?))
(gnc:html-table-append-row!
table
(list
(gnc:make-html-table-cell/size
1 (num-columns-required used-columns)
(gnc:make-html-text (gnc:html-markup-hr))))))
(for-each (lambda (currency)
(gnc:html-table-append-row/markup!
table
subtotal-style
(append (cons (gnc:make-html-table-cell/markup
"total-label-cell" label)
'())
(list (gnc:make-html-table-cell/size/markup
1 (colspan currency)
"total-number-cell"
(display-subtotal currency))))))
currency-totals)))))
(define (accumulate-totals split total-amount total-value
debit-amount debit-value
credit-amount credit-value)
(let* ((parent (xaccSplitGetParent split))
(account (xaccSplitGetAccount split))
(split-currency (if (not (null? account))
(xaccAccountGetCommodity account)
(gnc-default-currency)))
(split-amount (xaccSplitGetAmount split))
(trans-currency (xaccTransGetCurrency parent))
(split-value (xaccSplitGetValue split)))
(if (gnc-numeric-positive-p split-amount)
(debit-amount 'add split-currency split-amount)
(credit-amount 'add split-currency split-amount))
(if (gnc-numeric-positive-p split-value)
(debit-value 'add trans-currency split-value)
(credit-value 'add trans-currency split-value))
(total-amount 'add split-currency split-amount)
(total-value 'add trans-currency split-value)))
(define (add-other-split-rows split table used-columns row-style
action-for-num? ledger-type? total-collector)
(define (other-rows-driver split parent table used-columns i)
(let ((current (xaccTransGetSplit parent i)))
(if (not (null? current))
(begin
(add-split-row table current used-columns row-style #f #t
action-for-num? ledger-type? #f
(opt-val "Display" "Memo")
(opt-val "Display" "Description")
total-collector)
(other-rows-driver split parent table
used-columns (+ i 1))))))
(other-rows-driver split (xaccSplitGetParent split)
table used-columns 0))
;; ----------------------------------
;; main loop
;; ----------------------------------
(define (do-rows-with-subtotals leader
splits
table
used-columns
width
multi-rows?
action-for-num?
ledger-type?
double?
odd-row?
total-collector
debit-collector
credit-collector
total-value
debit-value
credit-value)
(if (null? splits)
;; ----------------------------------
;; exit condition reached
;; ----------------------------------
(begin
;; ------------------------------------
;; add debit/credit totals to the table
;; ------------------------------------
(if (reg-report-show-totals?)
(begin
(add-subtotal-row (_ "Total Debits") leader table used-columns
debit-collector "grand-total" #f)
(add-subtotal-row (_ "Total Credits") leader table used-columns
credit-collector "grand-total" #f)
(add-subtotal-row (_ "Total Value Debits") leader table used-columns
debit-value "grand-total" #t)
(add-subtotal-row (_ "Total Value Credits") leader table used-columns
credit-value "grand-total" #t)))
(if ledger-type?
(add-subtotal-row (_ "Net Change") leader table used-columns
total-collector "grand-total" #f)
)
(add-subtotal-row (_ "Value Change") leader table used-columns
total-value "grand-total" #t))
;; ----------------------------------
;; process the splits list
;; ----------------------------------
(let* ((current (car splits))
(current-row-style (if multi-rows? "normal-row"
(if odd-row? "normal-row"
"alternate-row")))
(rest (cdr splits))
(next (if (null? rest) #f
(car rest)))
(valid-split? (not (null? (xaccSplitGetAccount current)))))
;; ----------------------------------------------
;; update totals, but don't add them to the table
;; ----------------------------------------------
(if (and multi-rows? valid-split?)
(for-each (lambda (split)
(if (string=? (gncAccountGetGUID
(xaccSplitGetAccount current))
(gncAccountGetGUID
(xaccSplitGetAccount split)))
(accumulate-totals split
total-collector total-value
debit-collector debit-value
credit-collector credit-value)))
(xaccTransGetSplitList (xaccSplitGetParent current)))
(accumulate-totals current
total-collector total-value
debit-collector debit-value
credit-collector credit-value))
;; ----------------------------------
;; add the splits to the table
;; ----------------------------------
;; The general ledger has a split that doesn't have an account
;; set yet (the new entry transaction).
;; This split should be skipped or the report errors out.
;; See bug #639082
(if valid-split?
(add-split-row
table
current
used-columns
current-row-style
#t
(not multi-rows?)
action-for-num?
ledger-type?
double?
(opt-val "Display" "Memo")
(opt-val "Display" "Description")
total-collector
)
)
(if (and multi-rows? valid-split?)
(add-other-split-rows
current
table used-columns
"alternate-row"
action-for-num?
ledger-type?
total-collector
)
)
(do-rows-with-subtotals leader
rest
table
used-columns
width
multi-rows?
action-for-num?
ledger-type?
double?
(not odd-row?)
total-collector
debit-collector
credit-collector
total-value
debit-value
credit-value))))
;; -----------------------------------------------
;; needed for the call to (do-rows-with-subtotals)
;; -----------------------------------------------
(define (splits-leader splits)
(let ((accounts (map xaccSplitGetAccount splits)))
(if (null? accounts) '()
(begin
(set! accounts (cons (car accounts)
(delete (car accounts) (cdr accounts))))
(if (not (null? (cdr accounts))) '()
(car accounts))))))
;; ----------------------------------
;; make the split table
;; ----------------------------------
(let* ((table (gnc:make-html-table))
(used-columns (build-column-used options))
(width (num-columns-required used-columns))
(multi-rows? (reg-report-journal?))
(ledger-type? (reg-report-ledger-type?))
(double? (reg-report-double?))
(action-for-num? (qof-book-use-split-action-for-num-field
(gnc-get-current-book))))
(gnc:html-table-set-col-headers!
table
(make-heading-list used-columns
debit-string credit-string amount-string
multi-rows? action-for-num? ledger-type?))
(do-rows-with-subtotals (splits-leader splits)
splits
table
used-columns
width
multi-rows?
action-for-num?
ledger-type?
double?
#t
(gnc:make-commodity-collector)
(gnc:make-commodity-collector)
(gnc:make-commodity-collector)
(gnc:make-commodity-collector)
(gnc:make-commodity-collector)
(gnc:make-commodity-collector))
table))
;; -----------------------------------------------------------------
;; misc
;; -----------------------------------------------------------------
(define (string-expand string character replace-string)
(define (car-line chars)
(take-while (lambda (c) (not (eqv? c character))) chars))
(define (cdr-line chars)
(let ((rest (drop-while (lambda (c) (not (eqv? c character))) chars)))
(if (null? rest)
'()
(cdr rest))))
(define (line-helper chars)
(if (null? chars)
""
(let ((first (car-line chars))
(rest (cdr-line chars)))
(string-append (list->string first)
(if (null? rest) "" replace-string)
(line-helper rest)))))
(line-helper (string->list string)))
(define (make-client-table address)
(let ((table (gnc:make-html-table)))
(gnc:html-table-set-style!
table "table"
'attribute (list "border" 0)
'attribute (list "cellspacing" 0)
'attribute (list "cellpadding" 0))
(gnc:html-table-append-row!
table
(list
(string-append (_ "Client") ": ")
(string-expand address #\newline "<br>")))
(set-last-row-style!
table "td"
'attribute (list "valign" "top"))
table))
(define (make-info-table address)
(let ((table (gnc:make-html-table)))
(gnc:html-table-set-style!
table "table"
'attribute (list "border" 0)
'attribute (list "cellspacing" 20)
'attribute (list "cellpadding" 0))
(gnc:html-table-append-row!
table
(list
(string-append
(_ "Date") ": "
(string-expand (gnc-print-date (cons (current-time) 0))
#\space " "))
(make-client-table address)))
(set-last-row-style!
table "td"
'attribute (list "valign" "top"))
table))
(define (reg-renderer report-obj)
(define (opt-val section name)
(gnc:option-value
(gnc:lookup-option (gnc:report-options report-obj) section name)))
(let ((document (gnc:make-html-document))
(splits '())
(table '())
(query-scm (opt-val "__reg" "query"))
(query #f)
(journal? (opt-val "__reg" "journal"))
(debit-string (opt-val "__reg" "debit-string"))
(credit-string (opt-val "__reg" "credit-string"))
(invoice? #f)
(title (opt-val "General" "Title")))
(if invoice?
(set! title (_ "Invoice")))
(set! query (gnc-scm2query query-scm))
(qof-query-set-book query (gnc-get-current-book))
(set! splits (if journal?
(xaccQueryGetSplitsUniqueTrans query)
(qof-query-run query)))
(set! table (make-split-table splits
(gnc:report-options report-obj)
debit-string credit-string
(if invoice? (_ "Charge") (_ "Amount"))))
(if invoice?
(begin
(gnc:html-document-add-object!
document
(gnc:make-html-text
(gnc:html-markup-br)
"User Name"
(gnc:html-markup-br)
(string-expand
"User Address"
#\newline
"<br>")
(gnc:html-markup-br)))
(gnc:html-table-set-style!
table "table"
'attribute (list "border" 1)
'attribute (list "cellspacing" 0)
'attribute (list "cellpadding" 4))
(gnc:html-document-add-object!
document
(make-info-table
""))))
(gnc:html-document-set-title! document title)
(gnc:html-document-add-object! document table)
(qof-query-destroy query)
document))
(define register-report-guid "22104e02654c4adba844ee75a3f8d173")
;; we get called from elsewhere... but this doesn't work FIX-ME, find
;; out how to get report-guid's exported from report into the report
;; system at large. might have to define this at the report-system
;; level to get them read by other reports. Look at the aging reports
;; for suggestions, perhaps
(export register-report-guid)
(gnc:define-report
'version 1
'name (N_ "Register")
'report-guid register-report-guid
'options-generator options-generator
'renderer reg-renderer
'in-menu? #f)
(define (gnc:register-report-create-internal invoice? query journal? ledger-type?
double? title debit-string credit-string)
(let* ((options (gnc:make-report-options register-report-guid))
(query-op (gnc:lookup-option options "__reg" "query"))
(journal-op (gnc:lookup-option options "__reg" "journal"))
(ledger-type-op (gnc:lookup-option options "__reg" "ledger-type"))
(double-op (gnc:lookup-option options "__reg" "double"))
(title-op (gnc:lookup-option options "General" "Title"))
(debit-op (gnc:lookup-option options "__reg" "debit-string"))
(credit-op (gnc:lookup-option options "__reg" "credit-string"))
(account-op (gnc:lookup-option options "Display" "Account")))
(if invoice?
(begin
(set! journal? #f)
(gnc:option-set-value account-op #f)))
(gnc:option-set-value query-op query)
(gnc:option-set-value journal-op journal?)
(gnc:option-set-value ledger-type-op ledger-type?)
(gnc:option-set-value double-op double?)
(gnc:option-set-value title-op title)
(gnc:option-set-value debit-op debit-string)
(gnc:option-set-value credit-op credit-string)
(gnc:make-report register-report-guid options)))
(export gnc:register-report-create-internal)
| false |
8ca605857aecf00ac205f60580c5963b18454e82
|
c74dcb1facbd920d762017345171f47f8e41d0c5
|
/chapter_2/2.73.scm
|
d3dde018ef94b9746bf53ddaf1dec98b69ee9a8f
|
[] |
no_license
|
akash-akya/sicp-exercises
|
5125c1118c7f0e4400cb823508797fb67c745592
|
c28f73719740c2c495b7bc38ee8b790219482b67
|
refs/heads/master
| 2021-06-15T19:12:47.679967 | 2019-08-03T14:03:20 | 2019-08-03T14:03:20 | 136,158,517 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,448 |
scm
|
2.73.scm
|
#lang sicp
(#%require "utils.scm")
(#%require "dummy-env-helper.scm")
;; Exercise 2.73: 2.3.2 described a program that performs symbolic differentiation:
;; (define (deriv exp var)
;; (cond ((number? exp) 0)
;; ((variable? exp)
;; (if (same-variable? exp var) 1 0))
;; ((sum? exp)
;; (make-sum (deriv (addend exp) var)
;; (deriv (augend exp) var)))
;; ((product? exp)
;; (make-sum
;; (make-product
;; (multiplier exp)
;; (deriv (multiplicand exp) var))
;; (make-product
;; (deriv (multiplier exp) var)
;; (multiplicand exp))))
;; ⟨more rules can be added here⟩
;; (else (error "unknown expression type:
;; DERIV" exp))))
;; We can regard this program as performing a dispatch on the type of
;; the expression to be differentiated. In this situation the “type
;; tag” of the datum is the algebraic operator symbol (such as +) and
;; the operation being performed is deriv. We can transform this
;; program into data-directed style by rewriting the basic derivative
;; procedure as
;; (define (deriv exp var)
;; (cond ((number? exp) 0)
;; ((variable? exp)
;; (if (same-variable? exp var)
;; 1
;; 0))
;; (else ((get 'deriv (operator exp))
;; (operands exp)
;; var))))
;; (define (operator exp) (car exp))
;; (define (operands exp) (cdr exp))
;; 1. Explain what was done above. Why can’t we assimilate the
;; predicates number? and variable? into the data-directed
;; dispatch?
;; 2. Write the procedures for derivatives of sums and
;; products, and the auxiliary code required to install them in
;; the table used by the program above.
;; 3. Choose any additional
;; differentiation rule that you like, such as the one for
;; exponents (Exercise 2.56), and install it in this data-directed
;; system.
;; 4. In this simple algebraic manipulator the type of an
;; expression is the algebraic operator that binds it
;; together. Suppose, however, we indexed the procedures in the
;; opposite way, so that the dispatch line in deriv looked like
;; ((get (operator exp) 'deriv)
;; (operands exp) var)
;; What corresponding changes to the derivative system are required?
(define (attach-tag type-tag contents)
(cons type-tag contents))
(define (type-tag datum)
(if (pair? datum)
(car datum)
(error "Bad tagged datum:
TYPE-TAG" datum)))
(define (contents datum)
(if (pair? datum)
(cdr datum)
(error "Bad tagged datum:
CONTENTS" datum)))
;; 2.
(define (variable? x) (symbol? x))
(define (same-variable? v1 v2)
(and (variable? v1)
(variable? v2)
(eq? v1 v2)))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (deriv exp var)
(cond ((number? exp) 0)
((variable? exp)
(if (same-variable? exp var)
1
0))
(else ((get 'deriv (operator exp))
(operands exp)
var))))
(define (operator exp) (car exp))
(define (operands exp) (cdr exp))
(define (lhs s) (car s))
(define (rhs s) (cadr s))
(define (install-addition-package)
;; interface to the rest of the system
(define (tag x) (attach-tag '+ x))
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2))
(+ a1 a2))
(else (tag (list a1 a2)))))
(put '+ nil make-sum)
(put 'deriv '+
(lambda (args var)
(make-sum (deriv (lhs args) var)
(deriv (rhs args) var))))
'done)
(define (make-sum a b)
((get '+ nil) a b))
(define (install-product-package)
(define (make-product m1 m2)
(cond ((or (=number? m1 0)
(=number? m2 0))
0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2))
(* m1 m2))
(else (tag (list m1 m2)))))
;; interface to the rest of the system
(define (tag x) (attach-tag '* x))
(put '* nil make-product)
(put 'deriv '*
(lambda (args var)
(make-sum (make-product (deriv (lhs args) var)
(rhs args))
(make-product (lhs args)
(deriv (rhs args) var)))))
'done)
(define (make-product a b)
((get '* nil) a b))
;; test
(install-addition-package)
(install-product-package)
(test-equal (deriv '(+ x 3) 'x) 1)
(test-equal (deriv '(* x y) 'x) 'y)
(test-equal (deriv '(* (* x y) (+ x 3)) 'x) '(+ (* y (+ x 3)) (* x y)))
;; 3.
(define (install-exponentation-package)
(define (make-exponentation base exponent)
(cond ((=number? exponent 0) 1)
((=number? exponent 1) base)
(else (tag (list base exponent)))))
;; interface to the rest of the system
(define (tag x) (attach-tag '** x))
(put 'deriv '**
(lambda (args var)
(let ((b (lhs args))
(e (rhs args)))
(make-product (make-product e (make-exponentation b (- e 1)))
(deriv b var)))))
'done)
(install-exponentation-package)
(test-equal (deriv '(** x 3) 'x) '(* 3 (** x 2)))
;; 4.
;; just swap the order of 'deriv and operator in put & get function calls
| false |
c517c4d2f3bd8137c777db6a8a61b95a88cee229
|
fb9a1b8f80516373ac709e2328dd50621b18aa1a
|
/ch3/exercise3-18.scm
|
347106ae4d1f8df4bd9b93b65e4e661838b95e71
|
[] |
no_license
|
da1/sicp
|
a7eacd10d25e5a1a034c57247755d531335ff8c7
|
0c408ace7af48ef3256330c8965a2b23ba948007
|
refs/heads/master
| 2021-01-20T11:57:47.202301 | 2014-02-16T08:57:55 | 2014-02-16T08:57:55 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 699 |
scm
|
exercise3-18.scm
|
;;問題3.18
(define (circulate? items)
(define walks '())
(define (has-circulate? x)
(if (memq x walks)
#t
(begin (set! walks (cons x walks))
#f)))
(define (circulate?-iter i)
(if (not (pair? i))
#f
(if (has-circulate? (car i))
#t
(circulate?-iter (cdr i)))))
(circulate?-iter items))
(define z (make-cycle (list 'a 'b 'c)))
(circulate? (list 'a 'b 'c))
(circulate? z)
(circulate? '(a b c)) ;;3
(circulate? '((b a) a)) ;;4
(define x '(a b c))
(circulate? (cons x x)) ;;7
(define infinity
(let ((x '(a b c)))
(set-cdr! (last-pair x) x)
x))
(circulate? infinity) ;;帰ってこない
(circulate? '(((c) c) (c) c)) ;;7
| false |
f6f78f940b2e3d9d2c4b181ebf9ea9b9f4bdbb00
|
000dbfe5d1df2f18e29a76ea7e2a9556cff5e866
|
/ext/crypto/tests/testvectors/signature/ed448_test.scm
|
ede9db00a719d667fba8c5b55eed0367b40599e7
|
[
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"MIT",
"BSD-2-Clause"
] |
permissive
|
ktakashi/sagittarius-scheme
|
0a6d23a9004e8775792ebe27a395366457daba81
|
285e84f7c48b65d6594ff4fbbe47a1b499c9fec0
|
refs/heads/master
| 2023-09-01T23:45:52.702741 | 2023-08-31T10:36:08 | 2023-08-31T10:36:08 | 41,153,733 | 48 | 7 |
NOASSERTION
| 2022-07-13T18:04:42 | 2015-08-21T12:07:54 |
Scheme
|
UTF-8
|
Scheme
| false | false | 49,571 |
scm
|
ed448_test.scm
|
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 65 150 16 165 52 175 18 127 88 59 4 129 140 219 127 15 243 0 176 37 242 224 22 130 188 174 51 253 105 28 238 3 149 17 223 12 221 198 144 238 151 132 38 232 179 142 80 206 90 247 220 251 165 15 112 76 0)
:der-encode
#t
:tests
'(#(1
""
#vu8()
#vu8(207 121 83 0 118 102 225 47 115 175 158 201 46 62 1 141 165 238 90 141 91 23 245 16 10 53 76 88 241 213 244 187 55 171 131 92 82 247 35 116 199 45 97 38 137 20 156 246 211 106 112 219 109 197 166 196 0 181 151 52 142 14 49 229 30 101 187 20 78 99 200 146 163 103 180 192 85 192 54 170 108 215 231 40 205 210 160 152 150 59 218 134 57 3 230 221 2 91 90 93 137 18 9 244 226 133 55 105 72 4 229 11 8 0)
#t
())
#(2
""
#vu8(120)
#vu8(197 110 148 213 201 202 134 12 36 79 51 219 85 107 246 179 206 195 139 2 75 119 96 74 53 214 160 114 17 177 49 107 154 2 113 51 195 116 184 111 114 102 92 196 92 224 21 131 162 224 242 119 92 97 114 218 128 26 206 241 104 113 124 171 17 150 205 223 177 73 53 157 254 245 137 117 98 87 204 45 107 2 252 81 109 141 65 180 173 170 63 17 66 143 65 65 14 240 220 60 27 0 141 61 5 33 115 212 56 149 8 237 1 0)
#t
())
#(3
""
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0)
#t
())
#(4
""
#vu8(72 101 108 108 111)
#vu8(68 46 51 120 15 25 157 215 188 113 209 51 95 116 223 127 58 14 199 137 226 26 23 92 27 255 221 182 229 0 145 153 141 150 154 200 25 75 58 206 251 119 2 246 194 34 248 79 126 236 163 184 4 6 241 254 128 104 121 21 231 146 91 245 45 235 71 182 183 121 226 109 48 238 199 197 254 240 53 128 242 128 160 137 238 253 11 172 201 251 187 106 77 115 165 145 209 103 29 25 46 107 188 253 183 154 211 219 86 115 161 38 48 0)
#t
())
#(5
""
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 96 160 82 54 252 156 22 130 176 229 91 96 160 130 201 165 123 255 230 30 244 221 165 206 101 223 83 152 5 18 43 58 9 160 89 118 212 26 214 138 181 45 248 84 40 21 44 87 218 147 83 30 93 22 146 14 0)
#t
())
#(6
""
#vu8(0 0 0 0 0 0 0 0 0 0 0 0)
#vu8(168 202 100 209 171 0 234 231 127 210 133 77 132 34 219 58 225 47 202 145 193 79 39 79 48 164 77 249 133 144 120 110 196 203 185 106 149 100 252 27 155 22 194 45 43 208 10 166 95 8 118 50 55 41 245 172 128 159 176 184 154 77 63 39 175 186 187 89 104 81 216 53 23 61 96 234 52 224 135 83 89 243 214 173 177 60 239 19 149 183 234 165 249 20 117 131 255 56 180 222 177 131 6 40 116 145 91 241 148 174 97 7 35 0)
#t
())
#(7
""
#vu8(97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97)
#vu8(178 5 211 226 76 206 246 76 30 134 241 95 72 221 250 104 36 83 80 52 137 71 81 136 176 74 143 85 134 11 60 138 156 1 230 222 130 11 183 217 177 93 175 248 222 37 164 168 112 233 135 21 122 17 94 193 128 45 160 208 96 109 161 40 66 234 126 171 101 139 94 234 109 209 243 166 65 165 23 68 37 87 128 3 205 49 139 141 107 141 203 77 233 84 181 7 141 25 18 197 120 173 130 129 81 93 109 243 103 43 148 23 63 0)
#t
())
#(8
""
#vu8(32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96)
#vu8(52 146 239 102 229 253 241 80 62 158 32 108 92 47 13 75 120 145 170 215 147 87 85 39 210 37 30 13 241 185 124 47 234 193 136 188 56 44 227 201 44 75 195 107 162 105 95 50 190 218 221 72 14 170 147 35 0 208 219 31 154 156 96 132 77 46 165 174 166 73 51 199 190 70 196 249 210 28 180 139 57 234 226 61 8 73 109 231 206 149 1 25 113 133 204 93 79 248 170 75 1 140 231 173 50 31 106 125 119 140 74 7 4 0)
#t
())
#(9
""
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#vu8(84 94 25 5 175 27 88 134 85 46 175 120 225 115 4 198 248 63 207 179 68 77 242 209 234 5 100 134 219 97 94 59 178 145 49 187 12 31 210 149 54 77 197 21 218 229 129 150 113 72 235 35 198 201 1 46 128 109 54 35 186 255 0 84 140 100 142 60 179 117 106 170 175 101 159 47 183 221 46 113 199 97 20 72 89 60 166 63 42 152 145 58 183 241 130 230 130 14 175 19 52 226 116 94 14 123 192 220 202 185 141 231 22 0)
#t
())
#(10
"special values for r and s"
#vu8(63)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(11
"special values for r and s"
#vu8(63)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(12
"special values for r and s"
#vu8(63)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 242 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(13
"special values for r and s"
#vu8(63)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(14
"special values for r and s"
#vu8(63)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#f
())
#(15
"special values for r and s"
#vu8(63)
#vu8(1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(16
"special values for r and s"
#vu8(63)
#vu8(1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(17
"special values for r and s"
#vu8(63)
#vu8(1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 242 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(18
"special values for r and s"
#vu8(63)
#vu8(1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(19
"special values for r and s"
#vu8(63)
#vu8(1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#f
())
#(20
"special values for r and s"
#vu8(63)
#vu8(243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(21
"special values for r and s"
#vu8(63)
#vu8(243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(22
"special values for r and s"
#vu8(63)
#vu8(243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63 242 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(23
"special values for r and s"
#vu8(63)
#vu8(243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63 243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(24
"special values for r and s"
#vu8(63)
#vu8(243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#f
())
#(25
"special values for r and s"
#vu8(63)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(26
"special values for r and s"
#vu8(63)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(27
"special values for r and s"
#vu8(63)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 242 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(28
"special values for r and s"
#vu8(63)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 243 68 88 171 146 194 120 35 85 143 197 141 114 194 108 33 144 54 214 174 73 219 78 196 233 35 202 124 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 63)
#f
())
#(29
"special values for r and s"
#vu8(63)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 254 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#f
())
#(30
"empty signature"
#vu8(84 101 115 116)
#vu8()
#f
())
#(31
"s missing"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128)
#f
())
#(32
"signature too short"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152)
#f
())
#(33
"signature too long"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0 32 32)
#f
())
#(34
"include pk in signature"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0 65 150 16 165 52 175 18 127 88 59 4 129 140 219 127 15 243 0 176 37 242 224 22 130 188 174 51 253 105 28 238 3 149 17 223 12 221 198 144 238 151 132 38 232 179 142 80 206 90 247 220 251 165 15 112 76 0)
#f
())
#(35
"prepending 0 byte to signature"
#vu8(84 101 115 116)
#vu8(0 93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0)
#f
())
#(36
"prepending 0 byte to s"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 0 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0)
#f
())
#(37
"appending 0 byte to signature"
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38 0 0)
#f
())
#(38
"removing 0 byte from signature"
#vu8(84 101 115 116 48)
#vu8(219 214 56 69 22 171 107 14 178 214 9 65 69 100 236 33 115 131 182 96 64 223 176 103 97 40 37 26 226 76 29 124 23 156 33 169 238 48 125 193 63 143 230 85 11 196 1 135 240 147 218 133 97 123 207 93 0 157 62 232 183 152 173 151 139 110 104 59 196 233 17 148 14 168 46 160 183 233 93 194 79 224 178 158 68 102 50 17 137 44 42 170 52 81 55 157 34 194 137 185 67 120 241 31 183 0 241 104 157 74 0 215 62)
#f
())
#(39
"removing 0 byte from signature"
#vu8(84 101 115 116 53 53)
#vu8(206 43 47 255 11 244 69 163 104 19 207 42 118 224 204 86 25 164 241 110 229 63 15 227 205 70 252 4 20 219 114 72 179 47 189 165 75 187 55 231 8 214 35 128 118 234 18 191 133 11 150 75 4 69 32 187 128 251 175 14 29 30 211 188 171 38 20 98 223 94 127 45 231 58 201 203 174 38 223 162 144 21 3 154 207 144 87 89 97 252 155 145 185 202 39 109 174 125 95 168 5 189 32 44 85 121 160 244 198 110 128 20 0)
#f
())
#(40
"dropping byte from signature"
#vu8(84 101 115 116 54 51)
#vu8(194 131 237 54 215 140 39 90 93 2 247 147 154 237 44 78 246 131 32 174 27 246 252 37 232 52 183 88 4 106 109 82 164 128 33 106 148 45 254 119 31 59 211 7 244 206 125 63 68 110 8 36 150 27 213 222 128 205 164 43 92 195 142 110 195 213 63 56 105 120 185 135 125 60 152 162 138 200 252 102 99 15 253 23 137 51 161 141 225 174 226 60 171 80 17 201 255 76 146 119 49 27 76 108 51 172 184 232 43 140 105 60 0)
#f
())
#(41
"removing leading 0 byte from signature"
#vu8(84 101 115 116 51 54 49)
#vu8(98 230 41 189 43 143 89 93 244 1 195 98 199 102 33 109 69 222 137 252 238 205 153 198 157 50 59 92 83 173 90 195 234 114 36 150 63 235 162 242 137 85 81 217 79 84 130 72 239 133 151 210 169 89 248 128 213 153 52 165 232 240 120 71 131 77 102 186 26 107 9 222 93 186 105 33 114 177 63 118 143 12 41 232 25 97 68 193 48 210 53 52 69 214 60 189 11 105 7 148 253 173 48 164 142 139 183 204 37 4 248 7 0)
#f
())
#(42
"modified bit 0 in R"
#vu8(49 50 51 52 48 48)
#vu8(92 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 175 195 58 82 81 22 204 18 224 209 195 161 253 230 222 81 138 101 68 243 96 208 254 24 213 190 119 112 176 87 162 191 121 45 180 183 100 143 168 74 110 174 202 233 9 227 63 165 156 93 254 72 4 186 38 35)
#f
())
#(43
"modified bit 1 in R"
#vu8(49 50 51 52 48 48)
#vu8(95 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 249 19 134 195 233 221 158 124 154 247 202 107 190 248 183 164 74 227 214 142 234 222 68 157 125 251 179 29 232 65 158 185 67 226 236 188 221 6 223 82 39 232 43 157 237 81 154 86 231 15 10 28 15 193 123 6)
#f
())
#(44
"modified bit 2 in R"
#vu8(49 50 51 52 48 48)
#vu8(89 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 241 170 176 123 74 208 105 223 175 192 27 69 50 225 228 76 191 113 119 225 189 218 25 127 200 116 52 4 109 181 185 53 175 217 17 74 197 225 19 142 174 173 35 195 181 157 186 144 38 210 218 74 134 254 128 11)
#f
())
#(45
"modified bit 7 in R"
#vu8(49 50 51 52 48 48)
#vu8(221 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 118 104 64 43 123 9 63 199 84 1 147 36 7 124 31 132 42 125 46 53 173 247 184 112 148 17 92 236 69 154 213 65 158 22 41 136 239 66 177 152 141 155 148 77 157 90 124 224 156 111 52 42 250 80 8 57)
#f
())
#(46
"modified bit 8 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 184 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 39 155 112 51 133 134 185 225 62 102 145 145 204 13 252 42 147 125 80 166 17 135 88 222 4 164 202 65 244 135 122 189 185 113 175 168 127 228 184 59 194 67 184 223 210 203 54 138 163 137 164 203 17 232 62 49)
#f
())
#(47
"modified bit 16 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 77 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 199 184 71 85 107 58 111 148 71 72 56 153 171 115 10 35 0 76 105 80 84 221 87 177 195 33 79 168 127 99 47 57 200 255 20 113 240 83 43 142 238 65 84 147 14 28 163 13 87 75 143 158 133 176 67 43)
#f
())
#(48
"modified bit 31 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 211 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 11 1 121 23 71 43 19 10 28 193 200 233 149 162 82 97 125 93 218 241 243 212 137 48 180 135 111 160 210 207 237 236 144 168 200 92 130 116 137 42 28 163 182 207 206 99 235 254 188 48 114 16 184 68 174 12)
#f
())
#(49
"modified bit 32 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 17 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 95 56 246 55 24 96 252 196 242 236 81 90 253 53 203 5 216 148 30 36 72 204 70 154 21 184 83 126 117 139 22 212 107 18 53 129 97 52 98 194 187 32 216 160 114 153 171 121 93 9 152 225 228 39 121 49)
#f
())
#(50
"modified bit 63 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 159 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 23 17 27 166 254 253 69 226 73 15 29 83 161 132 0 127 160 115 71 7 6 215 244 169 96 111 202 210 149 78 116 195 33 22 186 119 1 210 37 183 110 85 22 78 100 223 50 69 193 3 31 13 247 52 189 49)
#f
())
#(51
"modified bit 64 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 109 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 141 125 10 161 253 129 208 227 23 137 146 23 113 198 84 51 143 150 240 181 87 182 21 227 218 85 103 2 113 96 138 14 2 46 78 140 243 147 227 9 248 246 65 34 129 182 20 126 127 206 66 176 137 235 30 12)
#f
())
#(52
"modified bit 97 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 12 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 176 141 59 230 235 244 230 11 246 215 78 16 94 162 250 155 150 92 98 129 107 189 34 234 59 176 193 172 253 18 48 5 35 202 118 249 75 111 120 148 136 169 87 251 235 33 45 113 59 172 207 149 253 89 79 61)
#f
())
#(53
"modified bit 127 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 96 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 162 63 84 133 126 155 15 114 178 239 144 210 118 136 52 89 4 100 215 89 51 237 8 196 84 250 167 98 179 112 42 43 99 28 51 195 57 208 91 46 36 194 10 130 20 249 154 243 31 147 248 15 65 106 17 41)
#f
())
#(54
"modified bit 240 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 129 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 115 75 220 57 146 115 211 64 61 147 76 234 174 22 232 122 104 198 191 246 183 125 128 55 255 65 201 121 34 73 138 88 231 4 194 154 181 25 212 27 171 112 115 95 113 252 38 245 137 54 30 43 33 117 67 0)
#f
())
#(55
"modified bit 247 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 0 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 186 150 28 200 208 118 92 153 213 116 112 238 28 12 119 240 165 98 161 152 253 1 117 237 219 12 3 62 15 184 82 83 40 197 226 197 22 226 176 15 115 96 156 127 118 145 149 235 26 2 255 84 9 13 120 31)
#f
())
#(56
"modified bit 248 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 169 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 231 38 133 144 125 169 229 166 78 65 66 237 2 252 12 107 249 87 99 32 29 181 148 42 172 5 95 168 126 111 221 50 228 131 253 33 237 65 16 213 215 239 97 155 116 15 239 42 216 167 31 232 33 228 42 42)
#f
())
#(57
"modified bit 253 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 136 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 80 6 70 214 124 116 241 52 113 240 173 3 77 165 48 247 35 143 231 137 126 83 42 248 236 41 119 100 58 65 11 29 5 73 52 223 86 126 23 2 118 56 158 102 179 243 204 179 193 90 237 35 157 4 247 43)
#f
())
#(58
"modified bit 254 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 232 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 123 177 83 184 227 80 170 115 106 145 201 33 33 117 120 83 150 0 193 41 154 183 101 34 239 143 105 2 215 156 147 242 116 7 62 230 190 175 230 32 14 202 245 159 124 209 27 177 200 51 242 75 243 14 213 45)
#f
())
#(59
"modified bit 255 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 40 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 128 74 103 178 43 229 153 214 67 59 135 234 150 28 130 196 87 171 80 246 74 198 183 239 176 178 249 9 136 146 127 131 116 35 3 194 120 248 36 142 2 213 103 155 65 237 80 90 186 15 181 17 16 208 222 248 16)
#f
())
#(60
"modified bit 440 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 243 128 127 69 46 251 12 217 125 171 85 6 2 139 123 135 104 48 222 224 42 156 12 189 20 13 205 229 9 99 141 77 84 108 48 133 107 33 81 189 247 153 48 223 91 187 17 242 190 182 107 205 194 90 215 95 33 22)
#f
())
#(61
"modified bit 441 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 240 128 141 120 35 27 179 201 168 124 91 141 22 143 224 95 129 151 80 58 61 115 166 215 0 244 54 181 167 106 184 102 56 139 170 105 48 25 26 7 122 202 121 112 5 137 50 200 139 127 158 110 203 19 200 157 205 29)
#f
())
#(62
"modified bit 447 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 114 128 158 90 132 6 6 63 179 84 95 15 182 39 248 65 178 227 168 90 213 211 120 1 142 139 88 254 88 225 78 229 82 13 87 171 201 20 14 156 90 117 168 176 154 195 51 77 208 202 214 155 72 119 18 132 50 29)
#f
())
#(63
"modified bit 448 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 129 26 223 146 32 16 136 224 81 238 72 181 122 236 244 110 223 198 142 91 174 237 90 228 145 11 165 104 29 55 15 117 171 89 56 17 225 130 147 239 8 8 88 28 37 65 150 188 191 43 76 69 65 54 166 113 27)
#f
())
#(64
"modified bit 449 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 130 94 6 195 153 158 131 8 190 67 156 64 148 11 0 117 211 228 246 81 71 193 96 140 190 110 156 67 46 51 190 214 104 111 147 147 174 37 104 240 173 96 254 188 180 182 23 156 13 144 208 52 231 195 196 104 16)
#f
())
#(65
"modified bit 454 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 192 36 86 187 209 65 223 4 141 191 24 67 190 109 95 239 64 36 131 49 76 42 245 71 179 97 160 159 51 25 72 158 174 222 67 64 77 249 250 246 52 193 41 141 103 139 82 97 200 8 176 190 55 38 1 62 57)
#f
())
#(66
"modified bit 455 in R"
#vu8(49 50 51 52 48 48)
#vu8(93 185 76 83 16 31 82 31 108 31 67 182 14 164 215 224 111 189 73 194 232 175 175 79 204 40 158 100 94 8 128 168 123 142 85 133 141 244 207 34 145 167 48 63 253 164 70 184 42 17 123 77 212 8 207 242 0 113 6 210 168 150 167 254 198 222 229 62 234 39 45 155 110 115 140 52 2 149 65 107 80 243 154 148 99 165 99 84 80 185 249 60 76 6 115 122 255 212 42 224 108 238 88 121 201 108 11 213 138 145 52 85 3)
#f
())
#(67
"R==0"
#vu8(49 50 51 52 48 48)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 39 171 152 171 134 46 78 126 195 54 26 69 172 25 147 233 180 125 154 196 13 185 31 174 215 82 57 156 238 4 19 18 43 71 52 101 148 253 125 44 137 73 180 62 76 171 175 23 216 51 158 160 227 7 2 63)
#f
())
#(68
"invalid R"
#vu8(49 50 51 52 48 48)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 209 27 174 51 160 153 159 211 253 43 237 111 165 87 118 133 232 253 89 94 121 192 6 229 143 211 95 105 249 27 29 133 53 83 251 64 6 1 154 7 114 90 163 119 115 136 61 190 18 37 56 18 136 122 200 40)
#f
())
#(69
"all bits flipped in R"
#vu8(49 50 51 52 48 48)
#vu8(162 70 179 172 239 224 173 224 147 224 188 73 241 91 40 31 144 66 182 61 23 80 80 176 51 215 97 155 161 247 127 87 132 113 170 122 114 11 48 221 110 88 207 192 2 91 185 71 213 238 132 178 43 247 48 13 127 51 78 72 20 26 240 250 222 20 105 245 222 219 133 28 158 114 93 39 189 101 1 43 173 160 94 112 205 230 65 170 217 206 11 234 73 131 22 79 115 129 107 111 19 9 94 107 147 235 3 232 80 202 208 207 13)
#f
())
#(70
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 36 27 214 20 45 219 2 192 249 250 19 57 85 211 230 16 180 178 124 184 20 34 125 232 178 65 239 78 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 102)
#f
("SignatureMalleability"))
#(71
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 23 96 46 192 191 157 123 227 78 138 217 198 199 149 83 50 68 233 82 103 94 253 203 172 156 101 185 203 133 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 166)
#f
("SignatureMalleability"))
#(72
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 253 233 222 22 229 34 109 42 249 168 100 226 172 26 45 117 100 86 255 196 241 179 105 53 112 173 77 197 132 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38)
#f
("SignatureMalleability"))
#(73
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 201 253 63 196 47 45 80 184 77 230 122 25 119 36 224 250 164 48 88 128 24 33 165 70 23 61 118 184 130 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38)
#f
("SignatureMalleability"))
#(74
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 102)
#f
("SignatureMalleability"))
#(75
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 166)
#f
("SignatureMalleability"))
#(76
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 49 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 134 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38)
#f
("SignatureMalleability"))
#(77
"checking malleability "
#vu8(84 101 115 116)
#vu8(93 5 63 245 183 31 110 195 40 69 37 211 93 119 147 49 120 200 225 152 121 136 109 8 236 204 108 125 39 233 229 181 224 37 55 219 196 212 114 53 6 232 209 113 252 23 51 133 117 115 221 2 209 143 72 242 128 48 214 125 105 154 24 138 156 164 107 78 171 226 16 122 239 35 124 166 9 203 70 46 36 201 29 37 210 133 64 43 110 247 134 43 120 163 134 149 2 70 255 56 214 210 244 88 19 109 18 227 201 127 221 152 38)
#f
("SignatureMalleability"))))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 95 215 68 155 89 180 97 253 44 231 135 236 97 106 212 106 29 161 52 36 133 167 14 31 138 14 167 93 128 233 103 120 237 241 36 118 155 70 199 6 27 214 120 61 241 229 15 108 209 250 26 190 175 232 37 97 128)
:der-encode
#t
:tests
'(#(78
"RFC 8032"
#vu8()
#vu8(83 58 55 246 187 228 87 37 31 2 60 13 136 249 118 174 45 251 80 74 132 62 52 210 7 79 216 35 212 26 89 31 43 35 63 3 79 98 130 129 242 253 122 34 221 212 125 120 40 197 155 208 162 27 253 57 128 255 13 32 40 212 177 138 157 246 62 0 108 93 28 45 52 91 146 93 141 192 11 65 4 133 45 185 154 197 199 205 218 133 48 161 19 160 244 219 182 17 73 240 90 115 99 38 140 113 217 88 8 255 46 101 38 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 67 186 40 244 48 205 255 69 106 229 49 84 95 126 205 10 200 52 165 93 147 88 192 55 43 250 12 108 103 152 192 134 106 234 1 235 0 116 40 2 184 67 142 164 203 130 22 156 35 81 96 98 123 76 58 148 128)
:der-encode
#t
:tests
'(#(79
"RFC 8032: 1 octet"
#vu8(3)
#vu8(38 184 249 23 39 189 98 137 122 241 94 65 235 67 195 119 239 185 198 16 212 143 35 53 203 11 208 8 120 16 244 53 37 65 177 67 196 185 129 183 225 143 98 222 140 205 246 51 252 27 240 55 171 124 215 121 128 94 13 188 192 170 225 203 206 225 175 178 224 39 223 54 188 4 220 236 191 21 67 54 193 159 10 247 224 166 71 41 5 231 153 241 149 61 42 15 243 52 138 178 26 164 173 175 209 210 52 68 28 248 7 192 58 0)
#t
())
#(80
"RFC 8032: 1 octet with context"
#vu8(3)
#vu8(212 248 246 19 23 112 221 70 244 8 103 214 253 93 80 85 222 67 84 31 140 94 53 171 188 208 1 179 42 137 247 210 21 31 118 71 241 29 140 162 174 39 159 184 66 214 7 33 127 206 110 4 47 104 21 234 0 12 133 116 29 229 200 218 17 68 166 161 171 167 249 109 228 37 5 215 167 41 133 36 253 165 56 252 203 187 117 79 87 140 28 173 16 213 77 13 84 40 64 126 133 220 188 152 164 145 85 193 55 100 230 108 60 0)
#f
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 220 234 158 120 243 90 27 243 73 154 131 27 16 184 108 144 170 192 28 216 75 103 160 16 155 85 163 110 147 40 177 227 101 252 225 97 215 28 231 19 26 84 62 164 203 95 126 159 29 139 0 105 100 71 0 20 0)
:der-encode
#t
:tests
'(#(81
"RFC 8032: 11 bytes"
#vu8(12 62 84 64 116 236 99 176 38 94 12)
#vu8(31 10 136 136 206 37 232 212 88 162 17 48 135 155 132 10 144 137 217 153 170 186 3 158 175 62 58 250 9 10 9 211 137 219 168 44 79 242 174 138 197 205 251 124 85 233 77 93 150 26 41 254 1 9 148 30 0 184 219 222 234 109 59 5 16 104 223 114 84 192 205 193 41 203 230 45 178 220 149 125 187 71 181 31 211 242 19 251 134 152 240 100 119 66 80 165 2 137 97 201 191 143 253 151 63 229 213 194 6 73 43 20 14 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 59 161 109 160 198 242 204 31 48 24 119 64 117 111 94 121 141 107 197 252 1 93 124 99 204 149 16 238 63 212 74 220 36 216 233 104 182 228 110 111 148 209 155 148 83 97 114 107 215 94 20 158 240 152 23 245 128)
:der-encode
#t
:tests
'(#(82
"RFC 8032: 12 bytes"
#vu8(100 166 95 60 222 220 221 102 129 30 41 21)
#vu8(126 238 171 124 78 80 251 121 155 65 142 229 227 25 127 246 191 21 212 58 20 195 67 137 181 157 209 167 177 184 91 74 233 4 56 172 166 52 190 164 94 58 38 149 241 39 15 7 253 205 247 198 43 142 254 175 0 180 92 44 150 186 69 126 177 168 191 7 90 61 178 142 92 36 246 185 35 237 74 215 71 195 201 224 60 112 121 239 184 124 177 16 211 169 152 97 231 32 3 203 174 109 107 139 130 126 78 108 20 48 100 255 60 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 179 218 7 155 10 164 147 165 119 32 41 240 70 123 174 190 229 168 17 45 157 58 34 83 35 97 218 41 79 123 179 129 92 93 197 158 23 107 77 159 56 28 160 147 142 19 198 192 123 23 75 230 93 250 87 142 128)
:der-encode
#t
:tests
'(#(83
"RFC 8032: 13 bytes"
#vu8(100 166 95 60 222 220 221 102 129 30 41 21 231)
#vu8(106 18 6 111 85 51 27 108 34 172 213 213 191 197 215 18 40 251 218 128 174 141 236 38 189 211 6 116 60 80 39 203 72 144 129 12 22 44 2 116 104 103 94 207 100 90 131 23 108 13 115 35 162 204 222 45 128 239 229 161 38 142 138 202 29 111 188 25 77 63 119 196 73 134 235 74 180 23 121 25 173 139 236 51 235 71 187 181 252 110 40 25 111 209 202 245 107 78 126 11 165 81 146 52 208 71 21 90 199 39 161 5 49 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 223 151 5 245 142 219 171 128 44 127 131 99 207 229 86 10 177 198 19 44 32 169 241 221 22 52 131 162 111 138 197 58 57 214 128 139 244 161 223 189 38 27 9 155 176 59 63 181 9 6 203 40 189 138 8 31 0)
:der-encode
#t
:tests
'(#(84
"RFC 8032: 64 bytes"
#vu8(189 15 106 55 71 205 86 27 221 223 70 64 163 50 70 26 74 48 161 42 67 76 208 191 64 215 102 217 198 212 88 229 81 34 4 163 12 23 209 245 11 80 121 99 31 100 235 49 18 24 45 163 0 88 53 70 17 19 113 141 26 94 249 68)
#vu8(85 75 194 72 8 96 180 158 171 133 50 210 165 51 183 213 120 239 71 62 235 88 201 139 178 208 225 206 72 138 152 177 141 253 233 185 185 7 117 230 127 71 212 161 195 72 32 88 239 201 244 13 44 160 51 160 128 27 99 212 91 59 114 46 245 82 186 211 180 204 182 103 218 53 1 146 182 28 80 140 247 182 181 173 173 194 200 217 164 70 239 0 63 176 92 186 95 48 232 142 54 236 39 3 179 73 202 34 156 38 112 131 57 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 121 117 111 1 77 207 226 7 159 93 217 231 24 190 65 113 226 239 36 134 160 143 37 24 111 107 255 67 169 147 107 155 254 18 64 43 8 174 101 121 138 61 129 226 46 158 200 14 118 144 134 46 243 212 237 58 0)
:der-encode
#t
:tests
'(#(85
"RFC 8032: 256 bytes"
#vu8(21 119 117 50 176 189 208 209 56 159 99 108 95 107 155 167 52 201 10 245 114 135 126 45 39 45 208 120 170 30 86 124 250 128 225 41 40 187 84 35 48 232 64 159 49 116 80 65 7 236 213 239 172 97 174 117 4 218 190 42 96 46 222 137 229 204 166 37 122 124 119 226 122 112 43 58 227 159 199 105 252 84 242 57 90 230 161 23 140 171 71 56 229 67 7 47 193 193 119 254 113 233 46 37 191 3 228 236 183 47 71 182 77 4 101 170 234 76 127 173 55 37 54 200 186 81 106 96 57 195 194 163 159 14 77 131 43 228 50 223 169 167 6 166 229 199 225 159 57 121 100 202 66 88 0 47 124 5 65 181 144 49 109 188 86 34 182 178 166 254 122 74 191 253 150 16 94 202 118 234 123 152 129 106 240 116 140 16 223 4 140 224 18 217 1 1 90 81 241 137 243 136 129 69 192 54 80 170 35 206 137 76 59 216 137 224 48 213 101 7 28 89 244 9 169 152 27 81 135 143 214 252 17 6 36 220 188 222 11 247 166 156 204 227 143 171 223 134 243 190 246 4 72 25 222 17)
#vu8(198 80 221 187 6 1 193 156 161 20 57 225 100 13 217 49 244 60 81 142 165 190 167 13 61 205 229 244 25 31 229 63 0 207 150 101 70 183 43 204 125 88 190 43 155 173 239 40 116 57 84 227 164 74 35 248 128 232 212 241 207 206 45 122 97 69 45 38 218 5 137 111 10 80 218 102 162 57 168 161 136 182 216 37 179 48 90 215 123 115 251 172 8 54 236 198 9 135 253 8 82 124 26 142 128 213 130 62 101 202 254 42 61 0)
#t
())))
(test-signature/testvector
"ed448_test"
:algorithm
"EDDSA"
:public-key
#vu8(48 67 48 5 6 3 43 101 113 3 58 0 168 27 46 138 112 165 172 148 255 219 204 155 173 252 63 235 8 1 242 88 87 139 177 20 173 68 236 225 236 14 121 157 160 142 255 184 28 93 104 92 12 86 246 78 236 174 248 205 241 28 195 135 55 131 140 244 0)
:der-encode
#t
:tests
'(#(86
"RFC 8032: 1023 bytes"
#vu8(109 223 128 46 26 174 73 134 147 95 127 152 27 163 240 53 29 98 115 192 160 194 44 156 14 131 57 22 142 103 84 18 163 222 191 175 67 94 214 81 85 128 7 219 67 132 182 80 252 192 126 59 88 106 39 164 247 160 10 200 166 254 194 205 134 174 75 241 87 12 65 230 164 12 147 29 178 123 47 170 21 168 206 221 82 207 247 54 44 78 110 35 218 236 15 188 58 121 182 128 110 49 110 252 199 182 129 25 191 70 188 118 162 96 103 165 63 41 109 175 219 220 17 199 127 119 119 233 114 102 12 244 182 169 179 105 166 102 95 2 224 204 155 110 223 173 19 107 79 171 231 35 210 129 61 179 19 108 253 233 182 208 68 50 47 238 41 71 149 46 3 27 115 171 92 96 51 73 179 7 189 194 123 198 203 139 139 189 123 211 35 33 155 128 51 165 129 181 158 173 235 176 155 60 79 61 34 119 212 240 52 54 36 172 200 23 128 71 40 178 90 183 151 23 43 76 92 33 162 47 156 120 57 214 67 0 35 46 182 110 83 243 28 114 63 163 127 227 135 199 211 229 11 223 152 19 163 14 91 177 44 244 205 147 12 64 207 180 225 252 98 37 146 164 149 136 121 68 148 213 109 36 234 75 64 200 159 192 89 108 201 235 185 97 200 203 16 173 222 151 106 93 96 43 28 63 133 185 185 160 1 237 60 106 77 59 20 55 245 32 150 205 25 86 208 66 165 151 213 97 165 150 236 211 209 115 90 141 87 14 160 236 39 34 90 44 74 175 242 99 6 209 82 108 26 243 202 109 156 245 162 201 143 71 225 196 109 185 163 50 52 207 212 216 31 44 152 83 138 9 235 231 105 152 208 216 253 37 153 124 125 37 92 109 102 236 230 250 86 241 17 68 149 15 2 119 149 230 83 0 143 75 215 202 45 238 133 216 233 15 61 195 21 19 12 226 160 3 117 163 24 199 195 217 123 226 200 206 91 109 180 26 98 84 255 38 79 166 21 91 174 227 176 119 60 15 73 124 87 63 25 187 79 66 64 40 31 11 31 79 123 232 87 164 229 157 65 108 6 180 197 15 160 158 24 16 221 198 177 70 123 174 172 90 54 104 209 27 110 202 169 1 68 0 22 243 137 248 10 204 77 185 119 2 94 127 89 36 56 140 126 52 10 115 46 85 68 64 231 101 112 248 221 113 183 214 64 179 69 13 31 213 240 65 10 24 249 163 73 79 112 124 113 123 121 180 191 117 201 132 0 176 150 178 22 83 181 210 23 207 53 101 201 89 116 86 247 7 3 73 122 7 135 99 130 155 192 27 177 203 200 250 4 234 220 154 110 63 102 153 88 122 158 117 201 78 91 171 0 54 224 178 231 17 57 44 255 0 71 208 214 176 91 210 165 136 188 16 151 24 149 66 89 241 216 102 120 165 121 163 18 15 25 207 178 150 63 23 122 235 112 242 212 132 72 38 38 46 81 184 2 113 39 32 104 239 91 56 86 250 133 53 170 42 136 178 212 31 42 14 47 218 118 36 194 133 2 114 172 74 47 86 31 143 47 122 49 139 253 92 175 150 150 20 158 74 200 36 173 52 96 83 143 220 37 66 27 238 194 204 104 24 22 45 6 187 237 12 64 163 135 25 35 73 219 103 161 24 186 218 108 213 171 1 64 238 39 50 4 246 40 170 209 193 53 247 112 39 154 101 30 36 216 193 77 117 166 5 157 118 185 106 111 216 87 222 245 224 179 84 178 122 185 55 165 129 93 22 181 250 228 7 255 24 34 44 109 30 210 99 190 104 201 95 50 217 8 189 137 92 215 98 7 174 114 100 135 86 127 154 103 218 215 154 190 195 22 246 131 177 127 45 2 191 7 224 172 139 91 198 22 44 249 70 151 179 194 124 209 254 164 155 39 242 59 162 144 24 113 150 37 6 82 12 57 45 168 182 173 13 153 247 1 63 188 6 194 193 122 86 149 0 200 167 105 100 129 193 205 51 233 177 78 64 184 46 121 165 245 219 130 87 27 169 123 174 58 211 224 71 149 21 187 14 43 15 59 252 209 253 51 3 78 252 98 69 237 221 126 226 8 109 218 226 96 13 140 167 62 33 78 140 43 11 219 43 4 124 106 70 74 86 46 215 123 115 210 216 65 196 179 73 115 85 18 87 113 59 117 54 50 239 186 52 129 105 171 201 10 104 244 38 17 164 1 38 215 203 33 181 134 149 86 129 134 247 229 105 210 255 15 158 116 93 4 135 221 46 185 151 202 252 90 191 157 209 2 230 47 246 108 186 135)
#vu8(227 1 52 90 65 163 154 77 114 255 248 223 105 201 128 117 160 204 8 43 128 47 201 178 182 188 80 63 146 107 101 189 223 127 76 143 28 180 159 99 150 175 200 167 10 190 109 138 239 13 180 120 212 198 178 151 0 118 198 160 72 79 231 109 118 179 169 118 37 215 159 28 226 64 231 197 118 117 13 41 85 40 40 111 113 155 65 61 233 173 163 232 235 120 237 87 54 3 206 48 216 187 118 23 133 220 48 219 195 32 134 158 26 0)
#t
())))
| false |
0330801db11582493cee2fc2de24bfce5fb32a6c
|
6bd63be924173b3cf53a903f182e50a1150b60a8
|
/chapter_2/2.70.scm
|
0d0bdc6d4780f03afb2977116a346b963a5ceaf5
|
[] |
no_license
|
lf2013/SICP-answer
|
d29ee3095f0d018de1d30507e66b12ff890907a5
|
2712b67edc6df8ccef3156f4ef08a2b58dcfdf81
|
refs/heads/master
| 2020-04-06T13:13:51.086818 | 2019-09-11T11:39:45 | 2019-09-11T11:39:45 | 8,695,137 | 0 | 1 | null | 2016-03-17T13:19:21 | 2013-03-11T02:24:41 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,767 |
scm
|
2.70.scm
|
; the thing worth doing typically take time and effort
; 2.70
(define (make-leaf symbol weight)
(list 'leaf symbol weight))
(define (leaf? leaf) (equal? 'leaf (car leaf)))
(define (symbol-leaf leaf) (cadr leaf))
(define (weight-leaf leaf) (caddr leaf))
(define (make-code-tree l r)
(list l r (append (symbols l) (symbols r)) (+ (weight l) (weight r))))
(define (left-branch tree) (car tree))
(define (right-branch tree) (cadr tree))
(define (symbols tree)
(if (leaf? tree) (list (symbol-leaf tree))
(caddr tree)))
(define (weight tree)
(if (leaf? tree) (weight-leaf tree)
(cadddr tree)))
(define (adjoin-set x set)
(cond ((null? set) (list x))
((< (weight x) (weight (car set))) (cons x set))
(else (cons (car set) (adjoin-set x (cdr set))))))
(define (make-leaf-set pairs)
(if (null? pairs) '()
(let ((pair (car pairs)))
(adjoin-set (make-leaf (car pair) (cadr pair))
(make-leaf-set (cdr pairs))))))
(define (successive-merge leaf-set)
(cond ((null? leaf-set) '())
((null? (cdr leaf-set)) (car leaf-set))
(else (successive-merge (adjoin-set (make-code-tree (car leaf-set) (cadr leaf-set)) (cddr leaf-set))))
))
(define (generate-huffman-tree pairs)
(successive-merge (make-leaf-set pairs)))
; picked from 2.68
(define (encode message tree)
(if (null? message) '()
(append (encode-symbol (car message) tree)
(encode (cdr message) tree))))
(define (symbol-contain x container)
(cond ((null? container) false)
((equal? x (car container)) true)
(else (symbol-contain x (cdr container)))))
(define (encode-symbol symbol tree)
(if (null? tree) (error "illegal tree")
(let ((cur-symbols (symbols tree)) (l (left-branch tree)) (r (right-branch tree)))
(if (symbol-contain symbol cur-symbols)
(cond ((leaf? tree) '())
((symbol-contain symbol (symbols l)) (cons 0 (encode-symbol symbol l)))
((symbol-contain symbol (symbols r)) (cons 1 (encode-symbol symbol r))))
(error "sysbol not contailed on the tree")
))))
(define (try)
(define sample-pairs '((A 2) (NA 16) (BOOM 1) (SHA 3) (GET 2) (YIP 9) (JOB 2) (WAH 1)))
(define sample-tree (generate-huffman-tree sample-pairs))
(define message1 '(get a job
sha na na na na na na na na
get a job
sha na na na na na na na na
wah yip yip yip yip yip yip yip yip yip
sha boom))
(display sample-pairs)
(newline)
(define result (encode message1 sample-tree))
(display result)
(newline)
(display (length result))
)
| false |
f41fff1e1a10cf04af39edac9b88261a0245dc13
|
9b0c653f79bc8d0dc87526f05bdc7c9482a2e277
|
/3/3-41.ss
|
08940df97a6dc90aab46cb35bc64d0674be1ec90
|
[] |
no_license
|
ndNovaDev/sicp-magic
|
798b0df3e1426feb24333658f2313730ae49fb11
|
9715a0d0bb1cc2215d3b0bb87c076e8cb30c4286
|
refs/heads/master
| 2021-05-18T00:36:57.434247 | 2020-06-04T13:19:34 | 2020-06-04T13:19:34 | 251,026,570 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 160 |
ss
|
3-41.ss
|
(define (dn x)
(display x)
(newline))
(define false #f)
(define true #t)
; **********************
; parallelExecute
; makeSerializer
; 不存在
(exit)
| false |
6d8fa515386900730362153777a7483684310f36
|
958488bc7f3c2044206e0358e56d7690b6ae696c
|
/poly/DesignPatterns/Flyweight/dict.scm
|
3485612188bd906e1f582fc580fa90639c56ec0e
|
[] |
no_license
|
possientis/Prog
|
a08eec1c1b121c2fd6c70a8ae89e2fbef952adb4
|
d4b3debc37610a88e0dac3ac5914903604fd1d1f
|
refs/heads/master
| 2023-08-17T09:15:17.723600 | 2023-08-11T12:32:59 | 2023-08-11T12:32:59 | 40,361,602 | 3 | 0 | null | 2023-03-27T05:53:58 | 2015-08-07T13:24:19 |
Coq
|
UTF-8
|
Scheme
| false | false | 29 |
scm
|
dict.scm
|
../../../scheme/dict/dict.scm
| false |
e1d4aebc4c5ee0737cfc41f917ea5c672b61b19a
|
e1c580145992634f089af18940508f5c26d2e264
|
/umcu/packages/perl.scm
|
20cba30c8fcf57f4af932da1c816ed6c5a6f2634
|
[] |
no_license
|
inijman/guix-additions
|
8542592972e644a4ccd7b36ad4dd9b5631008fb5
|
b8e0e3f3b9598aade3103e9f491307fa06ece03d
|
refs/heads/master
| 2021-07-13T21:35:25.731179 | 2020-05-28T14:01:04 | 2020-05-28T14:01:04 | 142,980,977 | 0 | 0 | null | 2018-07-31T07:49:53 | 2018-07-31T07:49:53 | null |
UTF-8
|
Scheme
| false | false | 19,429 |
scm
|
perl.scm
|
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016, 2017, 2018 Roel Janssen <[email protected]>
;;;
;;; This file is not officially part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (umcu packages perl)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix build-system perl)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix packages)
#:use-module (gnu packages)
#:use-module (gnu packages base)
#:use-module (gnu packages bioinformatics)
#:use-module (gnu packages compression)
#:use-module (gnu packages perl)
#:use-module (gnu packages perl-check)
#:use-module (gnu packages pkg-config))
(define-public perl-storable
(package
(name "perl-storable")
(version "2.51")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://cpan/authors/id/A/AM/AMS/Storable-"
version ".tar.gz"))
(sha256
(base32 "1gphq8yhqzrwwlx2i5a8914ccw41ywmpl7gc648s5frb269bfrm5"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Storable")
(synopsis "Persistence for Perl data structures")
(description "")
(license #f)))
(define-public perl-set-intervaltree
(package
(name "perl-set-intervaltree")
(version "0.10")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/B/BE/BENBOOTH/Set-IntervalTree-"
version ".tar.gz"))
(sha256
(base32 "1g1yam3fwl11wvy489yhhfzrfdlqaj1dh7pgks3myjq71p7rrgg3"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Set-IntervalTree")
(synopsis "Perform range-based lookups on sets of ranges.")
(description "")
(license #f)))
(define-public perl-math-vecstat
(package
(name "perl-math-vecstat")
(version "0.08")
(source (origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AS/ASPINELLI/Math-VecStat-"
version ".tar.gz"))
(sha256
(base32
"03bdcl9pn2bc9b50c50nhnr7m9wafylnb3v21zlch98h9c78x6j0"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Math-VecStat")
(synopsis "Some basic numeric stats on vectors")
(description "")
(license #f)))
(define-public perl-data-uuid
(package
(name "perl-data-uuid")
(version "1.221")
(source (origin
(method url-fetch)
(uri (string-append "mirror://cpan/authors/id/R/RJ/RJBS/"
"Data-UUID-" version ".tar.gz"))
(sha256
(base32
"0rw60wib0mj5z0v909mplh750y40hzyzf4z0b6h4ajxplyiv5irw"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Data-UUID")
(synopsis "Universally Unique Identifiers generator")
(description "Data::UUID provides a framework for generating Universally
Unique Identifiers (UUIDs), also known as Globally Unique Identifiers (GUIDs).
A UUID is 128 bits long, and is guaranteed to be different from all other
UUIDs/GUIDs generated until 3400 CE.")
(license (package-license perl))))
(define-public perl-const-fast
(package
(name "perl-const-fast")
(version "0.014")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://cpan/authors/id/L/LE/LEONT/"
"Const-Fast-" version ".tar.gz"))
(sha256
(base32
"1nwlldgrx86yn7y6a53cqgvzm2ircsvxg1addahlcy6510x9a1gq"))))
(inputs
`(("perl-module-build-tiny" ,perl-module-build-tiny)
("perl-test-fatal" ,perl-test-fatal)))
;; Needed for tests.
(native-inputs
`(("perl-sub-exporter-progressive" ,perl-sub-exporter-progressive)))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Const-Fast")
(synopsis "Facility for creating read-only scalars, arrays, and hashes")
(description "")
(license (package-license perl))))
(define-public perl-bio-db-hts
(package
(name "perl-bio-db-hts")
(version "2.9")
(source
(origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/R/RI/RISHIDEV/Bio-DB-HTS-"
version
".tar.gz"))
(sha256
(base32
"0z5qvs1xx38nwfr2fqk582apj1jxrbabjxcawp38swj8b5lnqrdb"))))
(build-system perl-build-system)
(arguments
`(#:tests? #f))
(native-inputs
`(("perl-module-build" ,perl-module-build)
("pkg-config" ,pkg-config)))
(inputs
`(("bioperl-minimal" ,bioperl-minimal)
("htslib" ,htslib)
("zlib" ,zlib)))
(home-page "http://search.cpan.org/dist/Bio-DB-HTS")
(synopsis "Perl interface to HTS library for DNA sequencing")
(description "")
(license license:asl2.0)))
(define-public perl-extutils-manifest
(package
(name "perl-extutils-manifest")
(version "1.70")
(source (origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/E/ET/ETHER/"
"ExtUtils-Manifest-" version ".tar.gz"))
(sha256
(base32
"159bypwl8xpq1yi39prr49hl7x2xww5aj97nv169c8xja0h0dzzf"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/ExtUtils-Manifest")
(synopsis "Utilities to write and check a MANIFEST file")
(description "This package contains functions to manipulate a MANIFEST
file. The package exports no functions by default. The following are exported
on request: mkmanifest, manifind, manicheck, filecheck, fullcheck, skipcheck,
maniread, maniskip, manicopy, maniadd.")
(license (package-license perl))))
(define-public perl-bio-pipeline-comparison
(package
(name "perl-bio-pipeline-comparison")
(version "1.123050")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://cpan/authors/id/A/AJ/AJPAGE/"
"Bio-Pipeline-Comparison-" version ".tar.gz"))
(sha256
(base32
"081kn3zyi7zcwkaxrk5w52nkx7jrp0pwjcr8sai25l45711xli49"))))
(build-system perl-build-system)
;; Only one test fails.
(arguments `(#:tests? #f))
(propagated-inputs
`(("htslib" ,htslib)
("which" ,which)))
(native-inputs
`(("perl-env-path" ,perl-env-path)
("perl-test-most" ,perl-test-most)))
(inputs
`(("bioperl-minimal" ,bioperl-minimal)
("perl-exception-class" ,perl-exception-class)
("perl-file-which" ,perl-file-which)
("perl-moose" ,perl-moose)
("perl-try-tiny" ,perl-try-tiny)))
(home-page "http://search.cpan.org/dist/Bio-Pipeline-Comparison")
(synopsis "Comparative assesment of variant calling (CAVar)")
(description "")
(license #f)))
(define-public perl-log-message
(package
(name "perl-log-message")
(version "0.08")
(source (origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/B/BI/BINGOS/Log-Message-"
version ".tar.gz"))
(sha256
(base32
"0ipyk7zbvz31kf3mj5ahwi2cbcfy54s8387hx4cd29mg5bb7ssdx"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Log-Message")
(synopsis "Powerful and flexible message logging mechanism")
(description "")
(license (package-license perl))))
(define-public perl-log-message-simple
(package
(name "perl-log-message-simple")
(version "0.10")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/B/BI/BINGOS/Log-Message-Simple-"
version ".tar.gz"))
(sha256
(base32
"15nxi935nfrf8dkdrgvcrf2qlai4pbz03yj8sja0n9mcq2jd24ma"))))
(build-system perl-build-system)
(inputs
`(("perl-log-message" ,perl-log-message)))
(home-page "http://search.cpan.org/dist/Log-Message-Simple")
(synopsis "Simplified interface to Log::Message")
(description "")
(license (package-license perl))))
(define-public perl-term-ui
(package
(name "perl-term-ui")
(version "0.46")
(source
(origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/B/BI/BINGOS/Term-UI-"
version ".tar.gz"))
(sha256
(base32
"19p92za5cx1v7g57pg993amprcvm1az3pp7y9g5b1aplsy06r54i"))))
(build-system perl-build-system)
(arguments `(#:tests? #f))
(propagated-inputs
`(("perl-log-message-simple" ,perl-log-message-simple)))
(home-page "http://search.cpan.org/dist/Term-UI")
(synopsis "User interfaces via Term::ReadLine made easy")
(description "")
(license (package-license perl))))
(define-public perl-bsd-resource
(package
(name "perl-bsd-resource")
(version "1.2911")
(source
(origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/J/JH/JHI/BSD-Resource-"
version ".tar.gz"))
(sha256
(base32 "0g8c7825ng2m0yz5sy6838rvfdl8j3vm29524wjgf66ccfhgn74x"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/BSD-Resource")
(synopsis "BSD process resource limit and priority functions")
(description "")
(license #f)))
(define-public perl-acme-damn
(package
(name "perl-acme-damn")
(version "0.08")
(source
(origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/I/IB/IBB/Acme-Damn-"
version
".tar.gz"))
(sha256
(base32
"03kykdsz3fk5ppb9g92pvnif67zlk501finrwi1csbcizw1js39i"))))
(build-system perl-build-system)
(inputs
`(("perl-test-exception" ,perl-test-exception)))
(home-page
"http://search.cpan.org/dist/Acme-Damn")
(synopsis "'Unbless' Perl objects.")
(description "")
(license #f)))
(define-public perl-sys-sigaction
(package
(name "perl-sys-sigaction")
(version "0.23")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/L/LB/LBAXTER/Sys-SigAction-"
version
".tar.gz"))
(sha256
(base32
"0lykjlq5dsf7z927lpllzixd953izi3w7bg2pgy32h2k8n9nrvy4"))))
(build-system perl-build-system)
(home-page
"http://search.cpan.org/dist/Sys-SigAction")
(synopsis
"Perl extension for Consistent Signal Handling")
(description "")
(license (package-license perl))))
(define-public perl-forks
(package
(name "perl-forks")
(version "0.36")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/R/RY/RYBSKEJ/forks-"
version
".tar.gz"))
(sha256
(base32
"14srnq51n98aizdlg6lhzpzdqyjvxf5nfm431qiylvsc9zj29gk1"))))
(build-system perl-build-system)
(propagated-inputs
`(("perl-acme-damn" ,perl-acme-damn)
("perl-devel-symdump" ,perl-devel-symdump)
("perl-list-moreutils" ,perl-list-moreutils)
("perl-sys-sigaction" ,perl-sys-sigaction)))
(home-page "http://search.cpan.org/dist/forks")
(synopsis "forks - emulate threads with fork")
(description "")
(license (package-license perl))))
(define-public perl-autodie
(package
(name "perl-autodie")
(version "2.29")
(source
(origin
(method url-fetch)
(uri (string-append
"https://cpan.metacpan.org/authors/id/P/PJ/PJF/autodie-"
version ".tar.gz"))
(sha256
(base32
"1gr9ab292xxman5zfyb3vbrrv88y9j51qlgq7z4pjh80wwbpkdzm"))))
(build-system perl-build-system)
(native-inputs
`(("perl-import-into" ,perl-import-into)))
(propagated-inputs
`(("perl-forks" ,perl-forks)
;("perl-bsd-resource" ,perl-bsd-resource)
;("perl-ipc-system-simple" ,perl-ipc-system-simple)
("perl-sub-identify" ,perl-sub-identify)))
(home-page "http://search.cpan.org/dist/autodie")
(synopsis "Replace functions with ones that succeed or die with lexical scope")
(description "")
(license (package-license perl))))
(define-public perl-parallel-iterator
(package
(name "perl-parallel-iterator")
(version "1.00")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AN/ANDYA/Parallel-Iterator-"
version ".tar.gz"))
(sha256
(base32
"1x252cqzcyxkmf8p5dw34ais47ci1ldv2ds02m7a2ijpryam0jg8"))))
(build-system perl-build-system)
(native-inputs
`(("perl-module-install" ,perl-module-install)
("perl-module-build" ,perl-module-build)
("perl-file-sharedir-install" ,perl-file-sharedir-install)))
(home-page
"http://search.cpan.org/dist/Parallel-Iterator")
(synopsis "Simple parallel execution")
(description "")
(license (package-license perl))))
(define-public perl-ppi
(package
(name "perl-ppi")
(version "1.236")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/M/MI/MITHALDU/PPI-"
version
".tar.gz"))
(sha256
(base32
"1v4a622h19d2d6m070jcxn47siqma9g9ly4fcrnrlz8bkhs4nry6"))))
(build-system perl-build-system)
(arguments
`(#:tests? #f))
(native-inputs
`(("perl-class-inspector" ,perl-class-inspector)
("perl-file-remove" ,perl-file-remove)
("perl-test-nowarnings" ,perl-test-nowarnings)
("perl-test-object" ,perl-test-object)
("perl-test-subcalls" ,perl-test-subcalls)))
(inputs
`(("perl-clone" ,perl-clone)
("perl-io-string" ,perl-io-string)
("perl-list-moreutils" ,perl-list-moreutils)
("perl-params-util" ,perl-params-util)
("perl-task-weaken" ,perl-task-weaken)))
(home-page "http://search.cpan.org/dist/PPI")
(synopsis "Parse, Analyze and Manipulate Perl (without perl)")
(description "")
(license (package-license perl))))
(define-public perl-test-subcalls
(package
(name "perl-test-subcalls")
(version "1.09")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AD/ADAMK/Test-SubCalls-"
version ".tar.gz"))
(sha256
(base32
"0w3fppif2pplbw8l1y3xc3vr1z016x02vdnvwadxff53gm2v0d53"))))
(build-system perl-build-system)
(propagated-inputs
`(("perl-module-install" ,perl-module-install)))
(inputs
`(("perl-hook-lexwrap" ,perl-hook-lexwrap)))
(home-page "http://search.cpan.org/dist/Test-SubCalls")
(synopsis "Track the number of times subs are called")
(description "")
(license (package-license perl))))
(define-public perl-hook-lexwrap
(package
(name "perl-hook-lexwrap")
(version "0.26")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/E/ET/ETHER/Hook-LexWrap-"
version ".tar.gz"))
(sha256
(base32
"0bgc6w8zs45n6ksgk0zisn9a2vcr3lmzipkan2a94kzrk1gxq2xn"))))
(build-system perl-build-system)
(home-page "http://search.cpan.org/dist/Hook-LexWrap")
(synopsis "Lexically scoped subroutine wrappers")
(description "")
(license (package-license perl))))
(define-public perl-test-object
(package
(name "perl-test-object")
(version "0.07")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AD/ADAMK/Test-Object-"
version ".tar.gz"))
(sha256
(base32
"0ah3c7nn4zpg4r7ca00zk5c6xc7zcaxxjyvcc5fxqa4r0cdsjhni"))))
(build-system perl-build-system)
(propagated-inputs
`(("perl-module-install" ,perl-module-install)))
(home-page "http://search.cpan.org/dist/Test-Object")
(synopsis "Thoroughly testing objects via registered handlers")
(description "")
(license (package-license perl))))
(define-public perl-ppi-html
(package
(name "perl-ppi-html")
(version "1.08")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/A/AD/ADAMK/PPI-HTML-"
version
".tar.gz"))
(sha256
(base32
"04f5sfrb6ckfdd3lnyipmky9mdgsxr5b724sp1xaszx86d09c9l4"))))
(build-system perl-build-system)
(arguments
`(#:tests? #f))
(propagated-inputs
`(("perl-module-install" ,perl-module-install)))
(inputs
`(("perl-css-tiny" ,perl-css-tiny)
("perl-params-util" ,perl-params-util)
("perl-ppi" ,perl-ppi)))
(home-page
"http://search.cpan.org/dist/PPI-HTML")
(synopsis
"Generate syntax-hightlighted HTML for Perl using PPI")
(description "")
(license (package-license perl))))
(define-public perl-css-tiny
(package
(name "perl-css-tiny")
(version "1.20")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/C/CH/CHORNY/CSS-Tiny-"
version
".tar.gz"))
(sha256
(base32
"1yjjn4li8v3d51l7jgrbbkhjdpfm9mmira2xfgf3s58wlkk9vx38"))))
(build-system perl-build-system)
(home-page
"http://search.cpan.org/dist/CSS-Tiny")
(synopsis
"Read/Write .css files with as little code as possible")
(description "")
(license (package-license perl))))
(define-public perl-devel-cover
(package
(name "perl-devel-cover")
(version "1.29")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://cpan/authors/id/P/PJ/PJCJ/Devel-Cover-"
version ".tar.gz"))
(sha256
(base32
"0afkabxbbbwbnfh6b957cwxx1vcz00r4q49jbhcip3w6ib4pv60n"))))
(build-system perl-build-system)
(arguments
`(#:tests? #f))
(native-inputs
`(("perl-test-differences" ,perl-test-differences)))
(inputs
`(("perl-browser-open" ,perl-browser-open)
("perl-capture-tiny" ,perl-capture-tiny)
("perl-class-xsaccessor" ,perl-class-xsaccessor)
("perl-moo" ,perl-moo)
("perl-namespace-clean" ,perl-namespace-clean)
("perl-parallel-iterator" ,perl-parallel-iterator)
("perltidy" ,perltidy)
("perl-pod-coverage" ,perl-pod-coverage)
("perl-ppi-html" ,perl-ppi-html)
("perl-template-toolkit" ,perl-template-toolkit)
("perl-test-differences" ,perl-test-differences)))
(home-page
"http://search.cpan.org/dist/Devel-Cover")
(synopsis "Code coverage metrics for Perl")
(description "")
(license (package-license perl))))
| false |
1f5e723712b16931853b369504777ef5a5079f2b
|
2e4afc99b01124a1d69fa4f44126ef274f596777
|
/apng/resources/dracula/test/test-modular.ss
|
512d5125b115e04460c63054a05ec2a3051696ac
|
[] |
no_license
|
directrix1/se2
|
8fb8204707098404179c9e024384053e82674ab8
|
931e2e55dbcc55089d9728eb4194ebc29b44991f
|
refs/heads/master
| 2020-06-04T03:10:30.843691 | 2011-05-05T03:32:54 | 2011-05-05T03:32:54 | 1,293,430 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,744 |
ss
|
test-modular.ss
|
#lang scheme/base
(require "../private/planet.ss"
"../proof/proof.ss"
"../proof/syntax.ss"
"../lang/acl2-module-v.ss"
"program-tests.ss")
(require (schemeunit test))
(provide test-modular)
(define (proof->sexp proof)
(for/list ([name (proof-parts proof)])
(part->sexp (proof-part proof name))))
(define (part->sexp part)
(for/list ([i (in-range (part-length part))])
(term-sexp (part-nth part i))))
(define (program defns [repl null])
(make-module-program/mred modular-acl2-module-v defns repl))
(define (test/modular name defns repl result proof)
(let* ([prog (program defns repl)])
(test-suite name
(test-case "proof"
(check-equal?
(proof->sexp (get-proof (car (check-expand-success prog))))
proof))
(test-case "program"
(check-equal? (check-eval-success prog) result)))))
(define test-modular
(test-suite "Modular"
(test/modular "top-level" '[] '[(integerp (+ 1 2 3))] 't '[])
(test/modular
"interface + module + invoke"
'[(interface IIdentity (sig id (x)) (con id-equal (equal (id x) x)))
(module MIdentity (defun id (x) x) (export IIdentity))
(invoke MIdentity)]
'[(id 1)]
1
'[[(defun id (x) x)
(defthm id-equal (equal (id x) x))]])
(test/modular
"link + invoke"
'[(interface IInc (sig inc (x)) (con inc-+ (equal (inc x) (+ x 1))))
(interface ISkip (sig skip (x)) (con skip-+ (equal (skip x) (+ x 2))))
(module MInc (defun inc (x) (+ 1 x)) (export IInc))
(module MInc-Skip (import IInc) (defun skip (x) (inc (inc x))) (export ISkip))
(link MSkip (MInc MInc-Skip))
(invoke MSkip)]
'[(skip 1)]
3
'[[(defun inc (x) (+ 1 x))
(defthm inc-+ (equal (inc x) (+ x 1)))]
[(progn (defstub inc (x) t)
(defaxiom inc-+ (equal (inc x) (+ x 1))))
(defun skip (x) (inc (inc x)))
(defthm skip-+ (equal (skip x) (+ x 2)))]])
(test/modular
"rename + link + invoke"
'[(interface IInc (sig inc (x)) (con inc-+ (equal (inc x) (+ x 1))))
(interface ISkip (sig skip (x)) (con skip-+ (equal (skip x) (+ x 2))))
(module MInc (defun add1 (x) (+ 1 x)) (export IInc (inc add1)))
(module MInc-Skip (import IInc (inc hop)) (defun skip (x) (hop (hop x))) (export ISkip))
(link MSkip (MInc MInc-Skip))
(invoke MSkip)]
'[(skip 1)]
3
'[[(defun add1 (x) (+ 1 x))
(defthm inc-+ (equal (add1 x) (+ x 1)))]
[(progn (defstub hop (x) t) (defaxiom inc-+ (equal (hop x) (+ x 1))))
(defun skip (x) (hop (hop x)))
(defthm skip-+ (equal (skip x) (+ x 2)))]])
(test/modular
"include + rename"
'[(interface ONE (sig f (x)))
(interface TWO (include ONE) (sig g (x)) (con f=g (equal (f x) (g x))))
(module M (import ONE (f it)) (export TWO (g it)))]
'['dummy]
'dummy
'[[(defstub it (x) t)
(defthm f=g (equal (it x) (it x)))]])
(test/modular
"induction (concrete function)"
'[(interface I (fun f (x) (if (endp x) 0 (1+ (f (cdr x))))))
(module A (defun f (x) (if (endp x) 0 (1+ (f (cdr x))))) (export I))
(module B (import I))
(invoke A)]
'[(f (list 1 2 3))]
3
'[[(defun f (x) (if (endp x) 0 (1+ (f (cdr x)))))
(defun f (x) (if (endp x) 0 (1+ (f (cdr x)))))]
[(skip-proofs (defun f (x) (if (endp x) 0 (1+ (f (cdr x))))))]])
(test/modular
"multiple returns in signatures"
'[(interface I (sig f (a b) (c d)))
(module A
(defun f (x y)
(mv (+ x y) (- x y)))
(export I))
(module B
(import I))
(invoke A)]
'[(mv-let (a b) (f 3 4) (list a b))]
(list 7 -1)
'[[(defun f (x y) (mv (+ x y) (- x y))) (progn)]
[(defstub f (a b) (mv c d))]])
(test/modular
"include-book / teachpack"
'[(interface I
(sig replicate (n x))
(con replicate/list (true-listp (replicate n x))))
(module LI
(include-book "list-utilities" :dir :teachpacks)
(export I))
(invoke LI)]
'[(replicate 5 'x)]
(list 'x 'x 'x 'x 'x)
'[[(include-book "list-utilities" :dir :teachpacks)
(defthm replicate/list (true-listp (replicate n x)))]])
(test/modular
"include-book / system"
'[(interface I (sig id (x)) (con ident (equal (id x) x)))
(module M
(include-book "arithmetic-3/extra/top-ext" :dir :system)
(defun id (x) x)
(export I))
(invoke M)]
'[(id 7)]
7
'[[(include-book "arithmetic-3/extra/top-ext" :dir :system)
(defun id (x) x)
(defthm ident (equal (id x) x))]])
))
| false |
f9daa287b9f1628e2906b7759598a79b8bf12a76
|
92b8d8f6274941543cf41c19bc40d0a41be44fe6
|
/testsuite/sva37684.scm
|
41fe19f6ef2b9a8e05c24a683490780e25c8a3a8
|
[
"MIT"
] |
permissive
|
spurious/kawa-mirror
|
02a869242ae6a4379a3298f10a7a8e610cf78529
|
6abc1995da0a01f724b823a64c846088059cd82a
|
refs/heads/master
| 2020-04-04T06:23:40.471010 | 2017-01-16T16:54:58 | 2017-01-16T16:54:58 | 51,633,398 | 6 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 323 |
scm
|
sva37684.scm
|
(define-alias C java.lang.Character)
(define c1 ::C (C:valueOf #\X))
(define c2 ::C:Subset C:UnicodeBlock:ARABIC)
(define-simple-class TestNestedType ()
(x1 ::C)
(x2 ::C:Subset))
(define tn ::TestNestedType (TestNestedType x1: c1 x2: c2))
(format #t "x1: ~a x2: ~a~%~!" tn:x1 tn:x2)
;; Output: x1: X x2: ARABIC
| false |
8ce817248ce99d7be37a845587f481385f174a70
|
6488db22a3d849f94d56797297b2469a61ad22bf
|
/make/make.scm
|
4a88bb77bfb3b6d4efda275531669a632f1c68bb
|
[] |
no_license
|
bazurbat/chicken-eggs
|
34d8707cecbbd4975a84ed9a0d7addb6e48899da
|
8e741148d6e0cd67a969513ce2a7fe23241df648
|
refs/heads/master
| 2020-05-18T05:06:02.090313 | 2015-11-18T16:07:12 | 2015-11-18T16:07:12 | 22,037,751 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 8,668 |
scm
|
make.scm
|
;;;; make.scm - PLT's `make' macro for CHICKEN - felix
#|
> (make ((target (depend ...) command ...) ...) argv)
expands to
(make/proc
(list (list target (list depend ...) (lambda () command ...)) ...)
argv)
> (make/proc spec argv) performs a make according to `spec' and using
`argv' as command-line arguments selecting one or more targets.
`argv' can either be a string or a vector of strings.
`spec' is a MAKE-SPEC:
MAKE-SPEC = (list-of MAKE-LINE)
MAKE-LINE = (list TARGET (list-of DEPEND-STRING) COMMAND-THUNK)
TARGET = (union string (list-of string)) ; either a string or a list of strings
DEPEND-STRING = string
COMMAND-THUNK = (-> void)
To make a target, make/proc is first called on each of the target's
dependencies. If a target is not in the spec and it exists, then the
target is considered made. If a target is older than any of its
dependencies, the corresponding COMMAND-THUNK is invoked. The
COMMAND-THUNK is optional; a MAKE-LINE without a COMMAND-THUNK is
useful as a target for making a number of other targets (the
dependencies).
Parameters:
> (make-print-checking [on?]) - If #f, make only prints when it is
making a target. Otherwise, it prints when it is checking the
dependancies of a target. Defaultly #t.
> (make-print-dep-no-line [on?]) - If #f, make only prints "checking..."
lines for dependancies that have a corresponding make line. Defaultly
#f.
> (make-print-reasons [on?]) If #t, make prints the reason for each
dependency that fires. Defaultly #t.
|#
(require-library srfi-1 posix)
(module make (make make/proc make-print-checking
make-print-dep-no-line
make-print-reasons
make-nonfile-targets)
(import scheme chicken extras posix srfi-1)
(define make-print-checking (make-parameter #f))
(define make-print-dep-no-line (make-parameter #f))
(define make-print-reasons (make-parameter #f))
(define make-nonfile-targets (make-parameter '()))
(define (make:find-matching-line str spec)
(let ((match? (lambda (s) (string=? s str))))
(let loop ((lines spec))
(cond
((null? lines) #f)
(else (let* ((line (car lines))
(names (if (string? (car line))
(list (car line))
(car line))))
(if (any match? names)
line
(loop (cdr lines)))))))))
(define (make:form-error s p)
(error (sprintf "~a: ~s" s p)))
(define (make:line-error s p n)
(error (sprintf "~a: ~s for line: ~a" s p n)))
(define (make:check-spec spec)
(and
(or (list? spec) (make:form-error "specification is not a list" spec))
(or (pair? spec) (make:form-error "specification is an empty list" spec))
(every
(lambda (line)
(and
(or (and (list? line) (<= 2 (length line) 3))
(make:form-error "list is not a list with 2 or 3 parts" line))
(or (or (string? (car line))
(and (list? (car line))
(every string? (car line))))
(make:form-error "line does not start with a string or list of strings" line))
(let ((name (car line)))
(or (list? (cadr line))
(make:line-error "second part of line is not a list" (cadr line) name)
(every (lambda (dep)
(or (string? dep)
(make:form-error "dependency item is not a string" dep)))
(cadr line)))
(or (null? (cddr line))
(procedure? (caddr line))
(make:line-error "command part of line is not a thunk" (caddr line) name)))))
spec)))
(define (make:check-argv argv)
(or (string? argv)
(every
string?
(if (vector? argv) (vector->list argv) argv))
(error "argument is not a string or string vector" argv)))
(define (make:make/proc/helper spec argv)
(make:check-spec spec)
(make:check-argv argv)
(letrec ((made '())
(exn? (condition-predicate 'exn))
(exn-message (condition-property-accessor 'exn 'message))
(make-file
(lambda (s indent)
(let ((line (make:find-matching-line s spec))
(date (and (file-exists? s)
(file-modification-time s))))
(when (and (make-print-checking)
(or line
(make-print-dep-no-line)))
(printf "make: ~achecking ~a~%" indent s))
(if line
(let ((deps (cadr line)))
(for-each (let ((new-indent (string-append " " indent)))
(lambda (d) (make-file d new-indent)))
deps)
(let ((reason
(or (not date)
(find (lambda (dep)
(and (not (member dep (make-nonfile-targets)))
(unless (file-exists? dep)
(error (sprintf "dependency ~a was not made~%" dep)))
(and (> (file-modification-time dep) date)
dep)))
deps))))
(when reason
(let ((l (cddr line)))
(unless (null? l)
(set! made (cons s made))
(printf
"make: ~amaking ~a~a~%"
(if (make-print-checking) indent "")
s
(if (make-print-reasons)
(cond
((and (not date) (not (member s (make-nonfile-targets))))
(string-append " because " s " does not exist"))
((string? reason)
(string-append " because " reason " changed"))
(else
(string-append (sprintf " just because (reason: ~a date: ~a)" reason date))))
""))
(handle-exceptions
exn
(begin
(printf "make: Failed to make ~a: ~a~%"
(car line)
(if (exn? exn)
(exn-message exn)
exn))
(signal exn) )
((car l))))))))
(unless date
(error (sprintf "don't know how to make ~a" s))))))))
(cond
((string? argv) (make-file argv ""))
((or (null? argv) (equal? argv '#())) (make-file (caar spec) ""))
(else (for-each (lambda (f) (make-file f ""))
(if (vector? argv) (vector->list argv) argv))))
(for-each (lambda (item)
(printf "make: made ~a~%" item))
(reverse made))))
(define make/proc
(case-lambda
((spec) (make:make/proc/helper spec '()))
((spec argv) (make:make/proc/helper spec argv))))
(define-syntax make
(er-macro-transformer
(lambda (expr rename compare)
(let ((make
(lambda (spec argv)
(let ((form-error (lambda (s . p) (apply error s spec p))))
(and (or (list? spec)
(form-error "illegal specification (not a sequence)"))
(or (pair? spec)
(form-error "empty specification"))
(every
(lambda (line)
(and
(or (and (list? line) (>= (length line) 2))
(form-error
"clause does not have at least 2 parts"
line))
(let ((name (car line)))
(or (list? (cadr line))
(form-error
"second part of clause is not a sequence"
(cadr line))))))
spec))
`(,(rename 'make/proc)
(list ,@(map (lambda (line)
`(,(rename 'list) ,(car line)
(,(rename 'list) ,@(cadr line))
,@(let ((l (cddr line)))
(if (null? l)
'()
`((,(rename 'lambda) ()
,@l))))))
spec))
,(if (vector? argv) `',argv (car argv)))))))
(cond
((null? (cdr expr))
(error "no arguments to make"))
((pair? (cddr expr))
(make (cadr expr) (cddr expr)))
(else
(make (cadr expr) '#())))))))
)
| true |
667b50b661673356f90b00e84735c9856c8d70da
|
53cb8287b8b44063adcfbd02f9736b109e54f001
|
/support/system.scm
|
4c3c777954284610d00df0c4d083d019e804d295
|
[] |
no_license
|
fiddlerwoaroof/yale-haskell-reboot
|
72aa8fcd2ab7346a4990795621b258651c6d6c39
|
339b7d85e940db0b8cb81759e44abbb254c54aad
|
refs/heads/master
| 2021-06-22T10:32:25.076594 | 2020-10-30T00:00:31 | 2020-10-30T00:00:31 | 92,361,235 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,422 |
scm
|
system.scm
|
;;; system.scm -- haskell system setup
;;;
;;; author : Sandra Loosemore
;;; date : 22 Nov 1991
;;;
;;; This file loads in the compilation unit definition files for all
;;; of the components of the haskell system.
;;;
;;; (The compilation unit facility is defined in support/shared/compile.scm.)
;;; First load the files containing module definitions.
;;; *** Add more files to the end of this list.
(load "support/support")
(load "ast/ast")
(load "top/top")
(load "util/haskell-utils")
(load "printers/printers")
(load "parser/parser")
(load "import-export/ie.scm")
(load "tdecl/tdecl.scm")
(load "derived/derived.scm")
(load "prec/prec.scm")
(load "depend/depend.scm")
(load "type/type.scm")
(load "cfn/cfn.scm")
(load "flic/flic.scm")
(load "backend/backend.scm")
(load "runtime/runtime.scm")
(load "csys/csys")
(load "command-interface/command-interface")
;;; Define some functions to actually do the work. The compilation unit
;;; facility has conveniently kept a list of all of the unit definitions,
;;; so we can just rip through them in sequence.
(define (compile-haskell)
(compile-and-load-unit-list compilation-units))
(define (recompile-haskell)
(unless (null? remaining-units)
(compile-and-load-unit-list remaining-units)))
(define (load-haskell)
(load-unit-list compilation-units))
(define (reload-haskell)
(unless (null? remaining-units)
(load-unit-list remaining-units)))
| false |
4998024a70c3b730d1e29015357ac1676f48fbae
|
d074b9a2169d667227f0642c76d332c6d517f1ba
|
/sicp/ch_4/exercise.4.69.scm
|
8721a1132f760705d6ec930a54a98c40d876ac8d
|
[] |
no_license
|
zenspider/schemers
|
4d0390553dda5f46bd486d146ad5eac0ba74cbb4
|
2939ca553ac79013a4c3aaaec812c1bad3933b16
|
refs/heads/master
| 2020-12-02T18:27:37.261206 | 2019-07-14T15:27:42 | 2019-07-14T15:27:42 | 26,163,837 | 7 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 802 |
scm
|
exercise.4.69.scm
|
#!/usr/bin/env csi -s
(require rackunit)
;;; Exercise 4.69
;; Beginning with the data base and the rules you
;; formulated in *Note Exercise 4-63::, devise a rule for adding
;; "greats" to a grandson relationship. This should enable the system
;; to deduce that Irad is the great-grandson of Adam, or that Jabal
;; and Jubal are the great-great-great-great-great-grandsons of Adam.
;; (Hint: Represent the fact about Irad, for example, as `((great
;; grandson) Adam Irad)'. Write rules that determine if a list ends
;; in the word `grandson'. Use this to express a rule that allows
;; one to derive the relationship `((great . ?rel) ?x ?y)', where
;; `?rel' is a list ending in `grandson'.) Check your rules on
;; queries such as `((great grandson) ?g ?ggs)' and `(?relationship
;; Adam Irad)'.
| false |
22fba9598e0f6e78fab6a3b2eb8b6f26a55cbcb8
|
427586e066e5d7d146d3b24c1400781a91011a94
|
/code/goto.scm
|
ad0d8fb0cd8330b289da186b6f6aabdb4c9aa447
|
[
"LicenseRef-scancode-public-domain"
] |
permissive
|
cslarsen/scheme-presentation
|
07cb3d5d7850cc6e7616dad43718c139178cbd7c
|
7b66aef60041f95358f0eab72c58ac400e1f902f
|
refs/heads/master
| 2016-08-11T14:50:33.517262 | 2016-01-28T07:25:06 | 2016-01-28T07:25:06 | 50,564,125 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 293 |
scm
|
goto.scm
|
(import (scheme base)
(scheme process-context)
(print)
(goto))
(define n 0)
(println "Should now print 100 \"Hi!\"s:")
(begin
(label 10)
(print "Hi! ")
(set! n (+ 1 n))
(if (< n 100)
(goto 10)
(exit))
(println "This line will never execute..."))
| false |
e2ec4ae5ef4f698962e16e9cdb173c942cb76573
|
abb7fc41490ade0707841086abb4f50866003844
|
/eval.scm
|
be48ed804d7008ea511be1dd6d549a647b90d56b
|
[] |
no_license
|
anttih/lol
|
8b23ab9ba9c9d8d3f4d96c9874ee043245af6b93
|
d56e9433a5f35ddfca7b3464af9df6a4d51fe4f1
|
refs/heads/master
| 2021-01-19T18:02:52.761819 | 2012-10-14T16:21:51 | 2012-10-14T16:21:51 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 11,060 |
scm
|
eval.scm
|
(declare
(unit evaler)
(uses srfi-1 srfi-69))
(define (definition? sexpr)
(tagged-list? sexpr 'def))
(define (frame-bind frame name val)
(cons (cons name (car frame))
(cons val (cdr frame))))
(define (frame-names frame)
(car frame))
(define (frame-values frame)
(cdr frame))
(define (define-variable! env name val)
(set-car! env (frame-bind (car env) name val)))
(define (lookup-variable-value frame name)
(let search-frame ((names (car frame))
(values (cdr frame)))
(if (null? names)
#f
(if (eq? (car names) name)
(car values)
(search-frame (cdr names)
(cdr values))))))
(define (empty-environment? env) (null? env))
; lookup a binding in the environment
(define (lookup-variable env name)
(if (empty-environment? env)
(throw (conc "Variable not bound: " name))
(let ((found (lookup-variable-value (car env) name)))
(if found
found
(lookup-variable (cdr env) name)))))
(define (frame-set-variable frame name value)
(let search-frame ((names (car frame))
(values (cdr frame)))
(if (null? names)
#f
(if (eq? (car names) name)
(begin (set-car! values value) #t)
(search-frame (cdr names)
(cdr values))))))
(define (env-set-variable env name value)
(if (null? env)
(begin (define-variable! root-env name value) value)
(let ((succ (frame-set-variable (car env) name value)))
(if succ value (env-set-variable (cdr env) name value)))))
(define (parameter-list? s) (list? s))
(define (tagged-list? sexpr tag)
(and (pair? sexpr)
(eq? (car sexpr) tag)))
(define (thunk? s)
(not (null? s)))
(define (lambda? sexpr)
(and (equal? (car sexpr) 'fn)
(parameter-list? (cadr sexpr))
(thunk? (cddr sexpr))))
(define (lambda-params s) (cadr s))
(define (lambda-sequence s)
(cons 'do (cddr s)))
(define (make-compound-procedure ptree seq env)
(list 'procedure ptree seq env))
(define (compound-procedure? p) (tagged-list? p 'procedure))
(define (make-primitive-procedure arity n-ary-flag p)
(list 'primitive arity n-ary-flag p))
(define (primitive-procedure? p) (tagged-list? p 'primitive))
(define (proc-env p)
(cadr p))
(define (proc-params p)
(caddr p))
(define (proc-sequence p)
(cadddr p))
(define (sequence? sexpr)
(tagged-list? sexpr 'do))
(define (last-exp? seq)
(null? (cdr seq)))
;; environment
(define (make-environment names values)
(extend-env '() names values))
(define (make-frame names values)
(cons names values))
(define (extend-env env names values)
(cons (make-frame names values) env))
(define (self-evaluating? e)
(or (number? e)
(string? e)
(keyword? e)))
(define (boolean-value? e)
(and (symbol? e)
(or (eq? e 'true)
(eq? e 'false))))
(define (boolean-eval s)
(if (eq? s 'true) #t #f))
(define (quoted? e) (tagged-list? e 'quote))
(define (expand-cond s)
(define (make-if test con alt)
(list 'if test con alt))
(define (else? s)
(tagged-list? s 'else))
(let process-cond ((conds (cdr s)))
(if (null? conds)
'false
(make-if (car conds)
(cadr conds)
(if (else? (cddr conds))
(cadddr conds)
(process-cond (cddr conds)))))))
(define (analyze-vector s)
(define (make-vector-cont c)
(lambda (xs) (c (list->vector xs))))
(let ((xs (map (lambda (val) (analyze val)) (vector->list s))))
(lambda (env c)
(eval-list c env (make-vector-cont c) xs))))
(define (analyze-hash-table s)
(define (interleave keys vals)
(if (null? keys)
'()
(cons
(cons (car keys) (car vals))
(interleave (cdr keys) (cdr vals)))))
(define (make-hash-cont c keys)
(lambda (vals) (c (alist->hash-table (interleave keys vals)))))
(let ((vals (map analyze (hash-table-values s))))
(lambda (env c)
(eval-list c env (make-hash-cont c (hash-table-keys s)) vals))))
(define (analyze-self-evaluating v)
(lambda (env c) (c v)))
(define (analyze-boolean s)
(let ((bool (boolean-eval s)))
(lambda (env c) (c bool))))
(define (analyze-variable s)
(lambda (env c) (c (lookup-variable env s))))
(define (analyze-quoted s)
(let ((quoted (cadr s)))
(lambda (env c) (c quoted))))
(define (analyze-if s)
(let ((test (analyze (cadr s)))
(then (analyze (caddr s)))
(alt (if (> (length s) 3)
(analyze (cadddr s))
(analyze-boolean 'false))))
(lambda (env c)
(test env (make-if-cont s c then alt env)))))
(define-record error msg calls)
(define (throw msg)
(make-error msg '()))
(define-syntax error-or
(syntax-rules ()
((_ source value cont alt ...)
(if (error? value)
(begin
(error-calls-set! value (cons source (error-calls value)))
(cont value))
(begin alt ...)))))
(define (make-if-cont source cont then alt env)
(lambda (v)
(error-or source v cont ((if (true? v) then alt) env (make-catch-cont source cont)))))
(define (error-add-history! error source)
(error-calls-set! error (cons source (error-calls error))))
(define (make-catch-cont s c)
(lambda (e)
(if (error? e)
(begin
(error-add-history! e s)
(c e))
(c e))))
(define (true? v)
(not (eq? v #f)))
(define (analyze-seq s)
(define (eval-seq procs env c)
(if (pair? procs)
(if (pair? (cdr procs))
((car procs) env (make-do-cont procs env c))
((car procs) env c))
(c '())))
(define (make-do-cont procs env c)
(lambda (v) (error-or s v c (eval-seq (cdr procs) env c))))
(let ((procs (map analyze s)))
(lambda (env c) (eval-seq procs env (make-catch-cont s c)))))
;; eval a list of values and return them to the continuation
(define (eval-list orig-cont env c args)
(define (make-list-cont c env args)
(lambda (evaled)
(if (error? evaled)
(orig-cont evaled)
(eval-list orig-cont env (make-gather-cont c evaled) (cdr args)))))
(define (make-gather-cont c evaled)
(lambda (v) (c (cons evaled v))))
(if (pair? args)
((car args) env (make-list-cont c env args))
(c '())))
(define (analyze-args s)
(let ((args (map analyze s)))
(lambda (env c) (eval-list c env c args))))
(define (analyze-anon ptree seq)
(let ((s (analyze-seq seq)))
(lambda (env c) (c (make-compound-procedure ptree s env)))))
(define (analyze-lambda s)
(analyze-anon (cadr s) (cddr s)))
(define (expand-let s)
(define (pairs s)
(if (null? s)
'()
(cons (cons (car s) (cadr s))
(pairs (cddr s)))))
(define (let-names spec)
(if (not (= (modulo (length spec) 2) 0))
(error "Unmatched number of let bindings")
(map car (pairs spec))))
(define (let-vals spec)
(map cdr (pairs spec)))
(cons
(cons 'fn
(cons (let-names (cadr s))
(cddr s)))
(let-vals (cadr s))))
(define (analyze-let s)
(analyze-application (expand-let s)))
(define (analyze-set! s)
(let ((var (cadr s))
(val (analyze (caddr s))))
(lambda (env c)
(val env (make-set-cont c env var)))))
(define (make-set-cont c env name)
(lambda (val) (c (env-set-variable env name val))))
(define (make-def-cont c name env)
(lambda (v)
(define-variable! env name v)
(c '(inert))))
(define (analyze-definition s)
(let ((name (cadr s))
(value (analyze (caddr s))))
(lambda (env c)
(value env (make-def-cont c name env)))))
(define (analyze-function-definition s)
(let ((name (cadr s))
(fun (analyze-anon (caddr s) (cdddr s))))
(lambda (env c)
(fun env (make-def-cont c name env)))))
(define (make-apply-cont s c args env)
(lambda (p) (args env (make-ptree-cont s (make-compound-invoke-cont s c p) p))))
(define (make-arity-check-cont c p)
(lambda (args)
(if (error? args)
(c args)
(if (or (= (length args) (cadr p))
(and (caddr p) ; n-ary
(>= (length args) (cadr p))))
(c args)
(c (throw (conc "Expected " (cadr p) " arguments but got " (length args))))))))
(define (make-ptree-cont s c p)
(define (ptree-match tree obj treem objm)
(cond ((symbol? tree) (cons (cons tree treem)
(cons obj objm)))
((null? tree)
(if (null? obj)
(cons treem objm)
(throw "ptree does not match")))
(else (if (not (pair? obj))
(throw "ptrees do not match")
(let* ((left (ptree-match (car tree) (car obj) treem objm)))
(ptree-match (cdr tree) (cdr obj) (car left) (cdr left)))))))
(lambda (args)
(c (ptree-match (cadr p) args '() '()))))
(define (make-primitive-invoke-cont s c p)
(lambda (args) (error-or s args c (c (apply (cadddr p) args)))))
(define (make-compound-invoke-cont s c p)
(lambda (args) (error-or s args c ((caddr p) (extend-env (cadddr p) (car args) (cdr args)) c))))
(define (analyze-application s)
(let ((p (car s))
(args (analyze-args (cdr s))))
(if (pair? p)
;; ((fn () ...) ...)
(let ((f (analyze-lambda p)))
(lambda (env c)
(f env (make-apply-cont s c args env))))
;; (proc ...)
(lambda (env c)
(let ((proc (lookup-variable env p)))
(error-or s proc c
(cond ((compound-procedure? proc)
(args env (make-ptree-cont s (make-compound-invoke-cont s c proc) proc)))
((primitive-procedure? proc)
(args env (make-arity-check-cont (make-primitive-invoke-cont s c proc) proc)))
(else (error (conc "cannot invoke " proc))))))))))
(define (analyze-call/cc s)
(define (c-args cc)
(let ((p (make-primitive-procedure 1 #f cc)))
(lambda (env c) (c (list p)))))
(let ((f (analyze-lambda (cadr s))))
(lambda (env c)
(f env (make-apply-cont s c (c-args c) env)))))
(define (analyze s)
(if (atom? s)
(cond ((self-evaluating? s) (analyze-self-evaluating s))
((boolean-value? s) (analyze-boolean s))
((symbol? s) (analyze-variable s))
((vector? s) (analyze-vector s))
((hash-table? s) (analyze-hash-table s)))
(case (car s)
((quote) (analyze-quoted s))
((if) (analyze-if s))
((cond) (analyze-if (expand-cond s)))
((let) (analyze-let s))
((set!) (analyze-set! s))
((fn) (analyze-lambda s))
((do) (analyze-seq (cdr s)))
((def) (analyze-definition s))
((defn) (analyze-function-definition s))
((call/cc) (analyze-call/cc s))
(else (analyze-application s)))))
(define (evaluate sexpr c env)
(set! root-env env)
((analyze sexpr) env c))
(define (inert? v) (tagged-list? v 'inert))
| true |
75052a4055df0a386aa3d4eb9515bb17d6554d7c
|
a8216d80b80e4cb429086f0f9ac62f91e09498d3
|
/tests/memory/test00-read-string.scm
|
8a1ca6655156fe2855f7766fe13baee2c3d9abe5
|
[
"BSD-3-Clause"
] |
permissive
|
ashinn/chibi-scheme
|
3e03ee86c0af611f081a38edb12902e4245fb102
|
67fdb283b667c8f340a5dc7259eaf44825bc90bc
|
refs/heads/master
| 2023-08-24T11:16:42.175821 | 2023-06-20T13:19:19 | 2023-06-20T13:19:19 | 32,322,244 | 1,290 | 223 |
NOASSERTION
| 2023-08-29T11:54:14 | 2015-03-16T12:05:57 |
Scheme
|
UTF-8
|
Scheme
| false | false | 424 |
scm
|
test00-read-string.scm
|
(define (show-string str)
(display "string: ")
(display (substring str 0 (min (string-length str) 4)))
(display "...\n"))
(define str-length (inexact->exact (round (* 2 1024 1024)))) ;; 2MB
(define str1
(let ((tmp (make-string str-length #\a)))
(string-set! tmp 0 #\")
(string-set! tmp (- str-length 1) #\")
tmp))
(show-string str1)
(define str2 (call-with-input-string str1 read))
(show-string str2)
| false |
01bec5686f34ce2495bd10d205b6e2a6e6f2336f
|
2c01a6143d8630044e3629f2ca8adf1455f25801
|
/scheme-tools/table.ss
|
9a3fd5ce342c4afc7b77dcead989624f70b5f73b
|
[] |
no_license
|
stuhlmueller/scheme-tools
|
e103fac13cfcb6d45e54e4f27e409adbc0125fe1
|
6e82e873d29b34b0de69b768c5a0317446867b3c
|
refs/heads/master
| 2021-01-25T10:06:33.054510 | 2017-05-09T19:44:12 | 2017-05-09T19:44:12 | 1,092,490 | 5 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 931 |
ss
|
table.ss
|
#!r6rs
(library
(scheme-tools table)
(export make-table
table-add!
table-lookup
table-lookup/set!)
(import (rnrs)
(rnrs mutable-pairs)
(scheme-tools readable-scheme))
(define (make-table equality)
(pair '() equality))
(define (table-add! table-container key val)
(set-car! table-container
(cons (cons key val) (car table-container))))
(define (table-lookup table-container key default-lambda)
(let* ([equality (cdr table-container)]
[val (find (lambda (v) (equality (car v) key)) (car table-container))])
(if val
(cdr val)
(default-lambda))))
(define (table-lookup/set! table-container key default-lambda)
(table-lookup table-container
key
(lambda () (let ([val (default-lambda)])
(table-add! table-container key val)
val))))
)
| false |
33a021c8e26d90ed70aab8e269af26f5b45f06b2
|
5eb631d9a0885a550b709c6e9f905066f6af531b
|
/ex/chap2/5.scm
|
fa17ebeaf49877b3c136a6e78a455b0903bc07bc
|
[] |
no_license
|
hanpum/sicp
|
344cb6456daf2c2f6b002aa20dc3e177c34b18bd
|
454efaf28ee0f0487e372ede28f452eb762de404
|
refs/heads/master
| 2023-06-09T08:11:55.080048 | 2021-06-29T00:01:49 | 2021-06-29T00:01:49 | 381,190,193 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 718 |
scm
|
5.scm
|
(load-option 'format)
;; compute power of given number: base^n, using +,-,*,/ only
(define (^ base n)
(define (iter base n answer)
(if (= n 0) answer
(iter base (- n 1) (* base answer))))
(iter base n 1))
(define (get-component val base answer)
(let ((next-val (/ val base)))
(if (integer? next-val)
(get-component next-val base (+ answer 1))
answer)))
(define (cons a b)
(* (^ 2 a)
(^ 3 b)))
(define (car n)
(get-component n 2 0))
(define (cdr n)
(get-component n 3 0))
;; test function
(define (test a b)
(let ((n (cons a b)))
(display (format '#f "~%cons(~S,~S) = ~S, car: ~S, cdr: ~S~%" a b n (car n) (cdr n)))))
(test 0 0)
(test 0 1)
(test 1 0)
(test 1 2)
(test 2 1)
| false |
b903ce546c56faa1333ff92ae239ac6a6d4ead28
|
8426c993833d88b3542477980ec82edb869f1a72
|
/test.scm
|
bc0cc3bdb5960eb252e9717744262ac9bff8f1f4
|
[] |
no_license
|
ayatoy/Gauche-control-actor
|
7a3622876e405b01a9d2ca8e0bae16272d89f315
|
664af6f599ee8e286bf1e51811c8d60a3056a32d
|
refs/heads/master
| 2020-06-04T11:22:18.197895 | 2013-09-16T10:59:27 | 2013-09-16T10:59:27 | 12,865,294 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,588 |
scm
|
test.scm
|
(use gauche.test)
(use util.queue)
(define-syntax test**
(syntax-rules ()
[(_ name expected form ...)
(test* name expected (begin form ...))]))
(test-start "control.actor")
(use control.actor)
(test-module 'control.actor)
(test** "make-actor" <actor>
(class-of (make-actor (^[] (undefined)))))
(test** "actor?" #t
(actor? (make-actor (^[] (undefined)))))
(test** "actor-name" #f
(actor-name (make-actor (^[] (undefined)))))
(test** "actor-name" "foo"
(actor-name (make-actor (^[] (undefined)) "foo")))
(test** "actor-name-set!" "foo"
(let1 actor (make-actor (^[] (undefined)))
(actor-name-set! actor "foo")
(actor-name actor)))
(test** "actor-specific" #f
(actor-specific (make-actor (^[] (undefined)))))
(test** "actor-specific-set!" "foo"
(let1 actor (make-actor (^[] (undefined)))
(actor-specific-set! actor "foo")
(actor-specific actor)))
(test** "actor-state" 'new
(actor-state (make-actor (^[] (undefined)))))
(test** "actor-start!" #t
(actor? (actor-start! (make-actor (^[] (undefined))))))
(test** "actor-start!" #t
(string=? "done" (actor-join! (actor-start! (make-actor (^[] "done"))))))
(test** "actor-start!" 'done
(let1 actor (make-actor (^[] (undefined)))
(actor-join! (actor-start! actor))
(actor-state actor)))
(test** "current-actor" #t
(let1 actor (make-actor (^[] (current-actor)))
(eq? actor (actor-join! (actor-start! actor)))))
(test** "actor-join!" #t
(string=? "done" (actor-join! (actor-start! (make-actor (^[] "done"))))))
(test** "actor-join!" #t
(let* ([actor1 (make-actor (^[] (undefined)))]
[actor2 (make-actor (^[] (actor-join! actor1) #t))])
(actor-start! actor2)
(actor-start! actor1)
(actor-join! actor2)))
(test** "actor-join!" #t
(let* ([num-actors 3]
[actor (make-actor (^[] (undefined)))]
[actors (map (^[n] (make-actor (^[] (actor-join! actor) n)))
(iota num-actors 1))])
(for-each actor-start! actors)
(actor-start! actor)
(let1 res (map actor-join! actors)
(and (eq? 'done (actor-state actor))
(every (^a (eq? 'done (actor-state a))) actors)
(= (/ (* num-actors (+ num-actors 1)) 2)
(apply + res))))))
(test** "actor-join!" (test-error <error>)
(let1 actor (actor-start! (make-actor (^[] (error ""))))
(actor-join! actor)))
(test** "actor-slice!" #t
(let* ([num-actors 100]
[n 100]
[actors (map (^_ (make-actor
(^[] (let loop ([nums (iota n 1)] [acc 0])
(actor-slice!)
(if (null? nums)
acc
(loop (cdr nums) (+ acc (car nums))))))))
(iota num-actors))])
(for-each actor-start! actors)
(let1 res (map actor-join! actors)
(and (every (^a (eq? 'done (actor-state a))) actors)
(= (* (/ (* n (+ n 1)) 2) num-actors)
(apply + res))))))
(test** "actor-yield!" #t
(let1 actor (actor-start! (make-actor (^[] (actor-yield!))))
(until (eq? 'yielding (actor-state actor)) (sys-nanosleep #e5e8))
(actor-resume! actor)
#t))
(test** "actor-resume!" #t
(let1 actor (actor-start! (make-actor (^[] (actor-yield!))))
(until (eq? 'yielding (actor-state actor)) (sys-nanosleep #e5e8))
(actor-resume! actor)
(until (eq? 'done (actor-state actor)) (sys-nanosleep #e5e8))
#t))
(test** "actor-send!" #t
(let* ([dst (actor-start! (make-actor (^[] (values->list (actor-receive!)))))]
[src (make-actor (^[] (actor-send! dst "foo")))])
(string=? "foo" (actor-join! (actor-start! src)))))
(test** "actor-receive!" #t
(let* ([dst (actor-start! (make-actor (^[] (values->list (actor-receive!)))))]
[src (make-actor (^[] (actor-send! dst "foo")))])
(until (eq? 'receiving (actor-state dst)) (sys-nanosleep #e5e8))
(actor-start! src)
(let1 res (actor-join! dst)
(and (string=? "foo" (~ res 0))
(eq? src (~ res 1))))))
(test** "actor-send!/actor-receive! complete graph ping/pong" #t
(let ([q (make-mtqueue)]
[num-actors 100])
(letrec ([actors (map (^n (make-actor
(^[]
(dolist [dst actors] (actor-send! dst 'ping))
(dotimes [_ (* 2 num-actors)]
(receive (val src) (actor-receive!)
(case val
[(ping) (actor-send! src 'pong)]
[(pong) (enqueue! q val)])))
n)))
(iota num-actors 1))])
(for-each actor-start! actors)
(let1 res (map actor-join! actors)
(and (every (^a (eq? 'done (actor-state a))) actors)
(= (expt num-actors 2) (queue-length q))
(= (/ (* num-actors (+ num-actors 1)) 2)
(apply + res)))))))
(test** "actor-kill! new" (test-error <actor-error>)
(let* ([actor1 (make-actor (^[] (undefined)))]
[actor2 (make-actor (^[] (actor-join! actor1)))])
(actor-start! actor2)
(actor-kill! actor1)
(and (eq? 'killed (actor-state actor1))
(actor-join! actor2))))
(test** "actor-kill! yielding" (test-error <actor-error>)
(let* ([actor1 (make-actor (^[] (actor-yield!)))]
[actor2 (make-actor (^[] (actor-join! actor1)))])
(actor-start! actor1)
(actor-start! actor2)
(actor-kill! actor1)
(and (eq? 'killed (actor-state actor1))
(actor-join! actor2))))
(test** "actor-kill! receiving" (test-error <actor-error>)
(let* ([actor1 (make-actor (^[] (actor-receive!)))]
[actor2 (make-actor (^[] (actor-join! actor1)))])
(actor-start! actor1)
(actor-start! actor2)
(actor-kill! actor1)
(and (eq? 'killed (actor-state actor1))
(actor-join! actor2))))
(test** "actor-kill! done" (test-error <actor-error>)
(let1 actor (actor-start! (make-actor (^[] (undefined))))
(until (eq? 'done (actor-state actor)) (sys-nanosleep #e5e8))
(actor-kill! actor)))
(test** "actor-kill! error" (test-error <actor-error>)
(let1 actor (actor-start! (make-actor (^[] (error (undefined)))))
(until (eq? 'error (actor-state actor)) (sys-nanosleep #e5e8))
(actor-kill! actor)))
(test** "actor-kill! killed" (test-error <actor-error>)
(let1 actor (make-actor (^[] (undefined)))
(actor-kill! actor)
(actor-kill! actor)))
(test-end :exit-on-failure #t)
| true |
192f8d98f99709be3353ec8c6878aab8dea9714b
|
018a7ce673c5be3cf3df61bd5c5036581d6646a7
|
/spec/eratosthenes.scm
|
67d8599c4eed09b6a88ca25768ceb14bb9a07ac0
|
[
"MIT"
] |
permissive
|
iwillspeak/feersum
|
e857deec2b8683960f9ac6d1f395fb5f625204a8
|
1602e8333aa11c0335c9775c0ab49bf01389ba98
|
refs/heads/main
| 2023-08-07T17:15:19.843607 | 2023-06-20T06:28:28 | 2023-06-20T06:28:28 | 223,348,583 | 31 | 2 |
MIT
| 2023-06-10T21:29:11 | 2019-11-22T07:33:04 |
F#
|
UTF-8
|
Scheme
| false | false | 1,136 |
scm
|
eratosthenes.scm
|
(import (scheme base)
(scheme write))
;; Implementation of the Sieve of Eratosthenes
;; https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
(define (eratosthenes n)
;; Mark multiples of the given prime in the vector
(define (mark-multiples p marked)
(define (mark-multiples-at p m marked)
(if (>= m (vector-length marked))
marked
(begin
(vector-set! marked m #t)
(mark-multiples-at p (+ m p) marked))))
(mark-multiples-at p (* p p) marked))
;; main prime sieve. Recursively marks multiples of each
;; prime and builds up a list of them as it goes.
(define (siv p marked primes)
(if (>= p (vector-length marked))
primes
;; If the item is marked, it is a multiple of some other prime.
(if (vector-ref marked p)
(siv (+ 1 p) marked primes)
(siv (+ 1 p) (mark-multiples p marked) (cons p primes)))))
(siv 2 (make-vector n #f) ()))
;; ;; Display the first 10,000 primes
;; (display (eratosthenes 104730))
(display (eratosthenes 10000))
| false |
0eea0c8e1134cf71603748c14f67130a651f48e5
|
483a1c3d153edd17f637ad1c304062776651fb33
|
/m-work.scm
|
a4380210a6e6003d300b28ac48a083e321087b8e
|
[] |
no_license
|
namin/lambdajam
|
c4fb047044676ba52c800c1343ffd4360afeb085
|
1ea7b3e424551c3d389199f392abb83ea27b046c
|
refs/heads/master
| 2023-08-30T19:54:06.203073 | 2023-08-12T19:56:36 | 2023-08-12T19:56:36 | 11,259,139 | 10 | 4 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 251 |
scm
|
m-work.scm
|
(load "test-check.scm")
(load "pmatch.scm")
(load "sugar.scm")
(let ()
(define M
(lambda (f)
(lambda (xs)
(if (null? xs)
'()
(cons (f (car xs)) ((M f) (cdr xs)))))))
(eg ((M add1) '(1 2 3)) '(2 3 4)))
| false |
6a64d4c5fa4b12d5c2780bfedd70cc5a8b534bf5
|
f956337abdb990945eb91fa03a889b122bbad8c1
|
/extra/condition.scm
|
3c3bca9507c03f95f924e5483b3d4402e698e7b0
|
[] |
no_license
|
ayatoy/Gauche-extra
|
86036a9050a27cd665e1b5d267753b7c3c3c0f07
|
7242e738fb9900d08db24854a7b72d64dbe1b479
|
refs/heads/master
| 2021-01-19T22:13:49.464319 | 2012-05-29T11:41:28 | 2012-05-29T11:42:01 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 295 |
scm
|
condition.scm
|
(define-module extra.condition
(export report-error-string))
(select-module extra.condition)
(define (report-error-string e :optional (detail #t))
(if detail
(call-with-output-string
(^[out] (with-error-to-port out (^[] (report-error e)))))
(condition-ref e 'message)))
| false |
e30cba8ea475dac355cd1ccc3e695ad4e2a8d8cf
|
11b227f71ec01f2e497680cc5f9090c984e9f48e
|
/sources/foreign-interfaces/hungarian.scm
|
2f45823f09322d0c76579126470a468a88b8faa9
|
[
"MIT"
] |
permissive
|
Mathieu-Desrochers/Scheme-Experimentations
|
30dd336abf40c422f6d9c2d49f31b3665b7a8f17
|
9879e811865fbef170681a7748784a525d950088
|
refs/heads/master
| 2020-03-30T22:55:35.004425 | 2015-04-23T20:08:33 | 2015-04-23T20:08:33 | 6,216,231 | 14 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,968 |
scm
|
hungarian.scm
|
(declare (unit hungarian))
(foreign-declare "
#include <hungarian.h>
// allocates a hungarian_problem on the heap
hungarian_problem_t* malloc_hungarian_problem()
{
hungarian_problem_t* hungarian_problem = malloc(sizeof(hungarian_problem_t));
return hungarian_problem;
}
// returns an assignment value from a solved hungarian_problem
int hungarian_problem_assignment_matrix_value(hungarian_problem_t* hungarian_problem, int row_index, int column_index)
{
return hungarian_problem->assignment[row_index][column_index];
}
// frees a hungarian_problem
void free_hungarian_problem(hungarian_problem_t* hungarian_problem)
{
hungarian_free(hungarian_problem);
}
// allocates a hungarian_cost_matrix on the heap
int*** malloc_hungarian_cost_matrix(int rows, int columns)
{
int*** hungarian_cost_matrix = malloc(sizeof(int**));
*hungarian_cost_matrix = malloc(sizeof(int*) * rows);
int i;
for (i = 0; i < rows; i++)
{
(*hungarian_cost_matrix)[i] = malloc(sizeof(int) * columns);
}
return hungarian_cost_matrix;
}
// sets a hungarian_cost_matrix value
void hungarian_cost_matrix_value_set(int*** hungarian_cost_matrix, int row_index, int column_index, int value)
{
(*hungarian_cost_matrix)[row_index][column_index] = value;
}
// indirects a hungarian_cost_matrix
int** indirect_hungarian_cost_matrix(int*** hungarian_cost_matrix)
{
return *hungarian_cost_matrix;
}
// frees a hungarian_cost_matrix
// already done in part by hungarian_free
void free_hungarian_cost_matrix(int*** hungarian_cost_matrix)
{
free(hungarian_cost_matrix);
}
")
;; hungarian-problem pointers definitions
(define-foreign-type hungarian-problem "hungarian_problem_t")
(define-foreign-type hungarian-problem* (c-pointer hungarian-problem))
;; hungarian-cost-matrix pointers definitions
(define-foreign-type hungarian-cost-matrix** (c-pointer (c-pointer int)))
(define-foreign-type hungarian-cost-matrix*** (c-pointer hungarian-cost-matrix**))
;; hungarian-assignment-matrix pointers definitions
(define-foreign-type hungarian-assignment-matrix** (c-pointer (c-pointer int)))
(define-foreign-type hungarian-assignment-matrix*** (c-pointer hungarian-cost-matrix**))
;; hungarian-problem pointers memory management
(define malloc-hungarian-problem (foreign-lambda hungarian-problem* "malloc_hungarian_problem"))
(define free-hungarian-problem (foreign-lambda void "free_hungarian_problem" hungarian-problem*))
;; hungarian-cost-matrix memory management
(define malloc-hungarian-cost-matrix** (foreign-lambda hungarian-cost-matrix*** "malloc_hungarian_cost_matrix" int int))
(define indirect-hungarian-cost-matrix*** (foreign-lambda hungarian-cost-matrix** "indirect_hungarian_cost_matrix" hungarian-cost-matrix***))
(define free-hungarian-cost-matrix** (foreign-lambda void "free_hungarian_cost_matrix" hungarian-cost-matrix***))
;; sets a hungarian-cost-matrix value
(define hungarian-cost-matrix-value-set! (foreign-lambda void "hungarian_cost_matrix_value_set" hungarian-cost-matrix*** int int int))
;; initializes a hungarian problem
(define hungarian-init (foreign-lambda int "hungarian_init" hungarian-problem* hungarian-cost-matrix** int int int))
;; solves a hungarian problem
(define hungarian-solve (foreign-lambda void "hungarian_solve" hungarian-problem*))
;; returns an assignment value from a solved hungarian_problem
(define hungarian-problem-assignment-matrix-value (foreign-lambda int "hungarian_problem_assignment_matrix_value" hungarian-problem* int int))
;; frees a hungarian problem
(define hungarian-free (foreign-lambda void "hungarian_free" hungarian-problem*))
;; hungarian modes
(define hungarian-mode-minimize-cost (foreign-value "HUNGARIAN_MODE_MINIMIZE_COST" int))
(define hungarian-mode-maximize-util (foreign-value "HUNGARIAN_MODE_MAXIMIZE_UTIL" int))
;; hungarian states
(define hungarian-not-assigned (foreign-value "HUNGARIAN_NOT_ASSIGNED" int))
(define hungarian-assigned (foreign-value "HUNGARIAN_ASSIGNED" int))
| false |
4fada5a4b6b670cad0f1413130fc1ec85f7d2b72
|
03e4064a7a55b5d00937e74cddb587ab09cf7af9
|
/nscheme/old/old-5/eval.scm
|
3c2e8e2e7b1846294d4380c37f500ca175fee66a
|
[
"BSD-2-Clause"
] |
permissive
|
gregr/ina
|
29f28396cd47aa443319147ecde5235d11e1c3d1
|
16188050caa510899ae22ff303a67897985b1c3b
|
refs/heads/master
| 2023-08-25T13:31:44.131598 | 2023-08-14T16:46:48 | 2023-08-14T16:46:48 | 40,606,975 | 17 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,321 |
scm
|
eval.scm
|
((require language:empty language:initial language:primitive
language:base-primitive language:base language:extended language:io
premodule premodule:parse module:premodule module-apply
namespace-link* program-arguments ns:nscheme)
(language base io))
(define name=>lang (list (cons 'empty language:empty)
(cons 'initial language:initial)
(cons 'primitive language:primitive)
(cons 'base-primitive language:base-primitive)
(cons 'base language:base)
(cons 'extended language:extended)
(cons 'io language:io)))
(define (module:file path)
(module:premodule name=>lang (premodule:parse '(base) (read*/file path))))
(define (eval/file path args)
(define ns (cons (cons 'program-arguments (cons path args)) ns:nscheme+))
(module-apply (module:file path) ns))
(define (eval form*)
(define ns (cons (cons 'program-arguments '(#f)) ns:nscheme+))
(define names (map car ns))
(define language '(base extended io))
(define pm (premodule names #f names #f language form*))
(module-apply (module:premodule name=>lang pm) ns))
(define ns:nscheme+ (list* (cons 'eval/file eval/file)
(cons 'ns:nscheme ns:nscheme) ns:nscheme))
(define path:nscheme (car program-arguments))
(define args (cdr program-arguments))
(define rpath:here (cdr (reverse path:nscheme)))
(define language '(base))
(define (usage) (printf '"Usage: ~s [-e <forms> | <program> <argument>...] \n"
(string-join path:nscheme '"/")))
(cond ((null? args) (let loop ()
(printf '"~a " '>)
(unless (eof?)
(printf '"~a\n" (eval (list (read)))) (loop))))
((equal? (car args) '-e)
(cond ((null? (cdr args)) (usage))
((null? (cddr args)) (eval (read*/string (cadr args))))
(#t (usage))))
(#t
(define str:program (car args))
(define rpath:program (reverse (string-split str:program '"/")))
(define path:program (reverse (append rpath:program rpath:here)))
(eval/file path:program (cdr args))))
| false |
fedf0b37d0234facf1b14df26a127fb636d418d9
|
8a0660bd8d588f94aa429050bb8d32c9cd4290d5
|
/src/proclib.stub
|
a7518cfd8c1495d143a3ef1216808f1e8bb80b10
|
[
"BSD-2-Clause"
] |
permissive
|
david135/sagittarius-scheme
|
dbec76f6b227f79713169985fc16ce763c889472
|
2fbd9d153c82e2aa342bfddd59ed54d43c5a7506
|
refs/heads/master
| 2016-09-02T02:44:31.668025 | 2013-12-21T07:24:08 | 2013-12-21T07:24:08 | 32,497,456 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,535 |
stub
|
proclib.stub
|
;; -*- scheme -*-
(library (sagittarius compiler procedure)
(export procedure-name procedure-inliner
procedure-inliner-set! procedure-reqargs
procedure-optional procedure-body
inline?
find-procedure)
(import :none)
(decl-code
(.define "LIBSAGITTARIUS_BODY")
(.include <sagittarius.h>))
(define-cise-stmt assertion-violation
((_ who msg)
`(begin
(Sg_AssertionViolation ,who (SG_MAKE_STRING ,msg) '())))
((_ who msg irritants)
`(begin
(Sg_AssertionViolation ,who (SG_MAKE_STRING ,msg) ,irritants)
)))
(define-c-proc procedure-name (arg0::<procedure>) ::<top>
(result (SG_PROCEDURE_NAME arg0)))
(define-c-proc procedure-inliner (arg0::<procedure>) ::<top>
(result (SG_PROCEDURE_INLINER arg0)))
(define-c-proc procedure-inliner-set! (arg0::<procedure> arg1) ::<top>
(set! (SG_PROCEDURE_INLINER arg0) arg1)
(result SG_UNDEF))
(define-c-proc procedure-reqargs (arg0::<procedure>) ::<fixnum>
(result (SG_PROCEDURE_REQUIRED arg0)))
(define-c-proc procedure-optional (arg0::<procedure>) ::<boolean>
(result (SG_PROCEDURE_OPTIONAL arg0)))
(define-c-proc inline? (arg0) ::<boolean>
(result (and (SG_PROCEDUREP arg0)
(not (SG_FALSEP (SG_PROCEDURE_INLINER arg0)))
(not (SG_VM_IS_SET_FLAG (Sg_VM) SG_NO_INLINE_ASM)))))
(define-c-proc find-procedure (name::<symbol> lib) ::<top>
(let ((g (Sg_FindBinding lib name SG_UNBOUND)))
(if (SG_UNBOUNDP g)
(result SG_FALSE)
(result (SG_GLOC_GET (SG_GLOC g)))))))
| false |
e808be4c13c9f6a8f21828a1d2ecbd0d272f423b
|
b9eb119317d72a6742dce6db5be8c1f78c7275ad
|
/racket/bridge/interactive-call.ss
|
0784a78bf555f7e31aa486311b07820a39a53352
|
[] |
no_license
|
offby1/doodles
|
be811b1004b262f69365d645a9ae837d87d7f707
|
316c4a0dedb8e4fde2da351a8de98a5725367901
|
refs/heads/master
| 2023-02-21T05:07:52.295903 | 2022-05-15T18:08:58 | 2022-05-15T18:08:58 | 512,608 | 2 | 1 | null | 2023-02-14T22:19:40 | 2010-02-11T04:24:52 |
Scheme
|
UTF-8
|
Scheme
| false | false | 4,701 |
ss
|
interactive-call.ss
|
#! /bin/sh
#| Hey Emacs, this is -*-scheme-*- code!
#$Id$
exec mred -qu "$0" ${1+"$@"}
|#
(module interactive-call mzscheme
(require (lib "class.ss"))
(require (lib "mred.ss" "mred"))
(require (all-except (lib "1.ss" "srfi") reverse! member map
for-each assoc append!))
(require "call.ss")
(require "misc.ss")
(require "auction.ss")
(provide make-bbox-window
reset-buttons-for-new-auction
interactively-get-call)
(define *choice* #f)
(define *sem* (make-semaphore))
(define *bidding-box-window* #f)
(define *column* #f)
(define doubles-and-pass #f)
(define *level/pane-alist* #f)
(define (make-bbox-window parent)
(when *bidding-box-window*
(error "I expected *bidding-box-window* to be #f"))
(set! *bidding-box-window*
(instantiate frame% ()
(parent parent)
(enabled #t)
(label "If you can see this, something is wrong.")))
(set! *column* (instantiate vertical-pane% ()
(parent *bidding-box-window*)))
(set! doubles-and-pass (instantiate horizontal-pane% ()
(parent *column*)))
(set! *level/pane-alist* (map (lambda (level)
(cons level (instantiate horizontal-pane% ()
(parent *column*))))
(reverse (iota 7 1))))
(for-each (lambda (sym enabled?)
(make-choice-button
(call->string sym)
doubles-and-pass
sym
enabled?))
`(double redouble pass)
`(#f #f #t) ; BUGBUG -- get double and
; redouble right
)
(for-each (lambda (level/pane-pair)
(for-each (lambda (denom)
(let ((b (make-bid (car level/pane-pair) denom)))
(make-bid-button b)))
*denominations*))
*level/pane-alist*)
(unless (= 38 (length *call/button-alist*))
(error "I was expecting exactly 38 buttons in *call/button-alist*, but instead it's "
(length *call/button-alist*)))
)
;; all 38 buttons (38 = 7 levels * 5 denominations plus 3 {pass,
;; double, redouble})
(define *call/button-alist* '())
(define (reset-buttons-for-new-auction)
(for-each (lambda (call/button-pair)
(send (cdr call/button-pair)
enable #t))
*call/button-alist*)
(send (cdr (assq 'double *call/button-alist*)) enable #f)
(send (cdr (assq 'redouble *call/button-alist*)) enable #f)
)
(define interactively-get-call #f)
(define (make-choice-button label parent value enabled?)
(let ((button (instantiate button% () (label label)
(parent parent)
(enabled enabled?)
(callback (lambda (button control-event-object)
(set! *choice* value)
(send *bidding-box-window* show #f)
(semaphore-post *sem*))))))
(set! *call/button-alist* (cons (cons value button)
*call/button-alist*))
button
))
(define make-bid-button
(lambda (b)
(make-choice-button
(call->string b)
(cdr (assq (bid-level b) *level/pane-alist*))
b
#t)))
(set! interactively-get-call
(lambda (the-auction frame-title)
(let ((highest-illegal-bid (last-bid the-auction)))
;; disable some more buttons.
;; BUGBUG: do the double and redouble too
(when highest-illegal-bid
(for-each (lambda (call/button-pair)
(when (and (bid? (car call/button-pair))
(not (bid> (car call/button-pair) highest-illegal-bid)))
(send (cdr call/button-pair)
enable #f)))
*call/button-alist*))
(send *bidding-box-window* set-label frame-title)
(send *bidding-box-window* show #t)
(yield *sem*)
*choice*)))
(when #f
;; a very short auction :-\
(make-bbox-window #f)
(let ((c1 (interactively-get-call #f "Testing .. testing .. is this thing on?")))
(let ((c2 (interactively-get-call (and (bid? c1) c1) "thump thump")))
(printf "~A~%" (call->string
c2)))
)))
| false |
10f6c2b861758d862e8b14ef7fc73f448b480693
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/mscorlib/system/text/decoder-exception-fallback.sls
|
e345adeeb932112606a66b413a61dd0494504d49
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,102 |
sls
|
decoder-exception-fallback.sls
|
(library (system text decoder-exception-fallback)
(export new
is?
decoder-exception-fallback?
get-hash-code
equals?
create-fallback-buffer
max-char-count)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Text.DecoderExceptionFallback a ...)))))
(define (is? a) (clr-is System.Text.DecoderExceptionFallback a))
(define (decoder-exception-fallback? a)
(clr-is System.Text.DecoderExceptionFallback a))
(define-method-port
get-hash-code
System.Text.DecoderExceptionFallback
GetHashCode
(System.Int32))
(define-method-port
equals?
System.Text.DecoderExceptionFallback
Equals
(System.Boolean System.Object))
(define-method-port
create-fallback-buffer
System.Text.DecoderExceptionFallback
CreateFallbackBuffer
(System.Text.DecoderFallbackBuffer))
(define-field-port
max-char-count
#f
#f
(property:)
System.Text.DecoderExceptionFallback
MaxCharCount
System.Int32))
| true |
ccc5613f0d683e88dc80ad6b3d626f157074a4e6
|
4fd95c081ccef6afc8845c94fedbe19699b115b6
|
/chapter_3/3.51.scm
|
94810470f14720e99bbf6fe74a0f4c5927b40cfc
|
[
"MIT"
] |
permissive
|
ceoro9/sicp
|
61ff130e655e705bafb39b4d336057bd3996195d
|
7c0000f4ec4adc713f399dc12a0596c770bd2783
|
refs/heads/master
| 2020-05-03T09:41:04.531521 | 2019-08-08T12:14:35 | 2019-08-08T12:14:35 | 178,560,765 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,402 |
scm
|
3.51.scm
|
(define (memo-proc proc)
(let ((already-run? false) (result false))
(lambda ()
(if (not already-run?)
(begin (set! result (proc))
(set! already-run? true)
result)
result))))
(define (delay expn) (memo-proc (lambda () expn)))
(define (force delayed-object) (delayed-object))
; WTF??????????????????????????
(define-syntax delay
(syntax-rules ()
((_ exp) (lambda () exp))))
(define-syntax cons-stream
(syntax-rules ()
((_ a b) (cons a (delay b)))))
(define (stream-car s) (car s))
(define (stream-cdr s) (force (cdr s)))
(define the-empty-stream '())
(define (stream-null? s) (eq? s the-empty-stream))
(define (stream-enumerate-interval low high)
(if (> low high)
the-empty-stream
(cons-stream low
(stream-enumerate-interval (+ low 1) high))))
(define (stream-for-each proc s)
(if (stream-null? s)
'done
(begin
(proc (stream-car s))
(stream-for-each proc (stream-cdr s)))))
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
(define (stream-map proc s)
(if (stream-null? s)
the-empty-stream
(cons-stream (proc (stream-car s))
(stream-map proc (stream-cdr s)))))
(define (display-stream s)
(stream-for-each display-line s))
(define (display-line x)
(newline)
(display x))
; -------------------------------------------------------------------------
; -------------------------------------------------------------------------
; -------------------------------------------------------------------------
(define (show x)
(display-line x)
x)
; With stream implementation described in book, (10, 9 ... 0) should be printed
; because of eager evaluation, which acually is the reason why this implementation
; is wrong since it stores all values in memory, but does not generate them on fly.
; To fix this issue macroinstruction(macro) should be introduced, but in book they are
; only described in the next chapter. All this situation introduces misunderstanding
; about the real internal work of streams. That really sucks.
; 0
(define x
(stream-map show
(stream-enumerate-interval 0 10)))
(newline)
(newline)
(stream-ref x 5) ; 1 ... 5
(newline)
(stream-ref x 7) ; 1 ... 7
| true |
0a8038c1784e080a0201cc1405a905a8d9dc4f5e
|
be32518c6f54b0ab1eaf33f53405ac1d2e1023c2
|
/np/lang/macros/test/partitioning/terminals/test-errors-extension-modification.ss
|
5d57302bfe75f97a89a1182a33cffbb70a5ca936
|
[
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
ilammy/np
|
7990302bc30fe7802a7f4fc33d8fa7449ef8b011
|
0e3cbdea0eb2583f9b272d97bc408011af6a7947
|
refs/heads/master
| 2016-09-05T17:11:03.893011 | 2015-06-13T16:37:39 | 2015-06-13T16:37:39 | 23,740,287 | 1 | 0 | null | 2015-06-13T16:39:43 | 2014-09-06T17:19:46 |
Scheme
|
UTF-8
|
Scheme
| false | false | 15,813 |
ss
|
test-errors-extension-modification.ss
|
(import (scheme base)
(np lang macros partitioning)
(np lang macros test utils)
(sr ck)
(sr ck kernel)
(te base)
(te conditions assertions)
(te utils verify-test-case))
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:invalid-syntax "Partitioning of extension terminal modification forms: invalid terminal syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang a-symbol)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! a-symbol)) ) )) ) )
(define-test ("clause 1")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (name predicate? ((+ x) (- y))))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (name predicate? ((+ x) (- y))))) ) )) ) )
(define-test ("clause 2")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (number? ((+ x) (- y)) x))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ x) (- y)) x))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang ())
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! ())) ) )) ) )
(define-test ("irregular list 1")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (car . cdr))) ) )) ) )
(define-test ("irregular list 2")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (a b . c))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (a b . c))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang #(symbol? ((+ s))))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! #(symbol? ((+ s))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:invalid-syntax)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-addition:names "Partitioning of extension terminal modification forms: meta variable addition names")
(define-test ("boolean")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #t)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((+ #t))))) ) )) ) )
(define-test ("char")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #\X)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((+ #\X))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang number? ())
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ ()))))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang num (car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((+ (car . cdr)))))) ) )) ) )
(define-test ("list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang number? (+ x))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ (+ x)))))) ) )) ) )
(define-test ("number")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num 11)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((+ 11))))) ) )) ) )
(define-test ("string")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num "now")
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((+ "now"))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #(x))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((+ #(x)))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-addition:names)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-addition:syntax "Partitioning of extension terminal modification forms: meta variable addition syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang number? (+ . foo))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ . foo))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("At least one meta-variable should be specified for addition" lang number? (+))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+))))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num (+ car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((+ car . cdr))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang number? (+ . #()))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ . #()))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-addition:syntax)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-invalid-syntax "Partitioning of extension terminal modification forms: meta variable invalid syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num atom)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num (atom (- x))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num ())
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- x) (+ y) ())))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num (y . z))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((+ x) (y . z))))) ) )) ) )
(define-test ("list")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num (random list))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- x) (+ y) (random list))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num #(z))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- x) (+ y) #(z))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-invalid-syntax)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-removal:names "Partitioning of extension terminal modification forms: meta variable removal names")
(define-test ("boolean")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #t)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((- #t))))) ) )) ) )
(define-test ("char")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #\.)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((- #\.))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang number? ())
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((- ()))))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang num (car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- (car . cdr)))))) ) )) ) )
(define-test ("list")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang number? (+ x))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((- (+ x)))))) ) )) ) )
(define-test ("number")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num 222)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((- 222))))) ) )) ) )
(define-test ("string")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num "right")
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((- "right"))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Name of the meta-variable must be an identifier" lang Num #(x))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (Num ((- #(x)))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-removal:names)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-removal:syntax "Partitioning of extension terminal modification forms: meta variable removal syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang number? (- . foo))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((- . foo))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("At least one meta-variable should be specified for removal" lang number? (-))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((-))))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang num (- car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- car . cdr))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the meta-variable modification" lang number? (- . #()))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((- . #()))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-removal:syntax)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:meta-var-syntax "Partitioning of extension terminal modification forms: meta variable extension syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (foo bar))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (foo bar))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Terminal modification should modify meta-variables" lang foo)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (foo ()))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (num ((- x) . foo)))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (num ((- x) . foo)))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the terminal modification" lang (bar #((+ x y z))))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (bar #((+ x y z))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:meta-var-syntax)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:name "Partitioning of extension terminal modification forms: terminal names")
(define-test ("boolean")
(assert-syntax-error ("Name of the terminal must be an identifier" lang (#t ((+ some) (- vars))) #t)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (#t ((+ some) (- vars))))) ) )) ) )
(define-test ("char")
(assert-syntax-error ("Name of the terminal must be an identifier" lang (#\O ((+ some) (- vars))) #\O)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (#\O ((+ some) (- vars))))) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("Name of the terminal must be an identifier" lang (() ((+ some) (- vars))) ())
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (() ((+ some) (- vars))))) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Name of the terminal must be an identifier" lang ((car . cdr) ((+ some) (- vars))) (car . cdr))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! ((car . cdr) ((+ some) (- vars))))) ) )) ) )
(define-test ("list")
(assert-syntax-error ("Name of the terminal must be an identifier" lang ((name) ((+ some) (- vars))) (name))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! ((name) ((+ some) (- vars))))) ) )) ) )
(define-test ("number")
(assert-syntax-error ("Name of the terminal must be an identifier" lang (11 ((+ some) (- vars))) 11)
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (11 ((+ some) (- vars))))) ) )) ) )
(define-test ("string")
(assert-syntax-error ("Name of the terminal must be an identifier" lang ("Eons" ((+ some) (- vars))) "Eons")
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! ("Eons" ((+ some) (- vars))))) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Name of the terminal must be an identifier" lang (#(1) ((+ some) (- vars))) #(1))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (#(1) ((+ some) (- vars))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:name)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ;
(define-test-case (terminals:extension-modification:syntax "Partitioning of extension terminal modification forms: extension syntax")
(define-test ("atom")
(assert-syntax-error ("Invalid syntax of the terminal extension" lang (! . right-away))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! . right-away)) ) )) ) )
(define-test ("empty list")
(assert-syntax-error ("At least one terminal should be specified for modification" lang (!))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((!)) ) )) ) )
(define-test ("irregular list")
(assert-syntax-error ("Invalid syntax of the terminal extension" lang (! (number? ((+ n))) . random))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! (number? ((+ n))) . random)) ) )) ) )
(define-test ("vector")
(assert-syntax-error ("Invalid syntax of the terminal extension" lang (! . #(number? ((+ n)))))
($ ($quote
($partition-extension-terminal-definitions 'lang
'((! . #(number? ((+ n))))) ) )) ) )
)
(verify-test-case! terminals:extension-modification:syntax)
| false |
7b7d291ad5b51789789ac5a0baa1fd83c99d3538
|
c74dcb1facbd920d762017345171f47f8e41d0c5
|
/chapter_3/3.82.scm
|
61d64b7308601f7eb17e1e327ce06dfdf290c05d
|
[] |
no_license
|
akash-akya/sicp-exercises
|
5125c1118c7f0e4400cb823508797fb67c745592
|
c28f73719740c2c495b7bc38ee8b790219482b67
|
refs/heads/master
| 2021-06-15T19:12:47.679967 | 2019-08-03T14:03:20 | 2019-08-03T14:03:20 | 136,158,517 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,683 |
scm
|
3.82.scm
|
#lang sicp
(#%require "utils.scm")
(#%require "stream-utils.scm")
;; Exercise 3.82: Redo Exercise 3.5 on Monte Carlo integration in
;; terms of streams. The stream version of estimate-integral will not
;; have an argument telling how many trials to perform. Instead, it
;; will produce a stream of estimates based on successively more
;; trials.
(define (random-in-range low high)
(let ((range (- high low)))
(+ low (random range))))
(define (monte-carlo experiment-stream
passed
failed)
(define (next passed failed)
(cons-stream
(/ passed (+ passed failed))
(monte-carlo
(stream-cdr experiment-stream)
passed
failed)))
(if (stream-car experiment-stream)
(next (+ passed 1) failed)
(next passed (+ failed 1))))
(define (create-experiment-stream P x1 x2 y1 y2)
(cons-stream
(P (random-in-range x1 x2) (random-in-range y1 y2))
(create-experiment-stream P x1 x2 y1 y2)))
(define (area x1 x2 y1 y2)
(* (- y2 y1) (- x2 x1)))
(define (estimate-integral P x1 x2 y1 y2)
(stream-map
(lambda (success-rate)
(* (area x1 x2 y1 y2) success-rate))
(monte-carlo (create-experiment-stream P x1 x2 y1 y2) 0 0)))
(define (create-predicate cx cy radius)
(lambda (x y)
(not (> (+ (square (- x cx))
(square (- y cy)))
(square radius)))))
(define (estimate-pi)
;; cx cy radius x1 x2 y1 y2
(/ (stream-ref (estimate-integral (create-predicate 1000 1000 1000) 0 2000 0 2000) 100000)
(square 1000.0)))
;; test
(define (test)
(< (abs (- (estimate-pi) 3.14285))
0.01))
;; test
| false |
f95ec68ea0d82e6393531fb28eb7c95bc02a35bb
|
abc7bd420c9cc4dba4512b382baad54ba4d07aa8
|
/src/ws/compat/compat.mzscheme.sls
|
6dc86d50ddf509bf1185f792fa2d2810794015c3
|
[
"BSD-3-Clause"
] |
permissive
|
rrnewton/WaveScript
|
2f008f76bf63707761b9f7c95a68bd3e6b9c32ca
|
1c9eff60970aefd2177d53723383b533ce370a6e
|
refs/heads/master
| 2021-01-19T05:53:23.252626 | 2014-10-08T15:00:41 | 2014-10-08T15:00:41 | 1,297,872 | 10 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 10,762 |
sls
|
compat.mzscheme.sls
|
#!r6rs
(library (ws compat compat)
(export
plt:include plt:include-at/relative-to
getenv syntax->list
random seed-random make-list
merge merge! sort! append! reverse! call/ec inspect native-inspect debug define-values
fluid-let parameterize reg:define-struct reg:struct?
void make-parameter
format printf fprintf pretty-print
format-syntax-nicely
gensym current-directory
syntax-error error
define-top-level-value set-top-level-value! top-level-bound? top-level-value
reg:top-level-eval simple-eval
warning warning-handler display-condition
real-time cpu-time time
print-level print-graph print-length pretty-maximum-lines pretty-line-length print-vector-length
with-output-to-string with-output-to-port
repl
process get-string-available
box unbox set-box! box?
promise? delay force
which-scheme IFCHEZ IFPLT
trace-define trace-lambda
(rename (sys:system system))
(rename (plt:include include))
; include
; make-rectangular
default-repl-env ;; TEMPTOGGLE -- exposing temporarily
)
(import (except (rnrs (6)) current-output-port error)
(for (rnrs eval (6)) run expand)
(for (only (scheme base) random getenv ;syntax->list
sort call/ec define-values parameterize
void make-parameter
format printf fprintf
gensym
time
file
current-milliseconds current-process-milliseconds
box unbox set-box! box?
current-output-port
) run expand)
;(scheme srfi/19)
; (scheme mzlib cml)
;(scheme mzlib/cml)
;(mzlib cml)
;(srfi 19)
;(only (lazy promise) promise? delay force)
(only (scheme promise) promise? delay force)
(for (prefix (scheme base) plt:) expand run)
(prefix (only (scheme include) include include-at/relative-to)
plt:)
(for (only (scheme mpair) list->mlist mlist->list) expand run)
(scheme pretty )
;(scheme process)
(prefix (scheme system) sys:)
;(mzlib process)
;(only (scheme list) merge )
;(only (srfi 1) ) ;make-list
;(scheme)
;(lib "lists.ss")
;(lib lists)
;(scheme lists)
;(mzscheme)
)
(define which-scheme 'mzscheme)
(define-syntax IFPLT
(syntax-rules ()
[(_ a b) a]))
#;
(define-syntax trace-lambda
(syntax-rules ()
[(_ name args bod ...)
(let ([closure (lambda args bod ...)]
[sym (plt:gensym)])
;; Need to define a real top-level value. Not sure if we can
;; do that hack in R6RS mode.
(define-top-level-value sym closure)
(trace sym)
closure)]))
(define seed-random
(case-lambda
;[() (plt:random-seed (time-nanosecond (current-time)))]
;[() (plt:random-seed (exact (round (current-time))))]
[() (plt:random-seed (plt:current-milliseconds))]
[(n) (plt:random-seed n)]))
;; PLT needs some help printing out the line numbers of a syntax object.
(define (format-syntax-nicely x)
(format "Syntax ~a, line ~a in ~a"
(syntax->datum x) (plt:syntax-line x) (plt:syntax-source x)))
;(define-syntax system (identifier-syntax sys:system))
;(define-syntax sort! (identifier-syntax sort))
;(define-syntax append! (identifier-syntax append))
;(define-syntax reverse! (identifier-syntax reverse))
;(define-syntax real-time (identifier-syntax current-milliseconds))
;(define-syntax cpu-time (identifier-syntax current-process-milliseconds))
;; Eta expanding to get around a present PLT bug:
(define (reverse! ls) (reverse ls))
(define (sort! fn ls) (sort fn ls))
(define (append! . ls) (apply append ls))
(define (real-time) (current-milliseconds))
(define (cpu-time) (current-process-milliseconds))
(define print-level pretty-print-depth) ;; Same param, diff name
(define pretty-line-length pretty-print-columns)
;; And these do nothing:
(define print-length (make-parameter 0))
(define pretty-maximum-lines (make-parameter 0))
(define print-graph (make-parameter #f))
(define print-vector-length (make-parameter #f))
(define implementation-specific-imports
'(
(prefix (scheme) plt:)
;; Ugh, I'm forced to bring in the whole (scheme) for the app syntax.
;(scheme)
))
(define (default-repl-env)
(printf "Building default repl...\n")
(let ([env
(environment '(except (rnrs (6)) error) ; (rnrs r5rs (6))
'(rnrs mutable-pairs (6)) '(rnrs mutable-strings (6))
'(main_r6rs) '(main) '(ws shortcuts)
'(prefix (scheme) plt:)
)])
(printf " Env ~s\n" env)
env))
;; Having problems with using the native PLT repl:
; (define repl plt:read-eval-print-loop)
(define (repl)
(define (cleanse-pairs x)
(syntax->datum (plt:datum->syntax #f x)))
;; Here's a simple repl
(let loop ()
(printf "> ")(flush-output-port (current-output-port))
(with-exception-handler
(lambda (exn)
(call/cc
(lambda (k)
(nice-print-exception exn k)
(loop))))
(lambda ()
(let ([exp (read)])
(unless (eof-object? exp)
(let ((val (reg:top-level-eval (cleanse-pairs exp))))
(unless (eq? val (void)) (write val))
(newline))
(loop)))))))
;; TEMP: duplicated code from compat.chez.sls
(define (nice-print-exception x k)
(if (who-condition? x)
(printf "\n *** ERROR in ~a *** \n" (condition-who x))
(printf "\n *** ERROR *** \n"))
(display-condition x) (newline)
;(printf "\nBacktrace: \n")
;(continuation->sourcelocs k)
)
(define make-list
(case-lambda
[(n) (make-list n #f)]
[(n x) (let loop ([n n])
(if (zero? n) '()
(cons x (loop (fx- n 1)))))]))
(define-syntax syntax-error
(syntax-rules ()
[(kwd form msg) (syntax-violation #f msg form)]
[(kwd msg) (syntax-violation #f msg #f)]))
;; Chez's system for warnings -- same as error.
(define (warning who str . args)
(apply (warning-handler) who str args))
(define warning-handler
(make-parameter
(lambda (who str . args)
(printf "Warning in ~a: ~a" who (apply format str args)))))
(define (with-output-to-string th)
(let-values ([(p extract) (open-string-output-port)])
(parameterize ([current-output-port p])
(th)
(extract))))
(define (with-output-to-port p th)
(parameterize ([current-output-port p])
(th)))
(define current-directory
;; Under PLT parameters are actually a different type than procedures.
;; This must be a real parameter if it is to be used with parameterize.
(make-parameter (plt:path->string (plt:current-directory))
(lambda (x)
(plt:current-directory x)
(plt:path->string (plt:current-directory))))
; (case-lambda
; [() (plt:path->string (plt:current-directory))]
; [(x) (plt:current-directory x)])
)
(define (process str)
(let ([ls (list->mlist (sys:process str))])
;; We drop to the Chez least-common-denominator:
(list (transcoded-port (car ls) (native-transcoder)) ;; Input port
(transcoded-port (cadr ls) (native-transcoder)) ;; Output port
(caddr ls) ;; PID
)
))
#;
(define (system-to-str str)
(match (plt:process str)
[(,in ,out ,id ,err ,fun)
(let ((p (open-output-string)))
(let loop ((c (read-char in)))
(if (and (eof-object? c)
(not (eq? 'running (fun 'status))))
(begin
(close-input-port in)
(close-output-port out)
(close-input-port err)
(get-output-string p))
(begin (unless (eof-object? c) (display c p))
(loop (read-char in))))))]))
(define (get-string-available inp)
(error 'get-string-available "non-blocking IO not implemented yet..."))
;(include "ws/compat/common.ss")
;(include "ws/compat/inspector.ss")
;; TEMP: making absolute:
; (include "/home/newton/wavescript/src/ws/compat/common.ss")
; (include "/home/newton/wavescript/src/ws/compat/inspector.ss")
; (include "/home/newton/wavescript/src/ws/compat/top-level-values.ss")
;; includes are relative to $REGIMENTD/src
;; Therefore we need to override the PLT default include.
;; Can't use this from this file or we'd run into a circular dependency.
;; TEMPTOGGLE [2010.03.07] SWITCHING BACK TO PLT BUILTIN INCLUDE:
#;
(define-syntax include
(lambda (x)
(syntax-case x ()
[(form fn)
(let* ([regd (getenv "REGIMENTD")]
[path (string-append regd "/src/" (syntax->datum #'fn))])
(printf "RESOLVED INCLUDE PATH ~s\n" path)
;#`(plt:include (file #,(datum->syntax #'_ path)))
#`(plt:include-at/relative-to fn fn (file #,(datum->syntax #'_ path)))
;(datum->syntax (car (syntax->list #'x)) (list #'plt:include `(file ,path)))
;(datum->syntax #'form (list #'plt:include `(file ,path)))
;(datum->syntax #'_ `(,#'plt:include (file ,path))) ;; Matthew's suggestion
;; Invalid <datum> :
;(datum->syntax #'form (plt:list #'plt:include (plt:list #'file path)))
;; Not a 'file' or 'lib' form:
;(datum->syntax #'form (syntax->datum #`(plt:include (file #,(datum->syntax #'form path)))))
;; silent fail -- no binding:
;#`(plt:include-at/relative-to #,x #,x (file #,(datum->syntax #'_ path)))
)])))
;; This necessitates building in-place:
(plt:include "reg_record.ss")
(plt:include "common.ss")
(define (native-inspect x)
(error 'mzscheme "doesn't have a built-in object inspector"))
(define (debug . x)
(error 'mzscheme "doesn't have a built-in debug mode"))
(plt:include "inspector.ss") (define inspect generic-inspect)
(plt:include "top-level-values.ss")
(plt:include "tracer.ss")
; (define (display-condition x . prt)
(define (display-condition x)
;(define port (if (null? prt) (current-output-port) (car prt)))
#;
(if (and (irritants-condition? x)
(message-condition? x)
(error? x))
;(apply fprintf port (condition-message x) (condition-irritants x))
;(display x port)
(if (null? prt)
(apply printf (condition-message x) (condition-irritants x))
(apply fprintf (car prt) (condition-message x) (condition-irritants x)))
(if (null? prt)
(display x)
(display x prt)))
#|
(if (and (irritants-condition? x)
(message-condition? x)
(error? x))
(apply printf (condition-message x) (condition-irritants x))
(if (message-condition? x)
(display (condition-message x))
(display x))
)
(printf "\nBacktrace:\n")
(pretty-print (plt:continuation-mark-set->context (plt:exn-continuation-marks x)))
(newline)
|#
((plt:error-display-handler) (if (message-condition? x) (condition-message x) "") x)
)
)
| true |
908acf331abd1824f0352e2e6f039fbb3f357d1f
|
dae624fc36a9d8f4df26f2f787ddce942b030139
|
/chapter-10/test.scm
|
a393a57097bcee4f9cc8863828b15f37152fc5f1
|
[
"MIT"
] |
permissive
|
hshiozawa/gauche-book
|
67dcd238c2edeeacb1032ce4b7345560b959b243
|
2f899be8a68aee64b6a9844f9cbe83eef324abb5
|
refs/heads/master
| 2020-05-30T20:58:40.752116 | 2019-10-01T08:11:59 | 2019-10-01T08:11:59 | 189,961,787 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,108 |
scm
|
test.scm
|
(define *num-tests* 0)
(define *num-passes* 0)
(define *num-failures* 0)
(define (mytest-start name)
(print "Testing " name " ...")
(set! *num-tests* 0)
(set! *num-passes* 0)
(set! *num-failures* 0))
(define (mytest-end)
(print *num-tests* " tests, "
*num-passes* " passed, "
*num-failures* " failed."))
(define (mytest label expected thunk . options)
(let-optionals* options ((cmp-fn equal?))
(print "Testing " label " ...")
(inc! *num-tests*)
(let ((result (guard (e (else 'test-error))
(thunk))))
(cond [(cmp-fn expected result)
(inc! *num-passes*)
(print " : OK")]
[else
(inc! *num-failures*)
(print " : ERROR expecting " expected ", but got " result)]))
))
(mytest-start "TEST")
(mytest "Test 1" 1 (lambda () (+ 1 1)) eq?)
(mytest "Test 1" '(1 2) (lambda () '(1 2 3)))
(mytest-end)
| false |
ac3e33e0e2201773479faea6c2dbf2a81186bb76
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System/system/collections/specialized/collections-util.sls
|
8a0c432bd044703aff14c01fcd0cb62d26d812d4
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,139 |
sls
|
collections-util.sls
|
(library (system collections specialized collections-util)
(export new
is?
collections-util?
create-case-insensitive-hashtable
create-case-insensitive-sorted-list)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Collections.Specialized.CollectionsUtil
a
...)))))
(define (is? a)
(clr-is System.Collections.Specialized.CollectionsUtil a))
(define (collections-util? a)
(clr-is System.Collections.Specialized.CollectionsUtil a))
(define-method-port
create-case-insensitive-hashtable
System.Collections.Specialized.CollectionsUtil
CreateCaseInsensitiveHashtable
(static: System.Collections.Hashtable System.Int32)
(static:
System.Collections.Hashtable
System.Collections.IDictionary)
(static: System.Collections.Hashtable))
(define-method-port
create-case-insensitive-sorted-list
System.Collections.Specialized.CollectionsUtil
CreateCaseInsensitiveSortedList
(static: System.Collections.SortedList)))
| true |
bbbef78491f565a761e6ae035e2c5e7c12701688
|
c38f6404e86123560ae8c9b38f7de6b66e30f1c4
|
/fernscode/spivey.ss
|
5dd0190c67e0db42922de399f15d83edd96fe631
|
[
"CC-BY-4.0"
] |
permissive
|
webyrd/dissertation-single-spaced
|
efeff4346d0c0e506e671c07bfc54820ed95a307
|
577b8d925b4216a23837547c47fb4d695fcd5a55
|
refs/heads/master
| 2023-08-05T22:58:25.105388 | 2018-12-30T02:11:58 | 2018-12-30T02:11:58 | 26,194,521 | 57 | 4 | null | 2018-08-09T09:21:03 | 2014-11-05T00:00:40 |
TeX
|
UTF-8
|
Scheme
| false | false | 208 |
ss
|
spivey.ss
|
(fcar (bind-bottom (ints-bottom 2)
(timed-lambda (a)
(bind-bottom (ints-bottom 2)
(timed-lambda (b)
(if (= (* a b) 9) (unit-bottom (list a b)) (mzero-bottom)))))))
| false |
fe56c1a84ad016689971b983ba6d8c9d37b9e052
|
29fd1454d19dc5682f751cff58e85023fe1a311d
|
/scheme/y!.ss
|
e4175bf4934286c28c206a9b28e4808fe9d2dfa0
|
[] |
no_license
|
rags/playground
|
5513c5fac66900e54a6d9f319defde7f6b34be5e
|
826ad4806cacffe1b3eed4b43a2541e273e8c96f
|
refs/heads/master
| 2023-02-03T04:30:46.392606 | 2023-01-25T13:45:42 | 2023-01-25T13:45:42 | 812,057 | 0 | 6 | null | 2022-11-24T04:54:25 | 2010-08-02T10:39:19 |
Python
|
UTF-8
|
Scheme
| false | false | 1,172 |
ss
|
y!.ss
|
(define Y (λ (f) ((λ (fn) (f (λ (l) ((fn fn) l))))
(λ (fn) (f (λ (l) ((fn fn) l)))))))
(define Y! (λ (f) (letrec ((fn (f (λ (l) (fn l))))) fn)))
(define Y1! (λ (f) (let ((fn (λ (l) `()))) (set! fn (f (λ (l) (fn l)))) fn)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;tests;;;;;;;;;;;;;;;;;;;;;;
(define len (Y (λ (fn)
(λ (l)
(cond ((null? l) 0)
(else (+ 1 (fn (cdr l)))))))))
(define len! (Y! (λ (fn)
(λ (l) w
(cond ((null? l) 0)
(else (+ 1 (fn (cdr l)))))))))
(define len1 (Y1! (λ (fn)
(λ (l)
(cond ((null? l) 0)
(else (+ 1 (fn (cdr l)))))))))
(define lst2 `(1))
;(len `(1 2 3 ))
;(len1 `(1 4 5 6 7 8 9 9))
(define lst5 `(1 35 5 5 55 5 5 5 5 5 5 5 5 5 55 5 5 5 5))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;biz;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define biz
(let ((x 0))
(λ (f)
(set! x (+ 1 x))
(λ (a) (if (= a x) 0 (f a))))))
;((Y biz) 5)
((Y! biz) 5)
;((Y!1 biz) 5)
| false |
df99c270ca9bb144b82a9a69b360e7fcbced6536
|
951b7005abfe3026bf5b3bd755501443bddaae61
|
/pi.scm
|
691547ec0318f4dd25cd49a3d6f8d142c08bd20f
|
[] |
no_license
|
WingT/scheme-sicp
|
d8fd5a71afb1d8f78183a5f6e4096a6d4b6a6c61
|
a255f3e43b46f89976d8ca2ed871057cbcbb8eb9
|
refs/heads/master
| 2020-05-21T20:12:17.221412 | 2016-09-24T14:56:49 | 2016-09-24T14:56:49 | 63,522,759 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 295 |
scm
|
pi.scm
|
(define (pi term a next b)
(define (pi-iter a ans)
(if (> a b)
ans
(pi-iter (next a) (* ans (term a)))))
(pi-iter a 1.0))
(define (fig-pi n)
(* 4 (pi (lambda (x)
(/ (* (- x 1) (+ x 1)) (* x x)))
3
(lambda (x) (+ x 2))
n)))
| false |
99c68bf357ab4715a1bde3898af43aa813bb1352
|
abc7bd420c9cc4dba4512b382baad54ba4d07aa8
|
/src/ws/passes/wavescope_bkend/type-annotate-misc.sls
|
3cf5fe73c5f23a3c77f951c26be498d366c5d3df
|
[
"BSD-3-Clause"
] |
permissive
|
rrnewton/WaveScript
|
2f008f76bf63707761b9f7c95a68bd3e6b9c32ca
|
1c9eff60970aefd2177d53723383b533ce370a6e
|
refs/heads/master
| 2021-01-19T05:53:23.252626 | 2014-10-08T15:00:41 | 2014-10-08T15:00:41 | 1,297,872 | 10 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,331 |
sls
|
type-annotate-misc.sls
|
#!r6rs
;; This adds some extra type annotations that we will need when generating code.
;; (After nominalize-types we can no longer use recover-type.)
(library (ws passes wavescope_bkend type-annotate-misc)
(export type-annotate-misc
type-annotate-misc-grammar
)
(import (except (rnrs (6)) error) (ws common)
(ws passes normalize_query ws-lift-let))
;; UNFINISHED, should reflect constraints on annotated prims:
(define type-annotate-misc-grammar
(let* ([hitforapp #f]
[filtered
(filter (lambda (x)
(match x
[(Const . ,_) #f]
[(AppConstructs ('foreign-app . ,_)) (set! hitforapp #t) #f]
[,else #t]))
ws-lift-let-grammar)])
(unless hitforapp (error 'type-annotate-misc-grammar
"failed to remove foreign-app production from previous pass's grammar."))
;; Add symbols to the literal grammar (for dataFile)
;; Remove 'Const' and make everything 'ComplexConst' (again)
(append `((Datum ,symbol?)
(Const ComplexConst)
(ComplexConst ('__foreign Const Const ComplexDatum))
(ComplexConst ('__foreign_source Const Const ComplexDatum))
(AppConstructs ('foreign-app Const ('assert-type Type Var) Simple ...))
)
filtered)))
;; Adds types to various primitives for code generation.
(define-pass type-annotate-misc
;(define annotated-prims '(print show cons hashtable seg_get))
(define annotate-outside-prims
'(hashtable prim_window List:append List:reverse cons
Array:make Array:makeUNSAFE
unionN
ptrToArray
;; Being lenient with these and not requiring direct annotation from the start.
foreign_source
; readFile
Mutable:ref
unmarshal
__type_unsafe_read ;; [2008.08.05]
))
(define annotate-first-arg
'(List:append List:length List:ref seg_get toArray
print show __show_ARRAY
Array:ref Array:set Array:length
car ;; [2008.03.22] Adding
cdr ;; [2008.07.30] Adding
< <= > >= max min
= wsequal?
Internal:hash ;; [2009.06.07] Adding
joinsegs subseg width toSigseg toArray timebase start end seg_get
emit ;; [2008.07.22] adding
;Mutable:ref ;; [2008.07.22]
marshal ;; [2008.08.04]
__type_unsafe_write
))
(define (not-poly? ty) (not (polymorphic-type? ty)))
(define (wrap ty x)
(ASSERT "shouldnt find polymorphism at this point" not-poly? ty)
`(assert-type ,ty ,x))
(define (maybewrap x tenv)
(match x
[(assert-type ,ty ,_) x]
[,_
(define recovered (recover-type x tenv))
(DEBUGASSERT (not (polymorphic-type? recovered)))
(wrap recovered x)]))
(define (process-expr x tenv fallthru)
; (printf "PE: \n")
(match x
;; These primitives need their assert-types on the INSIDE:
[(List:make ,[n] ,[init]) `(List:make ,n ,(maybewrap init tenv))]
[(set! ,v ,[x]) `(set! ,v ,(maybewrap x tenv))]
;; TODO, FIXME: THIS IS A HACKISH AND BROKEN APPROACH:
;; Here we catch these primitives where they're bound and just
;; use the pre-computed type. We wrap that assert-type
;; construct around the OUTSIDE of the form.
[,frm (guard (binding-form? frm))
;; After we're all done we run the fallthru function to complete processing.
;;
;; NOTE: we put the whole thing back through fallthru because
;; we don't NECESSARILY know whether "other"s are in the
;; scope of the variables or not.
(fallthru
(mvlet ([(vars types rhs* other k) (binding-form-visit-knowncode frm)])
(k vars types
(map (lambda (type rhs) ;rhs may be #f for 'unavailable'
(if (and (pair? rhs) (memq (car rhs) annotate-outside-prims))
(wrap type rhs)
rhs))
types rhs*)
other))
tenv)]
[(,annfirst ,[x] ,[y*] ...) (guard (memq annfirst annotate-first-arg))
`(,annfirst ,(maybewrap x tenv) . ,y*)]
;; Generically handle all the annotate-outside forms:
;; Wouldn't need this if the program were flattened so that
;; the above binding-form case caught everything.
#;
[(,annprim ,[e*] ...) (guard (memq annprim annotate-outside-prims))
(let ([exp `(,annprim . ,e*)])
,(maybewrap exp tenv))]
;; Tag the applications too:
[(foreign-app ',realname ,rator ,[arg*] ...)
; (ASSERT symbol? rator) ;; [2007.10.26] Not sure why this would need to be the case...
`(foreign-app ',realname
,(maybewrap rator tenv)
,@arg*)]
;; Anything already in assert form is covered.
;; [2007.01.24] Commenting:
;;[(assert-type ,t ,e) `(assert-type ,t ,(fallthru e tenv))]
#;
;; Safety nets:
[(,missed ,_ ...) (guard (memq missed '(dataFile readFile)))
(error 'type-annotate-misc "uncaught '~s' call: ~s" missed (cons missed _))]
;; For now it's an error for this stuff to occur otherwise.
;;
;; Can't assert this now because currently we put the whole
;; thing back through 'fallthru' in the above binding form case.
#;
[(,annprim ,e* ...) (guard (or (memq annprim annotate-outside-prims) (memq annprim annotate-first-arg)))
(error 'type-annotate-misc "was supposed to catch this prim at a binding site: ~s"
`(,annprim . ,e*))]
[,other (fallthru other tenv)]))
[Expr/Types process-expr]
;; TEMP FIXME!!!
;[OutputGrammar type-annotate-misc-grammar]
)
) ; End module
| false |
d7ada5073416f99649ddf9a6b3664803b772608d
|
d074b9a2169d667227f0642c76d332c6d517f1ba
|
/sicp/ch_4/exercise.4.19.scm
|
083596a0823622fed3d8845143e8daae1b71430f
|
[] |
no_license
|
zenspider/schemers
|
4d0390553dda5f46bd486d146ad5eac0ba74cbb4
|
2939ca553ac79013a4c3aaaec812c1bad3933b16
|
refs/heads/master
| 2020-12-02T18:27:37.261206 | 2019-07-14T15:27:42 | 2019-07-14T15:27:42 | 26,163,837 | 7 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,978 |
scm
|
exercise.4.19.scm
|
#!/usr/bin/env csi -s
(require rackunit)
(require-library eval)
(import eval)
;;; Exercise 4.19
;; Ben Bitdiddle, Alyssa P. Hacker, and Eva Lu Ator
;; are arguing about the desired result of evaluating the expression
;;
;; (let ((a 1))
;; (define (f x)
;; (define b (+ a x))
;; (define a 5)
;; (+ a b))
;; (f 10))
;;
;; Ben asserts that the result should be obtained using the
;; sequential rule for `define': `b' is defined to be 11, then `a' is
;; defined to be 5, so the result is 16. Alyssa objects that mutual
;; recursion requires the simultaneous scope rule for internal
;; procedure definitions, and that it is unreasonable to treat
;; procedure names differently from other names. Thus, she argues
;; for the mechanism implemented in *Note Exercise 4-16::. This
;; would lead to `a' being unassigned at the time that the value for
;; `b' is to be computed. Hence, in Alyssa's view the procedure
;; should produce an error. Eva has a third opinion. She says that
;; if the definitions of `a' and `b' are truly meant to be
;; simultaneous, then the value 5 for `a' should be used in
;; evaluating `b'. Hence, in Eva's view `a' should be 5, `b' should
;; be 15, and the result should be 20. Which (if any) of these
;; viewpoints do you support? Can you devise a way to implement
;; internal definitions so that they behave as Eva prefers?(3)
;; A: In order to support mutual recursion and for cleaner, more
;; consistent semantics, I prefer Eva's preference: simultaneous
;; definition. I find it conceptually cleaner. I'm not sure how to
;; implement it, except maybe by making the application lazy so
;; that b isn't truly defined until it is used. Futures could do
;; this well I guess. But I think you could probably do this via
;; transformation alone. Eg:
;; (let ((a 1))
;; (define (f x)
;; (letrec ((b (lambda () (+ a x)))
;; (a 5))
;; (+ a (b))))
;; (f 10))
| false |
426ff18a73af25edd0440b2ff42f9da98e51c69c
|
1384f71796ddb9d11c34c6d988c09a442b2fc8b2
|
/examples/hello-server
|
0d9cf40be9b145c5ec88a1fb3e142678194da238
|
[] |
no_license
|
ft/xmms2-guile
|
94c2479eec427a370603425fc9e757611a796254
|
29670e586bf440c20366478462f425d5252b953c
|
refs/heads/master
| 2021-07-08T07:58:15.066996 | 2020-10-12T01:24:04 | 2020-10-12T01:24:04 | 74,858,831 | 1 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,018 |
hello-server
|
;; -*- scheme-*-
;; Here is the simplest exchange you can do with an XMMS2 server. You create a
;; connection object, then use that object to connect to the server and then
;; you send the HELLO message to the server, to which the server will reply.
;;
;; The script prints the reply from the server to stdout.
(use-modules (ice-9 format)
(rnrs bytevectors)
(xmms2 constants meta)
(xmms2 io)
(xmms2 ipc main)
(xmms2 jump-table)
(xmms2 header)
(xmms2 data-conversion)
(xmms2 constants))
;; You'll notice the "socat" in the unix socket name here. What this hints at
;; is the use of socat to look at the byte-stream between client and server.
;; The thing is that it is impossible to sniff unix socket connections with
;; something like wireshark. But you can insert something that provides a
;; socket to a client and forwards everything to another socket while printing
;; all the traffic that goes through that pipe. "socat" does exactly that.
;;
;; Here is how I construct such a printing connection:
;;
;; socat -t100 -x -v \
;; UNIX-LISTEN:/tmp/xmms-ipc-"$USER".socat,mode=700,reuseaddr \
;; fork \
;; UNIX-CONNECT:/tmp/xmms-ipc-"$USER"
;;
;; Where "$USER" is my user name on the system, which is why getlogin is used
;; in the expression below.
(define server (make-xmms2-connection
(string-concatenate (list "unix:///tmp/xmms-ipc-"
(getlogin)
".socat"))))
(xmms2-connect server)
(xmms2-send server (ipc-hello PROTOCOL-VERSION "example-hello-server"
#:cookie 42))
;; Get the response from the server:
(define response (xmms2-recv server))
;; Extract the header from the response:
(define header (car response))
(format #t "Entire server response:~%")
(format #t "~a~%" response)
(format #t "Deconstruct header:~%")
(format #t "object-type: ~x~%" (header->object-type header))
(format #t "command-id: ~x~%" (header->command-id header))
(format #t "cookie: ~d~%" (header->cookie header))
(define pl (header->payload-length header))
(format #t "payload-length: ~d~%" pl)
;; The response from xmms2-recv contains a parsed version of the payload-length
;; and that should better match the payload-length field from the header.
(format #t "Payload length from header ~a payload from response list.~%"
(if (= pl (cadr response))
"matches"
"does NOT match"))
(define payload (caddr response))
;; In addition, the length of the payload byte-vector has to match that number
;; as well. If it doesn't either the server sends faulty data, data gets lost
;; in the transmission channel or we got a bug in this library.
(format #t "The length of the payload buffer ~a payload from response list.~%"
(if (= pl (bytevector-length payload))
"matches"
"does NOT match"))
(define expected-length 12)
(if (and (= pl expected-length)
(= (bytevector-length (caddr response)) expected-length))
(format #t "Payload length yields expected value. Good!~%")
(begin (format #t "Payload length looks fishy. Giving up.~%")
(exit 1)))
(define (incorrect-type payload)
(format #t "Server did NOT return integer client ID!~%")
(let ((n (uint32-ref payload 0)))
(format #t "Type code ~d suggests: ~a~%"
n (assoc-ref xref-types n)))
(exit 1))
(define (correct-type payload)
(format #t "Analysing payload data...~%client-id: ~d~%"
(uint64-ref payload 4)))
;; Build a trivial jump-table to get the client id from the server response's
;; payload. The type tag is four octets wide, the int64 data is eight bytes
;; wide. Hence, we expected twelve bytes earlier on.
(define jmptbl (make-jump-table (table (TYPE-INT64 correct-type))
#:others incorrect-type))
(apply-jump-table jmptbl (uint32-ref payload 0) payload)
| false |
|
6150f5719747729472cd4862361955ef44d2e595
|
00466b7744f0fa2fb42e76658d04387f3aa839d8
|
/sicp/chapter3/3.3/ex3.28.scm
|
49d90bfd6630eaf9d3b4fe441d65b1b6945f71f4
|
[
"WTFPL"
] |
permissive
|
najeex/stolzen
|
961da2b408bcead7850c922f675888b480f2df9d
|
bb13d0a7deea53b65253bb4b61aaf2abe4467f0d
|
refs/heads/master
| 2020-09-11T11:00:28.072686 | 2015-10-22T21:35:29 | 2015-10-22T21:35:29 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 711 |
scm
|
ex3.28.scm
|
#lang scheme
(define or-gate-delay 1)
(define (or-gate in1 in2 output)
(define (or-action-procedure)
(let
((new-value
(logical-or (get-signal in1) (get-signal in2))))
(after-delay or-gate-delay
(lambda () (set-signal! output new-value)))
)
)
(add-action! in1 or-action-procedure)
(add-action! in2 or-action-procedure)
(void)
)
(define (logical-or s1 s2)
(cond
((and (= s1 1) (= s2 1)) 1)
((and (= s1 0) (= s2 1)) 1)
((and (= s1 1) (= s2 0)) 1)
((and (= s1 0) (= s2 0)) 0)
(else
(error "Invalid signal" s))
)
)
| false |
224dd0c43da26d9ed821fe31790ea61129c757c8
|
be6fe59e871d13a473c8007d40c97623cda51cf9
|
/footwm/util.sls
|
a60865f054dd2db73e120fb81a3d3e3217719de8
|
[
"Unlicense",
"LicenseRef-scancode-public-domain"
] |
permissive
|
akce/footwm-chez
|
b072d64535903bfeb6f1863a325c5449e7cdbd00
|
a329141a732f96fd273d1e1a99060ab2f7562cab
|
refs/heads/master
| 2021-11-19T22:15:33.147720 | 2021-10-17T05:09:21 | 2021-10-17T05:09:21 | 172,157,105 | 6 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,258 |
sls
|
util.sls
|
;; Footwm misc utility functions.
;;
;; Written by Akce 2019-2020.
;;
;; SPDX-License-Identifier: Unlicense
(library (footwm util)
(export
bitmap
kebab-case->pascal-case
pascal-case->kebab-case
case-equal?
enum
list-combinations
list-combinations*
list-find-index
list-insert
list-replace
remove*
vector-enumerate)
(import
(rnrs)
(only (chezscheme) add1 fxsll iota sub1))
(define-syntax bitmap
(syntax-rules ()
[(_ name (symbol bit) ...)
(begin (define symbol (fxsll 1 bit)) ...)]))
;; https://en.wikipedia.org/wiki/Letter_case#Special_case_styles
;; https://en.wikipedia.org/wiki/Naming_convention_(programming)#Multiple-word_identifiers
(define kebab-case->pascal-case
(lambda (kc-str)
(let ([sl (string->list kc-str)])
(if (null? sl)
kc-str
(let loop ([next-upper? #f] [acc (list (char-upcase (car sl)))] [lsl (cdr sl)])
(cond
[(null? lsl)
(list->string (reverse acc))]
[(char=? (car lsl) #\-)
(loop #t acc (cdr lsl))]
[else
(loop #f (cons (if next-upper? (char-upcase (car lsl)) (car lsl)) acc) (cdr lsl))]))))))
(define pascal-case->kebab-case
(lambda (cc-str)
(let ([sl (string->list cc-str)])
(if (null? sl)
cc-str
(let loop ([acc (list (char-downcase (car sl)))] [lsl (cdr sl)])
(cond
[(null? lsl)
(list->string (reverse acc))]
[(char-upper-case? (car lsl))
(loop (cons (char-downcase (car lsl)) (cons #\- acc)) (cdr lsl))]
[else
(loop (cons (car lsl) acc) (cdr lsl))]))))))
;; [syntax] case-equal?: like case but compares using equal?.
(define-syntax case-equal?
(syntax-rules (else)
[(_ var (val body ...) ... (else bodye ...))
(let ([v var])
(cond
((equal? v val) body ...) ...
(else bodye ...)))]
[(_ var (val body ...) ...)
(let ([v var])
(cond
((equal? v val) body ...) ...))]))
(define-syntax enum
(syntax-rules ()
[(_ name (symbol value) ...)
(begin (define symbol value) ...)]))
(define list-combinations
(lambda (lst size)
(let loop ((part lst) (sz size))
(cond
[(= sz 0) '(())]
[(null? part) '()]
[else
(append
(map
(lambda (x)
(cons (car part) x))
(loop (cdr part) (sub1 sz)))
(loop (cdr part) sz))]))))
(define list-combinations*
(lambda (lst)
(apply
append
(map
(lambda (size)
(list-combinations lst size))
(iota (add1 (length lst)))))))
;; Like 'find' but returns the 0-based index of the first match for predicate, #f otherwise.
(define list-find-index
(lambda (pred lst)
(let ([index 0])
(if (find
(lambda (x)
(cond
[(pred x) #t]
[else (set! index (add1 index)) #f]))
lst)
index
#f))))
(define list-insert
(lambda (lst item pos)
(let loop ((i 0) (rem lst) (ret '()))
(if (null? rem)
(reverse (if (>= pos i) (cons item ret) ret))
(let ([tail (cons (car rem) (if (= pos i) (cons item ret) ret))])
(loop (fx+ i 1) (cdr rem) tail))))))
(define list-replace
(lambda (lst pos item)
(let loop ((i 0) (rem lst) (ret '()))
(if (null? rem)
(reverse ret)
(loop (add1 i) (cdr rem) (cons (if (= i pos) item (car rem)) ret))))))
;; [proc] remove* like remove but can remove mulitple items.
(define remove*
(lambda (lst . items)
(let loop ((ret lst) (i items))
(cond
[(null? i) ret]
[else
(loop (remove (car i) ret) (cdr i))]))))
(define vector-enumerate
(lambda (v)
(let* ([len (vector-length v)]
[res (make-vector len)])
(let loop ((i 0))
(cond
[(fx=? i len) res]
[else
(vector-set! res i i)
(loop (fx+ i 1))]))))))
| true |
556fcb42fb372d83b1a788fa0f1cb4b4bbd5d5a7
|
0011048749c119b688ec878ec47dad7cd8dd00ec
|
/src/040/solution.scm
|
95ea31e0b6a78f96aa6594dde2932947e48ee773
|
[
"0BSD"
] |
permissive
|
turquoise-hexagon/euler
|
e1fb355a44d9d5f9aef168afdf6d7cd72bd5bfa5
|
852ae494770d1c70cd2621d51d6f1b8bd249413c
|
refs/heads/master
| 2023-08-08T21:01:01.408876 | 2023-07-28T21:30:54 | 2023-07-28T21:30:54 | 240,263,031 | 8 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 720 |
scm
|
solution.scm
|
(import
(chicken fixnum))
(define (number-length n)
(let loop ((n n) (acc 0))
(if (fx= n 0)
acc
(loop (fx/ n 10) (fx+ acc 1)))))
(define (nth-digit n index)
(let loop ((n n) (index (fx- (number-length n) index)))
(if (fx= index 0)
(fxmod n 10)
(loop (fx/ n 10) (fx- index 1)))))
(define (solve n)
(let loop ((i 1) (index 1) (counted 0) (acc 1))
(if (fx> index n)
acc
(let* ((len (number-length i)) (total (fx+ counted len)))
(if (fx< total index)
(loop (fx+ i 1) index total acc)
(loop (fx+ i 1) (fx* index 10) total (fx* acc (nth-digit i (fx- len (fx- total index))))))))))
(let ((_ (solve #e1e6)))
(print _) (assert (= _ 210)))
| false |
08ce4d76c36847808c9ed9a9de30da2fb230f5e0
|
9b2eb10c34176f47f7f490a4ce8412b7dd42cce7
|
/lib-compat/nmosh-r7b/i6bv.sls
|
916b284a62a699cf0dbb28e31bdefb84f771c431
|
[
"LicenseRef-scancode-public-domain",
"CC0-1.0"
] |
permissive
|
okuoku/yuni
|
8be584a574c0597375f023c70b17a5a689fd6918
|
1859077a3c855f3a3912a71a5283e08488e76661
|
refs/heads/master
| 2023-07-21T11:30:14.824239 | 2023-06-11T13:16:01 | 2023-07-18T16:25:22 | 17,772,480 | 36 | 6 |
CC0-1.0
| 2020-03-29T08:16:00 | 2014-03-15T09:53:13 |
Scheme
|
UTF-8
|
Scheme
| false | false | 300 |
sls
|
i6bv.sls
|
(library (nmosh-r7b i6bv)
(export
get-output-bytevector
open-output-bytevector)
(import (rnrs)
(yuni-nmosh primitives))
(define get-output-bytevector sys-get-bytevector)
(define (open-output-bytevector) (sys-open-bytevector-output-port))
)
| false |
9603c1d1a5ab1fa86c6d906830a38e9d1b0c5ef3
|
b8eb3fdd0e4e38a696c4013a8f91054df3f75833
|
/scheme/json.ss
|
6fbf15ce280654c570a93b09f244b424ac568120
|
[
"Zlib"
] |
permissive
|
lojikil/digamma
|
952a7bdf176227bf82b3583020bc41764b12d906
|
61c7ffdc501f207a84e5d47157c3c84e5882fa0d
|
refs/heads/master
| 2020-05-30T07:11:20.716792 | 2016-05-11T11:32:15 | 2016-05-11T11:32:15 | 58,539,277 | 6 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,688 |
ss
|
json.ss
|
; a simple JSON parser that returns Digamma objects based on the source.
; Should provide File & string based versions, but currently is String only.
; File based should be easy enough.
; zlib/png licensed & (c) 2010 Stefan Edwards
;
(def (json-string s delim offset start)
"Parse a JSON string, breaking on delim. Delim should be either
#\" or #\'."
(cond
(>= offset (length s)) (error "JSON Parse Error: stream ends before string")
(eq? (nth s offset) delim) (list (cslice s start offset) offset)
else (json-string s delim (+ offset 1) start)))
; probably would be better as a lookup table:
; table => [#\t #\r #\u #\e '$] and state would be index into this table
(def (json-true s offset (state 0))
"Parse JSON true literal"
(if
(> offset (length s)) (error "JSON Parse Error: stream ends before literal")
(cond
(and (eq? state 0) (eq? (nth s offset) #\t)) (json-true s (+ offset 1) 1)
(and (eq? state 1) (eq? (nth s offset) #\r)) (json-true s (+ offset 1) 2)
(and (eq? state 2) (eq? (nth s offset) #\u)) (json-true s (+ offset 1) 3)
(and (eq? state 3) (eq? (nth s offset) #\e)) (json-true s (+ offset 1) 4)
(eq? state 4)
(cond
(>= offset (length s)) (list #t offset)
(eq? (nth s offset) #\}) (list #t offset)
(eq? (nth s offset) #\,) (list #t offset)
(eq? (nth s offset) #\space) (list #t offset)
else (error "JSON Parse Error: unknown literal in true")))))
(def (json-false s offset (state 0))
"Parse JSON false literal"
(if
(> offset (length s)) (error "JSON Parse Error: stream ends before literal")
(cond
(and (eq? state 0) (eq? (nth s offset) #\f)) (json-false s (+ offset 1) 1)
(and (eq? state 1) (eq? (nth s offset) #\a)) (json-false s (+ offset 1) 2)
(and (eq? state 2) (eq? (nth s offset) #\l)) (json-false s (+ offset 1) 3)
(and (eq? state 3) (eq? (nth s offset) #\s)) (json-false s (+ offset 1) 4)
(and (eq? state 4) (eq? (nth s offset) #\e)) (json-false s (+ offset 1) 5)
(eq? state 5)
(cond
(>= offset (length s)) (list #f offset)
(eq? (nth s offset) #\}) (list #f offset)
(eq? (nth s offset) #\,) (list #f offset)
(eq? (nth s offset) #\space) (list #f offset)
else (error "JSON Parse Error: unknown literal in false")))))
(def (json-null s offset (state 0))
"Parse JSON null literal"
(if
(> offset (length s)) (error "JSON Parse Error: stream ends before literal")
(cond
(and (eq? state 0) (eq? (nth s offset) #\n)) (json-null s (+ offset 1) 1)
(and (eq? state 1) (eq? (nth s offset) #\u)) (json-null s (+ offset 1) 2)
(and (eq? state 2) (eq? (nth s offset) #\l)) (json-null s (+ offset 1) 3)
(and (eq? state 3) (eq? (nth s offset) #\l)) (json-null s (+ offset 1) 4)
(eq? state 4)
(cond
(>= offset (length s)) (list '() offset)
(eq? (nth s offset) #\}) (list '() offset)
(eq? (nth s offset) #\,) (list '() offset)
(eq? (nth s offset) #\space) (list '() offset)
else (error "JSON Parse Error: unknown literal in null")))))
(def (json-number s offset (state 0))
"Parse JSON number"
#f)
(def (next-token s offset)
(if (>= offset (length s))
#e
(cond
(eq? (nth s offset) #\{) 'OCURLY
(eq? (nth s offset) #\}) 'CCURLY
(eq? (nth s offset) #\[) 'OVECTOR
(eq? (nth s offset) #\]) 'CVECTOR
(eq? (nth s offset) #\') (json-string s #\' (+ offset 1) (+ offset 1))
(eq? (nth s offset) #\") (json-string s #\" (+ offset 1) (+ offset 1))
(eq? (nth s offset) #\:) 'PAIRSEP
(eq? (nth s offset) #\,) 'MEMBERSEP
;(numeric? (nth s offset)) (json-number s offset)
(eq? (nth s offset) #\t) (json-true s offset 1) ;; skip to second state
(eq? (nth s offset) #\f) (json-false s offset 1)
(eq? (nth s offset) #\n) (json-null s offset 1)
else (error "JSON Parsing Failed: invalid JSON object"))))
(def (json-object s offset)
" returns a JSON object from the current stream "
#f)
(def (json-array s offset state)
" returns a JSON array from the current stream "
(with value (json->value s offset)
(cond
(eq? state 0)
(cons (car value) (json-array s (cadr value) 1))
(eq? state 1)
(cond
(eq? value 'MEMBERSEP) (json-array s (+ offset 1) 0)
(eq? value 'CVECTOR) '()
else (error "JSON Parsing Failed: invalid JSON vector (missing MEMBERSEP)")))))
; string->json should just call various intenral functions:
; parse object, array, number, literal, string
; should return whatever object is applicable:
; "true" => #t
; "nil" => '()
; "[1,2,3,4]" => [1 2 3 4]
; "{"test" : [1,2], "stuff" : [3,4]}" => { :test [1 2] :stuff [3 4]}
; "1" => 1
; "{\"test\"}" => Error
; "{1}" => Error
; &c. Vesta doesn't yet support Unicode, so that's one minor draw back.
; have to fix unicode support at some point.
;
(def (json->value s (offset 0))
" Convert a JSON string to a Digamma value"
(with value (next-token s offset)
(cond
(eq? value 'OVECTOR)
(json-array s (+ offset 1) 0)
(eq? value 'OCURLY)
(json-object s (+ offset 1) 0)
(pair? value)
value)))
(def (value->json s)
" Serialize a Digamma object to JSON"
#f)
| false |
c4a550ae368196987628f87cbe871fe8ac80769b
|
0768e217ef0b48b149e5c9b87f41d772cd9917f1
|
/sitelib/srfi/%3a8/receive.scm
|
f3a8105a620e902e3618a5a6a970c492b89d78e8
|
[
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] |
permissive
|
fujita-y/ypsilon
|
e45c897436e333cf1a1009e13bfef72c3fb3cbe9
|
62e73643a4fe87458ae100e170bf4721d7a6dd16
|
refs/heads/master
| 2023-09-05T00:06:06.525714 | 2023-01-25T03:56:13 | 2023-01-25T04:02:59 | 41,003,666 | 45 | 7 |
BSD-2-Clause
| 2022-06-25T05:44:49 | 2015-08-19T00:05:35 |
Scheme
|
UTF-8
|
Scheme
| false | false | 82 |
scm
|
receive.scm
|
#!nobacktrace
(library (srfi :8 receive) (export receive) (import (srfi srfi-8)))
| false |
72d7d649195a704b667e208413db22b1dfdcf659
|
b677139ff9a19f61d483c7ba16b58844d15f092c
|
/mephisto/examples/live-sample.scm
|
f10fee1617042f13795c0bf45315ad566361e353
|
[] |
no_license
|
torus/MEPHISTO
|
d68d63bf8b8083fe4b615e0a5463600a9a2c39ed
|
fe3664e4745ac33a6c9609ca353d7d6da98e30fe
|
refs/heads/master
| 2021-01-01T16:06:40.876833 | 2012-03-30T15:56:01 | 2012-03-30T15:56:01 | null | 0 | 0 | null | null | null | null |
EUC-JP
|
Scheme
| false | false | 2,669 |
scm
|
live-sample.scm
|
; -*- coding: euc-jp -*-
;; Simple sample with live-paint
;; $Id: live-sample.scm,v 1.1 2006/06/04 09:17:21 torus Exp $
(load "./live-paint")
;; If you are in the Emacs, run the main procedure now to get into the
;; interactive environment.
;(main '())
(define-wires count ux uy n o)
;; フレームカウンタの設定。
(append-painter-streams!
(stream-map (lambda (x)
(lambda ()
(wires-set-value! (count x))))
(make-time-stream)))
;; 適当に値を入れておく。
(wires-set-value! (ux (vector4f 1 0 0))
(uy (vector4f 0 1 0))
(n 5)
(o (point4f 0 0 0)))
;; 正多角形の形に cube を配置する。
(append-painter-streams!
(procedure-stream
(lambda/constraint
(ux uy n o)
(let ((radius 10))
(let loop ((i n))
(unless (zero? i)
(let ((angle (/ (* 2 PI i) n)))
((move-to (point4f-add (point4f-add o (vector4f-scale ux (* (cos angle) radius)))
(vector4f-scale uy (* (sin angle) radius)))
cube))
(loop (- i 1)))))))))
;; 正多角形の基底ベクトルを count によって変化させる。
(attach-constraint!
(count => ux)
(let1 angle (/ count 10)
(vector4f-add (vector4f-scale (vector4f 1 0 0) (cos angle))
(vector4f-scale (vector4f 0 0 1) (sin angle)))))
;; 上の制約が動作するように、いったんリセット。
(wire-reset! ux)
(attach-constraint!
(count => uy)
(let1 angle (/ count 30)
(vector4f-add (vector4f-scale (vector4f 0 1 0) (cos angle))
(vector4f-scale (vector4f 0 0 1) (sin angle)))))
(wire-reset! uy)
;; 多角形の角の数を変えてみる。
(wire-set-value! n 30)
;; 角の数を count にしたがって変化させる。
(attach-constraint!
(count => n)
(remainder (quotient count 30) 20))
(wire-reset! n)
;; 色を付けてみる。
(define-wires r g b)
(append-painter-streams!
(procedure-stream
(lambda/constraint
(r g b)
((paint-color (lambda ()) r g b)))))
(wires-set-value! (r 0)
(g 1)
(b 1))
;; 色相で色を指定できるようにする。
;; 0 <= hue < 3
;; rgb = (list r g b)
(define-wires rgb hue)
(attach-constraint!
(hue => rgb)
(cond ((< hue 1)
(list (- 1 hue) hue 1))
((< hue 2)
(list 1 (- hue 1) (- 2 hue)))
((< hue 3)
(list (- 3 hue) 1 (- hue 2)))
(else
#f)))
(attach-constraint!
(rgb => r)
(ref rgb 0))
(attach-constraint!
(rgb => g)
(ref rgb 1))
(attach-constraint!
(rgb => b)
(ref rgb 2))
;; 適当な値を入れてみる。
(wires-set-value! (hue 1.2))
(wire-reset! r)
(wire-reset! g)
(wire-reset! b)
;; 色相を count にしたがって変化させる。
(attach-constraint!
(count => hue)
(/ (remainder count 300) 100))
| false |
8f16c8ab95fd8bf287cf715d964c4aa9d8dd806c
|
9998f6f6940dc91a99e0e2acb4bc4e918f49eef0
|
/src/test/sample-moby-programs/simple-bootstrap-game.ss
|
23bec2b97746c7224f1c845759a7933ba4d018c2
|
[] |
no_license
|
JessamynT/wescheme-compiler2012
|
326d66df382f3d2acbc2bbf70fdc6b6549beb514
|
a8587f9d316b3cb66d8a01bab3cf16f415d039e5
|
refs/heads/master
| 2020-05-30T07:16:45.185272 | 2016-03-19T07:14:34 | 2016-03-19T07:14:34 | 70,086,162 | 0 | 0 | null | 2016-10-05T18:09:51 | 2016-10-05T18:09:51 | null |
UTF-8
|
Scheme
| false | false | 1,095 |
ss
|
simple-bootstrap-game.ss
|
;; The first three lines of this file were inserted by DrScheme. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-beginner-reader.ss" "lang")((modname simple-bootstrap-game) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ())))
(define WIDTH 320)
(define HEIGHT 480)
(define TITLE "My Simple Game")
(define background (empty-scene WIDTH HEIGHT))
(define (update-target-x x)
(add1 x))
(define (update-target-y y)
(sub1 y))
(define (update-player x key)
(cond
[(string=? key "left")
(- x 10)]
[(string=? key "right")
(+ x 10)]
[else x]))
(define (update-object y)
(- y 20))
(define target (circle 20 "solid" "green"))
(define player (rectangle 30 40 "solid" "blue"))
(define object (circle 10 "solid" "black"))
(define (offscreen? x y)
(or (< x 0)
(> x WIDTH)
(< y 0)
(> y HEIGHT)))
(start TITLE background update-target-x update-target-y update-player update-object target player object offscreen?)
| false |
31f6cc168692d8c0b7e11c6584103b4c32dd0871
|
d0f74e44c829469e7525aafa5a3c4c5e31fe1bfe
|
/desugar/tests/mazes.sch
|
9ed32215ee0f0d57782727e67ce7b0acbdc7692b
|
[] |
no_license
|
Vizerai/CFA
|
e83d568865333aef3bb1ef121cdc013d58f1f99f
|
5c593b885a1ead11a24202d881f0212fee753071
|
refs/heads/master
| 2021-01-23T10:44:37.535101 | 2014-12-09T02:01:13 | 2014-12-09T02:01:13 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 28,515 |
sch
|
mazes.sch
|
; Adapted from http://www.ccs.neu.edu/home/will/Twobit/benchmarksAboutR6.html (by Marc Feeley)
(define odd?
(lambda (n)
(= 1 (modulo n 2))))
(define even?
(lambda (n)
(= 0 (modulo n 2))))
(define map
(lambda (f lst)
(if (null? lst)
lst
(cons (f (car lst)) (map f (cdr lst))))))
(define foldr
(lambda (f base lst)
(letrec ((foldr-aux
(lambda (lst)
(if (null? lst)
base
(f (car lst) (foldr-aux (cdr lst)))))))
(foldr-aux lst))))
(define foldl
(lambda (f base lst)
(letrec ((foldl-aux
(lambda (base lst)
(if (null? lst)
base
(foldl-aux (f base (car lst)) (cdr lst))))))
(foldl-aux base lst))))
(define for
(lambda (lo hi f)
(letrec ((for-aux
(lambda (lo)
(if (< lo hi)
(cons (f lo) (for-aux (+ lo 1)))
(list)))))
(for-aux lo))))
(define concat
(lambda (lists)
(foldr (lambda (a b) (append a b)) (list) lists)))
(define list-read
(lambda (lst i)
(if (= i 0)
(car lst)
(list-read (cdr lst) (- i 1)))))
(define list-write
(lambda (lst i val)
(if (= i 0)
(cons val (cdr lst))
(cons (car lst) (list-write (cdr lst) (- i 1) val)))))
(define list-remove-pos
(lambda (lst i)
(if (= i 0)
(cdr lst)
(cons (car lst) (list-remove-pos (cdr lst) (- i 1))))))
(define member-of
(lambda (e lst)
(if (null? lst)
#f
(if (equal? e (car lst))
#t
(member-of e (cdr lst))))))
(define duplicates?
(lambda (lst)
(if (null? lst)
#f
(or (member-of (car lst) (cdr lst))
(duplicates? (cdr lst))))))
(define make-matrix
(lambda (n m init)
(for 0 n (lambda (i) (for 0 m (lambda (j) (init i j)))))))
(define matrix-read
(lambda (mat i j)
(list-read (list-read mat i) j)))
(define matrix-write
(lambda (mat i j val)
(list-write mat i (list-write (list-read mat i) j val))))
(define matrix-size
(lambda (mat)
(cons (length mat) (length (car mat)))))
(define matrix-map
(lambda (f mat)
(map (lambda (lst) (map f lst)) mat)))
(define initial-random 0)
(define next-random
(lambda (current-random)
(modulo (+ (* current-random 3581) 12751) 131072)))
(define neighboring-cavities
(lambda (pos cave)
(let ((size (matrix-size cave)))
(let ((n (car size)) (m (cdr size)))
(let ((i (car pos)) (j (cdr pos)))
(append (if (and (> i 0) (matrix-read cave (- i 1) j))
(list (cons (- i 1) j))
(list))
(if (and (< i (- n 1)) (matrix-read cave (+ i 1) j))
(list (cons (+ i 1) j))
(list))
(if (and (> j 0) (matrix-read cave i (- j 1)))
(list (cons i (- j 1)))
(list))
(if (and (< j (- m 1)) (matrix-read cave i (+ j 1)))
(list (cons i (+ j 1)))
(list))))))))
(define shuffle-aux
(lambda (lst current-random)
(if (null? lst)
(list)
(let ((new-random (next-random current-random)))
(let ((i (modulo new-random (length lst))))
(cons (list-read lst i)
(shuffle-aux (list-remove-pos lst i)
new-random)))))))
(define shuffle
(lambda (lst)
(shuffle-aux lst initial-random)))
(define cave-to-maze
(lambda (cave)
(matrix-map (lambda (x) (if x '_ '*)) cave)))
(define change-cavity-aux
(lambda (cave pos new-cavity-id old-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(let ((cavity-id (matrix-read cave i j)))
(if (equal? cavity-id old-cavity-id)
(foldl (lambda (c nc)
(change-cavity-aux c nc new-cavity-id old-cavity-id))
(matrix-write cave i j new-cavity-id)
(neighboring-cavities pos cave))
cave)))))
(define change-cavity
(lambda (cave pos new-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(change-cavity-aux cave pos new-cavity-id (matrix-read cave i j)))))
(define pierce
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write cave i j pos))))
(define try-to-pierce
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(let ((ncs (neighboring-cavities pos cave)))
(if (duplicates?
(map (lambda (nc) (matrix-read cave (car nc) (cdr nc))) ncs))
cave
(pierce pos
(foldl (lambda (c nc) (change-cavity c nc pos))
cave
ncs)))))))
(define pierce-randomly
(lambda (possible-holes cave)
(if (null? possible-holes)
cave
(let ((hole (car possible-holes)))
(pierce-randomly (cdr possible-holes)
(try-to-pierce hole cave))))))
(define make-maze
(lambda (n m)
(if (not (and (odd? n) (odd? m)))
(print 'error)
(let ((cave
(make-matrix n m (lambda (i j)
(if (and (even? i) (even? j))
(cons i j)
#f))))
(possible-holes
(concat
(for 0 n (lambda (i)
(concat
(for 0 m (lambda (j)
(if (equal? (even? i) (even? j))
(list)
(list (cons i j)))))))))))
(pierce-randomly (shuffle possible-holes) cave)))))
(begin (pretty-print (make-maze 15 15))
(pretty-print (make-maze 15 15))
(pretty-print (make-maze 15 15))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5))
(pretty-print (make-maze 5 5)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define odd?2
(lambda (n)
(= 1 (modulo n 2))))
(define even?2
(lambda (n)
(= 0 (modulo n 2))))
(define map2
(lambda (f lst)
(if (null? lst)
lst
(cons (f (car lst)) (map2 f (cdr lst))))))
(define foldr2
(lambda (f base lst)
(letrec ((foldr-aux
(lambda (lst)
(if (null? lst)
base
(f (car lst) (foldr-aux (cdr lst)))))))
(foldr-aux lst))))
(define foldl2
(lambda (f base lst)
(letrec ((foldl-aux
(lambda (base lst)
(if (null? lst)
base
(foldl-aux (f base (car lst)) (cdr lst))))))
(foldl-aux base lst))))
(define for2
(lambda (lo hi f)
(letrec ((for-aux
(lambda (lo)
(if (< lo hi)
(cons (f lo) (for-aux (+ lo 1)))
(list)))))
(for-aux lo))))
(define concat2
(lambda (lists)
(foldr (lambda (a b) (append a b)) (list) lists)))
(define list-read2
(lambda (lst i)
(if (= i 0)
(car lst)
(list-read2 (cdr lst) (- i 1)))))
(define list-write2
(lambda (lst i val)
(if (= i 0)
(cons val (cdr lst))
(cons (car lst) (list-write2 (cdr lst) (- i 1) val)))))
(define list-remove-pos2
(lambda (lst i)
(if (= i 0)
(cdr lst)
(cons (car lst) (list-remove-pos2 (cdr lst) (- i 1))))))
(define member-of2
(lambda (e lst)
(if (null? lst)
#f
(if (equal? e (car lst))
#t
(member-of2 e (cdr lst))))))
(define duplicates?2
(lambda (lst)
(if (null? lst)
#f
(or (member-of2 (car lst) (cdr lst))
(duplicates?2 (cdr lst))))))
(define make-matrix2
(lambda (n m init)
(for2 0 n (lambda (i) (for2 0 m (lambda (j) (init i j)))))))
(define matrix-read2
(lambda (mat i j)
(list-read2 (list-read2 mat i) j)))
(define matrix-write2
(lambda (mat i j val)
(list-write2 mat i (list-write2 (list-read2 mat i) j val))))
(define matrix-size2
(lambda (mat)
(cons (length mat) (length (car mat)))))
(define matrix-map2
(lambda (f mat)
(map2 (lambda (lst) (map2 f lst)) mat)))
(define next-random2
(lambda (current-random)
(modulo (+ (* current-random 3581) 12751) 131072)))
(define neighboring-cavities2
(lambda (pos cave)
(let ((size (matrix-size2 cave)))
(let ((n (car size)) (m (cdr size)))
(let ((i (car pos)) (j (cdr pos)))
(append (if (and (> i 0) (matrix-read2 cave (- i 1) j))
(list (cons (- i 1) j))
(list))
(if (and (< i (- n 1)) (matrix-read2 cave (+ i 1) j))
(list (cons (+ i 1) j))
(list))
(if (and (> j 0) (matrix-read2 cave i (- j 1)))
(list (cons i (- j 1)))
(list))
(if (and (< j (- m 1)) (matrix-read2 cave i (+ j 1)))
(list (cons i (+ j 1)))
(list))))))))
(define shuffle-aux2
(lambda (lst current-random)
(if (null? lst)
(list)
(let ((new-random (next-random2 current-random)))
(let ((i (modulo new-random (length lst))))
(cons (list-read lst i)
(shuffle-aux2 (list-remove-pos lst i)
new-random)))))))
(define shuffle2
(lambda (lst)
(shuffle-aux2 lst initial-random)))
(define cave-to-maze2
(lambda (cave)
(matrix-map2 (lambda (x) (if x '_ '*)) cave)))
(define change-cavity-aux2
(lambda (cave pos new-cavity-id old-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(let ((cavity-id (matrix-read2 cave i j)))
(if (equal? cavity-id old-cavity-id)
(foldl (lambda (c nc)
(change-cavity-aux2 c nc new-cavity-id old-cavity-id))
(matrix-write2 cave i j new-cavity-id)
(neighboring-cavities2 pos cave))
cave)))))
(define change-cavity2
(lambda (cave pos new-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(change-cavity-aux2 cave pos new-cavity-id (matrix-read2 cave i j)))))
(define pierce2
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write2 cave i j pos))))
(define try-to-pierce2
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(let ((ncs (neighboring-cavities2 pos cave)))
(if (duplicates?2
(map2 (lambda (nc) (matrix-read2 cave (car nc) (cdr nc))) ncs))
cave
(pierce pos
(foldl2 (lambda (c nc) (change-cavity c nc pos))
cave
ncs)))))))
(define pierce-randomly2
(lambda (possible-holes cave)
(if (null? possible-holes)
cave
(let ((hole (car possible-holes)))
(pierce-randomly2 (cdr possible-holes)
(try-to-pierce2 hole cave))))))
(define make-maze2
(lambda (n m)
(if (not (and (odd?2 n) (odd?2 m)))
(print 'error)
(let ((cave
(make-matrix2 n m (lambda (i j)
(if (and (even?2 i) (even?2 j))
(cons i j)
#f))))
(possible-holes
(concat2
(for2 0 n (lambda (i)
(concat2
(for2 0 m (lambda (j)
(if (equal? (even?2 i) (even?2 j))
(list)
(list (cons i j)))))))))))
(pierce-randomly2 (shuffle2 possible-holes) cave)))))
(begin (pretty-print (make-maze2 15 15))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4))
(pretty-print (make-maze2 4 4)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define odd?3
(lambda (n)
(= 1 (modulo n 2))))
(define even?3
(lambda (n)
(= 0 (modulo n 2))))
(define map3
(lambda (f lst)
(if (null? lst)
lst
(cons (f (car lst)) (map3 f (cdr lst))))))
(define foldr3
(lambda (f base lst)
(letrec ((foldr-aux
(lambda (lst)
(if (null? lst)
base
(f (car lst) (foldr-aux (cdr lst)))))))
(foldr-aux lst))))
(define foldl3
(lambda (f base lst)
(letrec ((foldl-aux
(lambda (base lst)
(if (null? lst)
base
(foldl-aux (f base (car lst)) (cdr lst))))))
(foldl-aux base lst))))
(define for3
(lambda (lo hi f)
(letrec ((for-aux
(lambda (lo)
(if (< lo hi)
(cons (f lo) (for-aux (+ lo 1)))
(list)))))
(for-aux lo))))
(define concat3
(lambda (lists)
(foldr (lambda (a b) (append a b)) (list) lists)))
(define list-read3
(lambda (lst i)
(if (= i 0)
(car lst)
(list-read3 (cdr lst) (- i 1)))))
(define list-write3
(lambda (lst i val)
(if (= i 0)
(cons val (cdr lst))
(cons (car lst) (list-write3 (cdr lst) (- i 1) val)))))
(define list-remove-pos3
(lambda (lst i)
(if (= i 0)
(cdr lst)
(cons (car lst) (list-remove-pos3 (cdr lst) (- i 1))))))
(define member-of3
(lambda (e lst)
(if (null? lst)
#f
(if (equal? e (car lst))
#t
(member-of3 e (cdr lst))))))
(define duplicates?3
(lambda (lst)
(if (null? lst)
#f
(or (member-of3 (car lst) (cdr lst))
(duplicates?3 (cdr lst))))))
(define make-matrix3
(lambda (n m init)
(for3 0 n (lambda (i) (for3 0 m (lambda (j) (init i j)))))))
(define matrix-read3
(lambda (mat i j)
(list-read3 (list-read3 mat i) j)))
(define matrix-write3
(lambda (mat i j val)
(list-write3 mat i (list-write3 (list-read3 mat i) j val))))
(define matrix-size3
(lambda (mat)
(cons (length mat) (length (car mat)))))
(define matrix-map3
(lambda (f mat)
(map3 (lambda (lst) (map3 f lst)) mat)))
(define next-random3
(lambda (current-random)
(modulo (+ (* current-random 3581) 12751) 131072)))
(define neighboring-cavities3
(lambda (pos cave)
(let ((size (matrix-size3 cave)))
(let ((n (car size)) (m (cdr size)))
(let ((i (car pos)) (j (cdr pos)))
(append (if (and (> i 0) (matrix-read3 cave (- i 1) j))
(list (cons (- i 1) j))
(list))
(if (and (< i (- n 1)) (matrix-read3 cave (+ i 1) j))
(list (cons (+ i 1) j))
(list))
(if (and (> j 0) (matrix-read3 cave i (- j 1)))
(list (cons i (- j 1)))
(list))
(if (and (< j (- m 1)) (matrix-read3 cave i (+ j 1)))
(list (cons i (+ j 1)))
(list))))))))
(define shuffle-aux3
(lambda (lst current-random)
(if (null? lst)
(list)
(let ((new-random (next-random3 current-random)))
(let ((i (modulo new-random (length lst))))
(cons (list-read lst i)
(shuffle-aux3 (list-remove-pos lst i)
new-random)))))))
(define shuffle3
(lambda (lst)
(shuffle-aux3 lst initial-random)))
(define cave-to-maze3
(lambda (cave)
(matrix-map3 (lambda (x) (if x '_ '*)) cave)))
(define change-cavity-aux3
(lambda (cave pos new-cavity-id old-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(let ((cavity-id (matrix-read3 cave i j)))
(if (equal? cavity-id old-cavity-id)
(foldl (lambda (c nc)
(change-cavity-aux3 c nc new-cavity-id old-cavity-id))
(matrix-write3 cave i j new-cavity-id)
(neighboring-cavities3 pos cave))
cave)))))
(define change-cavity3
(lambda (cave pos new-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(change-cavity-aux3 cave pos new-cavity-id (matrix-read3 cave i j)))))
(define pierce3
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write3 cave i j pos))))
(define try-to-pierce3
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(let ((ncs (neighboring-cavities3 pos cave)))
(if (duplicates?3
(map3 (lambda (nc) (matrix-read3 cave (car nc) (cdr nc))) ncs))
cave
(pierce pos
(foldl3 (lambda (c nc) (change-cavity c nc pos))
cave
ncs)))))))
(define pierce-randomly3
(lambda (possible-holes cave)
(if (null? possible-holes)
cave
(let ((hole (car possible-holes)))
(pierce-randomly3 (cdr possible-holes)
(try-to-pierce3 hole cave))))))
(define make-maze3
(lambda (n m)
(if (not (and (odd?3 n) (odd?3 m)))
(print 'error)
(let ((cave
(make-matrix3 n m (lambda (i j)
(if (and (even?3 i) (even?3 j))
(cons i j)
#f))))
(possible-holes
(concat3
(for3 0 n (lambda (i)
(concat3
(for3 0 m (lambda (j)
(if (equal? (even?3 i) (even?3 j))
(list)
(list (cons i j)))))))))))
(pierce-randomly3 (shuffle3 possible-holes) cave)))))
(begin (pretty-print (make-maze3 15 15))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4))
(pretty-print (make-maze3 4 4)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define change-cavity-aux4
(lambda (cave pos new-cavity-id old-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(let ((cavity-id (matrix-read3 cave i j)))
(if (equal? cavity-id old-cavity-id)
(foldl (lambda (c nc)
(change-cavity-aux3 c nc new-cavity-id old-cavity-id))
(matrix-write3 cave i j new-cavity-id)
(neighboring-cavities3 pos cave))
cave)))))
(define change-cavity4
(lambda (cave pos new-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(change-cavity-aux4 cave pos new-cavity-id (matrix-read3 cave i j)))))
(define pierce4
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write3 cave i j pos))))
(define try-to-pierce4
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(let ((ncs (neighboring-cavities3 pos cave)))
(if (duplicates?2
(map2 (lambda (nc) (matrix-read3 cave (car nc) (cdr nc))) ncs))
cave
(pierce pos
(foldl2 (lambda (c nc) (change-cavity c nc pos))
cave
ncs)))))))
(define pierce-randomly4
(lambda (possible-holes cave)
(if (null? possible-holes)
cave
(let ((hole (car possible-holes)))
(pierce-randomly4 (cdr possible-holes)
(try-to-pierce4 hole cave))))))
(define make-maze4
(lambda (n m)
(if (not (and (odd?2 n) (odd?3 m)))
(print 'error)
(let ((cave
(make-matrix2 n m (lambda (i j)
(if (and (even?3 i) (even?3 j))
(cons i j)
#f))))
(possible-holes
(concat3
(for3 0 n (lambda (i)
(concat3
(for2 0 m (lambda (j)
(if (equal? (even?3 i) (even?3 j))
(list)
(list (cons i j)))))))))))
(pierce-randomly3 (shuffle3 possible-holes) cave)))))
(begin (pretty-print (make-maze4 15 15))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4))
(pretty-print (make-maze4 4 4)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define odd?5
(lambda (n)
(= 1 (modulo n 2))))
(define even?5
(lambda (n)
(= 0 (modulo n 2))))
(define map5
(lambda (f lst)
(if (null? lst)
lst
(cons (f (car lst)) (map5 f (cdr lst))))))
(define foldr5
(lambda (f base lst)
(letrec ((foldr-aux
(lambda (lst)
(if (null? lst)
base
(f (car lst) (foldr-aux (cdr lst)))))))
(foldr-aux lst))))
(define foldl5
(lambda (f base lst)
(letrec ((foldl-aux
(lambda (base lst)
(if (null? lst)
base
(foldl-aux (f base (car lst)) (cdr lst))))))
(foldl-aux base lst))))
(define for5
(lambda (lo hi f)
(letrec ((for-aux
(lambda (lo)
(if (< lo hi)
(cons (f lo) (for-aux (+ lo 1)))
(list)))))
(for-aux lo))))
(define concat5
(lambda (lists)
(foldr (lambda (a b) (append a b)) (list) lists)))
(define list-read5
(lambda (lst i)
(if (= i 0)
(car lst)
(list-read5 (cdr lst) (- i 1)))))
(define list-write5
(lambda (lst i val)
(if (= i 0)
(cons val (cdr lst))
(cons (car lst) (list-write5 (cdr lst) (- i 1) val)))))
(define list-remove-pos5
(lambda (lst i)
(if (= i 0)
(cdr lst)
(cons (car lst) (list-remove-pos5 (cdr lst) (- i 1))))))
(define member-of5
(lambda (e lst)
(if (null? lst)
#f
(if (equal? e (car lst))
#t
(member-of5 e (cdr lst))))))
(define duplicates?5
(lambda (lst)
(if (null? lst)
#f
(or (member-of5 (car lst) (cdr lst))
(duplicates?5 (cdr lst))))))
(define make-matrix5
(lambda (n m init)
(for 0 n (lambda (i) (for5 0 m (lambda (j) (init i j)))))))
(define matrix-read5
(lambda (mat i j)
(list-read5 (list-read5 mat i) j)))
(define matrix-write5
(lambda (mat i j val)
(list-write5 mat i (list-write5 (list-read5 mat i) j val))))
(define matrix-size5
(lambda (mat)
(cons (length mat) (length (car mat)))))
(define matrix-map5
(lambda (f mat)
(map5 (lambda (lst) (map5 f lst)) mat)))
(define next-random5
(lambda (current-random)
(modulo (+ (* current-random 3581) 12751) 131072)))
(define neighboring-cavities5
(lambda (pos cave)
(let ((size (matrix-size5 cave)))
(let ((n (car size)) (m (cdr size)))
(let ((i (car pos)) (j (cdr pos)))
(append (if (and (> i 0) (matrix-read5 cave (- i 1) j))
(list (cons (- i 1) j))
(list))
(if (and (< i (- n 1)) (matrix-read5 cave (+ i 1) j))
(list (cons (+ i 1) j))
(list))
(if (and (> j 0) (matrix-read5 cave i (- j 1)))
(list (cons i (- j 1)))
(list))
(if (and (< j (- m 1)) (matrix-read5 cave i (+ j 1)))
(list (cons i (+ j 1)))
(list))))))))
(define shuffle-aux5
(lambda (lst current-random)
(if (null? lst)
(list)
(let ((new-random (next-random5 current-random)))
(let ((i (modulo new-random (length lst))))
(cons (list-read lst i)
(shuffle-aux5 (list-remove-pos lst i)
new-random)))))))
(define shuffle5
(lambda (lst)
(shuffle-aux5 lst initial-random)))
(define cave-to-maze5
(lambda (cave)
(matrix-map5 (lambda (x) (if x '_ '*)) cave)))
(define change-cavity-aux5
(lambda (cave pos new-cavity-id old-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(let ((cavity-id (matrix-read5 cave i j)))
(if (equal? cavity-id old-cavity-id)
(foldl (lambda (c nc)
(change-cavity-aux5 c nc new-cavity-id old-cavity-id))
(matrix-write5 cave i j new-cavity-id)
(neighboring-cavities5 pos cave))
cave)))))
(define change-cavity5
(lambda (cave pos new-cavity-id)
(let ((i (car pos)) (j (cdr pos)))
(change-cavity-aux5 cave pos new-cavity-id (matrix-read5 cave i j)))))
(define pierce5
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write5 cave i j pos))))
(define try-to-pierce5
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(let ((ncs (neighboring-cavities5 pos cave)))
(if (duplicates?5
(map5 (lambda (nc) (matrix-read5 cave (car nc) (cdr nc))) ncs))
cave
(pierce pos
(foldl5 (lambda (c nc) (change-cavity c nc pos))
cave
ncs)))))))
(define pierce-randomly5
(lambda (possible-holes cave)
(if (null? possible-holes)
cave
(let ((hole (car possible-holes)))
(pierce-randomly5 (cdr possible-holes)
(try-to-pierce5 hole cave))))))
(define make-maze5
(lambda (n m)
(if (not (and (odd?5 n) (odd?5 m)))
(print 'error)
(let ((cave
(make-matrix5 n m (lambda (i j)
(if (and (even?5 i) (even?5 j))
(cons i j)
#f))))
(possible-holes
(concat5
(for5 0 n (lambda (i)
(concat5
(for5 0 m (lambda (j)
(if (equal? (even?5 i) (even?5 j))
(list)
(list (cons i j)))))))))))
(pierce-randomly5 (shuffle5 possible-holes) cave)))))
(begin (pretty-print (make-maze5 15 15))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4))
(pretty-print (make-maze5 4 4)))
| false |
ab6d7b38ad40833b65df3de59941bdcb7334ea4f
|
120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193
|
/packages/slib/srfi.scm
|
6d9018ccbbd8b9492fae15a9a019db35a5c7845a
|
[
"MIT"
] |
permissive
|
evilbinary/scheme-lib
|
a6d42c7c4f37e684c123bff574816544132cb957
|
690352c118748413f9730838b001a03be9a6f18e
|
refs/heads/master
| 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 |
MIT
| 2022-06-16T05:54:55 | 2016-12-13T06:27:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,654 |
scm
|
srfi.scm
|
;;; "srfi.scm" Implement Scheme Request for Implementation -*-scheme-*-
; Copyright 2001 Aubrey Jaffer
;
;Permission to copy this software, to modify it, to redistribute it,
;to distribute modified versions, and to use it for any purpose is
;granted, subject to the following restrictions and understandings.
;
;1. Any copy made of this software must include this copyright notice
;in full.
;
;2. I have made no warranty or representation that the operation of
;this software will be error-free, and I am under no obligation to
;provide any services, by way of maintenance, update, or otherwise.
;
;3. In conjunction with products arising from the use of this
;material, there shall be no use of my name in any advertising,
;promotional, or sales literature without prior written consent in
;each case.
;;@code{(require 'srfi)}
;;@ftindex srfi
;;
;;@noindent Implements @dfn{Scheme Request For Implementation} (SRFI) as
;;described at @url{http://srfi.schemers.org/}
;;@args <clause1> <clause2> @dots{}
;;
;;@emph{Syntax:}
;;Each @r{<clause>} should be of the form
;;
;;@format
;;@t{(@r{<feature>} @r{<expression1>} @dots{})}
;;@end format
;;
;;where @r{<feature>} is a boolean expression composed of symbols and
;;`and', `or', and `not' of boolean expressions. The last @r{<clause>}
;;may be an ``else clause,'' which has the form
;;
;;@format
;;@t{(else @r{<expression1>} @r{<expression2>} @dots{})@r{.}}
;;@end format
;;
;;The first clause whose feature expression is satisfied is expanded.
;;If no feature expression is satisfied and there is no else clause, an
;;error is signaled.
;;
;;SLIB @0 is an extension of SRFI-0,
;;@url{http://srfi.schemers.org/srfi-0/srfi-0.html}.
(defmacro cond-expand clauses
(letrec ((errout
(lambda (form exp)
(slib:error 'cond-expand 'invalid form ': exp)))
(feature?
(lambda (exp)
(cond ((symbol? exp)
(or (provided? exp) (eq? exp (software-type))))
((and (pair? exp) (list? exp))
(case (car exp)
((not) (not (feature? (cadr exp))))
((or) (if (null? (cdr exp)) #f
(or (feature? (cadr exp))
(feature? (cons 'or (cddr exp))))))
((and) (if (null? (cdr exp)) #t
(and (feature? (cadr exp))
(feature? (cons 'and (cddr exp))))))
(else (errout 'expression exp)))))))
(expand
(lambda (clauses)
(cond ((null? clauses) (slib:error 'Unfulfilled 'cond-expand))
((not (pair? (car clauses))) (errout 'clause (car clauses)))
((or (eq? 'else (caar clauses)) (feature? (caar clauses)))
`(begin ,@(cdar clauses)))
(else (expand (cdr clauses)))))))
(expand clauses)))
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.