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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1c249bb01a47371c05c764b58473ff15ed664118
|
c693dbc183fdf13b8eeab4590b91bb6cac786a22
|
/scheme/sicp/src/p73_hierarchical_structure.scm
|
33f0c33dd21e3ce7e60202c08db6fa1af0b156a0
|
[] |
no_license
|
qianyan/functional-programming
|
4600a11400176978244f7aed386718614428fd13
|
34ba5010f9bf68c1ef4fa41ce9e6fdb9fe5a10b5
|
refs/heads/master
| 2016-09-01T21:09:32.389073 | 2015-08-14T07:58:59 | 2015-08-14T07:58:59 | 26,963,148 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,529 |
scm
|
p73_hierarchical_structure.scm
|
;;; count-leaves
(define tree (cons '(1 2) '(3 4)))
(define (length tr)
(if (null? tr)
0
(+ 1 (length (cdr tr)))))
(define (length-iteration tr)
(define (len tr count)
(if (null? tr) count
(len (cdr tr) (+ 1 count))))
(len tr 0))
(define (count-leaves tr)
(cond ((null? tr) 0)
((not (pair? tr)) 1)
(else
(+ (count-leaves (car tr))
(count-leaves (cdr tr))))))
(display (length tree))
(newline)
(display (count-leaves tree))
;;; 2.25
(newline)
(define l1 '(1 3 (5 7) 9))
(display (car (cdr (car (cdr (cdr l1))))))
(newline)
(define l2 '((7)))
(display (car (car l2)))
(newline)
(define l3 '(1 (2 (3 (4 (5 (6 (7))))))))
(display (car (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr l3))))))))))))))
(newline)
(define tr1 '((1 2) (3 4)))
;;; reverse ((1 2) (3 4)) => ((3 4) (1 2))
(define (reverse tr)
(if (null? tr)
'()
(append (reverse (cdr tr))
(list (car tr)))))
;;; deep reverse ((1 2) (3 4)) => ((4 3) (2 1))
(define (deep-reverse tr)
(cond ((null? tr)
'())
((not (pair? tr))
tr)
(else
(append (deep-reverse (cdr tr)) (list (deep-reverse (car tr)))))))
;;; fringe ((1 2) (3 4)) => (1 2 3 4)
(define (fringe tr)
(cond ((null? tr)
'())
((not (pair? tr))
(list tr))
(else
(append (fringe (car tr)) (fringe (cdr tr))))))
;;; extend
(define (extend k v)
((lambda (k v env)
(cons (k . v) env))
k v '()))
| false |
1ce8c5e4ed071a022e7e523348370831cfccbfef
|
958488bc7f3c2044206e0358e56d7690b6ae696c
|
/poly/DesignPatterns/Singleton/singleton.scm
|
64b155cf799ef1b289bf691e1167dea64106b1c2
|
[] |
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 | 1,373 |
scm
|
singleton.scm
|
; Singleton design pattern
(define SingleObject
(begin
; static interface
(define (static m)
(cond ((eq? m 'new) (new)) ; 'new' instead of '(new)' if 'data' involved
((eq? m 'getInstance)(getInstance))
(else (display "SingleObject: unknown static operation error\n"))))
; instance interface
(define (this) ; (this data) when applicable
(lambda (m)
(cond ((eq? m 'showMessage)(showMessage)) ; (showMessage data)
(else (display "SingleObject: unknown instance operation error\n")))))
; static data
(define mBuilt #f)
(define mInstance #f)
; class members
(define (getInstance)
(if (eq? #f mInstance) (set! mInstance (SingleObject 'new)))
mInstance)
;
(define (new)
(if (eq? #t mBuilt)
(begin (display "SingleObject: cannot create new instance\n") #f)
(begin (set! mBuilt #t) (this))))
; instance members
(define (showMessage)
(display "The single object is alive and well\n"))
; returning static interface
static))
; call will succeed but subsequent call to 'getInstance' will fail
;(define obj (SingleObject 'new))
(define object1 (SingleObject 'getInstance))
(object1 'showMessage)
(define object2 (SingleObject 'getInstance))
(if (eq? object1 object2) (display "The two objects are the same\n"))
(exit 0)
| false |
d83916f0337e8a628d7ce2d89c3500d295d55fd0
|
63596214900837f88d5d82f8437968b786f1e499
|
/oblig-2a.scm
|
69b6ba6ad63716654bb99be0cbe2b362a2d370be
|
[] |
no_license
|
kristiangyene/IN2040
|
d26ce582ae2271e8faf92ba39d293dd508f6688e
|
42c6854be3b92771bcd45c5f4bf1636610e94d6f
|
refs/heads/main
| 2022-12-26T23:14:48.712022 | 2020-01-16T14:19:30 | 2020-01-16T14:19:30 | 303,746,896 | 0 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,909 |
scm
|
oblig-2a.scm
|
;;1a)
(define (p-cons x y)
(lambda (proc) (proc x y)))
(define (p-car arg)
(arg (lambda (x y) x)))
(p-car (p-cons "foo" "bar")) ;foo
(define (p-cdr arg)
(arg (lambda (x y) y)))
(p-cdr (p-cons "foo" "bar")) ;bar
(p-car (p-cdr (p-cons "zoo" (p-cons "foo" "bar")))) ;foo
;;1b)
(define foo 42)
((lambda (foo x)
(= x foo)
(if (= x foo)
'same
'different))
foo 5) ;different
#|TODO ----- oversett til lambda uttrykk
(let ((bar foo)
(baz 'towel))
(let ((bar (list bar baz))
(foo baz))
(list foo bar)))
|#
;;1c)
(define (infix-eval exp)
((cadr exp) (car exp) (caddr exp)))
;TESTS
(define foo (list 21 + 21))
(define baz (list 21 list 21))
(define bar (list 84 / 2))
(infix-eval foo)
(infix-eval baz)
(infix-eval bar)
;;1d)
#|Når jeg kjører kallet får jeg feilmeldingen "application: not a procedure;
expected a procedure that can be applied to arguments given: /".
Dette hender ved at anførselstegnet som setter sammen listen i bah gjør at "/" ikke tolkes som
en prosedyre, men et tegn. Et annet eksempel med anførselstegn kan være '(* 3 4) som blir (list '* '3 '4).
Man burde helst alltid bruke list når man vil at argumentet skal evalueres.
|#
(load "huffman.scm")
;;2a)
#|hvis dekode-1 ikke hadde vært en hjelpemetode så hadde vi ikke hatt tilgang til det originale treet(noe vi trenger), fordi current-branch'
endrer seg hele tiden. Hvis `decode' skulle oppnådd det samme direkte måtte den ha tatt tre parametre, og bli kalt på f.eks. med (decode bits tree current-branch).
|#
;;2b)
;Halerekursiv versjon av decode i huffman.scm
(define (hale_decode bits tree)
(define (iterate output bits current-branch)
(if (not (null? bits))
(let ((next-branch
(choose-branch (car bits) current-branch)))
(if (leaf? next-branch)
(iterate (append output (cons (symbol-leaf next-branch) '())) (cdr bits) tree)
(iterate output (cdr bits) next-branch)))
output))
(iterate '() bits tree))
;;2c)
(decode sample-code sample-tree) ;→(ninjas fight ninjas by night)
(hale_decode sample-code sample-tree) ;→(ninjas fight ninjas by night)
#|TODO ----- gjøre ferdig
Mye av de resterende oppgavene er avhengig av denne modetoden så var synt jeg ikke fikk den til.
;;2d)
(define (encode seq tree)
(define (iterate symbol current-branch)
(if (leaf? current-branch)
'()
(let ((left (left-branch current-branch))
(right (right-branch current-branch)))))))
(decode (encode '(ninjas fight ninjas) sample-tree) sample-tree) ;→(ninjas fight ninjas by night)|#
;;2e)
;Lager huffantre ut av en liste med frekvens-par
(define (grow-huffman-tree sympairs)
(define (iterate nodes)
(if (not (null? (cdr nodes)))
(iterate (adjoin-set (make-code-tree (car nodes) (cadr nodes)) (cddr nodes))) ;Setter inn venstre,høyre node
(car nodes)))
(iterate (make-leaf-set sympairs)))
;Ikke ferdig med encode så brukte sample code som test: samplecode = '(0 1 0 0 1 1 1 1 1 0)
(define freqs '((a 2) (b 5) (c 1) (d 3) (e 1) (f 3)))
(define codebook (grow-huffman-tree freqs))
(decode sample-code codebook) ;(d f b b)
;;2f)
;Definerer gitt huffmantre
(define message '((samurais 57) (ninjas 20) (fight 45) (night 12) (hide 3) (in 2) (ambush 2) (defeat 1) (the 5) (sword 4)
(by 12) (assassin 1) (river 2) (forest 1) (wait 1) (poison 1)))
;(grow-huffman-tree message)
;Disse spørsmålene tror jeg er avhengig av encode metode..
;;2g
;Det motsatte av oppgave 2e. Lager frekvenspar ut av et tre.
(define (huffman-leaves tree)
(if (leaf? tree)
(cons (cdr tree) '())
(append (huffman-leaves (left-branch tree)) (huffman-leaves (right-branch tree)))))
(huffman-leaves sample-tree) ;((ninjas 8) (fight 5) (night 1) (by 1))
;;2h
| false |
fa69ce08feba6843cb7e7b927827bc6dd4a43874
|
fe0de995a95bcf09cd447349269dc0e550851b5a
|
/tests/0017-foreign-procedure.scm
|
9993d532e3728f7ac045fe95a8579a1a93e144b6
|
[
"MIT"
] |
permissive
|
mugcake/ruse-scheme
|
4974021858be5b7f2421212ec2eeafd34c53bce8
|
dd480e17edd9a233fd2bc4e8b41ff45d13fcc328
|
refs/heads/master
| 2022-02-12T04:31:55.031607 | 2019-08-01T21:44:14 | 2019-08-01T21:44:14 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 72 |
scm
|
0017-foreign-procedure.scm
|
(let ((frob (javascript-procedure frob)))
(frob "hello" " " "world"))
| false |
b0b45c78934440c8b38c5ef836423959844dbb8f
|
354ae3428451a81e5a6e07d282edb9bd79ff0e3f
|
/tests/examples/tutorial.ss
|
161947d7d5fc0d5faa01819f386622d48feb7046
|
[] |
no_license
|
jeapostrophe/datalog
|
385a478dc18a904a35cbe36ebc7b1a7ec0a26478
|
a5d59e455b49d091f3c5348e4c1f0071a1bc0134
|
refs/heads/master
| 2021-01-18T13:42:51.827415 | 2013-10-31T01:32:07 | 2013-10-31T01:32:07 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 759 |
ss
|
tutorial.ss
|
#lang planet jaymccarthy/datalog
parent(john,douglas).
parent(john,douglas)?
% parent(john, douglas).
parent(john,ebbon)?
parent(bob,john).
parent(ebbon,bob).
parent(A,B)?
% parent(john, douglas).
% parent(bob, john).
% parent(ebbon, bob).
parent(john,B)?
% parent(john, douglas).
parent(A,A)?
ancestor(A,B) :- parent(A,B).
ancestor(A,B) :- parent(A,C), ancestor(C, B).
ancestor(A, B)?
% ancestor(ebbon, bob).
% ancestor(bob, john).
% ancestor(john, douglas).
% ancestor(bob, douglas).
% ancestor(ebbon, john).
% ancestor(ebbon, douglas).
ancestor(X,john)?
% ancestor(bob, john).
% ancestor(ebbon, john).
parent(bob, john)~
parent(A,B)?
% parent(john, douglas).
% parent(ebbon, bob).
ancestor(A,B)?
% ancestor(john, douglas).
% ancestor(ebbon, bob).
| false |
6b517d7a2b3028f412e730ddeb78d4e958386704
|
0855447c3321a493efa9861b3713209e37c03a4c
|
/g-point/lib/encrypt.ss
|
198f77d9e60bab40e2d8714f087fa904b1e5a492
|
[] |
no_license
|
dasheng523/sicp
|
d04f30c50076f36928728ad2fe0da392dd0ae414
|
1c40c01e16853ad83b8b82130c2c95a5533875fe
|
refs/heads/master
| 2021-06-16T20:15:08.281249 | 2021-04-02T04:09:01 | 2021-04-02T04:09:01 | 190,505,284 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 806 |
ss
|
encrypt.ss
|
(library (lib encrypt)
(export sha1 md5)
(import (ffi encrypt)
(chezscheme))
(define (sha1 str)
(let ([buff (make-bytevector SHA_DIGEST_LENGTH)])
(sha1-ffi str (string-length str) buff)
(let loop ([i 0] [rs ""])
(if (>= i SHA_DIGEST_LENGTH)
rs
(let ([data (bytevector-u8-ref buff i)])
(loop (+ i 1)
(string-append rs (format "~2,'0x" data))))))))
(define (md5 str)
(let ([buff (make-bytevector MD5_DIGEST_LENGTH)])
(md5-ffi str (string-length str) buff)
(let loop ([i 0] [rs ""])
(if (>= i MD5_DIGEST_LENGTH)
rs
(let ([data (bytevector-u8-ref buff i)])
(loop (+ i 1)
(string-append rs (format "~2,'0x" data))))))))
)
| false |
462dd3186e41248f11efd984113f6e333cc52d5b
|
4b480cab3426c89e3e49554d05d1b36aad8aeef4
|
/chapter-02/ex2.60-falsetru-test.scm
|
bfd2f2c57893179654f04e8c3763925f0fc1623f
|
[] |
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 | 548 |
scm
|
ex2.60-falsetru-test.scm
|
(require (planet schematics/schemeunit:3))
(require (planet schematics/schemeunit:3/text-ui))
(load "ex2.60-falsetru.scm")
(define a '(1 2 3))
(define b '(1 3 4))
(define u (union-set a b))
(define ex2.60-falsetru-tests
(test-suite
"Test for ex2.60-falsetru"
(check-true (element-of-set? 1 u))
(check-true (element-of-set? 2 u))
(check-true (element-of-set? 3 u))
(check-true (element-of-set? 4 u))
(check-false (element-of-set? 5 u))
))
(exit
(cond
((= (run-tests ex2.60-falsetru-tests) 0))
(else 1)))
| false |
523aa39870c91c314a591cf431826d4487a3b2c3
|
a66514d577470329b9f0bf39e5c3a32a6d01a70d
|
/sdl2/audio-functions.ss
|
14c7d5074e20355c7bafb75b8260d4ae91d78905
|
[
"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 | 3,905 |
ss
|
audio-functions.ss
|
(define-sdl-func int sdl-get-num-audio-drivers () "SDL_GetNumAudioDrivers")
(define-sdl-func string sdl-get-audio-driver ((index int)) "SDL_GetAudioDriver")
(define-sdl-func int sdl-audio-init ((driver_name string)) "SDL_AudioInit")
(define-sdl-func void sdl-audio-quit () "SDL_AudioQuit")
(define-sdl-func string sdl-get-current-audio-driver () "SDL_GetCurrentAudioDriver")
(define-sdl-func int sdl-open-audio ((desired (* sdl-audio-spec-t)) (obtained (* sdl-audio-spec-t))) "SDL_OpenAudio")
(define-sdl-func int sdl-get-num-audio-devices ((iscapture int)) "SDL_GetNumAudioDevices")
(define-sdl-func string sdl-get-audio-device-name ((index int) (iscapture int)) "SDL_GetAudioDeviceName")
(define-sdl-func sdl-audio-device-id-t sdl-open-audio-device ((device string) (iscapture int) (desired (* sdl-audio-spec-t)) (obtained (* sdl-audio-spec-t)) (allowed_changes int)) "SDL_OpenAudioDevice")
(define-sdl-func sdl-audio-status-t sdl-get-audio-status () "SDL_GetAudioStatus")
(define-sdl-func sdl-audio-status-t sdl-get-audio-device-status ((dev sdl-audio-device-id-t)) "SDL_GetAudioDeviceStatus")
(define-sdl-func void sdl-pause-audio ((pause_on int)) "SDL_PauseAudio")
(define-sdl-func void sdl-pause-audio-device ((dev sdl-audio-device-id-t) (pause_on int)) "SDL_PauseAudioDevice")
(define-sdl-func (* sdl-audio-spec-t) sdl-load-wav-rw ((src (* sdl-rw-ops-t)) (freesrc int) (spec (* sdl-audio-spec-t)) (audio_buf (* uint8)) (audio_len (* uint32))) "SDL_LoadWAV_RW")
(define-sdl-func void sdl-free-wav ((audio_buf (* uint8))) "SDL_FreeWAV")
(define-sdl-func int sdl-build-audio-cvt ((cvt (* sdl-audio-cvt-t)) (src_format sdl-audio-format-t) (src_channels uint8) (src_rate int) (dst_format sdl-audio-format-t) (dst_channels uint8) (dst_rate int)) "SDL_BuildAudioCVT")
(define-sdl-func int sdl-convert-audio ((cvt (* sdl-audio-cvt-t))) "SDL_ConvertAudio")
(define-sdl-func (* sdl-audio-stream-t) sdl-new-audio-stream ((src_format sdl-audio-format-t) (src_channels uint8) (src_rate int) (dst_format sdl-audio-format-t) (dst_channels uint8) (dst_rate int)) "SDL_NewAudioStream")
(define-sdl-func int sdl-audio-stream-put ((stream (* sdl-audio-stream-t)) (buf void*) (len int)) "SDL_AudioStreamPut")
(define-sdl-func int sdl-audio-stream-get ((stream (* sdl-audio-stream-t)) (buf void*) (len int)) "SDL_AudioStreamGet")
(define-sdl-func int sdl-audio-stream-available ((stream (* sdl-audio-stream-t))) "SDL_AudioStreamAvailable")
(define-sdl-func int sdl-audio-stream-flush ((stream (* sdl-audio-stream-t))) "SDL_AudioStreamFlush")
(define-sdl-func void sdl-audio-stream-clear ((stream (* sdl-audio-stream-t))) "SDL_AudioStreamClear")
(define-sdl-func void sdl-free-audio-stream ((stream (* sdl-audio-stream-t))) "SDL_FreeAudioStream")
(define-sdl-func void sdl-mix-audio ((dst (* uint8)) (src (* uint8)) (len uint32) (volume int)) "SDL_MixAudio")
(define-sdl-func void sdl-mix-audio-format ((dst (* uint8)) (src (* uint8)) (format sdl-audio-format-t) (len uint32) (volume int)) "SDL_MixAudioFormat")
(define-sdl-func int sdl-queue-audio ((dev sdl-audio-device-id-t) (data void*) (len uint32)) "SDL_QueueAudio")
(define-sdl-func uint32 sdl-dequeue-audio ((dev sdl-audio-device-id-t) (data void*) (len uint32)) "SDL_DequeueAudio")
(define-sdl-func uint32 sdl-get-queued-audio-size ((dev sdl-audio-device-id-t)) "SDL_GetQueuedAudioSize")
(define-sdl-func void sdl-clear-queued-audio ((dev sdl-audio-device-id-t)) "SDL_ClearQueuedAudio")
(define-sdl-func void sdl-lock-audio () "SDL_LockAudio")
(define-sdl-func void sdl-lock-audio-device ((dev sdl-audio-device-id-t)) "SDL_LockAudioDevice")
(define-sdl-func void sdl-unlock-audio () "SDL_UnlockAudio")
(define-sdl-func void sdl-unlock-audio-device ((dev sdl-audio-device-id-t)) "SDL_UnlockAudioDevice")
(define-sdl-func void sdl-close-audio () "SDL_CloseAudio")
(define-sdl-func void sdl-close-audio-device ((dev sdl-audio-device-id-t)) "SDL_CloseAudioDevice")
| false |
8dd1f2d9b2dabe6e6f727b727f3e28bd2805e91c
|
382706a62fae6f24855ab689b8b2d87c6a059fb6
|
/0.3/interpreter/src/types-primitive.scm
|
bce053fc999dee8cdc98312dab7b83165a9cd044
|
[
"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 | 1,551 |
scm
|
types-primitive.scm
|
;;;; ***********************************************************************
;;;; FILE IDENTIFICATION
;;;;
;;;; Name: types-primitive.scm
;;;; Project: Bard
;;;; Purpose: schema <primitive>
;;;; Author: mikel evins
;;;; Copyright: 2013 by mikel evins
;;;;
;;;; ***********************************************************************
;;; =====================================================================
;;; base schemas
;;; =====================================================================
;;; ----------------------------------------------------------------------
;;; <primitive>
;;; ----------------------------------------------------------------------
(define tags:$bard-primitive (%next-bard-type-number))
(define <primitive> (make-base-schema '<primitive> tags:$bard-primitive))
;;; constructor
(define (make-primitive #!key
(procedure #f)
(required-count 0)
(restarg #f)
(debug-name 'an-anonymous-primitive))
(let* ((prim (make-primitive-instance <primitive> debug-name #f required-count restarg))
(prim-proc (lambda args (apply procedure args))))
(set-primitive-proc! prim prim-proc)
prim))
;;; accessors
(define primitive-name primitive-instance-name)
(define primitive-proc primitive-instance-proc)
(define set-primitive-proc! primitive-instance-proc-set!)
(define primitive-restarg primitive-instance-restarg)
(define primitive-required-count primitive-instance-required-count)
| false |
d5a510caeb35e5c4341419d651bfcdd562602893
|
f6ca8ae04f71c0c21d4756ab5efff944ebdfdf26
|
/modules/_utils.scm
|
0d4209df3e8207e3336a521d0575d1f755962d6c
|
[] |
no_license
|
jgarte/guixsd-config
|
b56e53c789c8a6e0be57f3d9998123374713874f
|
1c57cfd19b99f5d9c560b5a46d94dc257f692a82
|
refs/heads/master
| 2022-12-16T20:40:06.989263 | 2020-09-17T21:49:48 | 2020-09-17T21:49:48 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 964 |
scm
|
_utils.scm
|
(define-module (modules _utils)
#:use-module (gnu packages)
#:use-module (ice-9 optargs)
#:export (create-pkg-interface))
(define-syntax-rule
(create-pkg-interface name branch-alist)
"Creates a quick public interface of a toggle module.
It needs a name and an association list with the identifier as the key and a list of Guix packages as the value.
Upon return, it will create a public procedure that accepts an allowlist of branches with their associated list of packages to be added and returns the resulting package list."
(define*-public (name #:key (allow (list 'default)))
(let ((packages '()))
; Add the associated packages from the allowlisted subpackages.
(for-each (lambda (option)
(let ((hash-value (assq-ref branch-alist option)))
(if hash-value
(set! packages (append packages hash-value))))) allow)
; Return the package list.
packages)))
| true |
bf75cc2c07afa8752980a4273071343a91d19315
|
e8e2b3f22c7e1921e99f44593fc0ba5e5e44eebb
|
/PortableApps/GnuCashPortable/App/GnuCash/share/gnucash/scm/gnucash/import-export/qif-import.scm
|
54443fb363628608e79ecd1d9cf3b33fa15dd93b
|
[] |
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 | 3,713 |
scm
|
qif-import.scm
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; qif-import.scm
;;; virtual loader for QIF import facility
;;;
;;; Bill Gribble <[email protected]> 20 Feb 2000
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 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 import-export qif-import))
(use-modules (gnucash main)) ;; FIXME: delete after we finish modularizing.
;; We do this initialization here because src/gnome isn't a real module.
;; Note: Guile 2 needs to find the symbols from the extension at compile time already
(cond-expand
(guile-2
(eval-when
(compile load eval expand)
(load-extension "libgnc-gnome" "scm_init_sw_gnome_module")))
(else
(load-extension "libgnc-gnome" "scm_init_sw_gnome_module")))
(use-modules (sw_gnome))
(use-modules (gnucash gnc-module))
(use-modules (ice-9 regex))
(use-modules (srfi srfi-1))
(debug-enable 'debug)
(debug-enable 'backtrace)
(gnc:module-load "gnucash/engine" 0)
(gnc:module-load "gnucash/app-utils" 0)
(gnc:module-load "gnucash/gnome-utils" 0)
(load-from-path "qif-import/qif-objects") ;; class definitions
(load-from-path "qif-import/qif-parse") ;; string-to-value
(load-from-path "qif-import/qif-utils")
(load-from-path "qif-import/qif-file") ;; actual file reading
(load-from-path "qif-import/qif-dialog-utils") ;; build displays
(load-from-path "qif-import/qif-guess-map") ;; build acct mappings
(load-from-path "qif-import/qif-to-gnc") ;; conv QIF xtns to GNC
(load-from-path "qif-import/qif-merge-groups") ;; merge into user's acct
(export make-qif-file)
(export make-ticker-map)
(export qif-import:get-all-accts)
(export qif-import:fix-from-acct)
(export qif-import:any-new-accts?)
(export qif-import:update-security-hash)
(export qif-import:refresh-match-selection)
(export qif-import:save-map-prefs)
(export qif-import:load-map-prefs)
(export qif-import:qif-to-gnc)
(export qif-import:qif-to-gnc-undo)
(export qif-import:reset-cancel-pause)
(export qif-import:cancel)
(export qif-import:toggle-pause)
(export qif-map-entry:gnc-name)
(export qif-map-entry:set-gnc-name!)
(export qif-map-entry:clone)
(export qif-map-entry:qif-name)
(export qif-map-entry:new-acct?)
(export qif-file:read-file)
(export qif-file:parse-fields)
(export qif-file:parse-fields-results)
(export qif-file:check-from-acct)
(export qif-file:reparse-dates)
(export qif-file:check-from-acct)
(export qif-file:path-to-accountname)
(export qif-file:path)
(export qif-dialog:qif-file-loaded?)
(export qif-dialog:unload-qif-file)
(export qif-dialog:make-account-display)
(export qif-dialog:make-category-display)
(export qif-dialog:make-memo-display)
(export gnc:account-tree-find-duplicates)
(export gnc:account-tree-catenate-and-merge)
(export gnc:prune-matching-transactions)
| false |
be330334484d57c95a8d10f8b0836c836702fe8c
|
29d3283a910b6887e3e3e369a2dcef190f0d487e
|
/test-cardboard-prolog.scm
|
756c939cac6fa5b6ef6b3dbabf4cdad0c2568a87
|
[
"Unlicense"
] |
permissive
|
catseye/Cardboard-Prolog
|
170b0984e5c4f653952af83a88c05debebd25e10
|
c94d588ec3d257d86bade51b1419edb85d0aa5c0
|
refs/heads/master
| 2022-12-08T10:02:34.192649 | 2019-09-11T13:38:07 | 2019-09-11T13:38:07 | 207,822,030 | 6 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,251 |
scm
|
test-cardboard-prolog.scm
|
(load "cardboard-prolog.scm")
(load "utils.scm")
(define database
'(
((female alice))
((male bob))
((male dan))
((female emily))
((female fran))
((child alice bob))
((child dan bob))
((child emily dan))
((son #(X) #(Y)) (male #(X)) (child #(X) #(Y)))
((daughter #(X) #(Y)) (female #(X)) (child #(X) #(Y)))
((descendant #(X) #(Y)) (child #(X) #(Y)))
((descendant #(X) #(Y)) (child #(X) #(Z)) (descendant #(Z) #(Y)))
)
)
;-----------
(test rename-term-1
(rename-term '(descendant #(X) #(Y)) 1)
'(descendant #(X 1) #(Y 1))
)
(test rename-term-2
(rename-term '(descendant #(X 1) #(Y 1)) 2)
'(descendant #(X 2) #(Y 2))
)
(test collect-vars-1
(collect-vars '(descendant (son #(X)) #(Y)) '())
'(#(Y) #(X))
)
;------------
(test unify-1
(unify '(child bob #(Y)) '(child #(X) alice) '())
'( (#(Y) alice) (#(X) bob) )
)
(test unify-2
(unify '(son #(X) zeke) '(son #(X) #(Y)) '())
'( (#(Y) zeke) )
)
(test unify-3
(unify '(son #(P) zeke) '(son #(X) #(Y)) '())
'( (#(Y) zeke) (#(P) #(X)) )
)
;------------
(test expand-1
(expand '(child #(X) #(Y)) '( (#(Y) alice) (#(X) bob) ))
'(child bob alice)
)
;------------
(test match-all-1
(match-all database '( (female alice) ))
'(()) ; list containing empty env ==> true
)
(test match-all-2
(match-all database '( (female foobar) ))
'() ; list containing no envs ==> false
)
(test match-all-3
(match-all database '( (female #(A)) ))
'(((#(A) alice)) ((#(A) emily)) ((#(A) fran)))
)
(test match-all-4
(match-all database '( (child dan bob) ))
'(())
)
(test match-all-5
(match-all database '( (child #(A) bob) ))
'(((#(A) alice)) ((#(A) dan)))
)
(test match-all-6
(match-all database '( (female #(A)) (child #(A) bob) ))
'(((#(A) alice)))
)
(test match-all-7
(match-all database '( (female #(A)) (child #(A) #(B)) ))
'(((#(B) bob) (#(A) alice)) ((#(B) dan) (#(A) emily)))
)
(test match-all-son-1
(match-all database '( (son dan bob) ))
'(())
)
(test match-all-son-2
(match-all database '( (son dan emily) ))
'()
)
(test match-all-son-3
(match-all database '( (son alice bob) ))
'()
)
(test match-all-son-3a
(match-all database '( (son #(X) bob) ))
'(((#(X) dan)))
)
(test match-all-son-3b
(match-all database '( (son #(P) bob) ))
'(((#(P) dan)))
)
(test match-all-son-4
(match-all database '( (son dan #(X)) ))
'(((#(X) bob)))
)
(test match-all-son-4a
(match-all database '( (son dan #(P)) ))
'(((#(P) bob)))
)
(test match-all-son-5
(match-all database '( (son #(X) #(Y)) ))
'(((#(Y) bob) (#(X) dan)))
)
(test match-all-son-5a
(match-all database '( (son #(P) #(Q)) ))
'(((#(Q) bob) (#(P) dan)))
)
(test match-all-descendant-1
(match-all database '( (descendant alice bob) ))
'(())
)
(test match-all-descendant-2
(match-all database '( (descendant alice emily) ))
'()
)
(test match-all-descendant-3
(match-all database '( (descendant emily bob) ))
'(())
)
(test match-all-descendant-4
(match-all database '( (descendant #(X) bob) ))
'(((#(X) alice)) ((#(X) dan)) ((#(X) emily)))
)
(test match-all-descendant-5
(match-all database '( (descendant emily #(X)) ))
'(((#(X) dan)) ((#(X) bob)))
)
| false |
e6651e774275cf815815e8d9e4284d8a4d32966a
|
e26e24bec846e848630bf97512f8158d8040689c
|
/tests/generic-tests.scm
|
8c6fc72d35d97d999937b46b22f4bccb5a188783
|
[
"BSD-3-Clause"
] |
permissive
|
traviscross/chibi-scheme
|
f989df49cb76512dc59f807aeb2426bd6fe1c553
|
97b81d31300945948bfafad8b8a7dbffdcd61ee3
|
refs/heads/master
| 2023-09-05T16:57:14.338631 | 2014-04-01T22:02:02 | 2014-04-01T22:02:02 | 18,473,315 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 859 |
scm
|
generic-tests.scm
|
(import (chibi) (chibi generic) (chibi test))
(test-begin "generics")
(let ()
(define-generic add)
(define-method (add (x number?) (y number?))
(+ x y))
(define-method (add (x string?) (y string?))
(string-append x y))
(define-method (add x (y list?))
(append x y))
(test 4 (add 2 2))
(test "22" (add "2" "2"))
(test '(2 2) (add '() '(2 2)))
(test '(2 2) (add '(2) '(2)))
(test '(2 2) (add '(2 2) '()))
(test '(2) (add #f '(2)))
(test-error (add #(2) #(2))))
(let ()
(define-generic mul)
(define-method (mul (x number?) (y number?))
(* x y))
(define-method (mul (x inexact?) (y inexact?))
(+ (* x y) 0.1))
(define-method (mul (x exact?) (y exact?))
(inexact->exact (call-next-method)))
(test 21 (mul 3 7))
(test 21.0 (mul 3.0 7))
(test 21.0 (mul 3 7.0))
(test 21.1 (mul 3.0 7.0)))
(test-end)
| false |
466e9879f4a688a2a1dd804327a71c6cc21735d3
|
4f30ba37cfe5ec9f5defe52a29e879cf92f183ee
|
/src/tests/scm1.scm
|
9b2d6c0226ad1797c7b7383a704c56c0b5f76bd2
|
[
"MIT"
] |
permissive
|
rtrusso/scp
|
e31ecae62adb372b0886909c8108d109407bcd62
|
d647639ecb8e5a87c0a31a7c9d4b6a26208fbc53
|
refs/heads/master
| 2021-07-20T00:46:52.889648 | 2021-06-14T00:31:07 | 2021-06-14T00:31:07 | 167,993,024 | 8 | 1 |
MIT
| 2021-06-14T00:31:07 | 2019-01-28T16:17:18 |
Scheme
|
UTF-8
|
Scheme
| false | false | 151 |
scm
|
scm1.scm
|
(define (sum a b)
(define (iter sum i)
(if (< i b)
(iter (+ sum i) (+ i 1))
sum))
(iter 0 a))
(display (sum 0 10))
(newline)
| false |
4f59b7d9cf7d13e30c8a2f3738c682e669b598ca
|
9b2eb10c34176f47f7f490a4ce8412b7dd42cce7
|
/lib-r6rs/r7b-impl/write.sls
|
5935c18521d6cc1a9de6fd61055835f7770d0e11
|
[
"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 | 122 |
sls
|
write.sls
|
(library (r7b-impl write)
(export display write write-shared write-simple)
(import (r7b-compat write)))
| false |
5b46eadcf066e27d852026c46abe62aeb51c19c0
|
7cc14e6ab8e064fa967251e3249863e2cfbcc920
|
/chapter-1/e-1-8.scm
|
ce7d43d8067d0dce7d4125376c4d33d34ac69233
|
[] |
no_license
|
xueeinstein/sicp-code
|
0bec79419286705f58175067d474169afd6ba5fe
|
49602b0b13cb9c338b6af089f989c17890ba6085
|
refs/heads/master
| 2021-01-10T01:20:03.089038 | 2015-11-24T03:25:54 | 2015-11-24T03:25:54 | 43,536,317 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 719 |
scm
|
e-1-8.scm
|
;;; Bill Xue
;;; 2015-10-01
;;; newton cube-root with better precision evaluation
;; we can guess a y which may be the cube-root of x
;; then (x/y^2 + 2y)/3 is a better cube-root(x) estimation
(define (cube-root-iter guess guess-old x)
(if (good-enough? guess guess-old)
guess
(cube-root-iter (improve guess x)
guess
x)))
(define (improve guess x)
(one-third (* 2 guess) (/ x (square guess))))
(define (one-third x y)
(/ (+ x y) 3))
(define (square x)
(* x x))
;; |y2 - y1| < 0.00001 as good enough
(define (good-enough? guess guess-old)
(< (abs (- guess guess-old)) 0.00001))
;;===================================
(define (newton-cube-root x)
(cube-root-iter 1.0 0.0 x))
| false |
d90de73073cd5be69135473ffc4723ccc138d6d2
|
763ce7166523c52b12d92ad48150e6e29dae22f3
|
/filter.scm
|
e957f342592993f7e54c7c62a4c6f7a238f54edf
|
[] |
no_license
|
seandepagnier/cruisingplot
|
3cdbe87789267de0a1f8ca8354215167b334f51b
|
d3d83e7372e2c5ce1a8e8071286e30c2028088cf
|
refs/heads/master
| 2020-03-29T18:19:13.647065 | 2013-11-13T03:14:11 | 2013-11-13T03:14:11 | 5,801,818 | 6 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,018 |
scm
|
filter.scm
|
;; Copyright (C) 2011 Sean D'Epagnier <[email protected]>
;;
;; 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 3 of the License, or (at your option) any later version.
(declare (unit filter))
(declare (uses utilities options))
(define (create-filter arg)
(let* ((options (create-options
(list (make-number-verifier 'update-period "how often to apply" .1 0 1000)
(make-number-verifier 'frequency "filter frequency" 1 0 1000)
(make-number-verifier 'order "filter order" 1 0 10)
(make-discrete-verifier 'type "type of filter" 'lowpass
'(lowpass highpass derivative integral))
(make-string-verifier 'name "name of filter" "filter"))
(string-append " lowpass gps speed: '-f gps-speed,frequency=.1'\n")
#f))
(filter-string (parse-basic-arg-options-string options arg))
(filter (read-from-string filter-string))
(computation (computations-revaluate filter))
(value (make-list (options 'order) #f)))
(computation-register-unique-name (string->symbol (options 'name))
(string-append "filtered value of: " filter-string)
'() (lambda ()
(case (options 'type)
((lowpass) (last value))
((highpass) (let ((c (computation))) (if c (- (first c) (last value)) #f)))
(else (error "unknown filter type" (options 'type))))))
(verbose "created " (integer->primary-name (options 'order)) " order " (options 'type) " filter '"
(options 'name) "' filtering '" filter-string "' @ "
(/ (options 'update-period)) "hz")
(create-periodic-task
`(filter ,filter)
(options 'update-period)
(lambda ()
(let ((c (computation)))
(set! value
(if c (let ((fc (first c))
(lp (*
(current-task-period) (options 'frequency))))
(let each-order ((value value)
(fc fc))
(if (null? value) '()
(let ((filtered-value
(if (not (first value)) fc
(case (options 'type)
((lowpass highpass) (+ (* lp fc) (* (- 1 lp) (first value))))
(else (error "unknown filter type" (options 'type)))))))
(cons filtered-value
(each-order (cdr value) filtered-value))))))
(cons #f (cdr value)))))))))
| false |
aa232378aeb371f6f8f6b3dbba78f839f374cd3d
|
fb874bbe08e5843959092135244ee64bc3e4dbbb
|
/tests/syntax-tests/highlighted/SLS/test.sls
|
3e4c638637383ca9717bff638cf5f24516fc2da5
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
sharkdp/bat
|
40dee33e4c3be1201f71ada25e963ef8b3f066b5
|
1893405cbf6a0676db4cf93e64939eb29a0ca6cb
|
refs/heads/master
| 2023-08-31T07:45:08.872005 | 2023-06-12T20:32:26 | 2023-08-28T15:50:29 | 130,464,961 | 43,494 | 1,495 |
Apache-2.0
| 2023-09-14T03:45:47 | 2018-04-21T10:52:23 |
Rust
|
UTF-8
|
Scheme
| false | false | 8,833 |
sls
|
test.sls
|
[38;2;249;38;114mrequired_packages[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mpkg.installed[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mpkgs[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116mgit[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116mperl[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116mfortune[0m
[38;2;249;38;114mcowsay_source[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mgit.latest[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116mhttps://github.com/jasonm23/cowsay.git[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mtarget[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m/root/cowsay[0m
[38;2;249;38;114mrun_installer[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mcmd.run[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m./install.sh /usr/local[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mcwd[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m/root/cowsay[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114monchanges[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mgit[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116mcowsay_source[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mset[0m[38;2;248;248;242m [0m[38;2;255;255;255mcowfiles[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;255;255;255msalt[0m[38;2;248;248;242m.[0m[38;2;255;255;255mcmd[0m[38;2;248;248;242m.[0m[38;2;255;255;255mrun[0m[38;2;248;248;242m([0m[38;2;230;219;116m'[0m[38;2;230;219;116mcowsay -l[0m[38;2;230;219;116m'[0m[38;2;248;248;242m)[0m[38;2;248;248;242m.[0m[38;2;255;255;255msplit[0m[38;2;248;248;242m([0m[38;2;230;219;116m'[0m[38;2;190;132;255m\n[0m[38;2;230;219;116m'[0m[38;2;248;248;242m)[0m[38;2;248;248;242m[[0m[38;2;248;248;242m1[0m[38;2;248;248;242m:[0m[38;2;248;248;242m][0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mset[0m[38;2;248;248;242m [0m[38;2;255;255;255mascii_arts[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;255;255;255mcowfiles[0m[38;2;248;248;242m [0m[38;2;248;248;242m|[0m[38;2;248;248;242m [0m[38;2;255;255;255mjoin[0m[38;2;248;248;242m([0m[38;2;230;219;116m'[0m[38;2;230;219;116m [0m[38;2;230;219;116m'[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mfor[0m[38;2;248;248;242m [0m[38;2;255;255;255mascii_art[0m[38;2;248;248;242m [0m[38;2;249;38;114min[0m[38;2;248;248;242m [0m[38;2;255;255;255mascii_arts[0m[38;2;248;248;242m.[0m[38;2;255;255;255msplit[0m[38;2;248;248;242m([0m[38;2;230;219;116m'[0m[38;2;230;219;116m [0m[38;2;230;219;116m'[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;249;38;114mrun_cowsay_{{ ascii_art }}[0m[38;2;248;248;242m:[0m[38;2;117;113;94m [0m[38;2;117;113;94m#[0m[38;2;117;113;94m name must be unique[0m
[38;2;248;248;242m [0m[38;2;249;38;114mcmd.run[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mif[0m[38;2;248;248;242m [0m[38;2;255;255;255mascii_art[0m[38;2;248;248;242m [0m[38;2;249;38;114mis[0m[38;2;248;248;242m [0m[38;2;255;255;255min[0m[38;2;248;248;242m [0m[38;2;248;248;242m[[0m[38;2;230;219;116m'[0m[38;2;230;219;116mhead-in[0m[38;2;230;219;116m'[0m[38;2;248;248;242m,[0m[38;2;248;248;242m [0m[38;2;230;219;116m'[0m[38;2;230;219;116msodomized[0m[38;2;230;219;116m'[0m[38;2;248;248;242m,[0m[38;2;248;248;242m [0m[38;2;230;219;116m'[0m[38;2;230;219;116mtelebears[0m[38;2;230;219;116m'[0m[38;2;248;248;242m][0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116mecho cowsay -f {{ ascii_art }} should not be used[0m
[38;2;248;248;242m [0m[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114melse[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116mfortune | cowsay -f {{ ascii_art }}[0m
[38;2;248;248;242m [0m[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mendif[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mendfor[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;249;38;114mecho_pillar_demo_1[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mcmd.run[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mecho {{ pillar.demo_text | default('pillar not defined') }}[0m[38;2;230;219;116m"[0m
[38;2;249;38;114mecho_pillar_demo_2[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mcmd.run[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mecho {{ pillar.demo.text | default('pillar not defined') }}[0m[38;2;230;219;116m"[0m
[38;2;117;113;94m#[0m[38;2;117;113;94m Comment[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mset[0m[38;2;248;248;242m [0m[38;2;255;255;255mrand[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;255;255;255msalt[0m[38;2;248;248;242m[[0m[38;2;230;219;116m'[0m[38;2;230;219;116mrandom.get_str[0m[38;2;230;219;116m'[0m[38;2;248;248;242m][0m[38;2;248;248;242m([0m[38;2;248;248;242m20[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;166;226;46m{%[0m[38;2;248;248;242m [0m[38;2;249;38;114mset[0m[38;2;248;248;242m [0m[38;2;255;255;255mIP_Address[0m[38;2;248;248;242m [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;255;255;255mpillar[0m[38;2;248;248;242m[[0m[38;2;230;219;116m'[0m[38;2;230;219;116mIP_Address[0m[38;2;230;219;116m'[0m[38;2;248;248;242m][0m[38;2;248;248;242m [0m[38;2;166;226;46m%}[0m
[38;2;249;38;114mwait[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mcmd.run[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116msleep 210[0m[38;2;117;113;94m [0m[38;2;117;113;94m#[0m[38;2;117;113;94m another comment[0m
[38;2;249;38;114mcreate_roster_file[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;249;38;114mfile.managed[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mname[0m[38;2;248;248;242m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m/tmp/salt-roster-{{ rand }}[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;249;38;114mcontents[0m[38;2;248;248;242m:[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116m'[0m[38;2;230;219;116mswitch:[0m[38;2;230;219;116m'[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116m'[0m[38;2;230;219;116m host: {{ IP_Address }}[0m[38;2;230;219;116m'[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m user: test[0m[38;2;230;219;116m"[0m
[38;2;248;248;242m [0m[38;2;248;248;242m-[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m passwd: {{ passwd }}[0m[38;2;230;219;116m"[0m
| false |
a7f16ff557c0b84264412a66f4ebb4594bf3ad88
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System.Xml/mono/xml/dtdnotation-declaration-collection.sls
|
f4af889e51fac8b662e1a9a94908259401538373
|
[] |
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 | 787 |
sls
|
dtdnotation-declaration-collection.sls
|
(library (mono xml dtdnotation-declaration-collection)
(export new is? dtdnotation-declaration-collection? add item)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new Mono.Xml.DTDNotationDeclarationCollection a ...)))))
(define (is? a) (clr-is Mono.Xml.DTDNotationDeclarationCollection a))
(define (dtdnotation-declaration-collection? a)
(clr-is Mono.Xml.DTDNotationDeclarationCollection a))
(define-method-port
add
Mono.Xml.DTDNotationDeclarationCollection
Add
(System.Void System.String Mono.Xml.DTDNotationDeclaration))
(define-field-port
item
#f
#f
(property:)
Mono.Xml.DTDNotationDeclarationCollection
Item
Mono.Xml.DTDNotationDeclaration))
| true |
c487e4f31652750b7d33c2916c0a80c4c7225c66
|
d074b9a2169d667227f0642c76d332c6d517f1ba
|
/sicp/ch_4/exercise.4.78.scm
|
efbdf4aa41dd5f9e5e080c02d1e54a3b66c6aecb
|
[] |
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 | 712 |
scm
|
exercise.4.78.scm
|
#!/usr/bin/env csi -s
(require rackunit)
;;; Exercise 4.78
;; Redesign the query language as a nondeterministic
;; program to be implemented using the evaluator of section *Note
;; 4-3::, rather than as a stream process. In this approach, each
;; query will produce a single answer (rather than the stream of all
;; answers) and the user can type `try-again' to see more answers.
;; You should find that much of the mechanism we built in this
;; section is subsumed by nondeterministic search and backtracking.
;; You will probably also find, however, that your new query language
;; has subtle differences in behavior from the one implemented here.
;; Can you find examples that illustrate this difference?
| false |
b89f36456ac4bcc6514cd43af20b18ff7f51e294
|
893a879c6b61735ebbd213fbac7e916fcb77b341
|
/interpreter-cps/syntax-expansion.ss
|
fcd193e8470689adb5e5e959d9bd2047862b37a9
|
[] |
no_license
|
trittimo/PLC-Assignments
|
e5353c9276e93bca711b684c955d6c1df7cc6c82
|
666c2521f1bfe1896281e06f0da9a7ca315579bb
|
refs/heads/master
| 2016-08-31T04:52:26.143152 | 2016-06-05T01:00:18 | 2016-06-05T01:00:18 | 54,284,286 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,137 |
ss
|
syntax-expansion.ss
|
;-----------------------+
; |
; SYNTAX EXPANSION |
; |
;-----------------------+
(define (expand-or datum)
(if (null? datum)
#f
(list 'let (list (list 'ans (car datum))) (list 'if 'ans 'ans (expand-or (cdr datum))))))
(define (expand-and datum)
(cond
((null? datum) #t)
((null? (cdr datum)) (car datum))
(else (list 'if (car datum) (expand-and (cdr datum)) #f))))
(define (expand-cond datum)
(cond
((null? datum) )
((eqv? (caar datum) 'else) (cdar datum))
(else (list (append (list 'if (caar datum) (cadar datum)) (expand-cond (cdr datum)))))))
(define (expand-let* datum)
(cond
((null? (1st datum)) (list (append (list 'lambda (list)) (cdr datum))))
((null? (cdr (1st datum))) (list (append (list 'lambda (list (caaar datum))) (cdr datum)) (cadaar datum)))
(else (list (list 'lambda (list (caaar datum)) (expand-let* (cons (cdar datum) (cdr datum)))) (cadaar datum)))))
(define (expand-begin datum)
(list (append (list 'lambda '()) datum)))
(define (expand-case datum)
(letrec ((expr (1st datum))
(loop (lambda (datum)
(cond
((null? datum))
((eqv? (caar datum) 'else) (cdar datum))
(else (list (append (list 'if (list 'member expr (cons 'list (caar datum))) (cadar datum)) (loop (cdr datum)))))))))
(loop (cdr datum))))
(define (expand-while datum)
(list 'let (list (list 'loop (list 'lambda '(func)
(list 'if (1st datum)
(append (cons 'begin (cdr datum))
(list (list 'func 'func)))))))
(list 'loop 'loop)))
(define (expand-letrec datum)
(append (list 'let)
(append (append (list (map (lambda (x) (list (car x) #f)) (cadr datum)))
(map (lambda (x) (list 'set! (car x) (cadr x))) (cadr datum)))
(cddr datum))))
(define (expand-named-let datum)
(let ((temps (generate-temporaries (length (2nd datum)))) (args (map car (2nd datum))))
(list 'let (map list temps (map cadr (2nd datum)))
(list 'letrec
(cons (list (1st datum) (append (list 'lambda args) (cddr datum)))
(map list args temps))
(cons (1st datum) args)))))
(define (expand-let datum)
(cons (append (list 'lambda (map car (1st datum))) (cdr datum)) (map 2nd (1st datum))))
(define (expand-define datum)
(append (list 'set!) datum))
(define (expand-exp datum)
(let ((rest (cdr datum)))
(case (1st datum)
((while) (expand-while rest))
((or) (expand-or rest))
((and) (expand-and rest))
((cond) (car (expand-cond rest)))
((let*) (expand-let* rest))
((begin) (expand-begin rest))
((case) (car (expand-case rest)))
((letrec) (expand-letrec datum))
((let)
(if (symbol? (1st rest))
(expand-named-let rest)
(expand-let rest)))
((define) (expand-define rest))
)))
(define (has-expansion? datum)
(member (1st datum) '( or and cond let* begin case while letrec define let )))
| false |
2772da2921ae3bce683c73cec639ecd298ae8865
|
b16702c79458d126ecdd5d297bba86a743610b25
|
/Assignment-12/testcase.ss
|
4f2fbc8309ea7677c72557fcabbc55faec3121a3
|
[] |
no_license
|
yangchenyun/Grad-School-Code
|
d5353d001ce6e9ba454580c1daa68c964843d6e6
|
5fe2e5d9d01886c4998762061dc7d22ab2264cf7
|
refs/heads/master
| 2021-01-24T22:36:45.453167 | 2017-03-20T08:34:11 | 2017-03-20T08:34:11 | 34,314,124 | 1 | 1 | null | 2015-04-21T08:24:36 | 2015-04-21T08:24:36 | null |
UTF-8
|
Scheme
| false | false | 2,765 |
ss
|
testcase.ss
|
;(letrec ([fact.0 (lambda (n.3 k.4)
; (if (eq? n.3 '0)
; (k.4 '1)
; (fact.0 (- n.3 '1)
; (letrec ([anon.5 (lambda (v.6)
; (k.4 (* n.3 v.6)))])
; anon.5))))]
; [anon.1 (lambda (v.2) v.2)])
; (fact.0 '5 anon.1))
;
; (define-who uncover-free
; (define primitives
; '(+ - * <= < = >= > procedure? boolean? car cdr cons eq? fixnum? make-vector null? pair? set-car! set-cdr! vector? vector-length vector-ref vector-set! void ))
; (define Expr
; (lambda (params)
; (lambda (expr)
; (match expr
; [,uvar (guard (uvar? uvar))
; (if (memq uvar params) (values uvar '()) (values uvar `(,uvar)))]
; [(if ,[(Expr params) -> cond-expr cond-bindings] ,[(Expr params) -> conseq-expr conseq-bindings] ,[(Expr params) -> alt-expr alt-bindings])
; (values `(if ,cond-expr ,conseq-expr ,alt-expr) (append cond-bindings conseq-bindings alt-bindings))]
; [(quote ,[Immediate -> im-expr]) (values `(quote ,im-expr) '())]
; [(begin ,[(Expr params)-> exp-stmt* exp-binding*] ... ,[(Expr params) -> tail-stmt tail-binding])
; (values `(begin ,exp-stmt* ... ,tail-stmt) '(exp-binding* tail-binding))]
; [(letrec ([,uvar* ,[Body -> body*]] ...) ,[(Expr params) -> tail-expr tail-binding])
; (values `(letrec ([,uvar* ,body*] ...) ,tail-expr) '())]
; [(let ([,uvar* ,[(Expr params) -> exp* binding*]] ...) ,[(Expr params)-> tail binding])
; (values `(let ([,uvar* ,exp*] ...) ,tail) (union binding binding*))]
; [(,prim ,[(Expr params)-> expr* bindings*] ...) (guard (memq prim primitives))
; (values `(,prim ,expr* ...) (apply append bindings*))]
; [(,[(Expr params) -> exp binding] ,[(Expr params) -> rem* bindings*] ...)
; (values `(,exp ,rem* ...) (append bindings* binding))]))))
; (define Body
; (lambda (body)
; (match body
; [(lambda (,param* ...) ,body)
; (let-values ([(stmt* free*) ((Expr param*) body)])
; `(lambda (,param* ...) (free ,(clean-up free*) ,stmt*)))])))
; (define clean-up
; (trace-lambda clean(seti)
; (cond
; [(null? seti) '()]
; [(and (list? (car seti)) (null? (car seti))) (clean-up (cdr seti))]
; [(list? (car seti)) (set-cons (caar seti) (clean-up (cdr seti)))]
; [else (set-cons (car seti) (clean-up (cdr seti)))])))
; (define (Immediate imm)
; (cond
; [(memq imm '(#t #f ())) imm]
; [(and (integer? imm) (exact? imm))
; (unless (fixnum-range? imm)
; (error who "integer ~s is out of fixnum range" imm))
; imm]
; [else (error who "invalid Immediate ~s" imm)]))
; (lambda (x)
; (let-values ([(final-expr final-bindings) ((Expr '()) x)])
; final-expr)))
| false |
2c52f79bfad963279603f424d01899c5821c9454
|
bef204d0a01f4f918333ce8f55a9e8c369c26811
|
/tspl/c4-procedures-and-variable-bindings.ss
|
ca06db75a0df450c444260d819e340cef2fec89e
|
[
"MIT"
] |
permissive
|
ZRiemann/ChezSchemeNote
|
56afb20d9ba2dd5d5efb5bfe40410a5f7bb4e053
|
70b3dca5d084b5da8c7457033f1f0525fa6d41d0
|
refs/heads/master
| 2022-11-25T17:27:23.299427 | 2022-11-15T07:32:34 | 2022-11-15T07:32:34 | 118,701,405 | 5 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,102 |
ss
|
c4-procedures-and-variable-bindings.ss
|
;;; Chapter 4. Procedures and Variable Bindings
;;; Section 4.1. Variable Reference
;;; Section 4.2. Lambda
;;; Section 4.3. Case-Lambda
;;; Section 4.4. Local Binding
;;; Section 4.5. Multiple Values
;;; Section 4.6. Variable Definitions
;;; Section 4.7. Assignment
;;; Section 4.1. Variable Reference
;;; syntax: variable
;;; returns: the value of variable
list ; => #<procedure list>
(define x 'a)
x ; => a
(list x x) ; =>(a a)
;;; it is not necessary for the definition of a variable to appear before its first reference appears,
;;; as long as the reference is not actually evaluated until the definition has been completed.
(define f
(lambda (x)
(g x)))
; g 可以后于 f 定义, 优点: 库定义更灵活,相当于定义了接口规范,用户使用时可自定义g的行为
(define g
(lambda (x)
(+ x x)))
(define q (ggxx 3)) ; => variable ggxx is not bound
;;; Section 4.2. Lambda
;;; syntax: (lambda formals body1 body2 ...)
;;; returns: a procedure
(lambda (x) (+ x 3)) ; => #<procedure>
((lambda (x) (+ x 3)) 7) ; => 10
((lambda (x y) (* x (+ x y))) 7 13) ; => 140
((lambda (f x) (f x x)) + 11) ; => 22
((lambda () (+ 3 4))) ; => 7
((lambda (x . y) (list x y)) 28 37) ; => (28 (37))
((lambda (x . y) (list x y)) 28 37 47 28) ; => (28 (37 47 28))
((lambda (x y . z) (list x y z)) 1 2 3 4) ; => (1 2 (3 4))
((lambda x x) 7 13) ; => (7 13)
;;; Section 4.3. Case-Lambda
;;; syntax: (case-lambda clause ...)
;;; returns: a procedure
;;; libraries: (rnrs control) (rnrs)
(define make-list
(case-lambda
[(n) (make-list n #f)]
[(n x)
(do ([n n (- n 1)] [ls '() (cons x ls)])
((zero? n) ls))]))
(make-list 3 'a)
(make-list 3)
(define substring1
(case-lambda
[(s) (substring1 s 0 (string-length s))]
[(s start) (substring1 s start (string-length s))]
[(s start end) (substring s start end)]))
;;; Section4.4. Local Binding
;;; syntax: (let ((var expr) ...) body1 body2 ...)
;;; returns: the values of the final body expression
;;; libraries: (rnrs base), (rnrs)
;;; let, let*, letrec, and letrec*...
| false |
18e0a1d3802672dea264c98e9a01508fa3ce35bf
|
a4cd5242b2825972f6c8b905ade8d13b10ed9bf2
|
/kernal.scm
|
7ffdbc2b4a4848c0475c8a62026daab91b1f741a
|
[] |
no_license
|
zephyrfalcon/nepenthe
|
c46d7ec785a0bb4aa197d153a7da78ba40877032
|
2891f1aae55f728d235f81384134bd5299bf3bd5
|
refs/heads/master
| 2021-01-10T22:06:20.097187 | 2016-08-20T21:04:35 | 2016-08-20T21:04:35 | 5,472,352 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 159 |
scm
|
kernal.scm
|
;; kernal.scm
; names must start with "CBM:"
(define *kernal-addresses*
'(("CBM-CHROUT" #xFFD2)
("CBM-GETIN" #xFFE4)
("CBM-STOP" #xFFE1)))
| false |
821fb7b7245fd776249ec992fab27d76b65a39df
|
86a7d9ada5a7978cc6b3dc51c73a61abf82a6023
|
/src/compile.ss
|
4eedbd125e8fc36a147cbaa49773f0382d6a1723
|
[] |
no_license
|
themetaschemer/rackscad
|
6b249559ae9dbced4c12d3562284a41ab0265fe4
|
8915919c24bb93a63d13546610871bd11a823411
|
refs/heads/master
| 2021-06-26T07:31:04.723127 | 2017-09-15T15:32:41 | 2017-09-15T15:32:41 | 103,672,527 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 11,897 |
ss
|
compile.ss
|
#lang racket
(require "utils.ss")
(require "parse-tree.ss")
(require "svg-color.ss")
(require racket/include)
(require rackunit)
(define/provide (compile-expr expr)
(cond
[(transform? expr) (compile-transform expr)]
[(extrude? expr) (compile-extrude expr)]
[(projection? expr) (compile-projection expr)]
[(parameters? expr) (compile-parameters expr)]
[(height-map? expr) (compile-height-map expr)]
[(object? expr) (compile-object expr)]
[(list? expr) (with-current-indent (compile-group expr))]))
(define (compile-transform expr)
(match expr
[(basic-transform name x y z objects)
(with-current-indent "~a([~a, ~a, ~a]) ~a"
(compile-component name)
(compile-component x)
(compile-component y)
(compile-component z)
(compile-group objects))]
[(basic-color-transform r g b alpha objects)
(with-current-indent "color([~a, ~a, ~a, ~a]) ~a"
(compile-component r)
(compile-component g)
(compile-component b)
(compile-component alpha)
(compile-group objects))]
[(offset-transform radius depth chamfer objects)
(cond
[(and (not radius) (not depth))
(error 'compile-transform "Offset transform must at least have radius or depth: ~a~%" expr)]
[radius (with-current-indent "offset(r = ~a, chamfer = ~a) ~a"
(compile-component radius)
(compile-component chamfer)
(compile-group objects))]
[depth (with-current-indent "offset(d = ~a, chamfer = ~a) ~a"
(compile-component depth)
(compile-component chamfer)
(compile-group objects))])]
[(affine-transform matrix objects)
(with-current-indent "multmatrix(~a) ~a" (compile-affine-matrix matrix) (compile-group objects))]
[else (error 'compile-transform "Unknown transform: ~a~%" expr)]))
(define (compile-extrude expr)
(match expr
[(linear-extrude-transform objects height center convexity twist slices scale)
(with-current-indent "linear_extrude(height = ~a, center = ~a, convexity = ~a, twist = ~a, slices = ~a, scale = ~a) ~a"
(compile-component height)
(compile-component center)
(compile-component convexity)
(compile-component twist)
(compile-component slices)
(compile-component scale)
(compile-group objects))]
[(rotate-extrude-transform objects angle convexity)
(with-current-indent "rotate_extrude(angle = ~a, convexity = ~a) ~a"
(compile-component angle)
(compile-component convexity)
(compile-group objects))]
[else (error 'compile-extrude "Unknown extrude transform: ~a~%" expr)]))
(define (compile-projection expr)
(match expr
[(project-transform cut objects)
(with-current-indent "projection(~a) ~a" (compile-group objects))]
[else (error 'compile-projection "Unknown projection transform: ~a~%" expr)]))
(define (compile-height-map expr)
(match expr
[(height-map-transform file objects center convexity)
(with-current-indent "surface(file = ~s, center = ~a, convexity = ~a) ~a"
(compile-component file)
(compile-component center)
(compile-component convexity)
(compile-group objects))]))
(define (compile-parameters expr)
(match expr
[(parameters-transform params objs)
(with-current-indent
(++* (η "{\n") (with-indent-in
(apply ++*
(append (map compile-parameter-assignment params)
(map compile-expr objs))))
(η "};\n")))]))
(define (object? expr)
(or (2d-object? expr)
(3d-object? expr)
(set-operation? expr)
(import? expr)))
(define (compile-object expr)
(cond
[(2d-object? expr) (compile-2d-object expr)]
[(3d-object? expr) (compile-3d-object expr)]
[(set-operation? expr) (compile-set-operation expr)]
[(import? expr) (compile-import expr)]))
(define (compile-group exprs)
(if (equal? 1 (length exprs))
(++* " " (compile-expr (car exprs)) (η ";\n"))
(++* (η "{\n") (with-indent-in (apply ++* (map compile-expr exprs))) (η "};\n"))))
(define (compile-set-operation expr)
(match expr
[(set-operation-object op objects)
(with-current-indent "~a() ~a" (compile-component op) (compile-group objects))]))
(define (compile-import expr)
(match expr
[(import-object file)
(with-current-indent "import(~s)" (compile-component file))]))
(define (compile-2d-object obj)
(match obj
[(circle-object diameter)
(with-current-indent "circle(d=~a)" (compile-component diameter))]
[(rectangle-object x y center)
(with-current-indent "square([~a, ~a], ~a)" (compile-component x) (compile-component y) (compile-component center))]
[(polygon-object points paths)
(if (and paths (not (null? paths)))
(with-current-indent "polygon([~a])" (as-vector points))
(with-current-indent "polygon([~a], [~a])" (as-vector points) (as-vector paths)))]
[(text-object string size font halign valign spacing direction language script)
(with-current-indent
(++ "text(text = ~s, size = ~a, font = ~s, "
"halign = ~s, valign = ~s, spacing = ~a, "
"direction = ~s, language = ~s, script = ~s")
(compile-component string) (compile-component size) (compile-component font)
(compile-component halign) (compile-component valign) (compile-component spacing)
(compile-component direction) (compile-component language) (compile-component script))]
[else (error 'compile-2d-object "Unknown 2d-object: ~a~%" obj)]))
(define (compile-3d-object obj)
(match obj
[(sphere-object diameter) (with-current-indent "sphere(d=~a)" (compile-component diameter))]
[(cuboid-object width depth height center)
(with-current-indent "cube([~a,~a,~a],center=~a)"
(compile-component width)
(compile-component depth)
(compile-component height)
(compile-component center))]
[(conic-object height base-diameter top-diameter center)
(with-current-indent "cylinder(~a,d1=~a,d2=~a,center=~a)"
(compile-component height)
(compile-component base-diameter)
(compile-component top-diameter)
(compile-component center))]
[(polyhedron-object points faces convexity)
(with-current-indent "polyhedron(points = ~a, paths = ~a, convexity = ~a)"
(as-vector points)
(as-vector faces)
(compile-component convexity))]
[else (error 'compile-3d-object "Unknown 3d-object: ~a~%" obj)]))
;; Affine matrix is a list of list and has size 3x4
(define (compile-affine-matrix matrix)
(ensure-affine-matrix matrix)
(as-vector* (map as-vector matrix)))
(define (ensure-affine-matrix matrix)
(or (and (list? matrix)
(= (length matrix) 3)
(andmap (λ (row) (and (list? row) (= (length row) 4))) matrix))
(error 'ensure-affine-matrix "Not a 3d affine matrix: ~a~%" matrix)))
(define (component? expr)
(or (equal? expr #t)
(equal? expr #f)
(point? expr)
(face? expr)
(edge? expr)
(number? expr)
(string? expr)))
(define (compile-component obj)
(match obj
[#t (η "true")]
[#f (η "false")]
[(? number?) (η (exact->inexact obj))]
[(? string?) (η (format "~s" obj))]
[(point x y z) (as-vector (list x y z))]
[(face points) (as-vector points)]
[(edge from to) (as-vector (list from to))]))
(define (as-vector list)
(++* (η "[") (apply ++* #:separator ", " (map compile-component list)) (η "]")))
(define (as-vector* list)
(++* (η "[") (apply ++* #:separator ", " list) (η "]")))
(define (compile-parameter-assignment assgn)
(++* (compile-component (car assgn)) (η " = ") (compile-component (cadr assgn))))
;;---------------------------------------------------------------------------------
;; Monadic compilation
;;---------------------------------------------------------------------------------
;; The compilation monad carries around a port and the current indent level.
;; The monadic type expects a port and indent-level
;; The monadic type is: port x indent-level -> string , if port is #f
;; port x indent-level -> void , if port is valid
;; The code below is super cryptic.
;; the -m prefix indicates that value is of the monadic type.
;;---------------------------------------------------------------------------------
;; Basic monad
(define (η v)
(λ (port indent)
(let ([str (ensure-string v)])
(if port
(display str port)
str))))
(define (f* f v-m)
(λ (port indent-level)
((f (v-m port indent-level)) port indent-level)))
;;---------------------------------------------------------------------------------
;; String append in the monadic domain
(define (++-2* a-m b-m)
(λ (port indent-level)
(if port
((f* (λ (a) (f* (λ (b) (η a) (η b)) b-m)) a-m) port indent-level)
((f* (λ (a) (f* (λ (b) (η (++ a b))) b-m)) a-m) port indent-level))))
(define (++* a-m . b-ms)
(let loop ([b-ms b-ms]
[res-m a-m])
(cond
[(null? b-ms) res-m]
[else (loop (cdr b-ms) (++-2* res-m (car b-ms)))])))
;;---------------------------------------------------------------------------------
;; String formatting in the monadic domain
(define-syntax (format-indent* x)
(syntax-case x ()
[(_ fmt-string (args ...))
#'(λ (port indent)
(let ([str (add-indent-to-lines indent (format fmt-string args ...))])
(if port
(display str port)
str)))]
[(_ fmt-string (args ...) arg-m arg-ms ...)
(with-syntax ([v (datum->syntax #'_ (gensym))])
#'(f* (λ (v) (format-indent* fmt-string (args ... v) arg-ms ...)) arg-m))]))
(define-syntax (append-indent* x)
(syntax-case x ()
[(_ (args ...))
#'(λ (port indent)
(let ([str (add-indent-to-lines indent (++ args ...))])
(if port
(display str port)
str)))]
[(_ (args ...) arg-m arg-ms ...)
(with-syntax ([v (datum->syntax #'_ (gensym))])
#'(f* (λ (v) (append-indent* (args ... v) arg-ms ...)) arg-m))]))
(define-syntax (with-current-indent x)
(syntax-case x ()
[(_ fmt-string args ...)
(string? (syntax->datum #'fmt-string))
#'(format-indent* fmt-string () args ...)]
[(_ args ...)
#'(append-indent* () args ...)]))
;;---------------------------------------------------------------------------------
;; Adjustment of indents
(define (with-indent-in x-m)
(λ (port indent) (x-m port (++ indent " "))))
(define (with-indent-out x-m)
(λ (port indent) (x-m port (strip-one-indent indent))))
(define (add-indent-to-lines indent str)
(apply string-append-with-separator "\n"
(map (λ (x) (if (equal? "" x) x (++ indent x))) (regexp-split #rx"(?m:\n^)" str))))
(define (strip-one-indent string)
(match string
[(regexp #px"^ (.*)$" (list _ remaining)) remaining]
[else string]))
(include "compile-tests.ss")
| true |
d3b0023409bb57cbc83352b551b6cae373564f27
|
df0ba5a0dea3929f29358805fe8dcf4f97d89969
|
/exercises/software-engineering/08/pythagorean-tripples.scm
|
b3735ee837cb4e03cd7677952813dcf26e110086
|
[
"MIT"
] |
permissive
|
triffon/fp-2019-20
|
1c397e4f0bf521bf5397f465bd1cc532011e8cf1
|
a74dcde683538be031186cf18367993e70dc1a1c
|
refs/heads/master
| 2021-12-15T00:32:28.583751 | 2021-12-03T13:57:04 | 2021-12-03T13:57:04 | 210,043,805 | 14 | 31 |
MIT
| 2019-12-23T23:39:09 | 2019-09-21T19:41:41 |
Racket
|
UTF-8
|
Scheme
| false | false | 2,090 |
scm
|
pythagorean-tripples.scm
|
(load "./stream.scm")
(define (integers-from n)
(cons-stream n (integers-from (+ n 1))))
(define (take-stream n s)
(if (or (= n 0)
(empty-stream? s))
empty-stream
(cons-stream (head s)
(take-stream (- n 1) (tail s)))))
(define (range-stream from to)
(take-stream (+ to (- from) 1)
(integers-from from)))
(define (map-stream f s)
(if (empty-stream? s)
empty-stream
(cons-stream (f (head s))
(map-stream f (tail s)))))
(define (filter-stream p s)
(cond ((empty-stream? s) empty-stream)
((p (head s)) (cons-stream (head s)
(filter-stream p (tail s))))
(else (filter-stream p (tail s)))))
(define (append-stream s1 s2)
(if (empty-stream? s1)
s2
(cons-stream (head s1)
(append-stream (tail s1) s2))))
(define (concat-streams ss)
(cond ((empty-stream? ss) empty-stream)
((empty-stream? (head ss)) (concat-streams (tail ss)))
(else (cons-stream (head (head ss))
(append-stream (tail (head ss))
(concat-streams (tail ss)))))))
(define (flatmap-stream f s)
(concat-streams (map-stream f s)))
(define triples
(flatmap-stream (lambda (c)
(flatmap-stream (lambda (b)
(map-stream (lambda (a)
(list a b c))
(range-stream 1 b)))
(range-stream 1 c)))
(integers-from 1)))
(define (square x)
(* x x))
(define pythagorean-triples
(filter-stream (lambda (triple)
(= (+ (square (car triple))
(square (cadr triple)))
(square (caddr triple))))
triples))
(load "../testing/check.scm")
(check (stream->list (take-stream 5 pythagorean-triples))
=> '((3 4 5) (6 8 10) (5 12 13) (9 12 15) (8 15 17)))
(check-report)
(check-reset!)
| false |
e4f9cb77daeda48be680d81718fee20e362c06f0
|
000dbfe5d1df2f18e29a76ea7e2a9556cff5e866
|
/sitelib/srfi/%3a146/mappings.scm
|
3da27820e8b72213ec7253bbb40fd88f67f23e82
|
[
"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 | 19,545 |
scm
|
mappings.scm
|
;;; -*- mode:scheme; coding:utf-8; -*-
;;;
;;; srfi/%3a146/mappings.scm - Mappings
;;;
;;; Copyright (c) 2019 Takashi Kato <[email protected]>
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; 1. Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; 2. Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;
#!nounbound
(library (srfi :146 mappings)
(export (rename (make-mapping mapping)) mapping-unfold
mapping/ordered mapping-unfold/ordered
mapping? mapping-contains? mapping-empty? mapping-disjoint?
mapping-ref mapping-ref/default mapping-key-comparator
mapping-adjoin mapping-adjoin!
mapping-set mapping-set!
mapping-replace mapping-replace!
mapping-delete mapping-delete!
mapping-delete-all mapping-delete-all!
mapping-intern mapping-intern!
mapping-update mapping-update!
mapping-update/default mapping-update!/default
mapping-pop mapping-pop!
mapping-search mapping-search!
mapping-size mapping-find mapping-count mapping-any? mapping-every?
mapping-keys mapping-values mapping-entries
mapping-map mapping-map->list mapping-for-each mapping-fold
mapping-filter mapping-filter!
mapping-remove mapping-remove!
mapping-partition mapping-partition!
mapping-copy mapping->alist alist->mapping alist->mapping!
alist->mapping/ordered alist->mapping/ordered!
mapping=? mapping<? mapping>? mapping<=? mapping>=?
mapping-union mapping-intersection mapping-difference mapping-xor
mapping-union! mapping-intersection!
mapping-difference! mapping-xor!
make-mapping-comparator
mapping-comparator
mapping-min-key mapping-max-key
mapping-min-value mapping-max-value
mapping-key-predecessor mapping-key-successor
mapping-range= mapping-range< mapping-range>
mapping-range<= mapping-range>=
mapping-range=! mapping-range<!
mapping-range>! mapping-range<=! mapping-range>=!
mapping-split
mapping-catenate mapping-catenate!
mapping-map/monotone mapping-map/monotone!
mapping-fold/reverse
comparator?)
(import (rnrs)
(srfi :114 comparators)
(only (srfi :128) comparator-register-default!)
(only (sagittarius treemap) treemap-iterator)
(clos user)
(util treemap))
(define-record-type mapping
(fields key-comparator tree)
(protocol (lambda (p)
(lambda (comparator . args)
(assert (comparator? comparator))
(let ((m (make-rb-treemap/comparator comparator)))
(dopairs (k v args) (treemap-adjoin! m k v))
(p comparator m))))))
(define %tree mapping-tree)
(define-syntax dopairs
(syntax-rules ()
((_ (k v lis) body ...)
(let ((l lis))
(do ((xs l (cddr xs)))
((null? xs))
(when (null? (cdr xs))
(assertion-violation 'mapping "kv-list isn't even" l))
(let ((k (car xs)) (v (cadr xs)))
body ...))))))
(define (mapping-unfold p f g seed comparator)
(assert (comparator? comparator))
(let ((m (make-mapping comparator)))
(do ((seed seed (g seed)))
((p seed) m)
(let-values (((k v) (f seed)))
(mapping-adjoin! m k v)))))
(define mapping/ordered mapping)
(define mapping-unfold/ordered mapping-unfold)
(define (mapping-empty? m) (zero? (treemap-size (%tree m))))
(define (mapping-contains? m k) (treemap-contains? (%tree m) k))
(define (mapping-disjoint? m1 m2)
(assert (mapping? m1))
(assert (mapping? m2))
(let ((t2 (%tree m2)))
(treemap-seek (%tree m1)
(lambda (k _) (treemap-contains? t2 k))
(lambda (r k v) #f)
(lambda () #t))))
(define (mapping-fold kons knil m)
(assert (mapping? m))
(treemap-fold kons (%tree m) knil))
(define (mapping-copy m)
(assert (mapping? m))
(mapping-fold (lambda (k v m) (mapping-adjoin! m k v))
(make-mapping (mapping-key-comparator m)) m))
(define (mapping-adjoin! m . args)
(assert (mapping? m))
(let ((t (%tree m))) (dopairs (k v args) (treemap-adjoin! t k v)))
m)
(define (mapping-adjoin m . args)
(assert (mapping? m))
(apply mapping-adjoin! (mapping-copy m) args))
(define %unique (list #t))
(define (mapping-ref m key :optional (failure #f) (success values))
(assert (mapping? m))
(let ((v (treemap-ref (%tree m) key %unique)))
(if (eq? v %unique)
(if failure
(failure)
(error 'mapping-ref "Given key isn't in the mapping" m key))
(success v))))
(define (mapping-ref/default m key default)
(assert (mapping? m))
(treemap-ref (%tree m) key default))
(define (mapping-set m . args)
(assert (mapping? m))
(apply mapping-set! (mapping-copy m) args))
(define (mapping-set! m . args)
(assert (mapping? m))
(let ((t (%tree m))) (dopairs (k v args) (treemap-set! t k v)))
m)
(define (mapping-replace m k v)
(assert (mapping? m))
(mapping-replace! (mapping-copy m) k v))
(define (mapping-replace! m k v)
(assert (mapping? m))
(let ((t (%tree m))) (treemap-replace! t k v))
m)
(define (mapping-delete m . keys) (mapping-delete-all m keys))
(define (mapping-delete! m . keys) (mapping-delete-all! m keys))
(define (mapping-delete-all m keys)
(assert (mapping? m))
(mapping-delete-all! (mapping-copy m) keys))
(define (mapping-delete-all! m keys)
(assert (mapping? m))
(let ((t (%tree m)))
(for-each (lambda (k) (treemap-delete! t k)) keys)
m))
(define (mapping-intern m k newval)
(assert (mapping? m))
(mapping-intern! (mapping-copy m) k newval))
(define (mapping-intern! m k newval)
(assert (mapping? m))
(let ((v (mapping-ref/default m k %unique)))
(if (eq? v %unique)
(let ((v (newval)))
(mapping-set! m k v)
(values m v))
(values m v))))
(define (mapping-update m k updater . opts)
(assert (mapping? m))
(apply mapping-update! (mapping-copy m) k updater opts))
(define (mapping-update! m k updater :optional
(failure (lambda ()
(error 'mapping-update!
"Given mapping doesn't have key" m k)))
(success values))
(assert (mapping? m))
(let* ((v (mapping-ref/default m k %unique))
(v1 (if (eq? v %unique)
(updater (failure))
(updater (success v)))))
(mapping-set! m k v1)))
(define (mapping-update/default m k updater default)
(mapping-update m k updater (lambda () default)))
(define (mapping-update!/default m k updater default)
(mapping-update! m k updater (lambda () default)))
(define (mapping-pop m . opt)
(assert (mapping? m))
(apply mapping-pop! (mapping-copy m) opt))
(define (mapping-pop! m :optional
(failure
(lambda ()
(error 'mapping-pop!
"Can't pop from an empty map" m))))
(assert (mapping? m))
(let ((v (treemap-pop-first-entry! (%tree m))))
(if v
(values m (car v) (cdr v))
(failure))))
(define (mapping-search m k failure success)
(assert (mapping? m))
(mapping-search! (mapping-copy m) k failure success))
(define (mapping-search! m k failure success)
(assert (mapping? m))
(let ((v (mapping-ref/default m k %unique)))
(if (eq? v %unique)
(failure (lambda (v o) (mapping-set! m k v) (values m o)) ;; insert
(lambda (o) (values m o))) ;; ignore
(success k v
(lambda (k v o) (mapping-set! m k v) (values m o)) ;; update
(lambda (o) (mapping-delete! m k) (values m o)))))) ;; remove
(define (mapping-size m)
(assert (mapping? m))
(treemap-size (%tree m)))
(define (mapping-find pred m failure)
(assert (mapping? m))
(treemap-seek (%tree m) pred (lambda (r k v) (values k v)) failure))
(define (mapping-count pred m)
(assert (mapping? m))
(mapping-fold (lambda (k v c) (if (pred k v) (+ c 1) c)) 0 m))
(define (mapping-any? pred m)
(assert (mapping? m))
(treemap-seek (%tree m) pred (lambda (r k v) #t) (lambda () #f)))
(define (mapping-every? pred m)
(assert (mapping? m))
(treemap-seek (%tree m)
(lambda (k v) (not (pred k v)))
(lambda (r k v) #f) (lambda () #t)))
(define (mapping-keys m) (treemap-keys-list (%tree m)))
(define (mapping-values m) (treemap-values-list (%tree m)))
(define (mapping-entries m)
(let ((t (%tree m)))
(values (treemap-keys-list t) (treemap-values-list t))))
(define (mapping-map proc comparator m)
(assert (mapping? m))
(assert (comparator? comparator))
(let ((r (make-mapping comparator)))
(treemap-for-each (lambda (k v)
(let-values (((k v) (proc k v)))
(mapping-set! r k v))) (%tree m))
r))
(define (mapping-for-each proc m)
(assert (mapping? m))
(treemap-for-each proc (%tree m)))
(define (mapping-map->list proc m)
(assert (mapping? m))
(treemap-map proc (%tree m)))
(define (mapping-filter pred m)
(assert (mapping? m))
(mapping-filter! pred (mapping-copy m)))
(define (mapping-filter! pred m)
(assert (mapping? m))
(let-values (((keys values) (mapping-entries m)))
(for-each (lambda (k v)
(unless (pred k v)
(mapping-delete! m k))) keys values))
m)
(define (mapping-remove pred m)
(assert (mapping? m))
(mapping-remove! pred (mapping-copy m)))
(define (mapping-remove! pred m)
(assert (mapping? m))
(mapping-filter! (lambda (k v) (not (pred k v))) m))
(define (mapping-partition pred m)
(assert (mapping? m))
(mapping-partition! pred (mapping-copy m)))
(define (mapping-partition! pred m)
(assert (mapping? m))
(let ((r (make-mapping (mapping-key-comparator m))))
(let-values (((keys values) (mapping-entries m)))
(for-each (lambda (k v)
(unless (pred k v)
(mapping-delete! m k)
(mapping-set! r k v))) keys values))
(values m r)))
(define (alist->mapping comparator alist)
(assert (comparator? comparator))
(alist->mapping! (make-mapping comparator) alist))
(define (alist->mapping! m alist)
(assert (mapping? m))
(for-each (lambda (p) (mapping-adjoin! m (car p) (cdr p))) alist)
m)
(define alist->mapping/ordered alist->mapping)
(define alist->mapping/ordered! alist->mapping!)
(define (mapping->alist m)
(assert (mapping? m))
(mapping-map->list cons m))
(define (%mapping-compare who v=? pred ms)
(define (mapping-compare-as-sets m1 m2 value=?)
(define eof (cons #f #f))
(define kc1 (mapping-key-comparator m1))
(define kc2 (mapping-key-comparator m2))
(define (key-compare key1 key2) (comparator-compare kc1 key1 key2))
(cond ((eq? m1 m2) 0)
((not (eq? kc1 kc2)) #f)
(else
(let ((i1 (treemap-iterator (%tree m1)))
(i2 (treemap-iterator (%tree m2))))
(define (loop k1 v1 k2 v2 r)
(if (eq? k1 eof)
(cond ((eq? k2 eof) r)
((<= r 0) -1)
(else #f))
(if (eq? k2 eof)
(if (>= r 0) 1 #f)
(case (key-compare k1 k2)
((0) (and (value=? v1 v2)
(let-values (((k1 v1) (i1 eof))
((k2 v2) (i2 eof)))
(loop k1 v1 k2 v2 r))))
((-1) (and (>= r 0)
(let-values (((k1 v1) (i1 eof)))
(loop k1 v1 k2 v2 1))))
(else (and (<= r 0)
(let-values (((k2 v2) (i2 eof)))
(loop k1 v1 k2 v2 -1))))))))
(let-values (((k1 v1) (i1 eof))
((k2 v2) (i2 eof)))
(loop k1 v1 k2 v2 0))))))
(let loop ((ms ms))
(cond ((null? (cdr ms)))
((mapping-compare-as-sets (car ms) (cadr ms) v=?)
=> (lambda (r) (and (pred r) (loop (cdr ms)))))
(else #f))))
(define-syntax define-mapping-compare
(syntax-rules ()
((_ name op)
(define (name vcmp m . more)
(assert (comparator? vcmp))
(%mapping-compare 'name
(comparator-equality-predicate vcmp)
(lambda (x) (op x 0))
(cons m more))))))
(define-mapping-compare mapping=? =)
(define-mapping-compare mapping<? <)
(define-mapping-compare mapping<=? <=)
(define-mapping-compare mapping>? >)
(define-mapping-compare mapping>=? >=)
(define (mapping-union! m1 . more)
(define (union-2 m1 m2)
(assert (mapping? m1))
(assert (mapping? m2))
(mapping-for-each (lambda (k v) (mapping-adjoin! m1 k v)) m2)
m1)
(if (null? more)
m1
(apply mapping-union! (union-2 m1 (car more)) (cdr more))))
(define (mapping-union m1 . more)
(apply mapping-union! (mapping-copy m1) more))
(define (mapping-intersection! m1 . more)
(define (intersection-2 m1 m2)
(assert (mapping? m1))
(assert (mapping? m2))
(for-each (lambda (k)
(unless (mapping-contains? m2 k)
(mapping-delete! m1 k))) (mapping-keys m1))
m1)
(if (null? more)
m1
(apply mapping-intersection! (intersection-2 m1 (car more)) (cdr more))))
(define (mapping-intersection m1 . more)
(apply mapping-intersection! (mapping-copy m1) more))
(define (mapping-difference! m1 . more)
(define (difference-2 m1 m2)
(assert (mapping? m1))
(assert (mapping? m2))
(mapping-for-each (lambda (k v) (mapping-delete! m1 k)) m2)
m1)
(if (null? more)
m1
(apply mapping-difference! (difference-2 m1 (car more)) (cdr more))))
(define (mapping-difference m1 . more)
(apply mapping-difference! (mapping-copy m1) more))
(define (mapping-xor! m1 m2)
(assert (mapping? m1))
(assert (mapping? m2))
(mapping-for-each (lambda (k v)
(if (mapping-contains? m1 k)
(mapping-delete! m1 k)
(mapping-set! m1 k v))) m2)
m1)
(define (mapping-xor m1 m2) (mapping-xor! (mapping-copy m1) m2))
(define (mapping-min-key m)
(assert (mapping? m))
(let-values (((k v) (treemap-first-entry (%tree m)))) k))
(define (mapping-max-key m)
(assert (mapping? m))
(let-values (((k v) (treemap-last-entry (%tree m)))) k))
(define (mapping-min-value m)
(assert (mapping? m))
(let-values (((k v) (treemap-first-entry (%tree m)))) v))
(define (mapping-max-value m)
(assert (mapping? m))
(let-values (((k v) (treemap-last-entry (%tree m)))) v))
(define (mapping-key-predecessor m key failure)
(define (wrapped) (values (failure) #f))
(assert (mapping? m))
(let-values (((k v) (treemap-lower-entry (%tree m) key wrapped))) k))
(define (mapping-key-successor m key failure)
(define (wrapped) (values (failure) #f))
(assert (mapping? m))
(let-values (((k v) (treemap-higher-entry (%tree m) key wrapped))) k))
(define-syntax define-mapping-range
(syntax-rules ()
((_ name! name op)
(begin
(define (name! m probe)
(assert (mapping? m))
(let ((c (mapping-key-comparator m)))
(for-each (lambda (k)
(unless (op (comparator-compare c k probe) 0)
(mapping-delete! m k))) (mapping-keys m)))
m)
(define (name m probe)
(name! (mapping-copy m) probe))))))
(define-mapping-range mapping-range=! mapping-range= =)
(define-mapping-range mapping-range<! mapping-range< <)
(define-mapping-range mapping-range<=! mapping-range<= <=)
(define-mapping-range mapping-range>! mapping-range> >)
(define-mapping-range mapping-range>=! mapping-range>= >=)
(define (mapping-split m probe)
(assert (mapping? m))
(values (mapping-range< m probe)
(mapping-range<= m probe)
(mapping-range= m probe)
(mapping-range>= m probe)
(mapping-range> m probe)))
(define (mapping-catenate! comparator m1 key value m2)
(define (too-small key m)
(error 'mapping-catenate! "Catenating key is too small " key m))
(define (too-large key m)
(error 'mapping-catenate! "Catenating key is too large" key m))
(cond ((eq? comparator (mapping-key-comparator m1))
;; Reuse m1
(when (and (not (mapping-empty? m1))
(>= (comparator-compare comparator
(mapping-max-key m1) key) 0))
(too-small key m1))
(mapping-set! m1 key value)
(mapping-for-each (lambda (k v)
(when (<= (comparator-compare comparator k key) 0)
(too-large key m2))
(mapping-set! m1 k v))
m2)
m1)
((eq? comparator (mapping-key-comparator m2))
;; Reuse m2
(when (and (not (mapping-empty? m2))
(>= (comparator-compare comparator
(mapping-max-key m2) key) 0))
(too-large key m2))
(mapping-set! m2 key value)
(mapping-for-each (lambda (k v)
(when (>= (comparator-compare comparator k key) 0)
(too-small key m1))
(mapping-set! m2 k v))
m1)
m2)
(else
(let ((m (make-mapping comparator)))
(mapping-set! m key value)
(mapping-for-each
(lambda (k v)
(when (>= (comparator-compare comparator k key) 0)
(too-small key m1))
(mapping-set! m k v))
m1)
(mapping-for-each
(lambda (k v)
(when (<= (comparator-compare comparator k key) 0)
(too-large key m2))
(mapping-set! m k v))
m2)
m))))
(define (mapping-catenate comparator m1 key value m2)
;; inefficient...
(mapping-catenate! comparator (mapping-copy m1) key value (mapping-copy m2)))
(define mapping-map/monotone! mapping-map)
(define mapping-map/monotone mapping-map)
(define (mapping-fold/reverse kons knil m)
(assert (mapping? m))
(treemap-fold-reverse kons (%tree m) knil))
(define (make-mapping-compare value-comparator)
(define (mapping-compare m1 m2)
(define eof (cons #f #f))
(define kc1 (mapping-key-comparator m1))
(define kc2 (mapping-key-comparator m2))
(define (key-compare key1 key2) (comparator-compare kc1 key1 key2))
(unless (eq? kc1 kc2)
(error 'mapping-comparator "Mapping key comparaters are not the same"
m1 m2))
(cond ((eq? m1 m2) 0)
(else
(let ((i1 (treemap-iterator (%tree m1)))
(i2 (treemap-iterator (%tree m2))))
(define (loop k1 v1 k2 v2)
(if (eq? k1 eof)
(if (eq? k2 eof) 0 -1)
(if (eq? k2 eof)
1
(case (key-compare k1 k2)
((0)
(case (comparator-compare value-comparator v1 v2)
((0) (let-values (((k1 v1) (i1 eof))
((k2 v2) (i2 eof)))
(loop k1 v1 k2 v2)))
(else => values)))
(else => values)))))
(let-values (((k1 v1) (i1 eof))
((k2 v2) (i2 eof)))
(loop k1 v1 k2 v2))))))
mapping-compare)
(define (make-mapping-comparator value-comparator)
(make-comparator mapping? #t (make-mapping-compare value-comparator) #f))
(define mapping-comparator (make-mapping-comparator default-comparator))
(define default-mapping-compare (make-mapping-compare default-comparator))
(define-method object-compare ((m1 mapping) (m2 mapping))
(default-mapping-compare m1 m2))
;; for SRFI 128
(define dummy
(comparator-register-default! mapping-comparator))
)
| true |
933580e69c7a4f5180f3b25fa47fcc11f8226ea1
|
3323fb4391e76b853464a9b2fa478cd7429e9592
|
/exercise-1.37.ss
|
4810862c78580ff51ce6859fa73afe3028b9e5ef
|
[] |
no_license
|
simpleliangsl/hello-scheme
|
ceb203933fb056523f5288ce716569096a71ad97
|
31434fb810475ee0e8ec2e6816995a0041c47f44
|
refs/heads/master
| 2023-06-16T12:07:28.744188 | 2021-07-15T06:39:32 | 2021-07-15T06:39:32 | 386,197,304 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 111 |
ss
|
exercise-1.37.ss
|
(load "cont-frac.ss")
(define (fai k)
(+ 1
(cont-frac (lambda (i) 1.0) (lambda (i) 1.0) k)
)
)
| false |
27d14d9ada43f5f533f77a33fd304f7dbc2717bd
|
b199cdd5dc5b15468bed3819a3d79b8d66c69a0b
|
/scheme/bootstrap/syntax.scm
|
57797bac1d1090ccd47a188a27024cb463382118
|
[
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
nilern/Hiss
|
a449441f4c4c135564dbd10a6fa2cc269d068134
|
cdf4453e547bb4d37a5c60580ef864f363180a9d
|
refs/heads/master
| 2020-07-03T22:13:24.754379 | 2017-03-16T17:42:32 | 2017-03-16T17:42:32 | 74,226,804 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 992 |
scm
|
syntax.scm
|
;(define-syntax let
; (lambda (stx)
; (let* ((sexp (syntax-e stx))
; (bindings (syntax-e (cadr sexp)))
; (body (cddr sexp))
; (formals (map (comp car syntax-e) bindings))
; (args (map (comp cadr syntax-e) bindings)))
; (datum->syntax stx
; (list*
; (datum->syntax stx
; (list* (syntax lambda) (datum->syntax (cadr sexp) formals)
; body))
; args)))))
(define-syntax let
(lambda (stx)
((lambda (sexp)
(datum->syntax stx
(list*
(datum->syntax stx
(list* (syntax lambda)
(datum->syntax (cadr sexp)
(map (lambda (stx) (car (syntax-e stx)))
(syntax-e (cadr sexp))))
(cddr sexp)))
(map (lambda (stx) (cadr (syntax-e stx)))
(syntax-e (cadr sexp))))))
(syntax-e stx))))
(let ((a 3)
(b 5))
(list a b))
| true |
8cd4da5bff6c5c8317cc7fba16ef756238d666b3
|
6cf2e78840970768168f583716e8826b1902dafa
|
/learning-functional/work-in-university/home-practice/scheme-practice/part-2-recursion/solutions/digit_at_position.scm
|
8c80d90104824f0bce0b7b2eae5ac7ee1cce9e15
|
[] |
no_license
|
dianvaltodorov/learning-code
|
e4b3e5034c68cdf9d1e38f8b6a12af1d51d2e167
|
a92605345829e051c0b2420de6f3dfc1fe5eb65a
|
refs/heads/master
| 2021-01-17T12:24:58.618311 | 2016-02-02T17:48:55 | 2018-06-21T06:53:16 | 49,488,021 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 299 |
scm
|
digit_at_position.scm
|
(load "../../lib/unit.scm")
(load "fast_expt.scm")
(load "count_digits.scm")
(define (digit-at-pos x position)
(remainder (quotient x
(fast-exp 10
(- (count-digits-iter x)
position)))
10))
| false |
52ee9d805f11d397c9acfca55779896f086b4274
|
a968f55cb9b7a38be2978beecaa52a910721fcd9
|
/plc/10.ss
|
dc117d62040ae5ff6a2af20e736a44e8c3caccb0
|
[] |
no_license
|
fromasmtodisasm/rose_backup
|
bc4265922e8cb568f34f0a218a5963d290226b07
|
5899ef5b5ad4208250a0fea0307d90f0599bb524
|
refs/heads/master
| 2021-05-27T19:55:21.974510 | 2012-04-20T03:34:31 | 2012-04-20T03:34:31 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,947 |
ss
|
10.ss
|
(define-datatype expression expression? ; based on the simple expression grammar, EoPL-2 p6
(lit-exp
(id (lambda (x) (or (symbol? x) (boolean? x) (number? x) (string? x) (vector? x) (null? x)))))
(lambda-exp
(id (lambda (x) (or (symbol? x) (pair? x) (null? x))))
(body (list-of expression?)))
(app-exp
(rator (lambda (x) (map expression? x))))
(let-exp
(kind symbol?)
(assignments expression?)
(body (list-of expression?)))
(named-let-exp
(name symbol?)
(assignments expression?)
(body (list-of expression?)))
(set!-exp
(var symbol?)
(body expression?))
(if-exp
(test-exp expression?)
(true-exp expression?)
(false-exp expression?))
(if-2-exp
(test-exp expression?)
(true-exp expression?)))
(define list-of
(lambda (pred)
(lambda (val)
(or (null? val)
(and (pair? val)
(pred (car val))
((list-of pred) (cdr val)))))))
(define parse-exp
(lambda (datum)
(cond ((or (symbol? datum)
(boolean? datum)
(number? datum)
(string? datum)
(null? datum)
(vector? datum))
(lit-exp datum))
((and (eqv? (car datum) 'lambda) (validate-lambda datum))
(lambda-exp (cadr datum)
(map parse-exp (cddr datum))))
((and (eqv? (car datum) 'if) (validate-if datum) (eq? (length datum) 4))
(if-exp (parse-exp (cadr datum)) (parse-exp (caddr datum)) (parse-exp (cadddr datum))))
((and (eqv? (car datum) 'if) (validate-if datum))
(if-2-exp (parse-exp (cadr datum)) (parse-exp (caddr datum))))
((and (eqv? (car datum) 'set!) (validate-set datum))
(set!-exp (cadr datum) (parse-exp (caddr datum))))
((and (eqv? (car datum) 'let)
(> (length datum) 1)
(symbol? (cadr datum))
(validate-named-let datum))
(named-let-exp (cadr datum) (parse-exp (caddr datum)) (map parse-exp (cdddr datum))))
((and (or (eqv? (car datum) 'let)
(eqv? (car datum) 'let*)
(eqv? (car datum) 'letrec))
(validate-let datum))
(let-exp (car datum) (parse-exp (cadr datum)) (map parse-exp (cddr datum))))
(else
(if (list? datum)
(app-exp
(map parse-exp datum))
(eopl:error 'parse-exp "Not a proper list ~s" datum))))))
(define validate-lambda
(lambda (datum)
(if (> (length datum) 2)
(cond ((and (list? (cadr datum)) ((set-of symbol?) (cadr datum)) (not (andmap null? (cddr datum)))) #t)
((and (symbol? (cadr datum)) (not (andmap null? (cddr datum)))) #t)
((and (pair? (cadr datum)) (improper-set? (cadr datum)) (not (list? (cadr datum))) (not (andmap null? (cddr datum)))) #t)
(else
(eopl:error 'parse-exp "Invalid Lambda expression ~s" datum)))
(eopl:error 'parse-exp "Wrong number of args for lambda expression ~s" datum))))
(define improper-set?
(lambda (x)
(and (pair? x) (not (list? x)) (not (equal? (car x) (cdr x))))))
(define validate-named-let
(lambda (datum)
(if (> (length datum) 3)
(if (and (andmap list? (caddr datum))
((set-of symbol?) (map car (caddr datum))))
#t
(eopl:error 'parse-exp "Invalid let ~s" datum))
(eopl:error 'parse-exp "Invalid let ~s" datum))))
(define validate-let
(lambda (datum)
(if (> (length datum) 2)
(if (and (list? (cadr datum))
(list-of-2-lists? (cadr datum))
((set-of symbol?) (map car (cadr datum))))
#t
(eopl:error 'parse-exp "Invalid let 1 ~s" datum))
(eopl:error 'parse-exp "Invalid let 2 ~s" datum))))
(define valid-let-arg2?
(lambda (datum)
(and (list? datum)
(list-of-l2list? datum)
((set-of symbol?) (map car datum)))))
(define list-of-2-lists?
(lambda (lst)
(if (null? lst)
#t
(if (and (list? (car lst)) (= (length (car lst)) 2))
(list-of-2-lists? (cdr lst))
#f))))
(define set-of
(lambda (expr)
(lambda (datum)
(and ((list-of expr) datum)
(let loop ([datum datum])
(if (null? datum)
#t
(if (member (car datum) (cdr datum))
#f
(loop (cdr datum)))))))))
(define validate-set
(lambda (ls)
(if (and (eq? (length ls) 3) (symbol? (cadr ls)))
#t
(eopl:error 'parse-exp "Invalid set! ~s" ls))))
(define validate-if
(lambda (datum)
(if (or (eq? (length datum) 3) (eq? (length datum) 4))
#t
(eopl:error 'parse-exp "Invalid if ~s" datum))))
(define andmap
(lambda (func ls)
(or (null? ls)
(and (func (car ls))
(andmap func (cdr ls))))))
(define unparse-exp ; an inverse for parse-exp
(lambda (exp)
(cases expression exp
(lit-exp (id) id)
(lambda-exp (id body)
(append (list 'lambda id)
(map unparse-exp body)))
(if-exp (test-exp true-exp false-exp)
(list 'if (unparse-exp test-exp)
(unparse-exp true-exp)
(unparse-exp false-exp)))
(if-2-exp (test-exp true-exp)
(list 'if (unparse-exp test-exp)
(unparse-exp true-exp)))
(named-let-exp (name assignments body)
(append (list 'let name (unparse-exp assignments)) (map unparse-exp body)))
(let-exp (kind assignments body)
(append (list kind (unparse-exp assignments)) (map unparse-exp body)))
(set!-exp (var body)
(list 'set! var (unparse-exp body)))
(app-exp (rator)
(map unparse-exp rator)))))
| false |
c54b25f34305056fd8be8c79a3481f09ae2ccf4b
|
784dc416df1855cfc41e9efb69637c19a08dca68
|
/src/gerbil/prelude/gambit/threads.ss
|
608c75a162dde765bd015d90c04165cb3a6aec80
|
[
"LGPL-2.1-only",
"Apache-2.0",
"LGPL-2.1-or-later"
] |
permissive
|
danielsz/gerbil
|
3597284aa0905b35fe17f105cde04cbb79f1eec1
|
e20e839e22746175f0473e7414135cec927e10b2
|
refs/heads/master
| 2021-01-25T09:44:28.876814 | 2018-03-26T21:59:32 | 2018-03-26T21:59:32 | 123,315,616 | 0 | 0 |
Apache-2.0
| 2018-02-28T17:02:28 | 2018-02-28T17:02:28 | null |
UTF-8
|
Scheme
| false | false | 6,964 |
ss
|
threads.ss
|
;;; -*- Gerbil -*-
;;; (C) vyzo at hackzen.org
;;; thread primitives and gambit runtime symbols
package: gerbil/gambit
(export (except-out #t construct-actor-thread *thread-locals* *thread-locals-mutex*))
(extern namespace: #f
current-thread
thread?
make-thread
make-root-thread
thread-name
thread-specific
thread-specific-set!
thread-base-priority
thread-base-priority-set!
thread-priority-boost
thread-priority-boost-set!
thread-quantum
thread-quantum-set!
thread-start!
thread-yield!
thread-sleep!
thread-terminate!
thread-join!
thread-send
thread-receive
thread-mailbox-next
thread-mailbox-rewind
thread-mailbox-extract-and-rewind
mutex?
make-mutex
mutex-name
mutex-specific
mutex-specific-set!
mutex-state
mutex-lock!
mutex-unlock!
condition-variable?
make-condition-variable
condition-variable-name
condition-variable-specific
condition-variable-specific-set!
condition-variable-signal!
condition-variable-broadcast!
;; miscellanea
make-thread-group thread-group? thread-group-name
thread-group-specific thread-group-specific-set!
thread-group-parent thread-group-resume! thread-group-suspend!
thread-group-terminate! thread-group->thread-group-list
thread-group->thread-group-vector thread-group->thread-list
thread-group->thread-vector
thread-state thread-state-uninitialized? thread-state-initialized?
thread-state-running? thread-state-running-processor
thread-state-waiting? thread-state-waiting-for thread-state-waiting-timeout
thread-state-normally-terminated?
thread-state-normally-terminated-result
thread-state-abnormally-terminated?
thread-state-abnormally-terminated-reason
top thread-interrupt! thread-suspend! thread-resume!
thread-thread-group thread-init!
;; system processors
processor? current-processor processor-id
)
;;; spawn and friends
(def (spawn f . args)
(spawn-actor f args #!void #f))
(def (spawn/name name f . args)
(spawn-actor f args name #f))
(def (spawn/group name f . args)
(let (tgroup (make-thread-group name))
(spawn-actor f args name tgroup)))
(def (spawn-actor f args name tgroup)
(def (thread-main thunk)
;; install an abortive handler to force stack unwinding
;; this ensures that unwind-protect finalizers are invoked if
;; the actor exits with an unhandled exception.
;; debugging: when the unhandled-actor-exception-hook is set, then
;; it is invoked with the continuation and exception before unwinding
;; the stack.
;; in particular, set the hook to dump-stack-trace! to dump the
;; continuation backtrace together with the exception to ##stderr-port
(lambda ()
(with-exception-handler
(lambda (exn)
(##continuation-capture
(lambda (cont)
(when unhandled-actor-exception-hook
(with-catch void (cut unhandled-actor-exception-hook cont exn)))
;; unwind stack and continue with the primordial exception handler
;; see discussion in gambit#295 about ##continuation-last
(##continuation-graft
(##continuation-last cont)
##primordial-exception-handler
exn))))
thunk)))
(if (procedure? f)
(let ((thunk (if (null? args) f
(lambda () (apply f args))))
(tgroup (or tgroup (current-thread-group))))
(thread-start!
(thread-init!
(construct-actor-thread #f)
(thread-main thunk) name tgroup)))
(error "Bad argument; expected procedure" f)))
(extern
actor-thread? construct-actor-thread
actor-thread-locals actor-thread-locals-set!)
(begin-foreign
(namespace ("gerbil/gambit/threads#"
construct-actor-thread actor-thread?
actor-thread-locals actor-thread-locals-set!))
(define-type-of-thread actor-thread
constructor: construct-actor-thread
id: gerbil#actor-thread::t
locals))
(def (spawn-thread thunk (name absent-obj) (tgroup absent-obj))
(thread-start!
(make-thread thunk name tgroup)))
;;; thread locals
(def (thread-local-ref key (default absent-obj))
(let (tab (thread-local-table))
(hash-ref tab key default)))
(def (thread-local-get key)
(thread-local-ref key #f))
(def (thread-local-set! key value)
(let (tab (thread-local-table))
(hash-put! tab key value)))
(def (thread-local-clear! key)
(let (tab (thread-local-table))
(hash-remove! tab key)))
(def (thread-local-table)
(let (thr (current-thread))
(cond
((actor-thread? thr)
(cond
((actor-thread-locals thr) => values)
(else
(let (tab (make-hash-table-eq))
(actor-thread-locals-set! thr tab)
tab))))
((eq? thr ##primordial-thread)
*primordial-thread-locals*)
(else
(mutex-lock! *thread-locals-mutex*)
(cond
((hash-get *thread-locals* thr)
=> (lambda (tab)
(mutex-unlock! *thread-locals-mutex*)
tab))
(else
(let (tab (make-hash-table-eq))
(hash-put! *thread-locals* thr tab)
(mutex-unlock! *thread-locals-mutex*)
tab)))))))
(def *primordial-thread-locals*
(make-hash-table-eq))
(def *thread-locals*
(make-hash-table-eq weak-keys: #t))
(def *thread-locals-mutex*
(make-mutex 'thread-locals))
;;; actor debug hooks
(def unhandled-actor-exception-hook #f)
(def (unhandled-actor-exception-hook-set! proc)
(if (or (not proc) (procedure? proc))
(set! unhandled-actor-exception-hook proc)
(error "Bad argument; expected procedure or #f" proc)))
;; evaluate a thunk with an exception handler that dumps the stack trace
(def (with-exception-stack-trace thunk (error-port (current-error-port)))
(with-exception-handler
(let (E (current-exception-handler))
(lambda (exn)
(##continuation-capture
(lambda (cont)
(dump-stack-trace! cont exn error-port)
(E exn)))))
thunk))
;; hook to dump continuation backtraces to an error port
(extern dump-stack-trace!)
(begin-foreign
(namespace ("gerbil/gambit/threads#" dump-stack-trace!))
(define (dump-stack-trace! cont exn #!optional (error-port (current-error-port)))
(let ((out (open-output-string)))
(display "*** Unhandled exception in " out)
(display (current-thread) out)
(newline out)
(display-exception exn out)
(display "Continuation backtrace: " out)
(newline out)
(##display-continuation-backtrace
cont
out
#f ; display-env?
#f ; all-frames?
##backtrace-default-max-head
##backtrace-default-max-tail
0)
(##write-string (get-output-string out) error-port))))
;;; utitilities
(def (current-thread-group)
(thread-thread-group (current-thread)))
(def (with-lock mx proc)
(dynamic-wind
(cut mutex-lock! mx)
proc
(cut mutex-unlock! mx)))
| false |
88086d83a70fffa80e6cd44fa6716c1e7bc83978
|
9c105d2dcc2d17d61f24a9ce4b510fed696f3a65
|
/s03-to-c/examples/testand.scm
|
314b82dd57f2f2532dc59b33dec5dd68be6431e9
|
[] |
no_license
|
marcus3santos/wasCm
|
23e0dca9fabe14df47d0875f7a6c66b8c3f37223
|
594b541c47cf061d2f31ea1c6582eea6b0039d3a
|
refs/heads/master
| 2022-09-29T04:48:58.018517 | 2020-05-27T01:07:31 | 2020-05-27T01:07:31 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 238 |
scm
|
testand.scm
|
(letrec
[(fib (lambda(n) (// (&& (<fx n 2) (+fx n 1) )
(+fx (fib (-fx n 1))
(fib (-fx n 2))) )))]
(display (fib 0))
(display (fib 1))
(display (fib 2))
(display (fib 3))
(display (fib 4))
(display (fib 5)) )
| false |
b47be56a46bd984cac8cd7b6ea61eef6c00e7d51
|
464f876b034b518d8cf8a0b77ea4851f05148916
|
/Chapter2/ex2_60.scm
|
ca03919a82f0aa96a4cdbb98448a952491efa662
|
[] |
no_license
|
billy1kaplan/sicp
|
3302e6772af205fa8d1ac77c2d203cb329f5958b
|
71d3f93921e32567ae2becec3c9659cfdf013287
|
refs/heads/master
| 2021-03-22T01:01:15.409369 | 2019-02-10T04:13:56 | 2019-02-10T04:13:56 | 98,474,397 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 709 |
scm
|
ex2_60.scm
|
#lang sicp
(define (element-of-set? el set)
(cond ((null? set) #f)
((equal? el (car set)) #t)
(else (element-of-set? el (cdr set)))))
(define (adjoin-set el set)
(cons el set))
(define (union-set set1 set2)
(if (null? set1)
set2
(cons (car set1) (union-set (cdr set1) set2))))
; more concise (append set1 set2)
(define (intersection-set set1 set2)
(cond ((null? set1) '())
((element-of-set? (car set1) set2) (cons (car set1) (intersection-set (cdr set1) set2)))
(else (intersection-set (cdr set1) set2))))
(define set1 (list 1 2 3))
(define set2 (list 3 4 5))
(element-of-set? 3 set2)
(adjoin-set 4 set2)
(union-set set1 set2)
(intersection-set set1 set2)
| false |
2fec7ea7f68979ef1dec1de8f19302469bbe5e4e
|
d47ddad953f999e29ce8ef02b059f945c76a791e
|
/lab4/homeworks/03/tests.scm
|
5ba977cc49db370da7f84212781429ea2e65a483
|
[] |
no_license
|
IvanIvanov/fp2013
|
7f1587ef1f2261f8cd0cd3dd99ec147c4043a2ae
|
2ac1bb1102cb65e0ecbfa8d2fb3ca69953ae4ecf
|
refs/heads/master
| 2016-09-11T10:08:59.873239 | 2014-01-23T20:38:27 | 2014-01-23T20:40:34 | 13,211,029 | 5 | 2 | null | 2014-01-10T15:55:14 | 2013-09-30T09:18:33 |
Scheme
|
UTF-8
|
Scheme
| false | false | 669 |
scm
|
tests.scm
|
(load "cassie.scm")
(load "solution.scm")
(define-test accumulate-test
(assert (accumulate 1 10 0 + (lambda (x) x) (lambda (x) (+ x 1))) 55)
(assert (accumulate 1 10 1 * (lambda (x) x) (lambda (x) (+ x 1))) 3628800))
(define-test filter-and-accumulate-test
(assert (filter-and-accumulate even? 1 10 0 + (lambda (x) x) (lambda (x) (+ x 1))) 30)
(assert (filter-and-accumulate odd? 1 10 1 * (lambda (x) x) (lambda (x) (+ x 1))) 945))
(define-test divisor-count-test
(assert (divisor-count 10 1 10) 4)
(assert (divisor-count 4 1 10) 3)
(assert (divisor-count 42 1 10) 5))
(run-tests
accumulate-test
filter-and-accumulate-test
divisor-count-test)
| false |
eea28e5351cd6f4330cccd3b84dd0d53e09fb43f
|
b43e36967e36167adcb4cc94f2f8adfb7281dbf1
|
/sicp/ch4/exercises/4.7.scm
|
47e7a06f44ccaa76c287d0969c476c1d03e43066
|
[] |
no_license
|
ktosiu/snippets
|
79c58416117fa646ae06a8fd590193c9dd89f414
|
08e0655361695ed90e1b901d75f184c52bb72f35
|
refs/heads/master
| 2021-01-17T08:13:34.067768 | 2016-01-29T15:42:14 | 2016-01-29T15:42:14 | 53,054,819 | 1 | 0 | null | 2016-03-03T14:06:53 | 2016-03-03T14:06:53 | null |
UTF-8
|
Scheme
| false | false | 347 |
scm
|
4.7.scm
|
(define (let*? exp)
(tagged-list? exp 'let*))
(define (let*->nested-let exp)
(let ((let*-body (caddr exp))
(let*-binds (cadr exp)))
(define (build-let binds)
(if (null? binds)
let*-body
(list 'let
(list (car binds))
(build-let (cdr binds)))))
(build-let let*-binds)))
| false |
33f2d70d1f7f4800400edfc2998c685c3efc1c42
|
a6a1c8eb973242fd2345878e5a871a89468d4080
|
/3.30.scm
|
d49480d5c7d5ca3f57045c33413c231c095abfd3
|
[] |
no_license
|
takkyuuplayer/sicp
|
ec20b6942a44e48d559e272b07dc8202dbb1845a
|
37aa04ce141530e6c9803c3c7122016d432e924b
|
refs/heads/master
| 2021-01-17T07:43:14.026547 | 2017-02-22T03:40:07 | 2017-02-22T03:40:07 | 15,771,479 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 548 |
scm
|
3.30.scm
|
; 3.30
(define (ripple-carry-adder list-a list-b list-s c-out)
(let ((a (car list-a))
(b (car list-b))
(sum (car list-s))
(c-in (make-wire))
)
(if (null? a)
(set-signal! c-in 0)
(ripple-carry-adder (cdr list-a) (cdr list-b) (cdr list-s) c-in)
)
(full-adder a b c-in sum c-out)
))
; delay
; half-adder-delay = max of ( inverter-delay + 2 * and-gate-delay, or-gate-delay + and-gate-delaoy)
; full-adder-delay = 2 * half-adder-delay + or-gate-delay
; total-delay = n * full-adder-delay
| false |
c31b9bf9fe670591f7b517859b6090d756446496
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/internal/exclude-from-docs-attribute.sls
|
5985d008865b5c3500887dba6dbe01ab46646967
|
[] |
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 | 524 |
sls
|
exclude-from-docs-attribute.sls
|
(library (unity-engine internal exclude-from-docs-attribute)
(export new is? exclude-from-docs-attribute?)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
UnityEngine.Internal.ExcludeFromDocsAttribute
a
...)))))
(define (is? a)
(clr-is UnityEngine.Internal.ExcludeFromDocsAttribute a))
(define (exclude-from-docs-attribute? a)
(clr-is UnityEngine.Internal.ExcludeFromDocsAttribute a)))
| true |
5212df595b30b2615c199f415df588c76c74fa38
|
38fcd70df648a497ee1271fcdbd30e391fb310e5
|
/pass2/pass2/pass2.tests.sch
|
b8ac5f8f4f0efc1f6012a9e061ae2145787076ac
|
[] |
no_license
|
liutanyu/Useful
|
e9b3d3699dffa21bb1425dddff7d150ab7d7aee7
|
11a123126833e577a76ce32c22d8563c0f2bbd7d
|
refs/heads/master
| 2021-01-19T11:34:24.259506 | 2013-07-17T04:13:22 | 2013-07-17T04:13:22 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 11,550 |
sch
|
pass2.tests.sch
|
; Test data.
; MAKE-READABLE strips the referencing information
; and replaces (begin I) by I.
(define (make-readable exp)
(case (car exp)
((quote) exp)
((lambda) `(lambda ,(lambda.args exp)
,@(map (lambda (def)
`(define ,(def.lhs def)
,(make-readable (def.rhs def))))
(lambda.defs exp))
,(make-readable (lambda.body exp))))
((set!) `(set! ,(assignment.lhs exp)
,(make-readable (assignment.rhs exp))))
((if) `(if ,(make-readable (if.test exp))
,(make-readable (if.then exp))
,(make-readable (if.else exp))))
((begin) (if (variable? exp)
(variable.name exp)
`(begin ,@(map make-readable (begin.exprs exp)))))
(else `(,(make-readable (call.proc exp))
,@(map make-readable (call.args exp))))))
; MAKE-UNREADABLE does the reverse.
; It assumes there are no internal definitions.
(define (make-unreadable exp)
(cond ((symbol? exp) (list 'begin exp))
((pair? exp)
(case (car exp)
((quote) exp)
((lambda) (list 'lambda
(cadr exp)
'(begin)
'(() ())
(make-unreadable (cons 'begin (cddr exp)))))
((set!) (list 'set! (cadr exp) (make-unreadable (caddr exp))))
((if) (list 'if
(make-unreadable (cadr exp))
(make-unreadable (caddr exp))
(if (= (length exp) 3)
(list 'quote #!unspecified)
(make-unreadable (cadddr exp)))))
((begin) (if (= (length exp) 2)
(make-unreadable (cadr exp))
(cons 'begin (map make-unreadable (cdr exp)))))
(else (map make-unreadable exp))))
(else (list 'quote exp))))
; ANNOTATE takes an expression in the format accepted by pass 2
; and returns a copy of the expression with freshly computed
; referencing and free variable information.
(define (annotate exp)
; (f x e np) returns a copy of the expression x, using the environment e
; to accumulate referencing information and the notepad np to accumulate
; free variable information.
;
; The environment e has the form
; ((<identifier> <references> <assignments> <calls>) ...)
; so the operations on R-tables can be used on environments.
(define (f x e np)
(case (car x)
((quote) (list 'quote (cadr x)))
((begin) (if (variable? x)
(let* ((name (variable.name x))
(var (make-variable name))
(entry (R-entry e name)))
(notepad-var-add! np name)
(if entry
(R-entry.references-set!
entry
(cons var (R-entry.references entry))))
var)
(cons 'begin
(map (lambda (x) (f x e np))
(begin.exprs x)))))
((lambda) (let* ((entries
(map (lambda (name) (make-R-entry name '() '() '()))
(append (map def.lhs (lambda.defs x))
(make-null-terminated
(lambda.args x)))))
(e2 (append entries e))
(newnotepad (make-notepad x))
(newdefs (map (lambda (def)
(list 'define
(def.lhs def)
(f (def.rhs def) e2 newnotepad)))
(lambda.defs x)))
(y (f (lambda.body x) e2 newnotepad)))
(list 'lambda
(copy (lambda.args x))
(cons 'begin newdefs)
(list 'quote
(list entries
(union (notepad.vars newnotepad)
(apply union
(map (lambda (formals free)
(difference free formals))
(map make-null-terminated
(map lambda.args
(map def.rhs newdefs)))
(map lambda.F
(map def.rhs newdefs)))))))
y)))
((set!) (let ((y (list 'set!
(assignment.lhs x)
(f (assignment.rhs x) e np)))
(entry (R-entry e (assignment.lhs x))))
(if entry
(R-entry.assignments-set! entry
(cons y (R-entry.assignments entry))))
y))
((if) (list 'if
(f (if.test x) e np)
(f (if.then x) e np)
(f (if.else x) e np)))
(else (let ((proc (f (call.proc x) e np))
(args (map (lambda (y) (f y e np)) (call.args x))))
(let ((y (make-call proc args)))
(if (variable? proc)
(let ((entry (R-entry e (variable.name proc))))
(if entry
(R-entry.calls-set! entry
(cons y (R-entry.calls entry))))))
y)))))
(f exp '() (make-notepad #f)))
; Copies a list structure, preserving sharing relationships.
(define (copy x)
(define (copy x e k)
(cond ((not (pair? x))
(k x e))
((assq x e)
(k (cdr (assq x e)) e))
(else (let* ((p (cons '* '*))
(e2 (cons (cons x p) e)))
(copy (car x)
e2
(lambda (y e3)
(set-car! p y)
(copy (cdr x)
e3
(lambda (y e4)
(set-cdr! p y)
(k p e4)))))))))
(copy x '() (lambda (x e) x)))
(define (f x)
(pretty-print (make-readable x))
(let ((y (pass2 x)))
(pretty-print (make-readable y))
(pretty-print y)))
; (define (loop n)
; (if (zero? n)
; 'done
; (loop (- n 2))))
(define (test0)
(f (annotate
(make-unreadable
'(set! loop
(lambda (z)
((lambda (loop)
(begin
(set! loop
(lambda (n)
(if (zero? n) 'done (loop (- n 1)))))
((lambda () (loop z)))))
#!unspecified)))))))
; (define (loop n)
; (set! n (+ n 1))
; (if (zero? n)
; 'done
; (loop (- n 2))))
(define (test1)
(f (annotate
(make-unreadable
'(set! loop
(lambda (z)
((lambda (loop)
(begin
(set! loop
(lambda (n)
(begin (set! n (1+ n))
(if (zero? n) 'done (loop (- n 2))))))
((lambda () (loop z)))))
#!unspecified)))))))
; (define (reverse x)
; (define (loop x y)
; (if (null? x)
; y
; (loop (cdr x) (cons (car x) y))))
; (loop x '()))
(define (test2)
(f (annotate
(make-unreadable
'(set! rev
(lambda (z)
((lambda (reverse)
(begin
(set! reverse
(lambda (w)
((lambda (loop)
(begin
(set! loop
(lambda (x y)
(if (null? x)
y
(loop (cdr x)
(cons (car x) y)))))
((lambda ()
(loop w '())))))
#!unspecified)))
((lambda ()
(reverse z)))))
#!unspecified)))))))
(define (test3) #t)
; (define (length x)
; (do ((x x (cdr x))
; (n 0 (+ n 1)))
; ((null? x) n)))
(define (test4)
(f (annotate
(make-unreadable
'(set! len
(lambda (z)
((lambda (length)
(begin
(set! length
(lambda (w)
((lambda (DO18)
(begin
(set! DO18
(lambda (x n)
(if (null? x)
n
(DO18 (cdr x) (1+ n)))))
((lambda ()
(DO18 w 0)))))
#!unspecified)))
((lambda ()
(length z)))))
#!unspecified)))))))
; (define (ip v1 v2)
; (define (loop i sum)
; (if (negative? i)
; sum
; (loop (- i 1)
; (+ sum (* (vector-ref v1 i)
; (vector-ref v2 i))))))
; (define n (vector-length v1))
; (if (= n (vector-length v2))
; (loop (- n 1) 0)
; (error ...)))
(define (test5)
(f (annotate
(make-unreadable
'(set! ip
(lambda (z1 z2)
((lambda (ip)
(begin
(set! ip
(lambda (v1 v2)
((lambda (loop n)
(begin
(set! loop
(lambda (i sum)
(if (> 0 i)
sum
(loop (- i 1)
(+ sum
(* (vector-ref v1 i)
(vector-ref v2
i)))))))
(set! n (vector-length v1))
((lambda ()
(if (= n (vector-length v2))
(loop (- n 1) 0)
(error ...))))))
#!unspecified
#!unspecified)))
((lambda ()
(ip z1 z2)))))
#!unspecified)))))))
| false |
3e1e96576f88b47d1b5a3cbe2d89e519233039b5
|
58381f6c0b3def1720ca7a14a7c6f0f350f89537
|
/Chapter 1/1.2/Ex1.16.scm
|
36066e4acda205344d8f3c083b3e4fb0f00e7532
|
[] |
no_license
|
yaowenqiang/SICPBook
|
ef559bcd07301b40d92d8ad698d60923b868f992
|
c8a0228ebf66d9c1ddc5ef1fcc1d05d8684f090a
|
refs/heads/master
| 2020-04-19T04:03:15.888492 | 2015-11-02T15:35:46 | 2015-11-02T15:35:46 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 275 |
scm
|
Ex1.16.scm
|
(define (square n) (* n n))
(define (fast-expt2 a b)
(define (fast-expt-helper a b n)
(cond ((= n 0) a)
((even? n) (fast-expt-helper a (square b) (/ n 2)))
((odd? n) (fast-expt-helper (* a b) b (- n 1)))))
(fast-expt-helper 1 a b))
(fast-expt2 2 18)
| false |
64b7767e1c14c90e7f43b0db2a43f152c9ab5831
|
6b288a71553cf3d8701fe7179701d100c656a53c
|
/s/5_2.ss
|
f639471c143c50163c6a1603ca385e436bb2624e
|
[
"Apache-2.0"
] |
permissive
|
cisco/ChezScheme
|
03e2edb655f8f686630f31ba2574f47f29853b6f
|
c048ad8423791de4bf650fca00519d5c2059d66e
|
refs/heads/main
| 2023-08-26T16:11:15.338552 | 2023-08-25T14:17:54 | 2023-08-25T14:17:54 | 56,263,501 | 7,763 | 1,410 |
Apache-2.0
| 2023-08-28T22:45:52 | 2016-04-14T19:10:25 |
Scheme
|
UTF-8
|
Scheme
| false | false | 27,067 |
ss
|
5_2.ss
|
;;; 5_2.ss
;;; Copyright 1984-2017 Cisco Systems, Inc.
;;;
;;; 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.
;;; list and pair functions
(begin
(define atom?
(lambda (x)
(not (pair? x))))
(define list?
(lambda (x)
(let loop ([hare x] [tortoise x])
(if (pair? hare)
(let ([hare (cdr hare)])
(if (pair? hare)
(and (not (eq? hare tortoise))
(loop (cdr hare) (cdr tortoise)))
(null? hare)))
(null? hare)))))
(define null?
(lambda (x)
(eq? x '())))
(define caar (lambda (x) (#2%caar x)))
(define cadr (lambda (x) (#2%cadr x)))
(define cdar (lambda (x) (#2%cdar x)))
(define cddr (lambda (x) (#2%cddr x)))
(define caaar (lambda (x) (#2%caaar x)))
(define caadr (lambda (x) (#2%caadr x)))
(define cadar (lambda (x) (#2%cadar x)))
(define caddr (lambda (x) (#2%caddr x)))
(define cdaar (lambda (x) (#2%cdaar x)))
(define cdadr (lambda (x) (#2%cdadr x)))
(define cddar (lambda (x) (#2%cddar x)))
(define cdddr (lambda (x) (#2%cdddr x)))
(define caaaar (lambda (x) (#2%caaaar x)))
(define caaadr (lambda (x) (#2%caaadr x)))
(define caadar (lambda (x) (#2%caadar x)))
(define caaddr (lambda (x) (#2%caaddr x)))
(define cadaar (lambda (x) (#2%cadaar x)))
(define cadadr (lambda (x) (#2%cadadr x)))
(define caddar (lambda (x) (#2%caddar x)))
(define cadddr (lambda (x) (#2%cadddr x)))
(define cdaaar (lambda (x) (#2%cdaaar x)))
(define cdaadr (lambda (x) (#2%cdaadr x)))
(define cdadar (lambda (x) (#2%cdadar x)))
(define cdaddr (lambda (x) (#2%cdaddr x)))
(define cddaar (lambda (x) (#2%cddaar x)))
(define cddadr (lambda (x) (#2%cddadr x)))
(define cdddar (lambda (x) (#2%cdddar x)))
(define cddddr (lambda (x) (#2%cddddr x)))
(define $list-length)
(define length)
(define list-ref)
(define list-tail)
(define list-head)
(let ()
(define improper-list-error
(lambda (who ls)
($oops who "~s is not a proper list" ls)))
(define circular-list-error
(lambda (who ls)
($oops who "~s is circular" ls)))
(define index-range-error
(lambda (who ls n)
($oops who "index ~s is out of range for list ~s" n ls)))
(define index-type-error
(lambda (who n)
($oops who "index ~s is not an exact nonnegative integer" n)))
(define index-range/improper-list-error
(lambda (who tail ls n)
(if (null? tail)
(index-range-error who ls n)
(improper-list-error who ls))))
(define list-length
(lambda (ls who)
(let loop ([hare ls] [i 0])
(if (pair? hare)
(let ([hare (cdr hare)])
(if (pair? hare)
(if (fx<= i 10000)
(loop (cdr hare) (fx+ i 2))
(let loop ([hare hare] [tortoise hare] [i (fx+ i 1)])
(if (pair? hare)
(let ([hare (cdr hare)])
(if (pair? hare)
(if (eq? hare tortoise)
(circular-list-error who ls)
(loop (cdr hare)
(cdr tortoise)
(fx+ i 2)))
(if (null? hare)
(fx+ i 1)
(improper-list-error who ls))))
(if (null? hare)
i
(improper-list-error who ls)))))
(if (null? hare)
(fx+ i 1)
(improper-list-error who ls))))
(if (null? hare)
i
(improper-list-error who ls))))))
(define list-tail-cycle
(lambda (ls n)
(let loop ((fast (cdr ls)) (i 1))
(if (eq? fast ls)
(let ((i (remainder n i)))
(do ((ls ls (cdr ls)) (i i (fx- i 1)))
((fx= i 0) ls)))
(loop (cdr fast) (fx+ i 1))))))
(define fx-list-tail
(lambda (fast slow i)
(if (fx> i 0)
(if (pair? fast)
(let ((fast (cdr fast)))
(if (fx> i 1)
(if (not (eq? fast slow))
(if (pair? fast)
(fx-list-tail (cdr fast) (cdr slow) (fx- i 2))
(values 'error fast i))
(values 'cycle fast (fx- i 1)))
(values 'okay fast (fx- i 1))))
(values 'error fast i))
(values 'okay fast i))))
(set! $list-length (lambda (ls who) (list-length ls who)))
(set! length
(lambda (ls)
(list-length ls 'length)))
(set! list-ref
(lambda (ls n)
(cond
[(and (fixnum? n) (fx<= 0 n 1000))
(let loop ([l ls] [i n])
(if (pair? l)
(if (fx> i 1)
(let ([l (cdr l)])
(if (pair? l)
(loop (cdr l) (fx- i 2))
(index-range/improper-list-error 'list-ref l ls n)))
(if (fx= i 0)
(car l)
(let ([l (cdr l)])
(if (pair? l)
(car l)
(index-range/improper-list-error 'list-ref l ls n)))))
(index-range/improper-list-error 'list-ref l ls n)))]
[(and (or (fixnum? n) (bignum? n)) (>= n 0))
(let ((m (min n (most-positive-fixnum))))
(call-with-values
(lambda () (fx-list-tail ls ls m))
(lambda (what fast i)
(cond
[(and (eq? what 'okay) (pair? fast))
; can't happen with bignum input
(car fast)]
[(eq? what 'cycle)
(car (list-tail-cycle fast (+ i (- n m))))]
[else (index-range/improper-list-error 'list-ref fast ls n)]))))]
[else (index-type-error 'list-ref n)])))
(set! list-tail
(lambda (ls n)
(cond
[(and (fixnum? n) (fx<= 0 n 1000))
(let loop ([l ls] [i n])
(if (fx> i 1)
(if (pair? l)
(let ([l (cdr l)])
(if (pair? l)
(loop (cdr l) (fx- i 2))
(index-range/improper-list-error 'list-tail l ls n)))
(index-range/improper-list-error 'list-tail l ls n))
(if (fx= i 0)
l
(if (pair? l)
(cdr l)
(index-range/improper-list-error 'list-tail l ls n)))))]
[(and (or (fixnum? n) (bignum? n)) (>= n 0))
(let ((m (min n (most-positive-fixnum))))
(call-with-values
(lambda () (fx-list-tail ls ls m))
(lambda (what fast i)
(cond
[(eq? what 'okay) ; can't happen with bignum input
fast]
[(eq? what 'cycle) (list-tail-cycle fast (+ i (- n m)))]
[else (index-range/improper-list-error 'list-tail fast ls n)]))))]
[else (index-type-error 'list-tail n)])))
(set! list-head
(lambda (orig-ls orig-n)
(unless (and (fixnum? orig-n) (fx>= orig-n 0))
($oops 'list-head "invalid index ~s" orig-n))
(let f ([ls orig-ls] [n orig-n])
(cond
[(fx<= n 1)
(if (fx= n 0)
'()
(if (pair? ls)
(list (car ls))
(index-range/improper-list-error 'list-head ls orig-ls orig-n)))]
[(pair? ls)
(let ([a (car ls)] [ls (cdr ls)])
(if (pair? ls)
(list* a (car ls) (f (cdr ls) (fx- n 2)))
(index-range/improper-list-error 'list-head ls orig-ls orig-n)))]
[else (index-range/improper-list-error 'list-head ls orig-ls orig-n)]))))
(set! last-pair
(lambda (ls)
(unless (pair? ls)
($oops 'last-pair "~s is not a pair" ls))
(let loop ((fast ls) (slow ls))
(let ((fast1 (cdr fast)))
(if (pair? fast1)
(let ((fast2 (cdr fast1)))
(if (pair? fast2)
(if (not (eq? fast1 slow))
(loop fast2 (cdr slow))
(circular-list-error 'last-pair ls))
fast1))
fast))))))
(define make-list
(rec make-list
(case-lambda
[(n) (make-list n (void))]
[(n x)
(unless (and (fixnum? n) (fx>= n 0))
($oops 'make-list "invalid size ~s" n))
(let loop ([n n] [ls '()])
(if (fx= n 0) ls (loop (fx- n 1) (cons x ls))))])))
(define-who list-copy
(lambda (ls)
($list-length ls who)
(let f ([ls ls])
(if (null? ls)
ls
(cons (car ls) (f (cdr ls)))))))
(define-who append
(rec append
(case-lambda
[() '()]
[(x1 x2)
($list-length x1 who)
(let f ([ls x1])
(if (null? ls) x2 (cons (car ls) (f (cdr ls)))))]
[(x1 . xr)
(let f ([x1 x1] [xr xr])
(if (null? xr) x1 (append x1 (f (car xr) (cdr xr)))))])))
(define-who append!
(let ()
(define (do-append! x1 x2)
(if (null? x1)
x2
(let f ([ls x1])
(if (null? (cdr ls))
(begin (set-cdr! ls x2) x1)
(f (cdr ls))))))
(case-lambda
[() '()]
[(x1 x2)
($list-length x1 who)
(do-append! x1 x2)]
[(x1 . xr)
(let f ([x1 x1] [xr xr])
(if (null? xr)
x1
(begin
($list-length x1 who) ; make sure all checks occur before first set-cdr!
(do-append! x1 (f (car xr) (cdr xr))))))])))
(define-who reverse
(lambda (ls)
($list-length ls who)
(do ([ls ls (cdr ls)] [a '() (cons (car ls) a)])
((null? ls) a))))
(define-who reverse!
(lambda (ls)
(#%$list-length ls who)
(let loop ([l ls] [a '()])
(cond
[(pair? l) (let ([x (cdr l)]) (set-cdr! l a) (loop x l))]
[(null? l) a]
[else
(let loop ([l a] [a l])
(let ([x (cdr l)]) (set-cdr! l a) (loop x l)))]))))
(let ()
(define-syntax do-assoc
(syntax-rules ()
((_ x alist who pred?)
(let loop ((fast alist) (slow alist))
(cond
[(pair? fast)
(let ((a (car fast)))
(if (pair? a)
(if (pred? (car a) x)
a
(let ((fast (cdr fast)))
(cond
[(pair? fast)
(let ((a (car fast)))
(if (pair? a)
(if (pred? (car a) x)
a
(if (eq? fast slow)
(cyclic-alist who alist)
(loop (cdr fast) (cdr slow))))
(improper-alist who alist)))]
[(null? fast) #f]
[else (improper-alist who alist)])))
(improper-alist who alist)))]
[(null? fast) #f]
[else (improper-alist who alist)])))))
(define improper-alist
(lambda (who alist)
($oops who "improperly formed alist ~s" alist)))
(define cyclic-alist
(lambda (who alist)
($oops who "cyclic alist ~s" alist)))
(define ass-eq?
(lambda (x alist who)
(do-assoc x alist who eq?)))
(set! assq
(lambda (x alist)
(ass-eq? x alist 'assq)))
(set! assv
(lambda (x alist)
(if (or (symbol? x) (#%$immediate? x))
(ass-eq? x alist 'assv)
(do-assoc x alist 'assv eqv?))))
(set! assoc
(lambda (x alist)
(cond
[(string? x)
(do-assoc x alist 'assoc
(lambda (x y) (and (string? x) (string=? x y))))]
[(or (symbol? x) (#%$immediate? x))
(ass-eq? x alist 'assoc)]
[else
(do-assoc x alist 'assoc equal?)])))
(set! assp
(lambda (pred? alist)
(unless (procedure? pred?)
($oops 'assp "~s is not a procedure" pred?))
(let loop ((fast alist) (slow alist))
(cond
[(pair? fast)
(let ((a (car fast)))
(if (pair? a)
(if (pred? (car a))
a
(let ((fast (cdr fast)))
(cond
[(pair? fast)
(let ((a (car fast)))
(if (pair? a)
(if (pred? (car a))
a
(if (eq? fast slow)
(cyclic-alist 'assp alist)
(loop (cdr fast) (cdr slow))))
(improper-alist 'assp alist)))]
[(null? fast) #f]
[else (improper-alist 'assp alist)])))
(improper-alist 'assp alist)))]
[(null? fast) #f]
[else (improper-alist 'assp alist)]))))
)
(let ()
(define improper-list
(lambda (who ls)
($oops who "improper list ~s" ls)))
(define cyclic-list
(lambda (who ls)
($oops who "cyclic list ~s" ls)))
(define-syntax do-member
(syntax-rules ()
((_ x ls who pred?)
(let loop ((fast ls) (slow ls))
(cond
[(pair? fast)
(if (pred? (car fast) x)
fast
(let ((fast (cdr fast)))
(cond
[(pair? fast)
(if (pred? (car fast) x)
fast
(if (eq? fast slow)
(cyclic-list who ls)
(loop (cdr fast) (cdr slow))))]
[(null? fast) #f]
[else (improper-list who ls)])))]
[(null? fast) #f]
[else (improper-list who ls)])))))
(define mem-eq?
(lambda (x ls who)
(do-member x ls who eq?)))
(set! memq
(lambda (x ls)
(mem-eq? x ls 'memq)))
(set! memv
(lambda (x ls)
(if (or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(mem-eq? x ls 'memv)
(do-member x ls 'memv eqv?))))
(set! member
(lambda (x ls)
(cond
[(string? x)
(do-member x ls 'member
(lambda (x y) (and (string? x) (string=? x y))))]
[(or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(mem-eq? x ls 'member)]
[else
(do-member x ls 'member equal?)])))
(set! memp
(lambda (pred? ls)
(unless (procedure? pred?)
($oops 'memp "~s is not a procedure" pred?))
(let loop ((fast ls) (slow ls))
(cond
[(pair? fast)
(if (pred? (car fast))
fast
(let ((fast (cdr fast)))
(cond
[(pair? fast)
(if (pred? (car fast))
fast
(if (eq? fast slow)
(cyclic-list 'memp ls)
(loop (cdr fast) (cdr slow))))]
[(null? fast) #f]
[else (improper-list 'memp ls)])))]
[(null? fast) #f]
[else (improper-list 'memp ls)]))))
(set! find
(lambda (pred? ls)
(unless (procedure? pred?)
($oops 'find "~s is not a procedure" pred?))
(let loop ((fast ls) (slow ls))
(cond
[(pair? fast)
(if (pred? (car fast))
(car fast)
(let ((fast (cdr fast)))
(cond
[(pair? fast)
(if (pred? (car fast))
(car fast)
(if (eq? fast slow)
(cyclic-list 'find ls)
(loop (cdr fast) (cdr slow))))]
[(null? fast) #f]
[else (improper-list 'find ls)])))]
[(null? fast) #f]
[else (improper-list 'find ls)]))))
)
(let ()
(define improper-list
(lambda (who ls)
($oops who "~s is not a proper list" ls)))
(define-syntax do-remove
(syntax-rules ()
((_ x ls pred?)
(let f ((x x) (fast ls) (slow ls))
(if (pair? fast)
(let ((fast1 (cdr fast)))
(if (pair? fast1)
(and (not (eq? fast1 slow))
(let ((fast2 (cdr fast1)))
(let ((rest (f x fast2 (cdr slow))))
(and rest
(if (not (pred? (car fast) x))
(if (not (pred? (car fast1) x))
(if (eq? rest fast2)
fast
(list* (car fast) (car fast1) rest))
(cons (car fast) rest))
(if (not (pred? (car fast1) x))
(if (eq? rest fast2)
fast1
(cons (car fast1) rest))
rest))))))
(and (null? fast1)
(if (not (pred? (car fast) x))
fast
'()))))
(and (null? fast) '()))))))
(define rem-eq?
(lambda (x l)
(do-remove x l eq?)))
(set! remq
(lambda (x ls)
(or (rem-eq? x ls)
(improper-list 'remq ls))))
(set! remv
(lambda (x ls)
(or (if (or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(rem-eq? x ls)
(do-remove x ls eqv?))
(improper-list 'remv ls))))
(set! remove
(lambda (x ls)
(or (cond
[(string? x)
(do-remove x ls
(lambda (x y) (and (string? x) (string=? x y))))]
[(or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(rem-eq? x ls)]
[else
(do-remove x ls equal?)])
(improper-list 'remove ls))))
(set! remp
(lambda (pred? ls)
(unless (procedure? pred?)
($oops 'remp "~s is not a procedure" pred?))
(or (let f ((pred? pred?) (fast ls) (slow ls))
(if (pair? fast)
(let ((fast1 (cdr fast)))
(if (pair? fast1)
(and (not (eq? fast1 slow))
(let ((fast2 (cdr fast1)))
(let ((rest (f pred? fast2 (cdr slow))))
(and rest
(if (not (pred? (car fast)))
(if (not (pred? (car fast1)))
(if (eq? rest fast2)
fast
(list* (car fast) (car fast1) rest))
(cons (car fast) rest))
(if (not (pred? (car fast1)))
(if (eq? rest fast2)
fast1
(cons (car fast1) rest))
rest))))))
(and (null? fast1)
(if (not (pred? (car fast)))
fast
'()))))
(and (null? fast) '())))
(improper-list 'remp ls))))
(set! filter
(lambda (pred? ls)
(unless (procedure? pred?)
($oops 'filter "~s is not a procedure" pred?))
(or (let f ((pred? pred?) (fast ls) (slow ls))
(if (pair? fast)
(let ((fast1 (cdr fast)))
(if (pair? fast1)
(and (not (eq? fast1 slow))
(let ((fast2 (cdr fast1)))
(let ((rest (f pred? fast2 (cdr slow))))
(and rest
(if (pred? (car fast))
(if (pred? (car fast1))
(if (eq? rest fast2)
fast
(list* (car fast) (car fast1) rest))
(cons (car fast) rest))
(if (pred? (car fast1))
(if (eq? rest fast2)
fast1
(cons (car fast1) rest))
rest))))))
(and (null? fast1)
(if (pred? (car fast))
fast
'()))))
(and (null? fast) '())))
(improper-list 'filter ls))))
(set! partition
(lambda (pred? ls)
(unless (procedure? pred?)
($oops 'partition "~s is not a procedure" pred?))
(let f ([pred? pred?] [fast ls] [slow ls] [ls ls])
(if (pair? fast)
(let ([fast1 (cdr fast)])
(if (pair? fast1)
(if (eq? fast1 slow)
(improper-list 'partition ls)
(let ([fast2 (cdr fast1)])
(let-values ([(ins outs) (f pred? fast2 (cdr slow) ls)])
(if (pred? (car fast))
(if (pred? (car fast1))
(values
(if (eq? ins fast2)
fast
(list* (car fast) (car fast1) ins))
outs)
(values
(cons (car fast) ins)
(if (eq? outs fast2)
fast1
(cons (car fast1) outs))))
(if (pred? (car fast1))
(values
(if (eq? ins fast2)
fast1
(cons (car fast1) ins))
(cons (car fast) outs))
(values
ins
(if (eq? outs fast2)
fast
(list* (car fast) (car fast1) outs))))))))
(if (null? fast1)
(if (pred? (car fast))
(values fast '())
(values '() fast))
(improper-list 'partition ls))))
(if (null? fast)
(values '() '())
(improper-list 'partition ls))))))
)
(let ()
(define-syntax do-rem!
(syntax-rules ()
((_ pred?)
(rec rem!
(lambda (x ls)
(if (not (null? ls))
(if (not (pred? (car ls) x))
(begin
(let loop ((ls (cdr ls)) (prev ls))
(unless (null? ls)
(if (not (pred? (car ls) x))
(loop (cdr ls) ls)
(set-cdr! prev (rem! x (cdr ls))))))
ls)
(rem! x (cdr ls)))
'()))))))
(define rem-eq?! (do-rem! eq?))
(set! remq!
(lambda (x ls)
($list-length ls 'remq!)
(rem-eq?! x ls)))
(set! remv!
(lambda (x ls)
($list-length ls 'remv!)
(if (or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(rem-eq?! x ls)
((do-rem! eqv?) x ls))))
(set! remove!
(lambda (x ls)
($list-length ls 'remove!)
(if (or (symbol? x) (fixnum? x) (char? x) (procedure? x))
(rem-eq?! x ls)
((do-rem! equal?) x ls))))
)
(define substq
(lambda (new old tree)
(let f ([tree tree])
(if (eq? old tree)
new
(if (pair? tree)
(let ([a (f (car tree))] [d (f (cdr tree))])
(if (and (eq? a (car tree)) (eq? d (cdr tree)))
tree
(cons a d)))
tree)))))
(define substq!
(lambda (new old tree)
(let f ([tree tree])
(if (eq? old tree)
new
(if (pair? tree)
(begin
(set-car! tree (f (car tree)))
(set-cdr! tree (f (cdr tree)))
tree)
tree)))))
(define substv
(lambda (new old tree)
(let f ([tree tree])
(if (eqv? old tree)
new
(if (pair? tree)
(let ([a (f (car tree))] [d (f (cdr tree))])
(if (and (eq? a (car tree)) (eq? d (cdr tree)))
tree
(cons a d)))
tree)))))
(define substv!
(lambda (new old tree)
(let f ([tree tree])
(if (eqv? old tree)
new
(if (pair? tree)
(begin
(set-car! tree (f (car tree)))
(set-cdr! tree (f (cdr tree)))
tree)
tree)))))
(define subst
(lambda (new old tree)
(let f ([tree tree])
(if (equal? old tree)
new
(if (pair? tree)
(let ([a (f (car tree))] [d (f (cdr tree))])
(if (and (eq? a (car tree)) (eq? d (cdr tree)))
tree
(cons a d)))
tree)))))
(define subst!
(lambda (new old tree)
(let f ([tree tree])
(if (equal? old tree)
new
(if (pair? tree)
(begin
(set-car! tree (f (car tree)))
(set-cdr! tree (f (cdr tree)))
tree)
tree)))))
(let ()
(define ($iota n ls)
(if (fx> n 0)
($iota (fx- n 2) (list* (fx- n 1) n ls))
(if (fx= n 0)
(cons 0 ls)
ls)))
; (iota n) => (0 1 ... n-1)
(set! iota
(lambda (n)
(unless (and (fixnum? n) (fx>= n 0))
($oops 'iota "~s is not a nonnegative fixnum" n))
($iota (fx- n 1) '())))
; (enumerate '(a1 a2 ... aN)) => (0 1 ... n-1)
(set! enumerate
(lambda (ls)
($iota (fx- ($list-length ls 'enumerate) 1) '()))))
)
| true |
2446673b9ec2362076a9285514c3f5d806afd659
|
f5b99d59741af88067a78383cf2df94c06fe3710
|
/sicp/chap2/2.29.ss
|
5c8606cd7e9d50ac5382d984a48a261e2a458c30
|
[
"MIT"
] |
permissive
|
shouya/thinking-dumps
|
53921a23ff62dd6aa0580cec6da26b11b83dd818
|
6191a940f3fca4661a6f01663ef38b8ce57c9018
|
refs/heads/master
| 2023-06-08T17:53:34.143893 | 2023-06-04T15:41:18 | 2023-06-04T15:41:18 | 22,285,392 | 24 | 3 |
MIT
| 2022-06-11T12:23:49 | 2014-07-26T11:40:12 |
Coq
|
UTF-8
|
Scheme
| false | false | 2,064 |
ss
|
2.29.ss
|
(define (make-mobile left right)
(list left right))
(define (make-branch len struct)
(list len struct))
; (define (cadr x) (car (cdr x)))
;; Question a)
(define left-branch car)
(define right-branch cadr)
(define branch-length car)
(define branch-structure cadr)
(define mobile? list?)
;; Question b)
(define (total-weight struct)
(if (not (mobile? struct)) struct
(+ (total-weight (branch-structure (left-branch struct)))
(total-weight (branch-structure (right-branch struct))))))
(if #t
(begin
(display "testing `total-weight`") (newline)
'()
))
;; Question c)
(define (equilibrium? struct)
(if (not (mobile? struct)) #t
(let ((left (left-branch struct))
(right (right-branch struct)))
(and (equilibrium? (branch-structure left))
(equilibrium? (branch-structure right))
(= (* (branch-length left)
(total-weight (branch-structure left)))
(* (branch-length right)
(total-weight (branch-structure right))))))))
(if #t
(let ((eq-branch (make-mobile
(make-branch 10 11)
(make-branch 10
(make-mobile (make-branch 1 10)
(make-branch 10 1)))))
(diseq-branch (make-mobile
(make-branch 10 20)
(make-branch 10
(make-mobile (make-branch 1 10)
(make-branch 10 10))))))
(display "testing `equilibrium?`") (newline)
(display (equilibrium? eq-branch))
(newline)
(display (equilibrium? diseq-branch))
(newline))
'()
)
;; Question d)
;(if #f
; (begin
; (define make-mobile cons)
; (define left-branch car)
; (define right-branch cdr)
; (define make-branch cons)
; (define branch-length car)
; (define branch-structure cdr)
; (define mobile? pair?)
; ) '())
| false |
031bad0491e8f764ab8776c0c7b515d03790160f
|
979f2ccfb7bebe8b06399e749a10b77ace45eb76
|
/shared-library-06-expand-time-shared-library/run-time-library.scm
|
8332819f8e08ff19412d19ef625aeff8f46d546f
|
[
"Unlicense"
] |
permissive
|
marcomaggi/mmck-chicken-compiler-use-examples
|
58922c53841dfde8d4c3a954d1561f915e439fd7
|
061ff94be6d6449ab62ffb2c728705ccf5e2d255
|
refs/heads/master
| 2020-05-02T19:43:29.265839 | 2019-04-23T07:27:05 | 2019-04-23T07:27:05 | 178,166,720 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 860 |
scm
|
run-time-library.scm
|
;; run-time-library.scm --
(declare (unit run-time-library)
(emit-import-library run-time-library))
(require-library expand-time-library)
(module (run-time-library)
(the-func (syntax: the-macro))
(import (scheme)
(chicken pretty-print))
(import-for-syntax (prefix expand-time-library expand-time-library::))
(begin
(import (chicken syntax))
(import-for-syntax (chicken pretty-print))
(begin-for-syntax
(pretty-print 'evaluating-visit-code-of-run-time-library)))
(define-syntax the-macro
(ir-macro-transformer
(lambda (form inject compare?)
(let ((thing (expand-time-library::the-func)))
`(list 'run-time-library::the-macro (quote ,thing))))))
(define (the-func)
'run-time-library::the-func)
(pretty-print 'evaluating-invoke-code-of-run-time-library)
#| end of module |# )
;;; end of file
| true |
ea9c812dd3d4524487094432b8d00e698a287ee4
|
8a0660bd8d588f94aa429050bb8d32c9cd4290d5
|
/ext/crypto/math.scm
|
5f5e610fa35f0eb6fb40e63a71fceb42d1749599
|
[
"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 | 203 |
scm
|
math.scm
|
;; -*- mode: scheme; coding: utf-8; -*-
;; math.scm: mathmatic library.
#!compatible
(library (math)
(export :all)
(import (math random)
(math hash)
(math prime)
(math helper))
)
| false |
c30051f9b6f2a80c7c2304c46b5eea1d34064d1b
|
d074b9a2169d667227f0642c76d332c6d517f1ba
|
/sicp/ch_4/exercise.4.33.scm
|
17ab75867968ba49aba1b678a66d83545f301dac
|
[] |
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 | 563 |
scm
|
exercise.4.33.scm
|
#!/usr/bin/env csi -s
(require rackunit)
;;; Exercise 4.33
;; Ben Bitdiddle tests the lazy list implementation
;; given above by evaluating the expression
;;
;; (car '(a b c))
;;
;; To his surprise, this produces an error. After some thought, he
;; realizes that the "lists" obtained by reading in quoted
;; expressions are different from the lists manipulated by the new
;; definitions of `cons', `car', and `cdr'. Modify the evaluator's
;; treatment of quoted expressions so that quoted lists typed at the
;; driver loop will produce true lazy lists.
| false |
accbfb010c429d1562842f15de6c8a80f1f5dcb2
|
b9eb119317d72a6742dce6db5be8c1f78c7275ad
|
/wc/s48/wc.scm
|
eb15130954486c6789b9b7a36d35ca51602cf72d
|
[] |
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,896 |
scm
|
wc.scm
|
;; -*- mode: scheme48; scheme48-package: wc -*-
(define (iota how-many start)
(let loop ((how-many how-many)
(result '()))
(if (positive? how-many)
(loop (- how-many 1)
(cons (+ how-many start -1)
result))
result)))
(define *the-alphabet*
(list->vector
(map integer->char
(iota (- (char->integer #\z)
(- (char->integer #\a)
1))
(char->integer #\a)
))))
(define (twenty-five-varieties word index)
(let twenty-five-varieties-loop ((letters-to-examine (vector-length *the-alphabet*))
(result '()))
(if (zero? letters-to-examine )
result
(let ((this-letter (vector-ref *the-alphabet* (- letters-to-examine 1))))
(if (char=? this-letter (string-ref word index))
;; don't return the string we were passed in.
(twenty-five-varieties-loop (- letters-to-examine 1)
result)
(let ((new (string-copy word)))
(string-set! new index this-letter)
(twenty-five-varieties-loop (- letters-to-examine 1)
(cons new result))))))))
(define (olvs word)
(let olvs-loop ((letters-to-examine (string-length word))
(result '()))
(if (zero? letters-to-examine)
result
(olvs-loop (- letters-to-examine 1)
(append (twenty-five-varieties word (- letters-to-examine 1))
result)))))
(define (all-neighbors word)
(filter (lambda (n)
(table-ref (table-ref *the-hash-table*
(string-length word))
n))
(olvs word)))
(define (wc words)
(apply bfs (append words (list string=? all-neighbors))))
| false |
ec379eaecc13c261ce56e6a7e95f279d04508c9b
|
ae76253c0b7fadf8065777111d3aa6b57383d01b
|
/chap4/exec-4.70.ss
|
d68a7595a881e74d9efcc7012c2d7f6c854b4e52
|
[] |
no_license
|
cacaegg/sicp-solution
|
176995237ad1feac39355f0684ee660f693b7989
|
5bc7df644c4634adc06355eefa1637c303cf6b9e
|
refs/heads/master
| 2021-01-23T12:25:25.380872 | 2014-04-06T09:35:15 | 2014-04-06T09:35:15 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 187 |
ss
|
exec-4.70.ss
|
Since (cons-stream assertion THE-ASSERTIONS) will delay the second argument,
the set! will happen first.
Hence, it will becomes an infinite stream like (define ones (cons-stream 1 ones))
| false |
6dd7891d74b8d25a8dec8d62cd10fdc50dfd5966
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/mscorlib/system/random.sls
|
cd5e3ec9deeb32dfa9441bd02eba28197298b192
|
[] |
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 | 663 |
sls
|
random.sls
|
(library (system random)
(export new is? random? next-double next next-bytes)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e () ((_ a ...) #'(clr-new System.Random a ...)))))
(define (is? a) (clr-is System.Random a))
(define (random? a) (clr-is System.Random a))
(define-method-port
next-double
System.Random
NextDouble
(System.Double))
(define-method-port
next
System.Random
Next
(System.Int32 System.Int32 System.Int32)
(System.Int32 System.Int32)
(System.Int32))
(define-method-port
next-bytes
System.Random
NextBytes
(System.Void System.Byte[])))
| true |
4d9b17804e4265af091a34122c0217713e90f9e3
|
eb32c279a34737c769d4e2c498a62c761750aeb5
|
/lyonesse/munsch/nd-range.scm
|
a3d7bd99774c2d4073e3b10a5bad78cab91f3dc6
|
[
"Apache-2.0"
] |
permissive
|
theschemer/lyonesse
|
baaf340be710f68b84c1969befc6ddbd2be3739b
|
9d9624e3141ea3acaa670526cbe52c2d6546beef
|
refs/heads/master
| 2021-06-10T02:58:28.040995 | 2016-11-29T21:28:11 | 2016-11-29T21:28:11 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,949 |
scm
|
nd-range.scm
|
(library (lyonesse munsch nd-range)
(export make-nd-range nd-range?
nd-range-offset nd-range-index
nd-range-shape nd-range-carry
nd-range-end? nd-range-step)
(import (rnrs base (6))
(rnrs lists (6))
(rnrs control (6))
(rnrs records syntactic (6))
(lyonesse functional)
(lyonesse record-with-context))
#|! Not equal to, really this should be in the standard.
|#
(define /= (compose not =))
#|! Append two lists, reversing the first one.
|
| > (reverse-append '(3 2 1) (4 5 6))
| -> (1 2 3 4 5 6)
|#
(define (reverse-append rev lst)
(if (null? rev)
lst
(reverse-append (cdr rev) (cons (car rev) lst))))
#|! Compute the default strides for a shape.
|
| > (compute-stride '(3 4 5))
| -> (20 5 1)
|#
(define (compute-stride shape)
(let ([cum-prod (fold-right (lambda (x y) (cons (* x (car y)) y))
'(1) shape)])
(cdr cum-prod)))
#|! Compute the carry, which is the step between the end of
| a row and the begining of the next one.
|
| > (compute-carry '(3 76 2))
| -> (1 0 0)
|
| > (compute-carry '(3 4 5) '(2 12 96))
| -> (2 6 48)
|#
(define compute-carry
(case-lambda
[(shape) (compute-carry shape (compute-stride shape))]
[(shape stride)
(let loop ([carry (list (car (reverse stride)))]
[shape (reverse shape)]
[stride (reverse stride)])
(if (null? (cdr stride))
carry
(loop (cons (- (cadr stride) (* (car stride) (car shape)))
carry)
(cdr shape) (cdr stride))))]))
#|! The nd-range record contains information for doing walks in arrays.
|
| We define three constructors:
| `(make-nd-range shape)`: sets the iterator on the beginning of a
| contiguous array of the given shape.
| `(make-nd-range offset shape stride)`: sets the iterator on the
| beginning of a previously sliced array.
| `(make-nd-range offset index shape carry)`: the "naked" constructor,
| used in each iteration step.
|
| Fields:
| `offset`: linear (flat) offset within an array.
| `index`: N-d index.
| `shape`: size of the array in each dimension.
| `carry`: the step between the end on each axis and the beginning of the
| next, i.e. when a digit in the index reaches the value given in
| `shape`, it is set back to 0, and the `carry` is added as an extra to
| the `offset`.
|#
(define-record-with-context nd-range
(fields offset index shape carry)
(protocol
(lambda (new)
(case-lambda
[(shape) (new 0 (map (thunk 0) shape) shape
(compute-carry shape))]
[(offset shape stride) (new offset (map (thunk 0) shape) shape
(compute-carry shape stride))]
[(offset index shape carry)
(new offset index shape carry)]))))
#|! Checks if an iterator reached the end of the array. The `nd-range-step`
| function sets the `offset` field to `#xffffffff` when this happens.
|#
(define (nd-range-end? n)
(= (nd-range-offset n) #xffffffff))
#|! Move one step in a N-dimensional space. This can be used to do rather
| involved iterations on N-dimensional arrays.
|
| > (unfold nd-range-end?
| nd-range-index
| nd-range-step
| (make-nd-range '(2 2)))
| -> ((0 0) (0 1) (1 0) (1 1))
|
| > (unfold nd-range-end?
| nd-range-offset
| nd-range-step
| (make-nd-range 1 '(2 3) '(6 2)))
| -> (1 2 5 7 9 11)
|#
(define (nd-range-step n)
(with-nd-range n
(let loop ([offset (+ offset (car (reverse carry)))]
[lo-index (list (inc (car (reverse index))))]
[hi-index (cdr (reverse index))]
[shape* (reverse shape)]
[carry* (cdr (reverse carry))])
(cond
; we did not move past the end on this axis
[(/= (car lo-index)
(car shape*)) (make-nd-range offset
(reverse-append hi-index lo-index)
shape carry)]
; we moved pased the end of the array, set offset to FFFFFFFF
[(null? hi-index) (make-nd-range #xffffffff
(reverse-append hi-index lo-index)
shape carry)]
; we moved past the end of an axis.
[else (loop (+ offset (car carry*))
`(,(inc (car hi-index)) 0 . ,(cdr lo-index))
(cdr hi-index) (cdr shape*) (cdr carry*))]))))
)
| false |
9a6c461d5109fca3e310c9df8f4bb028c7a06e2f
|
7f8e3eb6b64a12225cbc704aedb390f8fb9186de
|
/ch3/sicp_3.5_common.scm
|
94031d02c9b2432ba491a034b97c2471f34838a2
|
[] |
no_license
|
fasl/sicp
|
70e257b6a5fdd44d2dc5783e99d98f0af527fe45
|
c7228b6b284c525a4195358f91e27ebd6a419fa3
|
refs/heads/master
| 2020-12-26T01:12:07.019658 | 2017-02-01T10:13:38 | 2017-02-01T10:13:38 | 17,853,161 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 22 |
scm
|
sicp_3.5_common.scm
|
;;; 3.5 共通関数
| false |
8e7a8c42e2967fc9bab8fcfd95acecc14bde635a
|
4f30ba37cfe5ec9f5defe52a29e879cf92f183ee
|
/src/util/vector.scm
|
d65c62a07b256584cee2a0e6b366bc240f4c106e
|
[
"MIT"
] |
permissive
|
rtrusso/scp
|
e31ecae62adb372b0886909c8108d109407bcd62
|
d647639ecb8e5a87c0a31a7c9d4b6a26208fbc53
|
refs/heads/master
| 2021-07-20T00:46:52.889648 | 2021-06-14T00:31:07 | 2021-06-14T00:31:07 | 167,993,024 | 8 | 1 |
MIT
| 2021-06-14T00:31:07 | 2019-01-28T16:17:18 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,553 |
scm
|
vector.scm
|
;; util/vector.scm
;; Vector utility functions
(define (vector-map func vec)
(let* ((n (vector-length vec))
(new-vec (make-vector n)))
(let loop ((i 0))
(if (< i n)
(begin (vector-set! new-vec i (func (vector-ref vec i)))
(loop (+ i 1)))
new-vec))))
(define (vector-accum op base vec)
(let ((n (vector-length vec)))
(let loop ((i 0) (val base))
(if (< i n)
(loop (+ i 1) (op val (vector-ref vec i)))
val))))
(define (vector-map-accum op base map vec)
(let ((n (vector-length vec)))
(let loop ((i 0) (val base))
(if (< i n)
(loop (+ i 1) (op val (map (vector-ref vec i))))
val))))
(define (vector-copy-up! src index-start index-end dst dst-offset)
(if (< index-start index-end)
(begin (vector-set! dst
dst-offset
(vector-ref src index-start))
(vector-copy-up! src
(+ index-start 1)
index-end
dst
(+ dst-offset 1)))))
(define (vector-copy-down! src index-start index-end dst dst-offset)
(if (>= index-end index-start)
(begin (vector-set! dst
dst-offset
(vector-ref src index-end))
(vector-copy-down! src
index-start
(- index-end 1)
dst
(- dst-offset 1)))))
(define (vector-copy! src index-start index-end dst dst-offset)
(cond ((not (eq? src dst))
(vector-copy-up! src index-start index-end dst dst-offset))
((<= index-start dst-offset index-end)
(vector-copy-down! src
index-start
(- index-end 1)
dst
(+ dst-offset (- index-end index-start 1))))
(else (vector-copy-up! src index-start index-end dst dst-offset))))
(define (vector-copy-full! src dst)
(vector-copy! src 0 (vector-length src) dst 0))
(define (vector-insert v i obj)
(let ((res (make-vector (+ (vector-length v) 1))))
(define (copy i j vi)
(if (< i j)
(begin (vector-set! res i (vector-ref v vi))
(copy (+ i 1) j (+ vi 1)))))
(copy 0 i 0)
(vector-set! res i obj)
(copy (+ i 1) (vector-length res) i)
res))
| false |
736853f36be1e7ffcfd93747a2cc452cc449f8c6
|
0011048749c119b688ec878ec47dad7cd8dd00ec
|
/src/spoilers/136/solution.scm
|
ecd0059acb34ab13e80a40928631dc2390c48794
|
[
"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 | 823 |
scm
|
solution.scm
|
(import
(chicken fixnum))
(define (make-number-solutions n)
(let ((acc (make-vector n 0)))
(let loop ((i 1))
(unless (fx= i n)
(let subloop ((j (fx/ (fx+ i 3) 4)))
(unless (fx= j i)
(let ((_ (fx* (fx- (fx* j 4) i) i)))
(unless (fx>= _ n)
(vector-set! acc _ (fx+ (vector-ref acc _) 1))
(subloop (fx+ j 1))))))
(loop (fx+ i 1))))
(define (number-solutions n)
(vector-ref acc n))
number-solutions))
(define (solve l n)
(let ((number-solutions (make-number-solutions l)))
(let loop ((i 1) (acc 0))
(if (fx= i l)
acc
(loop (fx+ i 1)
(if (fx= (number-solutions i) n)
(fx+ acc 1)
acc))))))
(let ((_ (solve #e5e7 1)))
(print _) (assert (= _ 2544559)))
| false |
757551fcae251d7c78c021aa1b40f65533a13b78
|
4bd59493b25febc53ac9e62c259383fba410ec0e
|
/Scripts/Task/dynamic-variable-names/scheme/dynamic-variable-names.ss
|
ee9ab8fc6687ff467a853b9a514f5013e814672d
|
[] |
no_license
|
stefanos1316/Rosetta-Code-Research
|
160a64ea4be0b5dcce79b961793acb60c3e9696b
|
de36e40041021ba47eabd84ecd1796cf01607514
|
refs/heads/master
| 2021-03-24T10:18:49.444120 | 2017-08-28T11:21:42 | 2017-08-28T11:21:42 | 88,520,573 | 5 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 166 |
ss
|
dynamic-variable-names.ss
|
=> (define (create-variable name initial-val)
(eval `(define ,name ,initial-val) (interaction-environment)))
=> (create-variable (read) 50)
<hello
=> hello
50
| false |
19e2b596a66b8d09371446481484f3ff5ea7a89c
|
fe0de995a95bcf09cd447349269dc0e550851b5a
|
/tests/0016-lambda-zero-arguments.scm
|
39f86292886e98771017c951dc101c6e421ebc75
|
[
"MIT"
] |
permissive
|
mugcake/ruse-scheme
|
4974021858be5b7f2421212ec2eeafd34c53bce8
|
dd480e17edd9a233fd2bc4e8b41ff45d13fcc328
|
refs/heads/master
| 2022-02-12T04:31:55.031607 | 2019-08-01T21:44:14 | 2019-08-01T21:44:14 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 39 |
scm
|
0016-lambda-zero-arguments.scm
|
(let ((proc (lambda () 42)))
(proc))
| false |
8260ba995c2dd72a6e0a1e4ffccfcd48082d3faa
|
1b51f1e88e9d98cf612d43d96e27555de2058bf7
|
/interpreter/src/scheme/add.scm
|
59175a7055e486e143bad982820d30bd0194323d
|
[] |
no_license
|
fbrosda/ts-lox
|
e87e2de8e9255b1b551f81ca7cdd4c2770dffda4
|
ff679e73e765d7de6d1138008fcc8b1d393eb8de
|
refs/heads/master
| 2023-08-10T18:54:46.145614 | 2022-04-24T12:36:53 | 2022-04-24T12:36:53 | 249,016,082 | 0 | 0 | null | 2023-07-18T21:49:05 | 2020-03-21T16:30:44 |
TypeScript
|
UTF-8
|
Scheme
| false | false | 352 |
scm
|
add.scm
|
(define *add*
(lambda (. args)
(cond ((every number? args)
(apply + args))
((any string? args)
(apply string-append
(map (lambda (x) (format #f "~a" x))
args)))
(else (throw 'invalidArgs
"Operands must be either strings or numbers.")))))
| false |
f2068abea33754e8fa3515172008088fa680cb42
|
f97599978922ae5201189b923ed51e8a1f8e4e29
|
/tests/run.scm
|
56613a9b85022b22aa0f47670926e3335e744018
|
[] |
no_license
|
kdltr/hardwood
|
972140864198ab23732744406f03fa216c915138
|
af0de71d77d53415f2ab76ba30e36170a1564ffc
|
refs/heads/master
| 2021-01-20T18:15:48.525101 | 2018-01-17T00:07:03 | 2018-01-17T03:36:03 | 61,128,105 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 109 |
scm
|
run.scm
|
(use test hardwood)
(setup-thread)
(load "ping")
(load "rpc")
(load "spam")
(load "monitors")
(test-exit)
| false |
662ef6f077850fd3ef0fffed7186bf8dcb69120f
|
fe0de995a95bcf09cd447349269dc0e550851b5a
|
/program.scm
|
0f0ae87982ffef89dc9b46c37db618d0cb66b47c
|
[
"MIT"
] |
permissive
|
mugcake/ruse-scheme
|
4974021858be5b7f2421212ec2eeafd34c53bce8
|
dd480e17edd9a233fd2bc4e8b41ff45d13fcc328
|
refs/heads/master
| 2022-02-12T04:31:55.031607 | 2019-08-01T21:44:14 | 2019-08-01T21:44:14 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,165 |
scm
|
program.scm
|
(begin
(let loop ([thunk ((lambda (k)
((lambda (k)
(k (lambda (k cont.0)
((lambda (k)
(lambda ()
((lambda (k)
(k (lambda (k t.1)
((lambda (k) (k 42)) k))))
(lambda (v)
(lambda ()
((lambda (k) (k 0))
(lambda (v0)
(lambda ()
(v k
(lambda (kv)
(kv v0)))))))))))
k))))
(lambda (proc)
(proc
k
(lambda (v) (v (lambda (a b c) (b k))))))))
display)])
(when (procedure? thunk) (loop (thunk))))
(newline))
| false |
52317466fb5550db8961db7af16560b2ed9f8029
|
b60cb8e39ec090137bef8c31ec9958a8b1c3e8a6
|
/test/changesBenevolPaper/sat/satAdd-2.scm
|
38939d0e5532d45d3f243d58784ac2bfc564a15e
|
[] |
no_license
|
acieroid/scala-am
|
eff387480d3baaa2f3238a378a6b330212a81042
|
13ef3befbfc664b77f31f56847c30d60f4ee7dfe
|
refs/heads/master
| 2021-01-17T02:21:41.692568 | 2021-01-15T07:51:20 | 2021-01-15T07:51:20 | 28,140,080 | 32 | 16 | null | 2020-04-14T08:53:20 | 2014-12-17T14:14:02 |
Scheme
|
UTF-8
|
Scheme
| false | false | 432 |
scm
|
satAdd-2.scm
|
(define (phi x1 x2 x3 x4 x5)
(and (or x1 (not x2) (not x3))
(or (not x2) (not x3))
(or x4 x2 x5)))
(define (try f)
(or (f #t) (f #f)))
(define (sat-solve-4 p)
(try (lambda (n1)
(try (lambda (n2)
(try (lambda (n3)
(try (lambda (n4)
(try (lambda (n5)
(p n1 n2 n3 n4 n5))))))))))))
(sat-solve-4 phi)
| false |
713f39934915c55e90ab2b4aa05636554f94cc94
|
2d1029e750a1cd71a650cceea8b7e02ae854ec01
|
/various-prologs-exp/prolog-first-pass/prolog-ng3-broken/syntax-helpers.ss
|
11288b4560de30d4af529e9a0104fa2fb5252dde
|
[] |
no_license
|
chinacat/unsorted
|
97f5ce41d228b70452861df707ceff9d503a0a89
|
46696319d2585c723bbc5bdff3a03743b1425243
|
refs/heads/master
| 2018-12-28T22:05:34.628279 | 2013-08-09T06:36:07 | 2013-08-09T06:36:07 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 10,650 |
ss
|
syntax-helpers.ss
|
#lang scheme
(provide (all-defined-out))
(define (varsym? stx)
(let ([x (syntax-e stx)])
(and (symbol? x)
(char=? (string-ref (symbol->string x) 0) #\?))))
(define (walk stx functor-bindings var-bindings)
(syntax-case stx ()
[()
(values #'(quote ()) functor-bindings var-bindings)]
[(functor arg ...)
(and (identifier? #'functor) (not (eq? '! (syntax-e #'functor))) (not (varsym? #'functor)))
(let* ([functor-sym (syntax-e #'functor)]
[arity (length (syntax->list #'(arg ...)))]
[functor-key (cons functor-sym arity)])
(define (parse-args args functor-bindings var-bindings)
(syntax-case args ()
[()
(values #'(quote ()) functor-bindings var-bindings)]
[(arg . rest)
(let-values ([(new-arg arg-functor-bindings arg-var-bindings)
(walk #'arg functor-bindings var-bindings)])
(let-values ([(new-rest rest-functor-bindings rest-var-bindings)
(parse-args #'rest arg-functor-bindings arg-var-bindings)])
(values #`(cons #,new-arg #,new-rest) rest-functor-bindings rest-var-bindings)))]))
(let ([binding (assoc functor-key functor-bindings)])
(if binding
(let-values ([(new-args arg-functor-bindings arg-var-bindings)
(parse-args #'(arg ...) functor-bindings var-bindings)])
(values #`(cons #,(cdr binding) #,new-args)
arg-functor-bindings
arg-var-bindings))
(let ([functor-tmp (car (generate-temporaries #'(functor)))])
(let-values ([(new-args arg-functor-bindings arg-var-bindings)
(parse-args #'(arg ...)
(cons (cons functor-key functor-tmp)
functor-bindings)
var-bindings)])
(values #`(cons #,functor-tmp #,new-args)
arg-functor-bindings
arg-var-bindings))))))]
[(item0 item ... . tail)
(let iter ([items #'(item0 item ...)]
[functor-bindings functor-bindings]
[var-bindings var-bindings])
(syntax-case items ()
[()
(walk #'tail functor-bindings var-bindings)]
[(a . rest)
(let-values ([(new-a a-functor-bindings a-var-bindings)
(walk #'a functor-bindings var-bindings)])
(let-values ([(new-rest rest-functor-bindings rest-var-bindings)
(iter #'rest a-functor-bindings a-var-bindings)])
(values #`(cons #,new-a #,new-rest)
rest-functor-bindings
rest-var-bindings)))]))]
[var
(and (identifier? #'var) (varsym? #'var))
(let ([varsym (syntax-e #'var)])
(if (eq? '? varsym)
(values #'(make-variable (gensym '?) (new-counter))
functor-bindings
var-bindings)
(let ([binding (assq varsym var-bindings)])
(if binding
(values (cdr binding) functor-bindings var-bindings)
(let ([var-tmp (car (generate-temporaries #'(var)))])
(values var-tmp
functor-bindings
(cons (cons varsym var-tmp) var-bindings)))))))]
[id
(identifier? #'id)
(values #'(quote id) functor-bindings var-bindings)]
[other
(values #'other functor-bindings var-bindings)]))
(define (walk-seq seq functor-bindings var-bindings)
(syntax-case seq ()
[()
(values #'(quote ()) functor-bindings var-bindings)]
[(item . rest)
(let-values ([(new-item item-functor-bindings item-var-bindings)
(walk #'item functor-bindings var-bindings)])
(let-values ([(new-rest rest-functor-bindings rest-var-bindings)
(walk-seq #'rest item-functor-bindings item-var-bindings)])
(values #`(cons #,new-item #,new-rest) rest-functor-bindings rest-var-bindings)))]))
;(define (compile-unification arity goal args functor-bindings var-bindings)
(define (compile-unification arity args functor-bindings var-bindings)
(case arity
[(1)
(syntax-case args ()
[(arg)
(let-values ([(new-arg arg-functor-bindings arg-var-bindings)
(walk #'arg functor-bindings var-bindings)])
(values #`(unify! (cadr goal) #,new-arg)
arg-functor-bindings
arg-var-bindings))])]
[(2)
(syntax-case args ()
[(arg0 arg1)
(let*-values ([(new-arg0 arg0-functor-bindings arg0-var-bindings)
(walk #'arg0 functor-bindings var-bindings)]
[(new-arg1 arg1-functor-bindings arg1-var-bindings)
(walk #'arg1 arg0-functor-bindings arg0-var-bindings)])
(values #`(let ([arg-list (cdr goal)])
(and (unify! (car arg-list) #,new-arg0)
(unify! (cadr arg-list) #,new-arg1)))
arg1-functor-bindings
arg1-var-bindings))])]
[(3)
(syntax-case args ()
[(arg0 arg1 arg2)
(let*-values ([(new-arg0 arg0-functor-bindings arg0-var-bindings)
(walk #'arg0 functor-bindings var-bindings)]
[(new-arg1 arg1-functor-bindings arg1-var-bindings)
(walk #'arg1 arg0-functor-bindings arg0-var-bindings)]
[(new-arg2 arg2-functor-bindings arg2-var-bindings)
(walk #'arg2 arg1-functor-bindings arg1-var-bindings)])
(values #`(let ([arg-list (cdr goal)])
(and (unify! (car arg-list) #,new-arg0)
(unify! (cadr arg-list) #,new-arg1)
(unify! (caddr arg-list) #,new-arg2)))
arg2-functor-bindings
arg2-var-bindings))])]
[else
(let-values ([(new-args args-functor-bindings args-var-bindings)
(walk-seq args functor-bindings var-bindings)])
(values #`(unify! (cdr goal) #,new-args)
args-functor-bindings
args-var-bindings))]))
(define (compile-fact stx)
(let-values ([(functor arity args)
(syntax-case stx ()
[(f arg ...)
(values #'f (length (syntax->list #'(arg ...))) #'(arg ...))])])
(if (= 0 arity)
#`(add-clause '#,functor #,arity
(lambda (goal success-cont cut-cont failure-cont)
(success-cont failure-cont)))
(let-values ([(new-unify-test functor-bindings var-bindings)
; (compile-unification arity #'goal args '() '())])
(compile-unification arity args '() '())])
#`(let #,(map (lambda (binding)
(list (cdr binding)
#`(intern-functor (quote #,(caar binding))
(quote #,(cdar binding)))))
(reverse functor-bindings))
(add-clause '#,functor #,arity
(lambda (goal success-cont cut-cont failure-cont)
(let #,(map (lambda (binding)
(list (cdr binding)
#`(make-variable (quote #,(car binding))
(new-counter))))
(reverse var-bindings))
(if #,new-unify-test
(success-cont failure-cont)
(failure-cont))))))))))
(define (compile-rule head body)
(let*-values ([(new-body body-functor-bindings body-var-bindings)
(walk body '() '())]
[(functor arity args)
(syntax-case head ()
[(f arg ...)
(values #'f (length (syntax->list #'(arg ...))) #'(arg ...))])])
(if (= 0 arity)
#`(let #,(map (lambda (binding)
(list (cdr binding)
#`(intern-functor (quote #,(caar binding))
(quote #,(cdar binding)))))
(reverse body-functor-bindings))
(add-clause '#,functor #,arity
(lambda (goal success-cont cut-cont failure-cont)
(let #,(map (lambda (binding)
(list (cdr binding)
#`(make-variable (quote #,(car binding))
(new-counter))))
(reverse body-var-bindings))
(prove-goals #,new-body
success-cont
cut-cont
failure-cont)))))
(let-values ([(new-unify-test args-functor-bindings args-var-bindings)
; (compile-unification arity #'goal args body-functor-bindings body-var-bindings)])
(compile-unification arity args body-functor-bindings body-var-bindings)])
#`(let #,(map (lambda (binding)
(list (cdr binding)
#`(intern-functor (quote #,(caar binding))
(quote #,(cdar binding)))))
(reverse args-functor-bindings))
(add-clause '#,functor #,arity
(lambda (goal success-cont cut-cont failure-cont)
(let #,(map (lambda (binding)
(list (cdr binding)
#`(make-variable (quote #,(car binding))
(new-counter))))
(reverse args-var-bindings))
(if #,new-unify-test
(prove-goals #,new-body
success-cont
cut-cont
failure-cont)
(failure-cont))))))))))
| false |
28cb9be7be52de5979be356163c516e766a697ce
|
e5a6f30aa5fb44e919bc423cfd05c3ddb8eab9f5
|
/config/color-schemes/tomorrow-night.scm
|
08eebe819a343eaadcbb2629b024cc9f9e0b18b5
|
[
"MIT"
] |
permissive
|
nyanpasu64/bintracker
|
46c55c9912fd04fa94832cb6cd816f21a66059c3
|
ebcc1677f701cee857d0dccfd3abeb574e32cc41
|
refs/heads/master
| 2022-09-24T20:46:11.448291 | 2020-06-04T14:17:08 | 2020-06-04T14:17:08 | 269,378,487 | 0 | 0 |
MIT
| 2020-06-04T14:15:44 | 2020-06-04T14:15:43 | null |
UTF-8
|
Scheme
| false | false | 617 |
scm
|
tomorrow-night.scm
|
;; A color scheme based on base16/Tomorrow Night by Chris Kempson
;; http://chriskempson.com/projects/base16/
(bt-color-scheme background: "#1d1f21" ; background
background-inactive: "#1d1f21" ; background
row-highlight-major: "#373b41" ; selection
row-highlight-minor: "#282a2e" ; current line
cursor: "#eee8d5" ; base02 TODO
text: "#c5c8c6" ; foreground
text-inactive: "#969896" ; comment
text-1: "#de935f" ; orange
text-2: "#cc6666" ; red
text-3: "#f0c674" ; yellow
text-4: "#81a2be" ; blue
text-5: "#b5bd68" ; green
text-6: "#8abeb7" ; aqua
text-7: "#b294bb" ; purple
)
| false |
c0d14189e8cca094d772a5650503c4d295faa730
|
5fa722a5991bfeacffb1d13458efe15082c1ee78
|
/src/c3_29.scm
|
4dd6930ef8e35138ec9070ea16c5a8ac0067387e
|
[] |
no_license
|
seckcoder/sicp
|
f1d9ccb032a4a12c7c51049d773c808c28851c28
|
ad804cfb828356256221180d15b59bcb2760900a
|
refs/heads/master
| 2023-07-10T06:29:59.310553 | 2013-10-14T08:06:01 | 2013-10-14T08:06:01 | 11,309,733 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 356 |
scm
|
c3_29.scm
|
; x ∨ y = ¬(¬x ∧ ¬y)
(define (or-gate a1 a2 output)
(let ((invert1 (make-wire))
(invert2 (make-wire))
(and-invert1-invert2 (make-wire)))
(inverter a1 invert1)
(inverter a2 invert2)
(and-gate invert1 invert2 and-invert1-invert2)
(inverter and-invert1-invert2 output)
'ok))
; (3*inverter-delay + and-gate-delay)
| false |
421b1bb5fd36434ca1ca76d7ba16d03e5ad8b525
|
a938b2b8a309a4fb1cf97b18add5cd420e726f01
|
/src/testresultobject.scm
|
6afbe78021c0a75b8631a8ff9fc4132986d0220d
|
[] |
no_license
|
aj07mm/scmUnit
|
d5da096bccf26e1627e6a2bac6c408813c05f747
|
6b76cc02395570de17a372b03842cd9d9dcbd0d6
|
refs/heads/master
| 2020-07-29T16:12:11.865484 | 2013-02-09T14:19:20 | 2013-02-09T14:19:20 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,805 |
scm
|
testresultobject.scm
|
;;;; --------------------------------------------------------------------------
;;;; scmUnit
;;;; Nicholas Russell
;;;; --------------------------------------------------------------------------
;;;; testresultobject.scm
;;;; Test result object
;;;; --------------------------------------------------------------------------
;; test-result-object
(define (scmunit:test:testresultobject:test-result-object)
(let ((test-suite-name '())
(test-name '())
(test-result '()))
(define (get-test-suite-name) test-suite-name)
(define (get-test-name) test-name)
(define (get-test-result) test-result)
(define (set-test-suite-name suite-name) (set! test-suite-name suite-name) (get-test-suite-name))
(define (set-test-name name) (set! test-name name) (get-test-name))
(define (set-test-result result) (set! test-result result) (get-test-result))
(define (test-result-object msg)
(cond ((eq? msg 'get-test-suite-name) (get-test-suite-name))
((eq? msg 'get-test-name) (get-test-name))
((eq? msg 'get-test-result) (get-test-result))
((eq? msg 'set-test-suite-name) (lambda (test-suite-name) (set-test-suite-name test-suite-name)))
((eq? msg 'set-test-name) (lambda (test-name) (set-test-name test-name)))
((eq? msg 'set-test-result) (lambda (test-result) (set-test-result test-result)))
((eq? msg 'type) scmunit:test:testresultobject:test-result-object-type)))
test-result-object))
;;;;
;; scmunit:test:testresultobject:get-test-suite-name
;;
;; @param test-result-object
(define (scmunit:test:testresultobject:get-test-suite-name test-result-object)
(test-result-object 'get-test-suite-name))
;;;;
;; scmunit:test:testresultobject:get-test-name
;;
;; @param test-result-object
(define (scmunit:test:testresultobject:get-test-name test-result-object)
(test-result-object 'get-test-name))
;;;;
;; scmunit:test:testresultobject:get-test-result
;;
;; @param test-result-object
(define (scmunit:test:testresultobject:get-test-result test-result-object)
(test-result-object 'get-test-result))
;;;;
;; scmunit:test:testresultobject:set-test-suite-name
;;
;; @param test-result-object
;; @param test-suite-name
(define (scmunit:test:testresultobject:set-test-suite-name test-result-object test-suite-name)
((test-result-object 'set-test-suite-name) test-suite-name))
;;;;
;; scmunit:test:testresultobject:set-test-name
;;
;; @param test-result-object
;; @param test-name
(define (scmunit:test:testresultobject:set-test-name test-result-object test-name)
((test-result-object 'set-test-name) test-name))
;;;;
;; scmunit:test:testresultobject:set-test-result
;;
;; @param test-result-object
;; @param test-result
(define (scmunit:test:testresultobject:set-test-result test-result-object test-result)
((test-result-object 'set-test-result) test-result))
;;;;
;; scmunit:test:testresultobject:create-test-result-object
;;
;; @param test-suite-name
;; @param test-name
;; @param result
;; @return test-result-object
(define (scmunit:test:testresultobject:create-test-result-object test-suite-name test-name result)
(let ((test-result-object (scmunit:test:testresultobject:test-result-object)))
(scmunit:test:testresultobject:set-test-suite-name test-result-object test-suite-name)
(scmunit:test:testresultobject:set-test-name test-result-object test-name)
(scmunit:test:testresultobject:set-test-result test-result-object result)
test-result-object))
;;;;
;; scmunit:testresult:testresultobject:test-result-object?
;; Returns true if object is a test-object
;;
;; @param object
;; @return boolean
(define (scmunit:test:testresultobject:test-result-object? object)
(scmunit:check-object-type object scmunit:test:testresultobject:test-result-object-type))
| false |
1389b70f014f31c4ee65d181f6f71ee0452d6549
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/social-platforms/impl/achievement.sls
|
97c69178e02019401aa22eb6bf81ee30d1f79117
|
[] |
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,332 |
sls
|
achievement.sls
|
(library (unity-engine social-platforms impl achievement)
(export new
is?
achievement?
report-progress
set-hidden
set-last-reported-date
set-completed
to-string
id-get
id-set!
id-update!
percent-completed-get
percent-completed-set!
percent-completed-update!
completed?
hidden?
last-reported-date)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
UnityEngine.SocialPlatforms.Impl.Achievement
a
...)))))
(define (is? a)
(clr-is UnityEngine.SocialPlatforms.Impl.Achievement a))
(define (achievement? a)
(clr-is UnityEngine.SocialPlatforms.Impl.Achievement a))
(define-method-port
report-progress
UnityEngine.SocialPlatforms.Impl.Achievement
ReportProgress)
(define-method-port
set-hidden
UnityEngine.SocialPlatforms.Impl.Achievement
SetHidden
(System.Void System.Boolean))
(define-method-port
set-last-reported-date
UnityEngine.SocialPlatforms.Impl.Achievement
SetLastReportedDate
(System.Void System.DateTime))
(define-method-port
set-completed
UnityEngine.SocialPlatforms.Impl.Achievement
SetCompleted
(System.Void System.Boolean))
(define-method-port
to-string
UnityEngine.SocialPlatforms.Impl.Achievement
ToString
(System.String))
(define-field-port
id-get
id-set!
id-update!
(property:)
UnityEngine.SocialPlatforms.Impl.Achievement
id
System.String)
(define-field-port
percent-completed-get
percent-completed-set!
percent-completed-update!
(property:)
UnityEngine.SocialPlatforms.Impl.Achievement
percentCompleted
System.Double)
(define-field-port
completed?
#f
#f
(property:)
UnityEngine.SocialPlatforms.Impl.Achievement
completed
System.Boolean)
(define-field-port
hidden?
#f
#f
(property:)
UnityEngine.SocialPlatforms.Impl.Achievement
hidden
System.Boolean)
(define-field-port
last-reported-date
#f
#f
(property:)
UnityEngine.SocialPlatforms.Impl.Achievement
lastReportedDate
System.DateTime))
| true |
af5d3b874595ff8af7aab3e58add3d45febd6b99
|
0b1826093fb47c0a7293573d80f03a28e859640f
|
/chapter-4/ex-4.03.scm
|
52bfc7fa3548e27cc6f12ea5e734876e167e2989
|
[
"MIT"
] |
permissive
|
yysaki/sicp
|
253ef8ef52a330af6c2107ca7063773e63f1a4aa
|
36d2964c980c58ba13a2687e0af773a5e12d770d
|
refs/heads/master
| 2021-01-20T11:50:20.648783 | 2017-12-10T03:43:38 | 2017-12-10T08:08:18 | 56,677,496 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 909 |
scm
|
ex-4.03.scm
|
(load "./4.1")
(load "../chapter-2/table")
(define (eval exp env)
(cond ((self-evaluating? exp) exp)
((variable? exp) (lookup-variable-value exp env))
(else
(if (get 'eval (operator exp))
((get 'eval (operator exp)) exp env) (apply (eval (operator exp) env)
(list-of-values (operands exp) env))))))
(define (install-eval-package)
(put 'eval 'quote text-of-quotation)
(put 'eval 'set eval-assignment)
(put 'eval 'define eval-definition)
(put 'eval 'if eval-if)
(put 'eval 'lambda
(lambda (exp env)
(make-procedure (lambda-parameters exp)
(lambda-body exp)
env)))
(put 'eval 'begin
(lambda (exp env)
(eval-sequence (begin-actions exp) env)))
(put 'eval 'cond
(lambda (exp env)
(eval (cond->if exp) env)))
'done)
(install-eval-package)
| false |
b5a5d70acf510d874e1408a3acd6a643e340d737
|
b14c18fa7a4067706bd19df10f846fce5a24c169
|
/Chapter1/1.26.scm
|
95bb38f83bccf4e4af32d3f3428cab8048cb71d6
|
[] |
no_license
|
silvesthu/LearningSICP
|
eceed6267c349ff143506b28cf27c8be07e28ee9
|
b5738f7a22c9e7967a1c8f0b1b9a180210051397
|
refs/heads/master
| 2021-01-17T00:30:29.035210 | 2016-11-29T17:57:16 | 2016-11-29T17:57:16 | 19,287,764 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 836 |
scm
|
1.26.scm
|
#lang scheme
(define (square x) (* x x))
(define (divides? a b)
(= (remainder b a) 0))
(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 (smallest-divisor n)
(find-divisor n 2))
; above from 1.21
(define (expmod base exp m)
(cond ((= exp 0) 1)
((even? exp)
(remainder (* (expmod base (/ exp 2) m)
(expmod base (/ exp 2) m))
m))
(else
(remainder (* base (expmod base (- exp 1) m))
m))))
(expmod 2 100 100)
; the original expmod gives O(logn)
; expanding square to duplicate call to expmod
; results in a binary tree of recursive call to expmod
; which incresed n to 2^n (tree depth -> tree node count)
; combine O(logn) and O(2^n), gets O(n)
| false |
7e76b0898628cdd7d558aa4eeb4b8a5fa312b57a
|
6b8bee118bda956d0e0616cff9ab99c4654f6073
|
/schcuda/testing/sine_structs.scm
|
ae3eed053086a865af80795197b8b06db34f84af
|
[] |
no_license
|
skchoe/2012.Functional-GPU-Programming
|
b3456a92531a8654ae10cda622a035e65feb762d
|
56efdf79842fc465770214ffb399e76a6bbb9d2a
|
refs/heads/master
| 2016-09-05T23:42:36.784524 | 2014-05-26T17:53:34 | 2014-05-26T17:53:34 | 20,194,204 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 966 |
scm
|
sine_structs.scm
|
#lang scheme
(require scheme/foreign)
(unsafe!)
(provide* (unsafe sine_array))
;; libcada
(define cuda-lib (ffi-lib "libcuda"))
(let* (
[sin (get-ffi-obj 'sin
cuda-lib
(_cprocedure (list _double)
_double)
(lambda (x) (printf "NOT found\n")))]
[out-val (sin 1.75)]
)
(printf "outval = ~s\n" out-val))
;; libgle
(define value-seT (cvector _float 1.0 100.0))
(define glew-lib (ffi-lib "/home/skchoe/local/glew/lib/libGLEW"))
(let* ([glVertex3f (get-ffi-obj 'glVertex3f
glew-lib
(_cprocedure (list _float _float _float)
_void)
(lambda (x) (printf "NOT found\n"))
)]
[out-valc (glVertex3f 0.1 0.2 0.3)])
#f
; (let (;[v1 (make-cvector* out-valc _float 2)])
; (printf "cvector 0: ~s\n" (cvector-ref out-valc 0))
; (printf "cvector 1: ~s\n" (cvector-ref out-valc 1))
)
| false |
9f41bee218b22c1116f7ad3f326d26241a6d7bdf
|
2f88dd127122c2444597a65d8b7a23926aebbac1
|
/st-xlate.scm
|
c67af1fc0a47865cae9348e8cf648c88a6c29a4f
|
[
"BSD-2-Clause"
] |
permissive
|
KenDickey/Crosstalk
|
6f980b7188c1cc6bd176a8e0cd10b032f768b4e6
|
b449fb7c711ad287f9b49e7167d8cedd514f5d81
|
refs/heads/master
| 2023-05-26T10:07:12.674162 | 2023-05-21T22:59:26 | 2023-05-21T22:59:26 | 58,777,987 | 11 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 13,017 |
scm
|
st-xlate.scm
|
;;; FILE: "st-xlate.scm"
;;; IMPLEMENTS: xlate -- translate st -> scheme
;;; AUTHOR: Ken Dickey
;;; DATE: 04 January 2017
;; (requires 'st-core-classes)
(define (AST->scm ast)
;; transliterate Abstract Syntax Tree
;; ..into Scheme syntax
(cond
((astSequence? ast)
(xlateSequence ast))
;; ((astMessageSequence? ast) ...)
;; ((astTemporaries? ast) ...)
((astLetTemps? ast)
(xlateLetTemps ast))
((astSubexpression? ast)
(AST->scm (astSubexpression-expression ast)))
((astReturn? ast)
(xlateReturn ast))
((astAssignment? ast)
(xlateAssignment ast))
((astBlock? ast)
(xlateBlock ast))
;; ((astBrace? ast) ...)
((astCascade? ast)
(xlateCascade ast))
((astIdentifier? ast)
(xlateIdentifier ast))
((astLiteral? ast)
(astLiteral-value ast))
((astSelector? ast)
`',(astSelector-value ast)) ;; NB: quoted
((astUnarySend? ast)
(xlateUnarySend ast))
;; ((astBinarySend? ast) ...)
((astKeywordSend? ast)
(xlateKeywordSend ast))
;; ((astUnaryMessage? ast) ...)
;; ((astBinaryMessage? ast) ...)
;; ((astKeywordMessage? ast) ...)
((astMessageSend? ast)
(xlateMessageSend ast))
((astArray? ast)
(xlateArray ast)
)
((astDynamicArray? ast)
(xlateDynamicArray ast)
)
;; ((astMethod ast) ...)
(else
(error
"unhandled/malformed AST" ast)
)
)
)
(define (st->scm aString)
(unless (string? aString)
(error "st->scm requires a Smalltalk string to translate"))
(AST->scm (st->AST aString)))
(define (identifier-token? t)
(and (token? t)
(eq? 'identifier (token-kind t)))
)
;;; Temps Statements
(define (xlateLetTemps ast)
(let ( (temps (->scm-temps (astLetTemps-temps ast)))
(statements (->scm-statements (astLetTemps-statements ast)))
)
`(let ,temps ,@statements)
) )
;;; Sequence
(define (xlateSequence ast)
(let ( (ast-statements
(astSequence-statements ast))
)
(if (null? ast-statements)
'(begin '()) ;; answer st-nil
(let ( (statements
(map xlateStatement ast-statements))
)
(if (= 1 (length statements))
(car statements)
`(begin ,@statements)
)
)
)
)
)
;;; Statement
(define xlateStatement AST->scm) ;; @@FIXME: checks
;;; Assignment
(define (xlateAssignment ast)
(let ( (var (AST->scm (astAssignment-var ast)))
(val (AST->scm (astAssignment-val ast)))
)
;; st semantics; assignment returns value
`(let ( (%%val%% ,val) )
(set! ,var %%val%%)
%%val%%)
)
)
;;; Block
;; dynamic var
(define within-return? (make-parameter #f))
(define (xlateBlock ast)
(let* ( (arguments
(->scm-args (astBlock-arguments ast)))
(temps
(->scm-temps (astBlock-temporaries ast)))
(hasReturn? (astBlock-hasReturn? ast))
(addReturn?
(and hasReturn?
(not (within-return?))
(not (simple-return? (astBlock-statements ast))))
)
(statements
(cond
;;;simplify:
;;; (call/cc (return) (return foo)) -> foo
((and (simple-return? (astBlock-statements ast))
(not (within-return?)))
(simplified-return (astBlock-statements ast))
)
(hasReturn?
(parameterize ((within-return? #t))
(->scm-statements (astBlock-statements ast)))
)
(else
(->scm-statements (astBlock-statements ast)))
))
)
(cond
((null? statements)
`(lambda ,arguments ,st-nil)
)
((null? temps)
(if addReturn?
`(lambda ,arguments
(call/cc (lambda (return) ,@statements)))
`(lambda ,arguments ,@statements))
)
(else
(if addReturn?
`(lambda ,arguments
(call/cc (lambda (return)
(let ,temps ,@statements))))
`(lambda ,arguments
(let ,temps ,@statements))
))
)
)
)
(define (simple-return? ast)
(and (list? ast)
(= 1 (length ast))
(astReturn? (car ast))))
(define (simplified-return ast)
(list (AST->scm (astReturn-expression (car ast)))))
;;;; Return
(define (xlateReturn ast)
`(return ,(AST->scm (astReturn-expression ast)))
)
;;; Identifier
(define (xlateIdentifier ast)
(let ( (ident (astIdentifier-symbol ast)) )
(cond
((capitalized-symbol? ident) ;; => Smalltalk Global
`(smalltalkAt: ',ident))
((memq ident '(nil true false self super))
ident) ;; normal Scheme identifier (less #super)
(else
ident) ;; local XOR instance accessor
) ) )
(define (capitalized-symbol? ident)
(and (symbol? ident) ;; invariant: symbol-length > 0
(char-upper-case? (string-ref (symbol->string ident) 0))))
(define (->scm-args ast-args-list)
(unless (every? astIdentifier? ast-args-list)
(error "Block arguments must be identifiers"
ast-args-list))
(map astIdentifier-symbol ast-args-list)
)
(define (->scm-temps ast-temps-list)
(unless (every? identifier-token? ast-temps-list)
(error "Block temporaries must be identifiers"
ast-temps-list))
(map (lambda (ident-tok)
`(,(token->native ident-tok) nil))
ast-temps-list)
)
(define (->scm-statements ast-list)
;;@@@FIXME: checks
(let ( (statements
(map AST->scm ast-list))
)
(if (null? statements)
'(nil)
statements)
)
)
;;; Message Sends
(define (astMessage? ast)
(or (astUnaryMessage? ast)
(astBinaryMessage? ast)
(astKeywordMessage? ast)
)
)
(define (xlateUnarySend ast)
(let ( (receiver (AST->scm (astUnarySend-receiver ast)))
(selector (astUnarySend-selector ast))
)
(if (eq? receiver 'super)
`(@ self ',selector)
`($ ,receiver ',selector))
) )
(define (xlateKeywordSend ast)
(let ( (rcvr (AST->scm (astKeywordSend-receiver ast)))
(selector (astKeywordSend-selector ast))
(arguments
(map AST->scm
(astKeywordSend-arguments ast)))
)
(if (eq? rcvr 'super)
(rsa->superPerform 'self selector arguments)
(rsa->perform rcvr selector arguments))
)
)
(define (xlateCascade ast)
(let* ( (rcvr (AST->scm (astCascade-receiver ast)))
(messages (astCascade-messages ast))
)
;; Presume #super NEVER allowed in this context
`(let ( (receiver ,rcvr) )
,(AST->scm (car messages))
,@(map (lambda (msg) (m->send 'receiver msg))
(cdr messages)))
)
)
(define (caddr l) (car (cddr l)))
(define (cadddr l) (cadr (cddr l)))
(define (rsa->perform rcvr selector arguments)
(case (length arguments)
((0) `($ ,rcvr ',selector)
)
((1) `($: ,rcvr ',selector ,(car arguments))
)
((2) `($::
,rcvr
',selector
,(car arguments)
,(cadr arguments))
)
((3) `($:::
,rcvr
',selector
,(car arguments)
,(cadr arguments)
,(caddr arguments))
)
((4) `($::::
,rcvr
',selector
,(car arguments)
,(cadr arguments)
,(caddr arguments)
,(cadddr arguments))
)
(else
`($*
,rcvr
',selector
,(cons 'list arguments))
)
)
)
(define (rsa->superPerform rcvr selector arguments)
(case (length arguments)
((0) `(@ self ',selector)
)
((1) `(@: self ',selector ,(car arguments))
)
((2) `(@::
self
',selector
,(car arguments)
,(cadr arguments))
)
((3) `(@:::
self
',selector
,(car arguments)
,(cadr arguments)
,(caddr arguments))
)
((4) `(@::::
self
',selector
,(car arguments)
,(cadr arguments)
,(caddr arguments)
,(cadddr arguments))
)
(else
`(@&
self
',selector
,(list->vector arguments))
)
)
)
(define (xlateMessageSend ast)
(let ( (receiver
(AST->scm
(astMessageSend-receiver ast)))
(messages
(astMessageSend-messages ast))
)
(m->send receiver messages)
)
)
(define (m->send rcvr ast-message)
(let ( (ast-msg
(if (and (list? ast-message)
(= 1 (length ast-message)))
(car ast-message)
ast-message))
(superSend? (eq? rcvr 'super))
)
(cond
((astMessageSequence? ast-msg)
(let ( (messages
(astMessageSequence-messages ast-msg))
)
(if (null? messages)
rcvr
(let loop ( (composed (m->send rcvr (car messages)))
(msgs (cdr messages))
)
(if (null? msgs)
composed
(loop (m->send composed (car msgs)) (cdr msgs)))
)
)
))
((astUnaryMessage? ast-msg)
(if superSend?
`(@ self
',(token->native (astUnaryMessage-selector ast-msg)))
`($ ,rcvr
',(token->native (astUnaryMessage-selector ast-msg)))
))
((astBinaryMessage? ast-msg)
(if superSend?
`(@: self
',(astBinaryMessage-selector ast-msg)
,(AST->scm (astBinaryMessage-argument ast-msg)))
`($: ,rcvr
',(astBinaryMessage-selector ast-msg)
,(AST->scm (astBinaryMessage-argument ast-msg)))
))
((astKeywordMessage? ast-msg)
(let ( (arguments
(map AST->scm
(astKeywordMessage-arguments ast-msg)))
)
((if superSend? rsa->superPerform rsa->perform)
rcvr
(astKeywordMessage-selector ast-msg)
arguments))
)
((and (token? ast-msg)
(eq? 'identifier (token-kind ast-msg)))
;; unary message
(if superSend?
`(@ self ',(token->native ast-msg))
`($ ,rcvr ',(token->native ast-msg))
))
(else
(error
"xlateMessageSend: does not understand"
ast-msg)
)
)
)
)
;;; Static Array
(define (xlateArray ast)
(list 'quote (list->vector (map AST->scm (astArray-elements ast))))
)
(define (xlateDynamicArray ast)
`(vector ,@(map AST->scm (astDynamicArray-element-expressions ast)))
)
(define (xlate-st-file->scm infile-name)
(set! next-st-token (tokenizer-for-file-named infile-name))
(set! curr-token #f)
(set! prev-token #f)
(call-with-port (current-output-port)
(lambda (outp)
(let loop ( (form (parse-st-code)) )
(format outp
"~%~y" ;; pretty-print
(AST->scm form))
(skip-whitespace)
(unless (eq? 'eof (curr-token-kind))
(loop (parse-st-code)))
) ) ) )
(define (xlate-st-file->scm-file infile-name outfile-name)
(set! next-st-token (tokenizer-for-file-named infile-name))
(set! curr-token #f)
(set! prev-token #f)
(delete-file-if-exists outfile-name) ;; OK to fail
(call-with-output-file outfile-name
(lambda (outp)
(format outp "~%;; \"~a\" (translated)~%" outfile-name)
(let loop ( (form (parse-st-code)) )
(format outp
"~%~y" ;; pretty-print
(AST->scm form))
(skip-whitespace)
(unless (eq? 'eof (curr-token-kind))
(loop (parse-st-code)))
)
(format outp "~%;; -- e o f --- ;;~%")
) ) )
;;; st-eval
;; In sis.scm
;;(define %%escape%% (make-parameter (lambda whatever '|%%escape%%|)))
(define (st-eval st-string)
(call/cc
(lambda (exit)
(parameterize ( (%%escape%% exit) ) ;; for send-failed
(with-exception-handler
(lambda (anException)
;; (($ ($ anException 'asException) 'defaultAction))
(exit
(let ( (exception ($ anException 'asException)) ) ; condition->ex
;;@@@DEBUG{
;;(display-ivars ex)
;;@@@DEBUG}
(cond
;; ((and (isKindOf: anException MessageNotUnderstood)
;; ($ anException 'reachedDefaultHandler))
((isKindOf: exception MessageNotUnderstood)
($ exception 'messageText)
;; (error ($ anException 'messageText)
;; ($ anException 'printString)
;; anException))
)
(else
;;@@@DEBUG{
(when (debug-st-runtime)
(format #t "about to ~a>>defaultAction"
($ exception 'printString)))
;;@@@DEBUG}
($ exception 'defaultAction))))))
(lambda () (eval (st->scm st-string)
(interaction-environment))))
) ) ) )
;;; DEBUG -- fake a Transcript
(smalltalkAt:Put: 'Transcript (current-output-port))
;; (provides st-xlate)
;;; --- E O F --- ;;;
| false |
93b2a419f8dd945ca46563d2792c85d22e7ba5c2
|
beac83b9c75b88060f4af609498541cf84437fd3
|
/site/all-publications.ss
|
05e12d5626603ca923a5187d3f8c96db6b53d892
|
[] |
no_license
|
nuprl/prl-website
|
272ce3b9edd5b3ada23798a694f6cb7c6d510776
|
31a321f629a62f945968c3e4c59d180de0f656f6
|
refs/heads/master
| 2021-05-16T02:06:38.847789 | 2016-09-16T14:41:22 | 2016-09-16T14:41:22 | 412,044 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 466 |
ss
|
all-publications.ss
|
(module all-publications scheme
(provide page)
(require "publications.ss")
(define recent-pubs (pubs-in-range-inclusive 1066 2061) )
(define page
`(div
(center
,@(map (lambda (year-group)
(let ((year (number->string (car year-group))))
`(span (a ((href ,(string-append "#year" year)))
,year) " ")))
recent-pubs))
,(pubs-date-page recent-pubs)))
)
| false |
eb2197928f33272d4282fff19cc7ac6af55d02fe
|
19e1e43abea015add4edaa8257602da08cadedb5
|
/vulkan/pipeline.scm
|
61459d9a1a388f11ecec9703b943087644ef584f
|
[] |
no_license
|
corrodedlabs/phoenix
|
1f3f34d00e8426fc92b7bc814d5b640e7a8738d5
|
8a2974cc4e886a5276b7a14598c7a55642feec5a
|
refs/heads/master
| 2022-02-20T18:25:36.486934 | 2022-02-06T09:32:22 | 2022-02-06T09:32:22 | 226,878,975 | 6 | 0 | null | 2022-02-06T09:30:10 | 2019-12-09T13:33:16 |
Scheme
|
UTF-8
|
Scheme
| false | false | 16,037 |
scm
|
pipeline.scm
|
;; depends on shaderc library
;; defined in shaderc.scm at the root
(define create-shader-stages
(lambda (device vertex-shader-filename fragment-shader-filename)
(define create-shader-module
(lambda (spv-array-pointer)
(let ((info
(make-vk-shader-module-create-info shader-module-create-info
0 0
(array-pointer-length
spv-array-pointer)
(array-pointer-raw-ptr
spv-array-pointer)))
(module (make-foreign-object vk-shader-module)))
(vk-create-shader-module device info 0 module)
module)))
(define create-shader-stage-info
(lambda (shader-stage-bit module)
(make-vk-pipeline-shader-stage-create-info pipeline-shader-stage-create-info
0 0
shader-stage-bit
(pointer-ref-value module)
"main"
0)))
(let ((vertex-spv (compile-shaders vertex-shader-filename
shaderc-vertex-shader))
(frag-spv (compile-shaders fragment-shader-filename
shaderc-fragment-shader)))
(list (create-shader-stage-info vk-shader-stage-vertex-bit
(create-shader-module vertex-spv))
(create-shader-stage-info vk-shader-stage-fragment-bit
(create-shader-module frag-spv))))))
;; vertex input
;; this will contain data about mesh component in a model
(define-record-type mesh-component
(nongenerative)
(fields index-count index-base))
;; components is a array of #<mesh-component>
(define-record-type vertex-input-metadata
(nongenerative)
(fields size vertices-list stride indices attrs components))
;; default vertex input struct
(define-record-type vertex-input
(nongenerative)
(fields position color texture-coord))
;; takes input a nested list and returns a list of cons cell (format . offset)
;; these are usually saved in the field attrs of vertex-input-metadata
(define vector->attr
(lambda (input)
(displayln "input is " input)
(let lp ((elems input)
(offset 0)
(attrs (list)))
(cond
((null? elems) (reverse attrs))
(else
(case (cond
((vector? (car elems)) (vector-length (car elems)))
((list? (car elems)) (length (car elems))))
((2) (lp (cdr elems)
(fx+ offset (* 2 4))
(cons (cons vk-format-r32g32-sfloat offset) attrs)))
((3) (lp (cdr elems)
(fx+ offset (* 3 4))
(cons (cons vk-format-r32g32b32-sfloat offset) attrs)))
(else (error "unsupported vector" v))))))))
(define create-vertex-input-metadata
(lambda (vertices-list indices-list)
(define vertex-input-total-length
(lambda (input)
(fx+ (vector-length (vertex-input-position input))
(vector-length (vertex-input-color input))
(vector-length (vertex-input-texture-coord input)))))
;; assuming that we are using float for everything
(define vertex-input-total-size
(lambda (input) (fx* 4 (vertex-input-total-length input))))
(define (sizeof-vertex-input arr)
(fold-left + 0 (map vertex-input-total-size arr)))
(define vertex-input->list
(lambda (vertices)
(let ((vertices-list (map (lambda (v)
(match v
(($ vertex-input pos color tex-coord)
(list pos color tex-coord))))
vertices)))
(let lp ((v vertices-list)
(flat-coll (list)))
(displayln "v" v)
(cond
((null? v) flat-coll)
(else (lp (cdr v)
(append flat-coll (apply append
(map (lambda (v) (vector->list v))
(car v)))))))))))
(define vertex-input-stride
(lambda (vertices)
(fx* 4 (vertex-input-total-length (car vertices)))))
(make-vertex-input-metadata (sizeof-vertex-input vertices-list)
(vertex-input->list vertices-list)
(vertex-input-stride vertices-list)
indices-list
(match (car vertices-list)
(($ vertex-input pos color tex-coord)
(vector->attr (list pos color tex-coord)))))))
;; setup vertex input descriptors
;; attrs is a list of (format . offset)
;; todo may be it should be in records
(define create-vertex-input
(lambda (stride attrs)
(define make-vertex-binding-description
(lambda ()
(make-vk-vertex-input-binding-description 0 stride vk-vertex-input-rate-vertex)))
(define make-attribute-descriptions
(lambda ()
(displayln "attrs is " attrs)
(array-pointer-raw-ptr
(list->vk-vertex-input-attribute-description-pointer-array
(map-indexed (lambda (attr i)
(displayln "attr" i)
(make-vk-vertex-input-attribute-description i
0
(car attr)
(cdr attr)))
attrs)))))
(make-vk-pipeline-vertex-input-state-create-info pipeline-vertex-input-state-create-info
0
0
1
(make-vertex-binding-description)
(length attrs)
(make-attribute-descriptions))))
;; input assembly
(define create-pipeline-assembly-state
(lambda ()
(make-vk-pipeline-input-assembly-state-create-info
pipeline-input-assembly-state-create-info 0 0
vk-primitive-topology-triangle-list
vk-false)))
;; viewport
(define (create-viewport-info swapchain-extent)
(define (create-viewport)
(make-vk-viewport 0.0
0.0
(exact->inexact (vk-extent-2d-width swapchain-extent))
(exact->inexact (vk-extent-2d-height swapchain-extent))
0.0
1.0))
(define (create-scissor)
(make-vk-rect-2d (make-vk-offset-2d 0 0) swapchain-extent))
(make-vk-pipeline-viewport-state-create-info pipeline-viewport-state-create-info 0 0
1
(create-viewport)
1
(create-scissor)))
;; rasterizer
(define (create-rasterizer-info)
(make-vk-pipeline-rasterization-state-create-info pipeline-rasterization-state-create-info
0
0
vk-false
vk-false
vk-polygon-mode-fill
vk-cull-mode-back-bit
vk-front-face-clockwise
vk-false
0.0
0.0
0.0
1.0))
;; multisampling
(define (create-multisampling-info)
(make-vk-pipeline-multisample-state-create-info pipeline-multisample-state-create-info 0 0
vk-sample-count-1-bit
vk-false
0.0
(make-ftype-pointer unsigned-32 0)
0
0))
;; color blending
(define (create-color-blending-info)
(let* ((color-write-mask (bitwise-ior vk-color-component-r-bit
vk-color-component-g-bit
vk-color-component-b-bit
vk-color-component-a-bit))
(color-attachment (make-vk-pipeline-color-blend-attachment-state vk-false
0
0
0
0
0
0
color-write-mask)))
(make-vk-pipeline-color-blend-state-create-info pipeline-color-blend-state-create-info 0 0
vk-false
vk-logic-op-copy
1
color-attachment
'(0.0 0.0 0.0 0.0))))
;; descriptor set layout
(define create-descriptor-layout
(lambda (device)
(let* ((uniform-buffer-binding
(make-vk-descriptor-set-layout-binding 0
vk-descriptor-type-uniform-buffer
1
vk-shader-stage-vertex-bit
(null-pointer vk-sampler)))
(texture-sampler-binding
(make-vk-descriptor-set-layout-binding 1
vk-descriptor-type-combined-image-sampler
1
vk-shader-stage-fragment-bit
(null-pointer vk-sampler)))
(bindings (list->vk-descriptor-set-layout-binding-pointer-array
(list uniform-buffer-binding texture-sampler-binding)))
(info (make-vk-descriptor-set-layout-create-info descriptor-set-layout-create-info
0
0
(array-pointer-length bindings)
(array-pointer-raw-ptr bindings)))
(layout (make-foreign-object vk-descriptor-set-layout)))
(vk-create-descriptor-set-layout device info 0 layout)
layout)))
;; pipeline layout
;; returns (pipeline-layout . descriptor-layout)
(define (create-pipeline-layout device)
(let* ((descriptor-layout (create-descriptor-layout device))
(layout-info
(make-vk-pipeline-layout-create-info pipeline-layout-create-info 0 0
1
descriptor-layout
0
(null-pointer vk-push-constant-range)))
(layout (make-foreign-object vk-pipeline-layout)))
(vk-create-pipeline-layout device layout-info 0 layout)
(cons layout descriptor-layout)))
;; let's capture all the custom information that can be supplied in the pipeline in a record
;; currently supported shaders
(define-record-type shaders
(nongenerative)
(fields vertex fragment))
(define-record-type vertex-input-details
(nongenerative)
(fields vertex-input-list stride attrs))
(define-record-type pipeline-data
(nongenerative)
(fields shaders vertex-input-details))
(define vertex-input->details
(lambda (input-metadata)
(match input-metadata
((@ vertex-input-metadata (vertices-list v) (stride s) (attrs a))
(make-vertex-input-details v s a)))))
;; render pass
(define create-render-pass
(lambda (physical-device device swapchain)
;; defined as (~0U)
(define vk-subpass-external 0)
(define create-render-pass-info
(lambda ()
(let* ((swapchain-image-format
(vk-surface-format-khr-format (swapchain-format swapchain)))
(color-attachment
(make-vk-attachment-description 0
swapchain-image-format
vk-sample-count-1-bit ;; samples
vk-attachment-load-op-clear ;; load-op
vk-attachment-store-op-store ;; store-op
vk-attachment-load-op-dont-care ;;stencil-load-op
vk-attachment-store-op-dont-care
vk-image-layout-undefined
vk-image-layout-present-src-khr))
(color-attachment-ref
(make-vk-attachment-reference 0
vk-image-layout-color-attachment-optimal))
(depth-attachment
(make-vk-attachment-description 0
(find-depth-format physical-device)
vk-sample-count-1-bit
vk-attachment-load-op-clear
vk-attachment-store-op-dont-care
vk-attachment-load-op-dont-care
vk-attachment-store-op-dont-care
vk-image-layout-undefined
vk-image-layout-depth-stencil-attachment-optimal))
(depth-attachment-ref
(make-vk-attachment-reference 1
vk-image-layout-depth-stencil-attachment-optimal))
(attachments (list->vk-attachment-description-pointer-array
(list color-attachment depth-attachment)))
(subpass
(make-vk-subpass-description 0
vk-pipeline-bind-point-graphics
0
(null-pointer vk-attachment-reference)
1
color-attachment-ref
(null-pointer vk-attachment-reference)
depth-attachment-ref
0
(null-pointer unsigned-32)))
(dependency
(make-vk-subpass-dependency vk-subpass-external
0
vk-pipeline-stage-color-attachment-output-bit
vk-pipeline-stage-color-attachment-output-bit
0
vk-access-color-attachment-write-bit
vk-dependency-by-region-bit)))
(make-vk-render-pass-create-info render-pass-create-info 0 0
(array-pointer-length attachments)
(array-pointer-raw-ptr attachments)
1
subpass
1
dependency))))
(let ((info (create-render-pass-info))
(render-pass (make-foreign-object vk-render-pass)))
(vk-create-render-pass device info 0 render-pass)
render-pass)))
;; record to save the pipeline information
(define-record-type pipeline
(nongenerative)
(fields handle layout render-pass descriptor-set-layout))
(define create-depth-stencil-state
(lambda ()
(let ((zero-op-state (make-vk-stencil-op-state 0 0 0 0 0 0)))
(make-vk-pipeline-depth-stencil-state-create-info pipeline-depth-stencil-state-create-info
0
0
vk-true
vk-true
vk-compare-op-less
vk-false
vk-false
zero-op-state
zero-op-state
0.0
1.0))))
(define create-graphics-pipeline
(lambda (physical-device device swapchain pipeline-data)
(let* ((shaders (pipeline-data-shaders pipeline-data))
(shader-stages (list->vk-pipeline-shader-stage-create-info-pointer-array
(create-shader-stages device
(shaders-vertex shaders)
(shaders-fragment shaders))))
(vertex-input-data (pipeline-data-vertex-input-details pipeline-data))
(render-pass (create-render-pass physical-device device swapchain))
(layout (create-pipeline-layout device))
(pipeline-info
(make-vk-graphics-pipeline-create-info
graphics-pipeline-create-info 0 0
;; shader stages
(array-pointer-length shader-stages)
(vk-pipeline-shader-stage-create-info-pointer-car shader-stages)
;; vertex input
(create-vertex-input (vertex-input-details-stride vertex-input-data)
(vertex-input-details-attrs vertex-input-data))
(create-pipeline-assembly-state)
;; tesselation
(null-pointer vk-pipeline-tessellation-state-create-info)
;; viewport
(create-viewport-info (swapchain-extent swapchain))
;; rasterizer
(create-rasterizer-info)
;; multisampling
(create-multisampling-info)
;; depth stencil
(create-depth-stencil-state)
(create-color-blending-info)
(null-pointer vk-pipeline-dynamic-state-create-info)
(pointer-ref-value (car layout))
(pointer-ref-value render-pass)
0
0
0))
(pipeline (make-foreign-object vk-pipeline)))
(vk-create-graphics-pipelines device
0
1
pipeline-info
0
pipeline)
(make-pipeline pipeline (car layout) render-pass (cdr layout)))))
;; (load "vulkan/mesh.scm")
;; samplte usage
;; (define device (vulkan-state-device vs))
;; (define physical-device (vulkan-state-physical-device vs))
;; (define swapchain-details (vulkan-state-swapchain vs))
;; (define vertices (list (make-vertex-input '#3( -0.5 -0.5 0.0) '#3(1.0 0.0 0.0) '#2(1.0 0.0))
;; (make-vertex-input '#3( 0.5 -0.5 0.0) '#3(0.0 1.0 0.0) '#2(0.0 0.0))
;; (make-vertex-input '#3( 0.5 0.5 0.0) '#3(0.0 0.0 1.0) '#2(0.0 1.0))
;; (make-vertex-input '#3(-0.5 0.5 0.0) '#3(1.0 1.0 1.0) '#2(1.0 1.0))
;; (make-vertex-input '#3( -0.5 -0.5 -0.5) '#3(1.0 0.0 0.0) '#2(1.0 0.0))
;; (make-vertex-input '#3( 0.5 -0.5 -0.5) '#3(0.0 1.0 0.0) '#2(0.0 0.0))
;; (make-vertex-input '#3( 0.5 0.5 -0.5) '#3(0.0 0.0 1.0) '#2(0.0 1.0))
;; (make-vertex-input '#3(-0.5 0.5 -0.5) '#3(1.0 1.0 1.0) '#2(1.0 1.0))))
;; (define indices (list 0 1 2 2 3 0
;; 4 5 6 6 7 4))
;; (define shaders (make-shaders "shaders/shader.vert" "shaders/shader.frag"))
;; (define vertex-input-metadata (model->vertex-input-metadata "models/box.obj"))
;; (define pipeline-data
;; (make-pipeline-data shaders (vertex-input->details vertex-input-metadata)))
;; (define pipeline
;; (create-graphics-pipeline physical-device device swapchain-details pipeline-data))
#!eof
=========================================================================================
(load "vulkan/pipeline.scm")
(define ss (create-shader-stages (vulkan-state-device vs)
(shaders-vertex shaders)
(shaders-fragment shaders)))
(ftype-pointer->sexpr (car ss))
(list->vk-pipeline-shader-stage-create-info-pointer-array ss)
(make-bytevector (* 4))
(bytevector-ieee-double-set!)
(define vertices-length (fold-left + 0 (map vertex-input-total-length vertices)))
(vertices->bytevector vertices)
(define attrs (vertex-input->attrs (car vertices)))
(define vertex-input-create-info (create-vertex-input stride attrs))
(define swapchain-extent (swapchain-details-extent (vulkan-state-swapchain vs)))
(create-graphics-pipeline device swapchain-details pipeline-data)
;; fix the list conversion
(list->vk-pipeline-shader-stage-create-info-pointer-array ss)
(vk-pipeline-shader-stage-create-info-pointer-map
ftype-pointer->sexpr
(list->vk-pipeline-shader-stage-create-info-pointer-array ss))
(load "vk.scm")
| false |
d877247f60b15b57af67f564ed87909d9d821936
|
648776d3a0d9a8ca036acaf6f2f7a60dcdb45877
|
/queries/hoon/locals.scm
|
159783fd091328aab9e75635c6c1b44cff1195cf
|
[
"Apache-2.0"
] |
permissive
|
nvim-treesitter/nvim-treesitter
|
4c3c55cbe6ff73debcfaecb9b7a0d42d984be3e6
|
f8c2825220bff70919b527ee68fe44e7b1dae4b2
|
refs/heads/master
| 2023-08-31T20:04:23.790698 | 2023-08-31T09:28:16 | 2023-08-31T18:19:23 | 256,786,531 | 7,890 | 980 |
Apache-2.0
| 2023-09-14T18:07:03 | 2020-04-18T15:24:10 |
Scheme
|
UTF-8
|
Scheme
| false | false | 65 |
scm
|
locals.scm
|
(tisfasTall
name: (name) @definition.var)
(name) @reference
| false |
6a2c1a777693bfb1bec16ac153b24f68ab5aeabd
|
9ff2abf87c905f4056e769fd3fc0a392904ac9e8
|
/ClassMaterials/SchemeIntro/live-demo.ss
|
f420be87b88a2a9a5f1fad2565d4b4207b8b8599
|
[] |
no_license
|
hernanre/csse304-1
|
b3cbc605aa4720bed1c16cab6da2385be6305d9b
|
4ae64ccd9858ead8a94245d4e20c4149fb4275f1
|
refs/heads/main
| 2023-08-30T04:03:02.067571 | 2021-10-23T21:55:01 | 2021-10-23T21:55:01 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,866 |
ss
|
live-demo.ss
|
; First show the use of SWL.
; Draw pictures for the following:
(define a '(3 4 5))
(cdr a)
(cddr a)
(cdddr a)
(cddddr a)
(cdddddr a)
(define b (cons 2 a))
(define c (cons a b))
(define d (list a b))
(define e (cons 1 (cons 2 3)))
b
c
d
e
; Procedures are not "operators" in Scheme.
(/ 4 5)
/
(define /
(lambda (x y) (* x (+ 1 y))))
(/ 4 5) ; Not a good idea, but it illustrates what / is.
; A useful procedure
(max 4 8 2 7 3)
(Max 3 2 1)
(max a)
(apply max a)
(mod 19 4)
(define t 6) ; what does it return?
(void)
(list (void))
; everything that is not #f is a "true value"
(if 0 1 2)
(if '() 1 2)
(if (void) 1 2)
; When we write procedures:
; No mutation
; Usually assume correct data
(define letter-to-number
(lambda (letter)
(if (eq? letter 'A)
4.0
(if (eq? letter 'B+)
3.5
3.0))))
(letter-to-number 'A)
(letter-to-number 'B+)
(letter-to-number 'B)
; End of Day 1
(define letter-to-number
(lambda (letter)
(cond [(eq? letter 'A) 4.0]
[(eq? letter 'B+) 3.5]
[else 3.0])))
(define letter-to-number
(lambda (letter)
(case letter
[(A) 4.0]
[(B+) 3.5]
[else 3.0])))
(define vector-sum ; 3D vectors as in A1, A2
(lambda (v1 v2)
(list (+ (car v1) (car v2))
(+ (cadr v1) (cadr v2))
(+ (caddr v1) (caddr v2)))))
(vector-sum '(2 3 4) '(5 6 7))
(define largest-in-list
(lambda (lon)
(if (null? lon)
(errorf 'largest-in-list "list is empty")
(largest-non-empty (car lon) (cdr lon)))))
(define largest-non-empty
(lambda (largest-so-far not-seen-yet)
(if (null? not-seen-yet)
largest-so-far
(largest-non-empty (max largest-so-far
(car not-seen-yet))
(cdr not-seen-yet)))))
(largest-in-list '())
(largest-in-list '(3 2 7 8 6))
(largest-in-list '(5 4 3))
(largest-in-list '(3 4 5))
(largest-in-list '(-3))
; A challenge for students (at each table):
; Write (positives? lon).
; procedures can be anonymous.
((lambda (n)
(* n 3))
4)
(define make-adder
(lambda (n)
(lambda (m)
(+ m n))))
(define add5 (make-adder 5))
add5
(add5 7)
((make-adder 8) 9)
(((lambda (n)
(lambda (m)
(+ m n)))
3)
7)
(define count-reflexive-pairs
(lambda (rel)
(cond [(null? rel) 0]
[(eq? (caar rel) (cadar rel))
(+ 1 (count-reflexive-pairs (cdr rel)))]
[else (count-reflexive-pairs (cdr rel))])))
(define count-reflexive-pairs
(lambda (rel)
(if (null? rel)
0
(let ([cdr-refl-count (count-reflexive-pairs (cdr rel))])
(if (eq? (caar rel) (cadar rel))
(+ 1 cdr-refl-count)
cdr-refl-count)))))
(define count-reflexive-pairs
(lambda (rel)
(if (null? rel)
0
(+ (count-reflexive-pairs (cdr rel))
(if (eq? (caar rel) (cadar rel))
1
0)))))
| false |
ac268547fef7fa9d8f90ca724ce048d2c2d84db5
|
cca999903bc2305da28e598c46298e7d31dbdef5
|
/src/web/collections/bootstrap2011/cage-teachpack.ss
|
94728999f1f502dcf3d0636f413d8e1741023d9f
|
[
"Apache-2.0"
] |
permissive
|
ds26gte/kode.pyret.org
|
211183f7045f69cf998a8ebd8a9373cd719d29a1
|
534f2d4b61a6d6c650a364186a4477a52d1cd986
|
refs/heads/master
| 2021-01-11T14:56:43.120765 | 2018-05-02T22:27:55 | 2018-05-02T22:27:55 | 80,234,747 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,744 |
ss
|
cage-teachpack.ss
|
;;#lang scheme/gui
;;
;;(require lang/prim
;; lang/posn
;; "bootstrap-common.rkt"
;; (except-in htdp/testing test)
;; (for-syntax scheme/base))
;;(provide (all-from-out "bootstrap-common.rkt"))
;;(provide-higher-order-primitive start (onscreen?))
(provide start)
(define WIDTH 640)
(define HEIGHT 480)
(define butterfly (bitmap/url "http://www.wescheme.org/images/teachpacks2011/butterfly.png"))
; a make-world is a (Number Number)
; each world has an x and y coordinate
(define-struct world [x y])
;; move: World Number -> Number
;; did the object move?
(define (move w key)
(cond
[(not (string? key)) w]
[(string=? key "left")
(make-world (- (world-x w) 10) (world-y w))]
[(string=? key "right")
(make-world (+ (world-x w) 10) (world-y w))]
[(string=? key "down")
(make-world (world-x w) (- (world-y w) 10))]
[(string=? key "up")
(make-world (world-x w) (+ (world-y w) 10))]
[else w]))
;; ----------------------------------------------------------------------------
;; draw-world: World -> Image
;; create an image that represents the world
(define (draw-world w)
(let* ((draw-butterfly
(lambda (w scene)
(place-image butterfly
(world-x w)
(- HEIGHT (world-y w))
scene)))
(draw-text
(lambda (w scene)
(place-image
(text
(string-append "x-coordinate: "
(number->string (world-x w))
" y-coordinate: "
(number->string (world-y w)))
14 "black")
(quotient (image-width scene) 2)
0
scene))))
(draw-butterfly w
(draw-text w (empty-scene WIDTH HEIGHT)))))
(define (start onscreen?)
(let* ((onscreen?* (if (= (procedure-arity onscreen?) 2)
onscreen?
(lambda (x y) (onscreen? x))))
(update (lambda (w k)
(if (onscreen?* (world-x (move w k))
(world-y (move w k)))
(move w k)
w))))
(big-bang (make-world (/ WIDTH 2) (/ HEIGHT 2))
(on-redraw draw-world)
(on-key update))))
(provide sq sine cosine tangent
pick subset? in?
type #;warn number->image string->image overlay-at)
;; warn : any* -> any, and a side effect.
;; display all arguments and return the last one.
#;(define (warn . args)
(begin
(map display args)
(newline)
(last args)))
;; type : any -> String
(define (type obj)
(cond
[(procedure? obj) "Function"]
[(number? obj) "Number"]
[(string? obj) "String"]
[(image? obj) "Image"]
[(boolean? obj) "Boolean"]
[(posn? obj) "Position"]
[(symbol? obj) "Symbol"]
[else "I don't know."]))
;; string->image : String -> Image
;; convert the given string to an image.
(define (string->image s)
(text s 14 "black"))
;; number->image : Number -> Image
;; convert the given number to an image.
(define (number->image n)
(string->image (number->string n)))
;; overlay-at : Image Number Number Image -> Image
;; Place the foreground on the background at x y
;; (in positive-y point space) relative to the center
(define (overlay-at background x y foreground)
(overlay/xy background x (- 0 y) foreground))
; sq : Number -> Number
(define (sq x) (* x x))
;; sine : Degrees -> Number
;; For a right triangle with non-right angle x in degrees,
;; find the ratio of the length of the opposite leg to the
;; length of the hypotenuse. sin = opposite / hypotenuse
(define (sine x) (sin (* x (/ pi 180))))
;; cosine : Degrees -> Number
;; For a right triangle with non-right angle x in degrees,
;; find the ratio of the length of the adjacent leg to the
;; length of the hypotenuse. cos = adjacent / hypotenuse
(define (cosine x) (cos (* x (/ pi 180))))
;; tangent : Degrees -> Number
;; For a right triangle with non-right angle x in degrees,
;; find the ratio of the length of the opposite leg to the
;; length of the adjacent leg. tan = opposite / adjacent
(define (tangent x) (tan (* x (/ pi 180))))
;; pick : List -> Element
;; pick a random element from the list
(define (pick lst)
(list-ref lst (random (length lst))))
;; subset? : List List -> Boolean
;; return true if list a is a (proper or improper) subset of b
(define (subset? a b)
(andmap
(lambda (ele) (member ele b))
a))
(define (in? a b)
(if (list? a) (subset? a b) (member a b)))
| false |
057de1c2b6d3ee3728e2e251d97adcba848ab169
|
dba788ee1c21fffe14d8cd517b66833ee2077700
|
/tests/tests.scm
|
7d084b0c4df2c687bdb3c0b3d0ac104369279d26
|
[] |
no_license
|
chicken-mobile/jni
|
50a63eda0b625ae5d1d0310d419280349d9a22e6
|
5f22613f9ac3dff56def0511dc58dc5a43392937
|
refs/heads/master
| 2020-12-24T16:15:09.813431 | 2014-09-11T17:40:57 | 2014-09-11T17:40:57 | 7,096,984 | 2 | 0 | null | 2013-04-16T15:43:25 | 2012-12-10T16:56:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 17,436 |
scm
|
tests.scm
|
;; check test.jar or java/jni-test project to see the test classes used in this file
(use jni lolevel expand-full moremacros srfi-13 test)
(import-for-syntax test)
(jvm-init "jars/test.jar:jars/jni-utils.jar")
(define-syntax test-jstring
(syntax-rules ()
((_ str jstring)
(test str (jstring->string jstring)))))
(define-syntax test-class
(syntax-rules ()
((_ class expr)
(test (string-append "class " (symbol->string 'class)) (to-string expr)))))
(define new-Foo (jlambda-constructor com.chicken_mobile.jni.test.Foo))
(define new-Bar (jlambda-constructor com.chicken_mobile.jni.test.Bar int))
(define new-N1 (jlambda-constructor com.chicken_mobile.jni.test.N1))
(define new-N2 (jlambda-constructor com.chicken_mobile.jni.test.N2))
(define new-Integer (jlambda-constructor java.lang.Integer int))
(test-group "primitives"
(test-class com.chicken_mobile.jni.test.Foo (get-object-class (new-Foo))))
(test-group "class"
(test-class java.lang.System (class java.lang.System))
(test-error (class System)))
(test-group "jlambda-field"
(let ((foo-lie (jlambda-field (static) boolean com.chicken_mobile.jni.test.Foo lie)))
(test #t (foo-lie))
(set! (foo-lie) #f)
(test #f (foo-lie)))
(let ((foo-noSense (jlambda-field (static) java.lang.String com.chicken_mobile.jni.test.Foo noSense))
(foo-sense (jlambda-field (static) java.lang.String com.chicken_mobile.jni.test.Foo sense)))
(test-jstring "lil oiuy pppq" (foo-noSense))
(test-jstring "cogito ergo sum" (foo-sense))
(set! (foo-noSense) (foo-sense))
(test-jstring "cogito ergo sum" (foo-noSense)))
(let ((foo-number (jlambda-field () int com.chicken_mobile.jni.test.Foo number))
(o (new-Foo)))
(test 12 (foo-number o))
(set! (foo-number o) 300)
(test 300 (foo-number o)))
(let ((o (new-Foo)))
(let ((foo-secret_number (jlambda-field (private) int com.chicken_mobile.jni.test.Foo secret_number)))
(test 8 (foo-secret_number o))
(set! (foo-secret_number o) 33)
(test 33 (foo-secret_number o)))
;!!!!! Notice that the modifier can be omitted: (all but static)
(let ((foo-secret_number (jlambda-field () int com.chicken_mobile.jni.test.Foo secret_number)))
(test 33 (foo-secret_number o))
(set! (foo-secret_number o) 55)
(test 55 (foo-secret_number o))))
(test-error "class not found" (jlambda-field () int com.chicken_mobile.jni.test.AFoo secret_number))
(test #f (exception-check))
(test-error "field not found" (jlambda-field () int java.lang.String size))
(test #f (exception-check))
(let ((foo (new-Foo))
(Foo-bar (jlambda-field (private final) com.chicken_mobile.jni.test.Bar com.chicken_mobile.jni.test.Foo bar))
(Bar-id (jlambda-field #f int com.chicken_mobile.jni.test.Bar id)))
(let* ((bar (Foo-bar foo)))
(test 11 (Bar-id bar))))
); end jlambda-field test group
(test-group "jlambda-constant"
(define CONSTANT (jlambda-constant int com.chicken_mobile.jni.test.Bar CONSTANT))
(define constant-field (jlambda-field (static) int com.chicken_mobile.jni.test.Bar CONSTANT))
(test 36 (CONSTANT))
(set! (constant-field) 1)
(test 1 (constant-field))
(test 36 (CONSTANT))
); end jlambda-constant test group
(test-group "jlambda-method"
;test #(..) signature, if not defined raises an error
(jlambda-method #f #(java.lang.reflect.Method) java.lang.Class getMethods)
(define jstring-value-of
(jlambda-method (static) java.lang.String java.lang.String valueOf int))
(define jstring-contains
(jlambda-method #f boolean java.lang.String contains java.lang.CharSequence))
(define jstring-contains2 ;testing modifiers
(jlambda-method (public) boolean java.lang.String contains java.lang.CharSequence))
(let ((eleven (jstring-value-of 11)))
(test #t (jobject? eleven))
(test-jstring "11" eleven)
(test #t (jstring-contains eleven (jstring-value-of 1)))
(test #t (jstring-contains2 eleven (jstring-value-of 1))))
(test-error "class not found" (jlambda-method (static) boolean AFoo hi))
(test #f (exception-check))
(test-error "method not found" (jlambda-method (static) boolean java.lang.String hi))
(test #f (exception-check))
); end jlambda-method test group
(test-group "jlambda-methods"
(let* ((bar (new-Bar 1))
(hola (jstring "hola"))
(ov1 (jlambda-methods 'com.chicken_mobile.jni.test.Bar 'ov1
'((#f int)
(#f int int)
(#f int java.lang.String)
(#f int com.chicken_mobile.jni.test.Bar)
(#f int int java.lang.String)
(#f int int com.chicken_mobile.jni.test.Bar)
(#f int long)
(#f int short)
(#f int long int)
(#f int float)
(#f int double)
(#f int int long)
(#f int int int)
(#f int com.chicken_mobile.jni.test.N1)
(#f int com.chicken_mobile.jni.test.N2)
(#f int java.lang.Integer)
(#f int char)))))
(test 01 (ov1 bar))
(test 02 (ov1 bar hola))
(test 03 (ov1 bar 3))
(test 04 (ov1 bar bar))
(test 05 (ov1 bar 1 hola))
(test 06 (ov1 bar 2 bar))
(test 07 (ov1 bar (expt 2 32)))
(test 08 (ov1 bar (type: short 1)))
(test 09 (ov1 bar (type: long 1) 1))
(test 10 (ov1 bar 1.3))
(test 10 (ov1 bar (type: float 1)))
(test 11 (ov1 bar ((jlambda-field (static) double java.lang.Double MIN_VALUE))))
(test 12 (ov1 bar 1 (expt 2 32)))
(test 13 (ov1 bar 10 10))
(test 14 (ov1 bar (new-N1)))
(test 14 (ov1 bar (type: com.chicken_mobile.jni.test.N1 (new-N2))))
(test 15 (ov1 bar (new-N2)))
(test 16 (ov1 bar (new-Integer 1)))
(test 17 (ov1 bar #\c))
(delete-local-ref hola))
(let* ((bar (new-Bar 1))
(ov1 (jlambda-methods 'com.chicken_mobile.jni.test.Bar 'ov1
'((#f int)
(#f int java.lang.String)
(#f int com.chicken_mobile.jni.test.Bar)
(#f int int java.lang.String)
(#f int int com.chicken_mobile.jni.test.Bar)
(#f int long)
(#f int short)
(#f int float)
(#f int double)
(#f int int long)
(#f int int int)
(#f int com.chicken_mobile.jni.test.N1)
(#f int com.chicken_mobile.jni.test.N2)
(#f int java.lang.Integer)
(#f int char)))))
(test 7 (ov1 bar 3))) ; not defined for int so prefer long
(let* ((bar (new-Bar 1))
(ov1 (jlambda-methods 'com.chicken_mobile.jni.test.Bar 'ov1
'((#f int)
(#f int java.lang.String)
(#f int com.chicken_mobile.jni.test.Bar)
(#f int int java.lang.String)
(#f int int com.chicken_mobile.jni.test.Bar)
(#f int short)
(#f int float)
(#f int double)
(#f int int long)
(#f int int int)
(#f int com.chicken_mobile.jni.test.N1)
(#f int com.chicken_mobile.jni.test.N2)
(#f int java.lang.Integer)
(#f int char)))))
(test 10 (ov1 bar 3))) ; not defined for int or long so prefer float
(let* ((bar (new-Bar 1)) ; testing diff return-types
(hi (jstring "hi"))
(ov2 (jlambda-methods 'com.chicken_mobile.jni.test.Bar 'ov2
'((#f int int)
(#f java.lang.String java.lang.String)))))
(test 1 (ov2 bar 3))
(test-jstring "ov2" (ov2 bar hi))
(delete-local-ref hi))
); end jlambda-methods tests
(test-group "jlambda-constructor"
(define new-Integer-int (jlambda-constructor java.lang.Integer int))
(define Integer-toString
(jlambda-method #f java.lang.String java.lang.Integer toString))
(let ((n (new-Integer-int 30)))
(test-jstring "30" (Integer-toString n)))
(test-error "class not found" (jlambda-constructor java.lang.AInteger int))
(test #f (exception-check))
(test-error "method not found" (jlambda-constructor java.lang.Integer int int))
(test #f (exception-check))
); end jlambda-constructor test group
(test-group "import-java-ns"
(import-java-ns ((java.lang String)))
(test-class java.lang.String (class java.lang.String))
(test-class java.lang.String (class String))
(test-error (class OtherString))
(import-table #f) ; reset import-table
(import-java-ns ((java.lang *)
(com.chicken_mobile.jni.test *)))
(test-class java.lang.String (class java.lang.String))
(test-class java.lang.String (class String))
(test-class java.lang.System (class System))
(test-class java.lang.Short (class Short))
(test-error (class OtherString))
(import-table #f) ; reset import-table
(import-java-ns ((java.lang (String System))))
(test-class java.lang.String (class java.lang.String))
(test-class java.lang.String (class String))
(test-class java.lang.System (class System))
(test-error (class OtherString))
(import-table #f) ; reset import-table
(import-java-ns ((java.lang *)
(com.chicken_mobile.jni.test *)))
(let ((jstring-value-of (jlambda-method (static) java.lang.String java.lang.String valueOf int))
(jstring-value-of2 (jlambda-method (static) String String valueOf int)))
(test-jstring "11" (jstring-value-of 11))
(test-jstring "11" (jstring-value-of2 11)))
(let ((foo-noSense (jlambda-field (static) String Foo noSense))
(foo-sense (jlambda-field (static) String Foo sense)))
(set! (foo-noSense) (foo-sense)))
(import-table #f) ; reset import-table
(import-java-ns ((java.lang *)
(com.chicken_mobile.jni.test (Bar Foo))))
(let ((foo (new-Foo))
(Foo-bar (jlambda-field (private final) Bar Foo bar))
(Bar-id (jlambda-field #f int Bar id)))
(let* ((bar (Foo-bar foo)))
(test 11 (Bar-id bar))))
); end import-java-ns test group
(test-group "exceptions"
(let ((foo-xxx2 (jlambda-method #f java.lang.String com.chicken_mobile.jni.test.Foo xxx2))
(o (new-Foo)))
(test-error (foo-xxx2 o)))
(define (exception-thunk)
(let ((foo-xxx (jlambda-method #f void com.chicken_mobile.jni.test.Foo xxx))
(o (new-Foo)))
(foo-xxx o)))
(call/cc
(lambda (k)
(with-exception-handler (lambda (exception)
(let ((e (exception-cause exception)))
(test #t (java-exception? e))
(test "bad protocol" (java-exception-message e))
(test 'java.lang.RuntimeException (java-exception-type e))
(test #f (exception-check))
(k '())))
exception-thunk)))
); end exceptions test group
(test-group "jlambda"
;jlambda class
(test-class java.lang.System (jlambda java.lang.System))
;; jlambda field
(let ((foo-number (jlambda com.chicken_mobile.jni.test.Foo number))
(o (new-Foo)))
(test 12 (foo-number o))
(set! (foo-number o) 300)
(test 300 (foo-number o)))
;;;invalid
(begin-for-syntax
(require-library test)
(test-error (jlambda com.chicken_mobile.jni.test.Foo sense2)))
(let* ((bar (new-Bar 1))
(ov1 (jlambda com.chicken_mobile.jni.test.Bar ov1))
(hola (jstring "hola")))
(test 01 (ov1 bar))
(test 02 (ov1 bar hola))
(test 03 (ov1 bar 3))
(test 04 (ov1 bar bar))
(test 05 (ov1 bar 1 hola))
(test 06 (ov1 bar 2 bar))
(test 07 (ov1 bar (expt 2 32)))
(test 10 (ov1 bar 1.3))
(test 11 (ov1 bar ((jlambda-field (static) double java.lang.Double MIN_VALUE))))
(test 12 (ov1 bar 1 (expt 2 32)))
(test 13 (ov1 bar 10 10))
(test 14 (ov1 bar (new-N1)))
(test 15 (ov1 bar (new-N2)))
(test 16 (ov1 bar (new-Integer 1)))
(test 17 (ov1 bar #\c))
(delete-local-ref hola))
(let ((new-Bar (jlambda com.chicken_mobile.jni.test.Bar new)))
(test-class com.chicken_mobile.jni.test.Bar (get-object-class (new-Bar 1)))
(test-class com.chicken_mobile.jni.test.Bar (get-object-class (new-Bar)))
(test-class com.chicken_mobile.jni.test.Bar (get-object-class
(let* ((a (jstring " "))
(bar (new-Bar a)))
(delete-local-ref a)
bar))))
(begin-for-syntax
(require-library test)
(test-error (jlambda com.chicken_mobile.jni.test.Foo secret_number))) ;is private
); end jlambda test group
(test-group "jimport"
(jimport java.lang.String)
(test "class java.lang.String$CaseInsensitiveComparator" (to-string (get-object-class (CASE_INSENSITIVE_ORDER))))
(test-jstring "1" (valueOf 1))
(jimport com.chicken_mobile.jni.test.Bar (prefix <> bar-))
(test 1 (bar-ov1 (bar-new)))
(jimport com.chicken_mobile.jni.test.Handler (prefix <> handler-))
(test 1 (handler-send (bar-handler (bar-new)) 0))
(jimport java.lang.String (prefix (only <> valueOf) String-))
(test-jstring "1" (String-valueOf 1))
(jimport com.chicken_mobile.jni.test.N2 (prefix <> N2-))
(test 1 (N2-h)) ;;defined in superclass
(test 2 (N2-j))
(jimport com.chicken_mobile.jni.test.Foo (prefix <> Foo-))
(test #f (Foo-returnNull))
(test #f (Foo-same #f))
(jimport java.util.concurrent.ConcurrentLinkedQueue (prefix <> Queue-))
(jimport java.lang.Integer (prefix <> Integer-))
(jimport java.lang.Character (prefix <> Integer-))
); end jimport test group
(test-exit)
| true |
e482f62f54c008e50035c847348b32857d683fc6
|
57eba9063c7e90877207c3ccff9316ccd4ef2527
|
/nils/scheme/s9fes/s9/s9.scm
|
6dbcc6fba5e84d74cdebf2755d00747d612f2587
|
[
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] |
permissive
|
rigidus/uexp
|
7f34136fa3b9e806ae26a8e08492568dca9b77cf
|
81c8e6f1997c5eddf09abb62a6e10ded11218ae3
|
refs/heads/master
| 2023-01-11T02:31:53.470831 | 2020-11-12T01:40:48 | 2020-11-12T01:40:48 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 21,356 |
scm
|
s9.scm
|
; DO NOT EDIT THIS FILE! EDIT "edoc/s9.scm.edoc" INSTEAD.
;;
;; Scheme 9 from Empty Space
;; By Nils M Holm, 2007-2010
;; Placed in the Public Domain
;;
;; Some obvious procedures first
(define (void) (if #f #f))
(define call-with-current-continuation call/cc)
;; Auxiliary definitions, will be redefined later
(define append append2)
; There is no LET or LETREC yet, so
(define-syntax (let bindings . exprs)
((lambda (split)
((lambda (tmp-split)
(set! split tmp-split)
(apply (lambda (vars args)
(append
(list (append
(list 'lambda)
(append (list vars)
exprs)))
args))
(split bindings '() '())))
(lambda (bind* vars args)
(if (null? bind*)
(list vars args)
(split (cdr bind*)
(cons (caar bind*) vars)
(cons (cadr (car bind*)) args))))))
#f))
(define (map-car f a)
(let ((mapcar1 #f))
(let ((tmp-mapcar1
(lambda (a)
(if (null? a)
'()
(cons (f (car a))
(mapcar1 (cdr a)))))))
(set! mapcar1 tmp-mapcar1)
(mapcar1 a))))
(define (map f a b)
(let ((map2 #f))
(let ((tmp-map2
(lambda (a b)
(if (null? a)
'()
(cons (f (car a) (car b))
(map2 (cdr a) (cdr b)))))))
(set! map2 tmp-map2)
(map2 a b))))
(define-syntax (letrec bindings . exprs)
(let ((append3
(lambda (a b c)
(append a (append b c))))
(tmps (map-car (lambda (x) (gensym)) bindings))
(vars (map-car car bindings))
(args (map-car cadr bindings)))
(let ((undefineds (map-car (lambda (v) (list v #f))
vars))
(tmp-bindings (map list tmps args))
(updates (map (lambda (v t) (list 'set! v t))
vars
tmps)))
(list 'let
undefineds
(append3 '(let)
(list tmp-bindings)
(append updates exprs))))))
;; Type predicates
(define number? integer?)
(define (port? x)
(or (input-port? x)
(output-port? x)))
;; Equivalence predicates
(define (equal? a b)
(cond ((eq? a b))
((and (pair? a)
(pair? b))
(and (equal? (car a) (car b))
(equal? (cdr a) (cdr b))))
((string? a)
(and (string? b)
(string=? a b)))
((vector? a)
(and (vector? b)
(equal? (vector->list a)
(vector->list b))))
(else
(eqv? a b))))
;; List procedures
(define (list? x)
(letrec
((l? (lambda (x y)
(cond ((eq? x y) #f)
((null? x) #t)
((pair? x) (or (null? (cdr x))
(and (pair? (cdr x))
(l? (cddr x) (cdr y)))))
(else #f)))))
(or (null? x)
(and (pair? x)
(l? (cdr x) x)))))
(define (assoc x a)
(cond ((null? a) #f)
((equal? (caar a) x) (car a))
(else (assoc x (cdr a)))))
(define (member x a)
(cond ((null? a) #f)
((equal? (car a) x) a)
(else (member x (cdr a)))))
; Auxiliary functions for FOLD-LEFT, FOLD-RIGHT, MAP
(define (map-car f a)
(letrec
((mapcar1
(lambda (a r)
(if (null? a)
(reverse! r)
(mapcar1 (cdr a)
(cons (f (car a)) r))))))
(mapcar1 a '())))
(define car-of
(let ((map-car map-car))
(lambda (a*)
(map-car car a*))))
(define cdr-of
(let ((map-car map-car))
(lambda (a*)
(map-car cdr a*))))
(define (any-null a*)
(memq '() a*))
(define fold-left
(let ((car-of car-of)
(cdr-of cdr-of)
(any-null any-null))
(lambda (f b . a*)
(letrec
((fold
(lambda (a* r)
(if (any-null a*)
r
(fold (cdr-of a*)
(apply f r (car-of a*)))))))
(if (null? a*)
(error "fold-left: too few arguments")
(fold a* b))))))
(define fold-right
(let ((car-of car-of)
(cdr-of cdr-of)
(any-null any-null)
(map-car map-car))
(lambda (f b . a*)
(letrec
((foldr
(lambda (a* r)
(if (any-null a*)
r
(foldr (cdr-of a*)
(apply f (append2 (car-of a*)
(list r))))))))
(if (null? a*)
(error "fold-right: too few arguments")
(foldr (map-car reverse a*) b))))))
(define append
(let ((append2 append2))
(letrec
((foldr-app
(lambda (a)
(cond ((null? a)
'())
((and (pair? a)
(not (pair? (car a)))
(null? (cdr a)))
(car a))
(else
(append2 (car a) (foldr-app (cdr a))))))))
(lambda a
(foldr-app a)))))
(define (list-ref x n)
(car (list-tail x n)))
(define map
(let ((car-of car-of)
(cdr-of cdr-of)
(any-null any-null))
(lambda (f . a*)
(letrec
((map2
(lambda (a* r)
(if (any-null a*)
(reverse! r)
(map2 (cdr-of a*)
(cons (apply f (car-of a*))
r))))))
(if (null? a*)
(error "map: too few arguments")
(map2 a* '()))))))
(define (for-each f . a*)
(if (null? a*)
(error "for-each: too few arguments")
(apply map f a*))
(void))
;; Arithmetic procedures
(define (expt x y)
(letrec
((square
(lambda (x) (* x x)))
(expt2
(lambda (x y)
(cond ((zero? y) 1)
((even? y) (square (expt2 x (quotient y 2))))
(else (* x (square (expt2 x (quotient y 2)))))))))
(if (negative? y)
(error "expt: expected non-negative exponent, got" y))
(expt2 x y)))
(define gcd
(let ((fold-left fold-left))
(lambda a
(letrec
((gcd2
(lambda (a b)
(cond ((zero? b) a)
((zero? a) b)
((< a b) (gcd2 a (remainder b a)))
(else (gcd2 b (remainder a b)))))))
(fold-left gcd2 0 (map abs a))))))
(define lcm
(let ((fold-left fold-left))
(lambda a
(letrec
((lcm2
(lambda (a b)
(let ((cd (gcd a b)))
(* cd (* (quotient a cd)
(quotient b cd)))))))
(fold-left lcm2 1 (map abs a))))))
(define (modulo a b)
(let ((rem (remainder a b)))
(cond ((zero? rem) 0)
((eq? (negative? a) (negative? b)) rem)
(else (+ b rem)))))
;; String procedures
(define (number->string n . radix)
(letrec
((digits
(string->list "0123456789abcdef"))
(conv
(lambda (n rdx res)
(if (zero? n)
(if (null? res) '(#\0) res)
(conv (quotient n rdx)
rdx
(cons (list-ref digits (remainder n rdx))
res)))))
(conv-int
(lambda (n rdx)
(if (negative? n)
(list->string (cons #\- (conv (abs n) rdx '())))
(list->string (conv n rdx '())))))
(get-radix
(lambda ()
(cond ((null? radix)
10)
((<= 2 (car radix) 16)
(car radix))
(else
(error "number->string: invalid radix"
(car radix)))))))
(conv-int n (get-radix))))
(define (string->number str . radix)
(letrec
((digits
(string->list "0123456789abcdef"))
(value-of-digit
(lambda (x)
(letrec
((v (lambda (x d n)
(cond ((null? d) 17)
((char=? x (car d)) n)
(else (v x (cdr d) (+ n 1)))))))
(v (char-downcase x) digits 0))))
(conv3
(lambda (lst res rdx)
(if (null? lst)
res
(let ((dval (value-of-digit (car lst))))
(and (< dval rdx)
(conv3 (cdr lst)
(+ dval (* res rdx))
rdx))))))
(conv
(lambda (lst rdx)
(and (not (null? lst))
(conv3 lst 0 rdx))))
(sconv
(lambda (lst rdx)
(cond ((null? lst)
#f)
((char=? (car lst) #\+)
(conv (cdr lst) rdx))
((char=? (car lst) #\-)
(let ((r (conv (cdr lst) rdx)))
(if r (- r) #f)))
(else
(conv lst rdx)))))
(get-radix
(lambda ()
(cond ((null? radix)
10)
((<= 2 (car radix) 17)
(car radix))
(else
(error "string->number: invalid radix" radix)))))
(base-prefix?
(lambda (s)
(and (> (string-length s) 2)
(char=? #\# (string-ref s 0))
(memv (string-ref s 1) '(#\b #\d #\o #\x))
#t))))
(let ((r (if (base-prefix? str)
(let ((rc (string-ref str 1)))
(cond ((char=? rc #\b) 2)
((char=? rc #\d) 10)
((char=? rc #\o) 8)
(else 16)))
(get-radix)))
(s (if (base-prefix? str)
(substring str 2 (string-length str))
str)))
(and r (sconv (string->list s) r)))))
;; Input/output procedures
(define (newline . port)
(apply write-char #\newline port))
(define (call-with-input-file file proc)
(let ((f (open-input-file file)))
(let ((r (proc f)))
(close-input-port f)
r)))
(define (call-with-output-file file proc)
(let ((f (open-output-file file)))
(let ((r (proc f)))
(close-output-port f)
r)))
(define with-input-from-file
(let ((set-input-port! set-input-port!))
(lambda (file thunk)
(let ((outer-port (current-input-port))
(new-port (open-input-file file)))
(set-input-port! new-port)
(let ((r (thunk)))
(close-input-port new-port)
(set-input-port! outer-port)
r)))))
(define with-output-to-file
(let ((set-output-port! set-output-port!))
(lambda (file thunk)
(let ((outer-port (current-output-port))
(new-port (open-output-file file)))
(set-output-port! new-port)
(let ((r (thunk)))
(close-output-port new-port)
(set-output-port! outer-port)
r)))))
;; Quasiquote Expander
(define-syntax (quasiquote tmpl)
(letrec
((qq-cons
(lambda (a b)
(cond ((and (pair? a)
(eq? 'unquote-splicing (car a)))
(list 'append (cadr a) b))
(else
(list 'cons a b)))))
(qq-expand-1
(lambda (x)
(cond ((vector? x)
(list 'list->vector (qq-expand-1 (vector->list x))))
((not (pair? x))
(list 'quote x))
((eq? 'unquote (car x))
(cadr x))
((eq? 'unquote-splicing (car x))
x)
(else
(qq-cons (qq-expand-1 (car x))
(qq-expand-1 (cdr x)))))))
(qq-expand
(lambda (tmpl q)
(let ((embedded-qq '()))
(letrec
((extract-nested-qq
(lambda (tmpl q)
(cond ((not (pair? tmpl))
tmpl)
((or (eq? (car tmpl) 'unquote)
(eq? (car tmpl) 'unquote-splicing))
(if (not q)
(error
"quasiquote: extra unquote/unquote-splicing"))
(if (and (pair? (cdr tmpl))
(null? (cddr tmpl)))
(list (car tmpl)
(extract-nested-qq (cadr tmpl) #f))
(error (string-append
(symbol->string (car tmpl))
": wrong number of arguments")
tmpl)))
((eq? 'quasiquote (car tmpl))
(if q (error "quasiquote: may not be nested"))
(if (and (pair? (cdr tmpl))
(null? (cddr tmpl)))
(let ((g (gensym)))
(set! embedded-qq
(cons (list g (qq-expand (cadr tmpl)
#t))
embedded-qq))
g)
(error "quasiquote: wrong number of arguments"
tmpl)))
(else
(cons (extract-nested-qq (car tmpl) q)
(extract-nested-qq (cdr tmpl) q)))))))
(let ((tmpl (extract-nested-qq tmpl q)))
(if (null? embedded-qq)
(qq-expand-1 tmpl)
(list 'let embedded-qq (qq-expand-1 tmpl)))))))))
(qq-expand tmpl #t)))
;; Derived Syntax
; LET/LET*/LETREC helper
(define (check-bindings who b opt-arg)
(cond ((null? b))
((and (pair? b)
(pair? (car b))
(symbol? (caar b))
(pair? (cdar b))
(or (null? (cddar b))
(and opt-arg
(pair? (cddar b))
(null? (cdddar b)))))
(check-bindings who (cdr b) opt-arg))
(else
(error (string-append who ": invalid syntax") b))))
(define (split-bindings clauses)
(letrec
((split3
(lambda (clauses vars args opt)
(cond ((null? clauses)
(list (reverse! vars)
(reverse! args)
(reverse! opt)))
(else
(split3 (cdr clauses)
(cons (caar clauses) vars)
(cons (cadar clauses) args)
(if (null? (cddar clauses))
(cons (caar clauses) opt)
(cons (caddar clauses) opt))))))))
(split3 clauses '() '() '())))
; Now that the QQ expander is here, define a
; clean version of LET (including named LET).
; Can't name it LET yet, because it uses LET.
(define-syntax %full-let
(let ((check-bindings check-bindings)
(split-bindings split-bindings))
(lambda (a1 a2 . a3)
(if (symbol? a1)
(if (null? a3)
(error "named let: missing body"
`(let ,a1 ,a2 ,@a3))
(begin (check-bindings "let" a2 #f)
(let ((va (split-bindings a2)))
(let ((v (car va))
(a (cadr va)))
`((letrec ((,a1 (lambda ,v ,@a3)))
,a1) ,@a)))))
(begin (check-bindings "let" a1 #f)
(let ((va (split-bindings a1)))
(let ((v (car va))
(a (cadr va)))
`((lambda ,v ,a2 ,@a3) ,@a))))))))
(define-syntax let %full-let)
; Also define a clean version of LETREC.
(define-syntax %clean-letrec
(let ((check-bindings check-bindings)
(split-bindings split-bindings))
(lambda (bindings expr . exprs)
(check-bindings "letrec" bindings #f)
(let ((va (split-bindings bindings)))
(let ((tmps (map (lambda (x) (gensym)) bindings))
(vars (car va))
(args (cadr va)))
(let ((undefineds (map (lambda (v) (list v #f))
vars))
(tmp-bindings (map (lambda (t a) (list t a))
tmps
args))
(updates (map (lambda (v t) (list 'set! v t))
vars
tmps)))
`(let ,undefineds
(let ,tmp-bindings
,@updates
,expr
,@exprs))))))))
(define-syntax letrec %clean-letrec)
(define-syntax let*
(let ((check-bindings check-bindings))
(lambda (bindings expr . exprs)
(letrec
((nest-let
(lambda (b)
(if (null? (cdr b))
`(let (,(car b))
,@(cons expr exprs))
`(let (,(car b))
,(nest-let (cdr b)))))))
(check-bindings "let*" bindings #f)
(if (null? bindings)
`(let () ,expr ,@exprs)
(nest-let bindings))))))
(define-syntax (case key . clauses)
(letrec
((gen-clauses
(lambda (k c*)
(cond ((null? c*) '())
((or (not (pair? c*))
(not (pair? (car c*)))
(not (pair? (cdar c*))))
(error "case: syntax error" c*))
((null? (cdr c*))
(if (eq? 'else (caar c*))
`((else ,@(cdar c*)))
`(((memv ,k ',(caar c*)) ,@(cdar c*)))))
(else
`(((memv ,k ',(caar c*)) ,@(cdar c*))
,@(gen-clauses k (cdr c*))))))))
(let ((k (gensym)))
`(let ((,k ,key))
(cond ,@(gen-clauses k clauses))))))
(define-syntax do
(let ((check-bindings check-bindings)
(split-bindings split-bindings))
(lambda (var-clauses test . body)
(if (or (not (pair? test))
(not (list? (cdr test))))
(error "do: invalid syntax" test))
(check-bindings "do" var-clauses #t)
(let ((loop (gensym))
(var+init+step (split-bindings var-clauses)))
(let ((v (car var+init+step))
(i (cadr var+init+step))
(s (caddr var+init+step)))
`(letrec
((,loop
(lambda ,v
(if ,(car test)
(begin ,@(cdr test))
(begin ,@body (,loop ,@s))))))
(,loop ,@i)))))))
(define-syntax (delay expr)
`(let ((value #f))
(lambda ()
(if value
(car value)
(let ((x ,expr))
(if value
(car value)
(begin (set! value (list x))
(car value))))))))
(define (force x) (x))
;; Utilities
(define (print . x*)
(letrec
((p (lambda (x* first)
(cond ((not (null? x*))
(if (not first) (write-char #\space))
(write (car x*))
(p (cdr x*) #f))))))
(p x* #t)
(newline)))
(define (locate-file file)
(letrec
((split
(lambda (s)
(let loop ((in (string->list s))
(tmp '())
(out '()))
(cond ((null? in)
(if (null? tmp)
out
(reverse! (cons (list->string (reverse! tmp))
out))))
((char=? #\: (car in))
(loop (cdr in)
'()
(cons (list->string (reverse! tmp))
out)))
(else
(loop (cdr in)
(cons (car in) tmp)
out)))))))
(let loop ((path (split *library-path*)))
(and (not (null? path))
(let ((full-path (string-append (car path) "/" file)))
(if (file-exists? full-path)
full-path
(loop (cdr path))))))))
(define load-from-library
(let ((locate-file locate-file))
(lambda (file)
(let ((full-path (locate-file file))
(do-load (lambda (file)
(begin (if (not *loading*)
(begin (display "; loading from ")
(display file)
(newline)))
(load file)))))
(if full-path
(do-load full-path)
(let ((full-path (locate-file (string-append file ".scm"))))
(if full-path
(do-load full-path)
(error "cannot locate file" file))))))))
(define-syntax (require-extension . x*)
(do ((x* x* (cdr x*))
(na '()))
((null? x*)
(if (not (null? na))
(error "extension(s) required, but not compiled-in"
(reverse! na))))
(if (not (memq (car x*) *extensions*))
(set! na (cons (car x*) na)))))
| true |
992c70d3c79fae072e696f14b1b65bcd20085656
|
ac2a3544b88444eabf12b68a9bce08941cd62581
|
/lib/scheme/load/load.sld
|
102bf03cdf95619edf799208f0acbcf2b8436305
|
[
"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 | 69 |
sld
|
load.sld
|
(define-library (scheme load)
(namespace "")
(export
load
))
| false |
3fbf5e5af2398e8c2c7f84ad14b572276192e88d
|
893a879c6b61735ebbd213fbac7e916fcb77b341
|
/assignments/assignment_05.ss
|
40bff3a097e9cbb74ef74e109f9e26ef39d27e59
|
[] |
no_license
|
trittimo/PLC-Assignments
|
e5353c9276e93bca711b684c955d6c1df7cc6c82
|
666c2521f1bfe1896281e06f0da9a7ca315579bb
|
refs/heads/master
| 2016-08-31T04:52:26.143152 | 2016-06-05T01:00:18 | 2016-06-05T01:00:18 | 54,284,286 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,142 |
ss
|
assignment_05.ss
|
(define (sort-intervals ls)
(sort (lambda (a b) (<= (car a) (car b))) ls))
(define (combine a b)
(list (apply min (append a b)) (apply max (append a b))))
(define (intersects? a b)
(or
(<= (car b) (cadr a) (cadr b))
(<= (car a) (cadr b) (cadr a))))
(define (collapse ls)
(cond
([= (length ls) 0]
'())
([= (length ls) 1]
ls)
(else
(if (intersects? (car ls) (cadr ls))
(collapse (cons (combine (car ls) (cadr ls)) (cddr ls)))
(cons (car ls) (collapse (cdr ls)))))))
(define (minimize-interval-list ls)
(collapse (sort-intervals ls)))
(define (exists? pred ls)
(if (null? ls)
#f
(or (pred (car ls)) (exists? pred (cdr ls)))))
(define (list-index pred ls)
(define (list-index-helper ls accum)
(if (null? ls)
#f
(if (pred (car ls))
accum
(list-index-helper (cdr ls) (add1 accum)))))
(list-index-helper ls 0))
(define (fact n)
(if (> n 1)
(* n (fact (- n 1)))
1))
(define (choose n k)
(/ (fact n) (* (fact k) (fact (- n k)))))
(define (pascal-row n ls)
(if (= (length ls) n)
(cons 1 ls)
(pascal-row n (cons (choose n (length ls)) ls))))
(define (pascal-triangle n)
(cond
((< n 0) '())
((= n 0) '((1)))
(else
(cons (pascal-row n '()) (pascal-triangle (sub1 n))))))
(define (product set1 set2)
(if (null? set1)
'()
(append (map (lambda(x) (list (car set1) x)) set2) (product (cdr set1) set2))))
(define (max-edges n)
(/ (* n (sub1 n)) 2))
(define (valid-node? n g)
(and
(not (member (car n) (cadr n)))
(andmap (lambda (x) (member (car n) (cadr x))) g)))
(define (complete? g)
(or (null? g) (not (member #f (map (lambda (x) (valid-node? x (remove x g))) g)))))
(define (complete ls)
(map (lambda (x) (list x (remove x ls))) ls))
(define (replace old new ls)
(cond
((null? ls) '())
((equal? (car ls) old) (cons new (replace old new (cdr ls))))
(else (cons (car ls) (replace old new (cdr ls))))))
(define (remove-first element ls)
(if (null? ls)
'()
(if (equal? element (car ls)) (cdr ls)
(cons (car ls) (remove-first element (cdr ls))))))
(define (remove-last element ls)
(reverse (remove-first element (reverse ls))))
| false |
927ede939d192b36cee93fd2601afcf1b61b7ae4
|
95cf66a8b36c421b6e04da3e91c22d97b88d6e48
|
/Scheme/laba3/0(1).scm
|
e1e0714c4c4b5af9abb1c1c44110f668aeb5f519
|
[] |
no_license
|
AleksMa/Tasks
|
79ab063888fd0544a7c7ba569febc7ed46796ae6
|
bc516a02bf94f8502f1d56384ef6c5bd3165d2c9
|
refs/heads/master
| 2020-03-18T02:14:00.562793 | 2020-02-28T17:22:01 | 2020-02-28T17:22:01 | 134,180,799 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 438 |
scm
|
0(1).scm
|
(define state #f)
(define (use-assertions . xs)
(call-with-current-continuation
(lambda (c)
(set! state c))))
(use-assertions)
(define-syntax assert
(syntax-rules ()
((_ fs)
;(define f (quote fs))
(if (not fs)
(begin
(state (and
(display "FAILED: ")
(display (quote fs)))))))))
(define (1/x x)
(assert (not (zero? x)))
(/ 1 x))
;(map 1/x '(1 2 3 4 5))
; (map 1/x '(-2 -1 0 1 2))
| true |
8ba452ee9ce238a753535fcc525ae40ee54b3ab6
|
f0747cba9d52d5e82772fd5a1caefbc074237e77
|
/text.sld
|
379e209c4dde501301887724f1f26e97b445e884
|
[] |
no_license
|
philhofer/distill
|
a3b024de260dca13d90e23ecbab4a8781fa47340
|
152cb447cf9eef3cabe18ccf7645eb597414f484
|
refs/heads/master
| 2023-08-27T21:44:28.214377 | 2023-04-20T03:20:55 | 2023-04-20T03:20:55 | 267,761,972 | 3 | 0 | null | 2021-10-13T19:06:55 | 2020-05-29T04:06:55 |
Scheme
|
UTF-8
|
Scheme
| false | false | 244 |
sld
|
text.sld
|
(define-library (distill text)
(export
lines
map-lines
join-with
tabular)
(import
scheme
(only (chicken port) with-output-to-string)
(only (chicken base) include intersperse identity unless))
(include "text.scm"))
| false |
f2d92815952a5b0a8fe93ff97f001071822756ef
|
11b227f71ec01f2e497680cc5f9090c984e9f48e
|
/sources/infrastructure/services/services.scm
|
fa393ab36c568fedbce74002438a5c272499d547
|
[
"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 | 1,457 |
scm
|
services.scm
|
(declare (unit services))
(declare (uses sql))
;; invokes a service
(define (invoke-service service request success-procedure validation-errors-procedure)
;; open a database connection
(with-sql-connection "/var/databases/customers.db"
(lambda (sql-connection)
;; enable the foreign keys enforcement
(sql-enable-foreign-keys sql-connection)
;; disable the synchronous disk
;; writes for improved performance
(sql-disable-synchronous-writes sql-connection)
;; start a transaction
(sql-begin-transaction sql-connection)
;; check for exceptions
(handle-exceptions
exception
(begin
;; rollback the transaction
(with-exception-hiding
(lambda ()
(sql-rollback-transaction sql-connection)))
;; check if a validation exception was raised
(if (validation-exception? exception)
;; report the validation errors
;; through the error procedure
(validation-errors-procedure (validation-errors exception))
;; re-raise any other exception
(abort exception)))
;; invoke the service
(let ((response (service sql-connection request)))
;; commit the transaction
(sql-commit-transaction sql-connection)
;; report the response through
;; the success procedure
(success-procedure response))))))
| false |
6a7f9f9073e71a07083cf814e3af895a8fbbf35f
|
ac2a3544b88444eabf12b68a9bce08941cd62581
|
/tests/unit-tests/13-modules/prim_char.scm
|
183577687f95a0b98bb07f3397e03d6cb50ad8e7
|
[
"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 | 2,560 |
scm
|
prim_char.scm
|
(include "#.scm")
(check-same-behavior ("" "##" "~~lib/_prim-char#.scm")
;; R4RS
(char->integer #\a)
(char-alphabetic? #\a) (char-alphabetic? #\ ) (char-alphabetic? #\A) (char-alphabetic? #\0)
(char-ci<?) (char-ci<? #\a) (char-ci<? #\a #\b) (char-ci<? #\b #\a) (char-ci<? #\a #\b #\c) (char-ci<? #\a #\a #\a) (char-ci<? #\c #\b #\a) (char-ci<? #\a #\A) (char-ci<? #\A #\a)
(char-ci<=?)(char-ci<=? #\a)(char-ci<=? #\a #\b)(char-ci<=? #\b #\a)(char-ci<=? #\a #\b #\c)(char-ci<=? #\a #\a #\a)(char-ci<=? #\c #\b #\a)(char-ci<=? #\a #\A)(char-ci<=? #\A #\a)
(char-ci=?) (char-ci=? #\a) (char-ci=? #\a #\b) (char-ci=? #\b #\a) (char-ci=? #\a #\b #\c) (char-ci=? #\a #\a #\a) (char-ci=? #\c #\b #\a) (char-ci=? #\a #\A) (char-ci=? #\A #\a)
(char-ci>?) (char-ci>? #\a) (char-ci>? #\a #\b) (char-ci>? #\b #\a) (char-ci>? #\a #\b #\c) (char-ci>? #\a #\a #\a) (char-ci>? #\c #\b #\a) (char-ci>? #\a #\A) (char-ci>? #\A #\a)
(char-ci>=?)(char-ci>=? #\a)(char-ci>=? #\a #\b)(char-ci>=? #\b #\a)(char-ci>=? #\a #\b #\c)(char-ci>=? #\a #\a #\a)(char-ci>=? #\c #\b #\a)(char-ci>=? #\a #\A)(char-ci>=? #\A #\a)
(char-downcase #\a) (char-downcase #\ ) (char-downcase #\A) (char-downcase #\0)
(char-lower-case? #\a) (char-lower-case? #\ ) (char-lower-case? #\A) (char-lower-case? #\0)
(char-numeric? #\a) (char-numeric? #\ ) (char-numeric? #\A) (char-numeric? #\0)
(char-upcase #\a) (char-upcase #\ ) (char-upcase #\A) (char-upcase #\0)
(char-upper-case? #\a) (char-upper-case? #\ ) (char-upper-case? #\A) (char-upper-case? #\0)
(char-whitespace? #\a) (char-whitespace? #\ ) (char-whitespace? #\A) (char-whitespace? #\0)
(char<=?)(char<=? #\a)(char<=? #\a #\b)(char<=? #\b #\a)(char<=? #\a #\b #\c)(char<=? #\a #\a #\a)(char<=? #\c #\b #\a)(char<=? #\a #\A)(char<=? #\A #\a)
(char<?) (char<? #\a) (char<? #\a #\b) (char<? #\b #\a) (char<? #\a #\b #\c) (char<? #\a #\a #\a) (char<? #\c #\b #\a) (char<? #\a #\A) (char<? #\A #\a)
(char=?) (char=? #\a) (char=? #\a #\b) (char=? #\b #\a) (char=? #\a #\b #\c) (char=? #\a #\a #\a) (char=? #\c #\b #\a) (char=? #\a #\A) (char=? #\A #\a)
(char>?) (char>? #\a) (char>? #\a #\b) (char>? #\b #\a) (char>? #\a #\b #\c) (char>? #\a #\a #\a) (char>? #\c #\b #\a) (char>? #\a #\A) (char>? #\A #\a)
(char>=?)(char>=? #\a)(char>=? #\a #\b)(char>=? #\b #\a)(char>=? #\a #\b #\c)(char>=? #\a #\a #\a)(char>=? #\c #\b #\a)(char>=? #\a #\A)(char>=? #\A #\a)
(char? 'a) (char? #\a) (char? "a")
(integer->char 65)
;; R7RS
(char-foldcase #\a) (char-foldcase #\ ) (char-foldcase #\A) (char-foldcase #\0)
(digit-value #\x) (digit-value #\4)
)
| false |
8f6d2ce208d2330198ceee68bd220f67c371adc2
|
000dbfe5d1df2f18e29a76ea7e2a9556cff5e866
|
/ext/crypto/tests/testvectors/signature/rsa_pss_2048_sha1_mgf1_20_test.scm
|
cf9a5beaca715440bd437acdfa87c19de8ee9869
|
[
"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 | 83,301 |
scm
|
rsa_pss_2048_sha1_mgf1_20_test.scm
|
(test-signature/testvector
"rsa_pss_2048_sha1_mgf1_20_test"
:algorithm
"RSASSA-PSS"
:digest
"SHA-1"
:public-key
#vu8(48 130 1 34 48 13 6 9 42 134 72 134 247 13 1 1 1 5 0 3 130 1 15 0 48 130 1 10 2 130 1 1 0 189 49 199 160 38 145 210 217 88 126 246 169 70 255 120 133 68 204 173 212 178 152 138 214 32 134 121 42 107 249 108 134 22 180 173 19 49 125 34 112 185 1 208 252 209 216 128 203 143 82 251 135 48 74 82 88 193 27 56 223 234 232 223 103 10 238 231 234 29 13 157 248 224 14 128 132 126 65 229 152 158 212 2 212 78 120 179 15 239 23 181 103 29 58 219 248 104 94 77 194 4 73 158 205 24 99 225 213 175 242 138 124 246 110 173 243 31 236 146 54 193 32 173 209 52 81 82 44 100 124 152 50 166 114 205 100 211 40 193 195 34 24 63 70 97 208 155 218 96 184 221 95 3 40 218 84 32 130 20 36 175 218 187 26 128 197 209 39 99 161 176 35 140 216 157 7 66 191 197 11 106 47 203 112 29 130 66 24 249 130 111 79 120 162 58 43 90 164 42 206 127 23 83 118 251 108 189 178 186 210 147 186 88 61 77 49 198 184 249 2 158 70 177 54 137 36 152 85 245 5 117 110 0 226 37 166 164 90 24 118 155 216 210 179 164 172 185 241 194 61 62 81 136 37 97 229 2 3 1 0 1)
:mgf
"MGF1"
:mgf-digest
"SHA-1"
:salt-length
20
:der-encode
#t
:tests
'(#(1
""
#vu8()
#vu8(29 90 155 180 156 177 245 194 134 47 54 228 81 220 231 252 96 127 61 48 46 185 169 251 234 91 103 58 41 250 144 35 48 131 129 38 44 83 140 181 57 16 181 119 58 122 68 255 70 88 40 189 252 207 138 122 78 249 2 233 69 221 95 98 38 255 183 213 176 95 35 53 229 118 44 90 206 255 113 200 64 129 80 149 156 23 128 204 156 34 252 206 189 52 5 232 31 27 193 109 39 108 7 228 165 69 221 177 170 222 183 81 181 113 210 47 62 75 196 224 32 32 238 197 144 26 30 188 4 65 94 157 223 233 103 251 228 236 113 102 146 58 160 149 185 252 122 129 252 33 186 55 181 34 10 151 63 197 243 47 219 142 8 65 237 50 20 80 36 132 2 161 89 210 192 142 74 114 183 128 49 13 66 10 110 73 156 43 52 176 189 111 224 209 208 225 167 129 5 99 50 74 216 231 120 114 7 85 235 0 172 110 40 178 4 255 95 187 1 252 252 145 232 241 210 241 19 165 243 40 67 17 159 94 6 190 236 15 233 78 91 253 12 205 215 243 34 189 171 123 5 196 248 60 5 4)
#t
("WeakHash"))
#(2
""
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#vu8(1 233 177 212 243 109 4 10 85 62 225 42 251 118 163 109 4 198 197 160 243 223 132 174 34 66 46 129 87 229 123 28 67 167 189 170 222 48 174 115 7 54 50 164 103 153 115 236 16 188 187 48 22 246 226 12 156 173 41 161 79 150 5 37 7 129 158 144 207 86 186 80 201 125 245 229 0 28 127 148 129 126 210 159 117 0 248 57 235 65 94 243 24 42 237 178 72 75 172 228 60 210 252 170 166 245 219 196 182 73 23 145 89 47 8 75 42 20 171 48 62 137 222 178 138 104 199 43 11 99 10 232 91 236 182 127 43 114 47 35 160 243 33 243 167 73 107 37 24 149 17 22 64 69 41 50 87 154 165 63 251 143 143 180 255 211 49 250 72 198 241 232 225 82 206 126 4 207 236 148 28 217 109 207 122 136 90 48 34 228 38 216 126 129 17 51 111 17 102 135 141 207 141 25 15 251 22 165 116 254 169 235 109 126 39 14 2 92 109 152 129 126 117 201 104 247 140 71 80 190 1 143 116 150 141 127 62 92 185 214 244 125 90 175 201 156 133 200 58 247 23 92 115 9 26 232)
#t
("WeakHash"))
#(3
""
#vu8(84 101 115 116)
#vu8(172 60 51 43 82 240 107 162 25 12 110 227 18 195 35 33 172 55 112 25 195 84 83 83 122 57 59 207 12 30 111 54 151 247 112 204 236 9 39 64 16 10 112 9 203 162 15 134 48 65 8 22 93 93 229 114 223 137 196 36 35 234 186 249 16 97 157 85 95 123 39 247 172 163 24 97 219 11 202 131 87 149 100 102 211 121 47 182 102 156 119 185 139 237 60 114 31 113 50 21 72 248 180 49 62 83 94 171 86 56 185 227 65 244 186 198 201 202 2 189 7 17 29 164 227 159 44 184 237 142 165 218 206 211 173 168 55 110 200 219 39 246 214 25 173 146 224 31 180 155 179 229 62 195 184 76 166 123 24 194 104 219 8 236 40 117 43 12 19 242 105 163 159 167 0 218 193 99 181 185 67 156 215 169 136 54 115 51 95 43 126 204 7 40 171 56 223 23 140 225 68 121 191 106 138 161 226 74 67 62 65 249 242 23 190 92 1 129 36 81 53 209 226 101 225 202 26 160 109 214 232 83 245 209 241 68 135 142 47 100 70 21 153 207 136 73 2 133 181 42 121 183 68 242 94 197)
#t
("WeakHash"))
#(4
""
#vu8(49 50 51 52 48 48)
#vu8(11 185 71 61 58 140 196 171 214 60 111 42 193 62 39 138 156 209 221 168 68 253 189 19 233 183 124 221 82 193 176 90 197 145 38 228 93 39 103 119 232 177 188 66 60 178 97 210 150 117 152 137 84 201 221 195 139 185 166 123 236 94 3 225 231 128 145 83 51 223 228 148 221 138 79 11 250 13 116 136 5 136 92 56 157 111 127 182 247 134 197 141 33 164 104 179 88 147 70 215 14 17 83 226 157 205 185 29 236 138 193 133 80 30 254 162 71 186 199 198 62 60 84 110 214 53 230 71 9 123 174 59 140 203 153 39 1 167 93 32 156 67 156 93 190 129 34 218 97 106 78 35 11 206 8 245 65 171 255 133 79 185 60 135 253 222 15 180 87 196 75 39 131 86 139 203 191 187 166 17 216 233 132 65 13 54 12 78 195 115 44 182 148 38 169 65 145 213 160 203 51 20 155 81 141 237 134 134 71 6 199 35 178 114 40 215 72 54 81 49 145 206 188 121 7 147 229 128 146 135 176 39 158 123 200 47 38 109 67 125 25 46 152 151 89 96 208 1 77 208 46 23 43 127 226 81)
#t
("WeakHash"))
#(5
""
#vu8(77 101 115 115 97 103 101)
#vu8(27 146 1 91 211 79 204 232 25 188 247 90 108 56 160 90 226 180 37 244 178 24 2 48 108 26 246 69 209 25 125 44 132 184 75 36 212 83 236 204 68 245 120 70 91 129 0 173 157 96 172 73 18 199 170 77 87 69 161 172 234 209 118 216 117 143 106 187 83 45 135 75 165 64 125 158 62 57 159 44 214 22 107 157 58 209 116 92 210 13 219 181 132 137 24 121 235 231 27 253 66 117 212 193 118 201 218 30 19 144 62 66 190 104 255 42 120 210 218 147 36 168 207 199 168 226 253 8 48 124 14 225 66 136 8 113 150 200 64 160 226 179 129 29 158 155 218 110 194 75 200 110 124 165 227 75 87 150 158 58 172 49 56 143 210 230 150 82 143 125 81 54 189 68 193 34 21 106 81 71 240 91 201 177 24 211 163 62 230 215 250 236 187 4 130 144 187 13 71 25 194 91 167 23 65 215 67 77 102 252 75 171 169 185 149 223 188 86 227 80 124 252 151 170 45 103 172 250 16 131 224 239 88 230 219 105 117 179 189 107 16 221 241 193 48 135 210 191 84 106 147 31 11 170 12 198)
#t
("WeakHash"))
#(6
""
#vu8(97)
#vu8(171 140 30 149 172 195 106 214 33 142 72 240 51 131 93 21 236 107 199 24 21 82 254 182 221 110 18 133 70 145 123 172 137 47 91 52 154 35 77 5 26 131 234 100 105 226 113 137 242 153 83 2 56 131 55 194 255 179 167 70 219 23 177 87 146 59 207 110 152 94 189 32 58 78 154 35 105 124 242 146 89 18 236 173 195 211 246 130 82 229 224 30 17 45 177 130 150 88 177 111 254 113 136 34 137 33 130 158 229 157 87 92 106 216 41 157 118 199 245 214 203 32 75 118 152 84 222 2 4 8 117 96 70 89 4 199 62 195 187 193 180 123 188 152 88 111 11 161 123 153 196 50 52 210 98 183 241 225 159 178 205 210 11 146 195 34 214 228 152 131 91 60 232 72 14 218 23 41 33 181 164 112 125 92 203 102 46 30 228 179 180 195 107 91 72 90 16 174 207 27 18 68 151 50 1 142 89 74 115 75 104 200 250 212 167 48 180 105 208 151 200 156 65 33 212 246 220 227 75 231 143 101 89 27 103 59 29 14 225 112 203 60 24 82 202 34 189 83 185 178 107 47 161 159 242 117)
#t
("WeakHash"))
#(7
""
#vu8(224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255)
#vu8(38 77 201 121 205 178 147 209 128 241 94 243 24 51 52 212 148 4 16 201 99 151 18 145 0 6 198 142 55 102 195 171 161 221 149 81 13 113 231 217 29 147 230 17 40 218 69 108 176 216 76 68 85 47 51 80 75 210 218 227 6 153 211 114 227 148 145 42 102 195 52 232 136 135 58 148 157 88 163 183 215 212 62 118 57 26 176 204 73 14 124 58 254 230 165 243 38 43 125 41 137 25 214 76 94 123 184 28 215 191 142 97 43 159 110 38 110 178 131 22 167 253 1 228 75 98 16 15 75 70 43 165 178 56 17 80 129 83 106 209 246 160 104 214 86 208 0 0 67 26 253 27 106 91 87 244 63 39 202 119 140 8 164 248 111 98 239 132 199 58 167 43 12 54 28 104 52 92 16 89 158 215 49 214 66 60 117 4 98 172 251 70 153 16 165 10 162 252 173 62 248 201 8 99 59 211 251 11 46 126 137 136 249 190 46 189 113 83 51 56 28 101 6 224 205 171 167 105 17 9 204 235 138 213 54 79 188 3 92 48 154 80 145 45 187 103 10 140 37 92 40 122 155 169 146 240)
#t
("WeakHash"))
#(8
""
#vu8(56 54 51 50 55 50 55 56 48)
#vu8(145 213 246 125 212 249 58 96 147 173 184 167 104 107 231 228 88 246 108 35 227 36 100 148 47 70 25 48 85 198 28 41 219 148 235 18 249 108 145 142 28 191 203 205 46 214 244 239 109 39 28 182 222 249 3 117 177 192 123 178 213 231 193 201 36 37 177 107 45 138 207 184 123 138 236 236 184 116 183 188 46 201 178 134 95 136 130 224 128 125 185 237 72 30 213 254 208 243 220 165 182 67 104 110 112 180 148 10 246 208 134 237 127 185 31 195 11 50 44 233 253 161 58 183 10 114 6 254 171 21 41 145 65 93 80 174 88 110 138 146 41 165 210 235 221 28 254 86 193 49 251 131 47 29 195 155 217 252 231 183 59 25 8 50 180 5 47 93 211 76 255 203 57 245 176 213 39 219 35 34 210 146 66 123 186 97 28 202 248 175 215 206 248 135 131 55 241 168 178 188 15 90 192 132 151 238 204 149 178 59 161 113 112 119 149 253 245 57 127 148 234 214 184 86 155 72 113 174 239 16 82 251 78 137 91 173 159 23 70 44 29 253 113 41 80 99 31 98 85 3 209 51 110 133 14 111)
#t
("WeakHash"))
#(9
""
#vu8(54 49 54 57 51 57 53 49 51 55)
#vu8(80 11 164 149 41 69 223 83 46 86 92 152 3 238 8 234 226 183 182 158 2 25 156 220 81 1 132 250 179 242 38 19 244 160 5 251 66 91 207 249 110 37 186 79 102 168 73 171 189 41 159 46 167 213 48 178 99 186 180 137 158 227 182 18 27 136 177 242 186 1 134 134 127 202 207 104 106 113 253 186 70 194 229 55 145 103 96 59 216 138 158 26 32 245 33 20 32 161 115 122 119 196 15 206 58 119 34 17 86 130 136 43 160 79 181 33 8 135 80 23 143 59 102 89 33 1 18 9 244 4 107 153 129 183 150 150 203 65 147 254 86 120 62 169 111 254 166 47 211 245 148 94 71 144 237 26 16 89 181 248 17 36 229 45 253 174 88 230 129 74 30 169 24 81 192 69 215 25 96 96 10 42 148 219 5 244 15 220 198 27 144 232 70 229 99 18 46 111 255 74 209 186 116 57 74 247 252 19 236 70 253 123 239 232 130 90 187 64 179 101 232 236 236 113 49 118 154 227 135 30 128 110 255 79 96 146 128 42 142 218 168 204 71 172 128 83 200 254 252 162 22 72 171 202 182 15)
#t
("WeakHash"))
#(10
""
#vu8(51 48 54 53 51 49 48 54 49)
#vu8(50 150 210 203 171 201 37 125 145 183 91 81 185 148 223 184 247 119 253 38 48 128 20 20 195 61 64 88 96 227 247 91 139 8 84 9 82 228 222 251 162 80 211 148 101 55 119 79 147 168 200 134 7 200 214 115 160 161 199 22 30 161 76 86 184 211 226 209 120 98 233 50 20 111 41 147 123 0 132 41 95 22 189 169 246 197 85 175 14 38 247 221 210 35 175 97 24 199 149 70 58 201 181 190 112 189 65 59 190 218 145 83 159 5 218 21 114 117 194 66 105 240 57 190 136 179 195 88 158 76 188 153 116 111 58 207 24 107 121 191 39 136 46 242 239 62 220 13 199 23 237 43 148 237 85 23 127 153 83 122 50 97 207 80 152 82 17 86 82 55 98 97 176 144 239 118 108 198 138 153 236 78 199 170 142 198 202 183 36 180 236 202 233 128 95 48 12 72 160 118 240 221 52 91 96 24 148 27 190 79 219 249 78 84 139 221 107 219 108 98 163 88 64 126 211 200 79 245 135 235 179 108 168 40 24 253 130 97 140 148 189 53 89 68 84 123 9 175 148 160 62 104 163 240 127 148)
#t
("WeakHash"))
#(11
""
#vu8(56 53 57 57 54 55 52 53 54 57)
#vu8(151 229 133 156 8 15 119 111 170 19 3 157 177 157 73 234 242 161 107 4 130 70 201 57 239 135 95 219 78 40 235 43 244 238 60 17 75 45 153 178 7 83 209 8 32 97 252 73 53 66 154 146 170 211 212 134 113 134 87 168 202 33 65 135 62 105 102 142 221 116 159 153 241 205 117 125 254 124 194 219 41 124 241 188 170 31 130 195 205 146 72 47 77 202 108 166 107 12 40 39 108 50 196 194 134 76 142 135 232 196 43 64 8 168 122 65 0 82 49 48 200 228 187 53 183 250 125 26 247 234 96 151 218 127 122 232 55 45 90 237 162 11 74 75 163 166 201 62 27 119 177 122 8 50 138 39 217 117 204 250 109 27 144 16 179 76 204 18 235 192 195 212 230 187 20 193 182 85 161 91 127 104 96 64 104 201 196 147 245 97 1 122 26 174 199 200 77 26 36 217 239 151 170 104 58 36 10 189 20 26 85 218 163 194 16 23 78 115 29 175 246 62 179 154 195 170 177 167 155 154 15 145 120 167 195 116 240 189 1 72 228 255 216 201 225 127 45 199 239 143 178 14 63 95 16 67)
#t
("WeakHash"))
#(12
""
#vu8(49 53 57 54 55 56 48 54 53 52 49)
#vu8(131 87 191 115 12 102 140 246 50 207 43 27 95 159 159 56 55 6 26 29 224 184 105 6 222 190 205 67 7 123 209 50 182 198 160 120 179 91 104 120 160 122 141 10 132 206 180 92 147 207 142 86 226 30 124 252 9 81 7 65 38 114 181 143 174 234 124 219 167 23 101 16 24 144 177 42 146 175 49 209 47 99 112 82 146 21 194 153 70 158 191 220 170 32 85 210 194 38 27 252 231 50 153 119 241 63 206 181 29 68 91 86 165 122 78 52 231 198 171 203 215 236 209 58 240 217 42 99 0 204 175 112 227 174 138 130 115 128 197 139 254 79 56 26 176 133 120 69 69 214 178 62 191 137 110 168 196 83 175 27 73 135 132 2 92 158 158 176 30 16 233 209 226 46 175 44 119 144 43 100 67 91 228 197 75 159 61 116 182 52 130 230 156 247 81 245 34 245 163 255 89 163 92 206 200 230 18 50 20 149 167 39 253 171 224 137 18 101 203 69 161 140 153 132 106 236 39 188 235 221 121 25 95 101 224 90 77 87 153 163 51 33 149 137 198 30 26 170 147 84 121 116 19 135 70 250)
#t
("WeakHash"))
#(13
""
#vu8(51 50 55 48 56 51 56 57 57)
#vu8(70 242 80 125 8 23 193 71 83 237 93 74 159 166 201 140 188 247 72 63 35 126 207 93 38 215 110 101 34 233 64 33 88 65 218 7 243 242 13 74 246 216 163 94 24 38 23 21 1 21 6 60 30 29 200 151 182 122 222 107 98 99 112 15 84 32 167 246 89 92 230 32 249 12 230 184 57 63 240 6 254 79 8 37 222 232 45 220 168 69 126 247 77 120 227 53 47 5 236 206 25 106 27 244 212 95 1 131 23 166 164 44 89 162 242 135 111 149 228 5 214 92 75 197 240 56 13 14 9 86 118 111 137 177 88 80 251 247 54 203 4 41 33 228 88 151 33 181 173 154 187 98 19 191 236 248 234 178 237 7 124 108 243 59 226 110 139 159 197 249 90 220 4 94 255 248 101 130 49 226 143 213 149 112 21 49 232 188 60 116 180 47 18 39 31 7 126 8 207 147 134 213 182 17 189 136 33 142 66 174 117 126 171 92 12 155 151 76 43 193 125 161 44 139 171 173 62 239 218 138 22 165 108 227 67 29 163 84 96 177 173 29 242 178 225 114 205 252 0 101 18 225 164 172 134 111)
#t
("WeakHash"))
#(14
""
#vu8(52 54 48 53 56 52 53 54 48 52)
#vu8(12 59 63 81 32 251 156 125 195 167 21 73 135 134 170 232 226 223 229 214 63 84 207 128 93 2 186 253 54 200 6 200 61 10 147 175 93 30 218 41 63 79 254 109 10 178 24 100 138 130 173 18 221 50 138 96 246 198 50 219 249 246 229 229 4 253 8 184 184 77 141 88 0 10 45 42 159 154 150 110 232 152 217 203 117 166 156 147 11 38 15 109 186 58 3 1 174 135 110 33 45 79 185 113 216 25 194 12 176 122 175 15 205 188 21 39 101 57 129 115 220 13 114 41 235 205 138 154 173 223 244 93 17 139 246 58 179 151 173 179 154 249 18 3 232 250 90 125 40 242 147 127 247 207 49 174 144 221 158 252 159 37 73 191 108 188 195 198 90 175 120 169 60 118 0 123 238 39 32 147 14 42 83 49 51 89 131 148 58 109 147 87 11 17 97 81 101 25 111 157 125 218 223 128 93 68 48 33 88 5 20 217 33 244 57 137 20 70 193 251 29 215 64 121 75 189 109 236 176 23 172 194 56 168 28 234 179 96 113 190 88 85 21 87 176 150 67 205 43 215 190 110 105 183 122 168)
#t
("WeakHash"))
#(15
""
#vu8(49 49 49 55 56 54 54 52 50 48 50)
#vu8(148 183 119 33 93 26 225 159 149 157 4 111 192 47 222 62 17 62 21 189 173 177 215 146 199 68 242 23 32 14 39 93 57 84 183 152 180 62 94 227 130 135 116 32 20 64 135 190 52 14 17 210 135 156 16 175 99 118 67 123 90 143 98 99 79 161 155 147 56 54 10 49 140 149 201 66 29 144 246 3 55 99 79 58 3 162 38 7 150 216 146 142 5 106 167 117 156 177 63 59 188 114 149 79 156 157 167 234 177 211 86 64 80 228 38 124 237 85 126 54 132 229 9 12 239 150 245 133 21 61 184 199 50 183 139 79 125 245 157 178 25 215 174 172 66 212 242 11 29 201 130 81 113 187 235 194 113 46 114 46 214 254 209 45 252 114 220 203 30 154 44 109 147 228 200 102 65 225 223 225 109 109 67 98 157 238 125 128 235 168 233 99 158 165 148 255 162 6 207 63 14 86 27 41 83 162 144 216 205 112 189 12 203 239 100 179 43 214 107 41 79 31 177 236 151 186 208 224 150 229 226 0 229 129 47 224 37 51 60 237 215 209 236 140 17 27 40 190 180 164 2 245 202 191 47 153)
#t
("WeakHash"))
#(16
""
#vu8(56 48 53 52 53 53 52 54 52)
#vu8(129 159 98 75 13 254 104 34 211 146 58 193 229 199 95 121 225 218 61 251 193 59 51 40 116 212 5 46 235 179 15 155 42 9 236 247 95 17 34 153 12 55 54 125 117 228 236 81 15 70 69 185 244 31 228 242 249 128 90 152 30 168 28 233 50 18 118 19 18 108 175 142 4 185 209 148 169 39 183 32 178 76 217 241 114 30 51 209 33 197 153 48 236 72 165 245 87 79 154 168 198 186 251 92 140 207 157 221 178 219 180 24 217 136 78 203 74 147 26 146 101 54 13 172 116 117 222 126 76 199 149 206 122 88 108 125 71 107 164 112 221 167 192 59 63 26 182 157 147 114 215 207 243 66 35 6 237 216 254 143 109 215 69 89 111 31 202 207 185 153 20 71 12 19 231 82 191 170 220 230 50 254 65 36 214 204 216 14 235 248 122 105 130 169 152 170 74 8 146 194 112 174 109 224 185 188 191 188 156 189 150 223 242 226 249 63 128 217 55 15 162 160 21 225 61 3 118 180 217 220 189 237 234 41 186 155 97 106 131 38 28 207 110 197 96 121 255 46 201 61 114 152 156 249 52 84)
#t
("WeakHash"))
#(17
""
#vu8(50 55 51 53 50 51 48 53 53 49)
#vu8(17 141 77 207 235 216 46 167 75 40 4 27 216 191 95 150 157 4 225 96 226 184 171 47 187 225 194 161 103 60 221 79 167 216 1 170 75 194 63 152 152 188 13 203 36 14 138 62 222 7 111 145 31 254 178 116 156 3 210 25 35 5 95 136 120 174 237 136 86 61 187 196 84 34 182 88 248 100 125 200 104 136 92 146 1 93 244 213 146 95 62 109 117 232 87 84 183 240 2 55 77 69 131 237 49 11 201 145 202 210 129 47 210 157 9 6 196 222 165 197 41 33 254 33 132 136 12 94 140 165 27 6 188 86 84 237 213 224 231 46 32 146 42 156 155 47 205 6 140 112 14 200 40 120 182 172 4 165 107 236 215 111 187 233 253 74 191 169 52 135 86 249 131 191 169 37 57 66 77 151 45 118 78 120 19 187 189 52 187 54 158 193 71 252 177 169 78 134 2 227 89 241 239 49 39 37 242 187 129 192 73 50 193 196 235 235 250 9 227 22 93 2 135 168 90 34 240 137 141 99 133 83 128 102 36 106 222 7 203 81 88 13 177 252 202 134 175 173 6 254 47 150 149 194 248 253)
#t
("WeakHash"))
#(18
""
#vu8(49 50 50 56 52 52 48 56 48 55)
#vu8(83 113 19 68 8 133 71 228 5 177 227 247 96 94 68 249 183 182 115 93 93 60 50 238 14 64 143 231 236 156 207 88 153 132 135 68 63 102 212 237 192 2 13 186 136 239 222 249 234 212 3 162 135 75 40 146 5 78 57 31 97 193 179 110 73 10 134 35 134 142 163 227 238 176 126 182 162 222 150 80 59 147 244 251 83 66 37 7 44 107 249 8 55 192 41 161 245 194 165 216 25 77 242 226 3 251 12 42 174 234 80 103 103 149 40 151 217 0 217 251 32 200 207 79 123 104 169 122 82 120 215 170 166 227 131 240 204 141 43 83 187 116 138 182 176 220 95 177 206 130 176 138 169 134 68 155 60 49 55 165 150 89 133 208 205 98 183 161 161 27 49 164 152 102 154 11 48 114 105 46 237 154 19 147 228 45 126 97 185 2 38 172 198 43 40 78 197 80 192 129 60 74 250 37 161 182 252 16 60 184 12 244 41 148 75 85 126 19 52 232 28 17 115 223 74 134 171 16 124 216 236 108 117 57 44 199 203 17 201 33 47 21 238 126 24 170 13 39 0 106 245 197 237 231 176 230)
#t
("WeakHash"))
#(19
""
#vu8(53 49 49 54 53 56 57 56 55)
#vu8(151 42 181 223 211 170 146 239 159 244 0 38 118 71 22 120 76 135 21 79 18 150 126 211 240 42 222 229 247 63 233 160 89 75 34 89 158 130 155 205 174 176 2 23 161 34 24 218 223 6 201 148 10 175 156 2 199 92 177 73 168 158 37 138 84 136 148 191 71 98 16 11 161 123 200 188 96 167 160 208 83 7 183 19 54 120 219 164 186 191 102 13 18 65 134 89 206 162 92 159 152 43 219 155 29 35 0 253 217 209 68 162 93 79 21 14 84 202 124 163 68 221 233 233 225 186 87 131 194 203 96 107 188 134 52 26 185 52 74 8 64 220 81 93 209 213 137 190 222 46 63 72 59 32 24 15 8 105 92 202 14 158 28 239 198 139 107 252 53 39 228 143 240 38 10 63 105 108 6 128 54 75 212 182 131 13 103 94 196 152 102 56 233 118 184 60 177 245 106 213 254 112 93 93 238 12 12 94 178 155 209 90 36 242 101 150 80 0 235 206 229 168 85 26 216 239 116 180 5 146 71 114 85 22 155 218 86 220 143 53 250 250 247 150 251 250 68 211 102 3 62 21 172 254 4 139)
#t
("WeakHash"))
#(20
""
#vu8(54 56 52 53 56 53 54 55 50 52)
#vu8(122 124 222 173 6 186 33 46 141 214 180 70 249 17 207 55 180 12 90 199 249 200 23 18 92 13 94 227 205 228 158 243 54 184 126 185 79 125 138 147 225 217 253 14 254 183 126 114 71 105 178 125 111 99 186 145 247 33 159 35 224 133 163 67 62 77 105 202 143 142 66 5 52 245 84 198 154 114 33 215 14 87 248 168 36 107 36 181 152 103 22 197 13 164 148 42 23 32 229 27 58 184 126 253 173 66 224 44 172 37 75 226 103 61 91 250 70 105 231 100 222 251 64 17 33 162 80 85 153 61 197 235 186 34 23 104 52 180 162 249 168 163 163 77 53 174 44 52 78 154 132 103 93 148 239 143 86 177 109 132 141 21 133 28 5 138 230 77 248 164 4 238 224 155 99 187 100 254 1 124 32 106 148 219 215 178 116 68 15 4 254 7 210 45 7 156 45 42 134 134 242 71 235 152 58 14 230 37 178 212 185 253 212 217 173 229 55 18 240 209 60 241 255 26 172 3 208 159 128 51 91 249 54 67 39 168 145 113 168 165 31 66 25 248 102 70 190 150 240 217 108 108 178 127 67 211)
#t
("WeakHash"))
#(21
""
#vu8(50 55 55 54 50 57 57 49 52 53)
#vu8(187 21 145 85 2 173 119 179 160 128 238 215 11 68 75 117 52 150 69 10 65 20 212 53 210 174 233 251 241 179 69 7 79 232 92 35 173 78 245 38 3 179 168 160 119 213 2 78 61 86 221 98 1 105 182 220 15 247 67 127 225 165 32 194 147 215 143 170 119 37 142 140 134 50 16 14 6 68 244 105 240 163 37 10 83 72 62 154 47 141 171 11 218 234 213 223 65 221 27 186 145 221 1 215 158 218 29 248 56 221 69 103 208 69 38 176 225 252 181 208 124 198 40 244 255 98 254 203 101 210 56 106 246 56 186 109 14 89 69 24 105 156 86 133 3 54 53 175 108 179 2 208 123 243 154 29 197 181 14 222 6 186 172 175 173 154 46 233 172 72 191 136 193 19 41 210 190 98 213 101 176 49 40 19 252 129 201 227 205 36 58 172 170 108 17 220 203 182 148 30 42 186 111 147 82 75 1 64 243 9 135 22 128 54 177 56 16 193 15 101 240 172 196 67 247 223 112 9 194 56 168 213 191 171 0 17 111 26 220 180 203 245 92 72 66 57 104 148 4 120 139 210 158 183 135 248)
#t
("WeakHash"))
#(22
""
#vu8(50 56 55 57 50 56 50 56 51 52)
#vu8(79 233 101 232 182 133 209 239 243 143 38 38 31 92 22 139 119 86 13 229 242 215 36 58 51 195 193 199 242 103 215 182 14 154 97 68 75 108 240 167 28 170 24 202 129 243 137 96 244 94 242 149 134 145 12 36 12 147 130 5 81 243 218 94 21 24 6 132 128 127 170 93 159 211 97 50 91 157 57 199 184 232 5 171 215 91 105 175 77 2 3 69 188 218 38 106 21 84 11 50 204 210 142 87 247 6 62 220 34 143 188 129 95 26 185 101 250 84 46 214 121 196 63 123 73 73 247 68 142 104 130 188 54 168 241 4 18 220 14 130 139 51 173 78 9 165 199 45 55 48 20 53 32 228 235 98 83 86 97 91 244 158 81 204 235 233 4 175 124 99 151 120 93 224 242 3 113 104 159 41 117 102 101 36 16 59 219 180 191 39 241 226 2 1 138 202 128 3 222 97 95 7 55 115 204 167 230 71 231 30 229 29 151 204 48 53 106 23 181 10 163 196 122 116 225 51 170 187 164 174 65 117 7 134 169 177 229 132 227 25 131 108 60 126 124 140 46 178 206 102 4 50 56 86 179 153)
#t
("WeakHash"))
#(23
""
#vu8(54 54 53 55 54 55 57 55 51)
#vu8(158 18 220 30 200 129 130 249 70 42 121 93 113 13 208 116 71 231 154 78 3 91 151 193 110 53 28 75 93 78 152 69 155 142 90 82 226 245 29 204 30 220 76 137 67 134 63 169 171 200 251 215 94 226 244 118 145 165 132 40 3 64 33 198 211 50 49 145 165 165 253 178 218 42 193 178 161 73 184 209 2 85 118 48 158 33 65 12 148 0 203 211 182 125 42 196 212 175 111 87 198 56 15 218 40 23 194 99 152 71 149 147 75 72 132 79 94 164 118 20 2 53 65 18 162 168 226 192 109 204 234 14 83 90 6 182 177 39 74 66 242 24 177 212 66 194 200 52 126 127 209 104 16 14 246 88 198 60 121 14 107 223 173 63 78 87 165 54 226 206 24 26 151 109 238 29 96 92 238 148 123 245 178 40 247 197 64 194 201 201 242 202 160 70 27 247 55 227 47 84 84 245 44 245 48 11 35 232 169 146 29 94 74 56 14 184 54 182 69 81 92 12 113 234 128 59 115 13 6 103 219 164 155 227 130 92 122 95 73 175 183 233 137 200 82 70 206 236 35 108 58 14 180 62 216 190)
#t
("WeakHash"))
#(24
""
#vu8(55 52 54 53 53 53 55 48 55)
#vu8(63 85 71 14 97 44 131 46 234 0 205 115 139 97 82 189 3 216 140 58 189 169 92 204 46 214 235 106 165 192 228 216 88 152 42 84 141 37 145 78 172 118 73 197 61 33 105 218 90 212 240 155 182 77 98 144 201 19 211 70 66 77 24 155 194 65 78 213 13 210 189 207 227 233 232 10 153 44 102 17 236 134 181 55 168 181 205 146 152 92 182 34 106 3 103 194 255 32 210 133 156 33 136 47 175 178 185 196 127 72 253 25 207 161 79 121 62 15 255 69 208 106 46 136 98 83 162 9 237 149 3 13 160 90 28 110 163 93 41 147 198 0 73 27 73 61 237 118 233 82 172 176 68 44 82 118 15 187 31 115 89 87 161 171 48 254 254 166 231 181 150 167 170 78 164 121 186 106 106 235 134 108 230 202 243 140 183 198 51 139 41 147 33 60 57 201 139 12 221 110 70 201 112 32 105 184 90 140 126 5 12 16 121 177 31 210 9 253 224 204 88 211 123 238 196 109 180 200 201 91 64 44 69 178 245 183 144 111 30 241 159 42 132 219 184 229 75 213 213 221 57 165 50 237 110 55)
#t
("WeakHash"))
#(25
""
#vu8(57 56 55 52 49 50 49 53 56 56)
#vu8(8 130 58 62 239 196 209 63 128 20 25 179 116 165 216 205 81 249 40 30 18 77 235 4 21 37 14 158 53 62 58 47 151 74 131 52 124 160 157 59 94 194 78 201 64 72 176 150 164 177 29 250 197 47 36 128 181 34 247 14 180 238 238 214 248 73 65 188 55 209 221 29 130 215 185 136 59 238 241 166 205 205 197 179 246 2 77 146 153 177 13 118 151 192 50 94 44 117 118 79 34 92 223 95 237 72 58 195 0 164 137 182 149 54 172 201 252 144 213 129 223 161 13 103 5 107 62 249 176 94 9 170 141 253 61 104 142 196 214 63 72 60 48 26 68 147 75 186 24 65 134 9 72 193 48 214 53 62 125 116 201 202 158 118 76 68 227 182 251 22 101 175 211 139 106 125 248 137 45 144 160 213 72 61 250 236 98 112 8 74 215 106 165 15 56 227 67 137 248 145 250 100 85 237 159 60 186 204 66 34 102 246 202 43 16 174 165 195 202 248 48 53 192 104 51 205 123 187 186 131 218 223 178 136 7 247 179 215 244 172 110 144 37 164 114 23 195 221 29 254 148 38 170 230 23 95)
#t
("WeakHash"))
#(26
""
#vu8(50 54 48 50 51 48 50 51 55 48)
#vu8(187 108 5 91 63 85 103 31 12 232 92 86 65 185 112 181 202 13 209 241 184 151 139 145 92 142 54 57 7 0 246 191 199 101 220 107 22 148 98 86 114 247 12 11 220 151 81 125 129 204 169 25 10 196 188 158 181 16 93 243 69 127 72 20 74 185 220 192 73 174 84 242 129 35 175 2 4 23 102 133 239 108 45 113 176 230 24 56 148 0 225 142 144 253 29 254 101 205 232 139 98 143 220 65 6 49 236 174 141 100 184 109 163 41 34 140 228 201 159 207 87 46 119 227 234 54 108 230 211 61 20 1 226 80 199 90 50 156 113 199 245 54 58 149 207 222 39 188 140 240 16 190 245 122 172 189 68 198 10 77 91 122 234 65 223 155 157 89 239 160 203 108 211 67 179 201 92 122 203 216 77 119 135 58 87 117 200 117 124 88 93 102 92 250 233 191 16 9 95 228 249 121 181 134 107 111 179 147 176 152 144 225 24 163 90 232 161 127 126 184 246 13 214 228 149 64 16 186 144 62 105 244 205 198 56 128 187 36 195 1 154 204 89 110 96 40 181 241 170 134 204 22 214 249 114 11)
#t
("WeakHash"))
#(27
""
#vu8(51 55 50 54 54 49 49 54 48 56)
#vu8(128 172 9 125 0 85 92 143 106 195 79 62 169 101 112 67 34 131 179 115 191 191 195 39 229 225 248 139 155 37 216 220 205 97 209 6 74 148 74 16 65 143 251 134 60 162 238 226 129 130 208 70 234 129 155 119 110 0 166 253 98 131 106 163 243 52 170 247 209 72 151 151 23 130 168 229 87 197 51 20 163 218 22 243 191 9 149 156 19 154 191 66 201 90 148 62 143 115 111 230 172 71 170 194 196 69 61 42 112 145 33 78 157 108 129 9 143 57 144 125 0 27 76 218 239 106 102 180 38 181 113 16 90 148 51 19 73 208 196 212 86 38 62 9 12 14 208 26 210 25 92 160 231 175 253 54 208 245 89 205 241 44 140 129 40 199 207 26 138 235 174 246 21 75 75 248 227 189 141 183 137 234 176 128 177 75 69 177 5 39 232 0 69 47 190 47 32 52 92 180 26 250 228 243 85 48 147 108 27 153 19 122 51 112 244 241 201 236 207 168 27 250 55 73 254 196 177 176 103 43 80 233 112 198 33 186 10 102 209 231 117 187 77 240 103 79 88 124 147 138 41 23 108 96 51 24)
#t
("WeakHash"))
#(28
""
#vu8(55 51 52 52 54 51 52 52 50 53)
#vu8(102 159 50 86 32 59 79 254 115 236 1 194 215 209 32 171 156 2 186 184 42 199 84 149 220 250 36 219 47 142 121 151 6 115 212 121 13 167 114 244 177 107 20 248 16 71 8 96 52 179 173 146 113 150 164 131 144 119 74 239 224 210 119 255 70 103 152 211 73 124 14 16 141 81 71 105 69 228 195 36 211 33 69 175 93 140 175 232 139 253 106 75 82 200 224 51 171 75 149 188 91 92 52 81 128 143 1 155 57 40 94 253 79 235 108 33 112 139 0 170 91 199 129 175 168 127 215 71 92 173 103 56 51 97 113 89 231 80 81 100 96 100 216 30 212 32 68 121 28 39 227 126 236 66 24 147 253 55 29 124 217 107 70 44 21 133 96 84 93 243 245 134 47 233 121 88 201 151 76 147 50 180 109 137 68 134 233 124 132 82 138 31 85 163 217 173 212 41 205 124 26 5 251 88 42 255 193 47 163 174 238 152 10 147 184 22 143 40 77 127 149 250 162 221 241 55 228 69 210 197 101 139 137 162 162 48 169 166 64 187 238 64 102 92 43 237 227 241 107 152 108 114 173 21 180 242)
#t
("WeakHash"))
#(29
""
#vu8(57 49 48 50 52 48 57 49 51 55)
#vu8(80 25 28 214 72 21 85 5 66 49 235 37 183 212 79 55 64 82 162 40 3 111 30 121 108 45 146 60 157 249 191 210 248 129 98 8 112 238 77 125 255 164 99 126 87 13 96 85 52 92 135 182 26 44 143 79 59 83 109 137 203 3 121 136 60 153 250 36 110 58 233 198 161 87 119 7 103 187 1 141 112 35 130 132 14 81 37 234 89 187 99 103 249 140 7 3 39 211 11 196 225 124 64 180 101 251 83 20 229 150 146 82 125 121 44 145 85 245 241 194 217 244 6 26 59 120 71 65 120 141 146 215 97 225 163 197 83 50 11 65 101 200 100 232 116 242 70 100 222 61 198 181 114 219 189 79 220 73 84 49 222 40 131 137 194 105 11 207 86 72 38 50 238 52 182 56 170 144 47 94 168 8 147 58 234 206 78 239 189 43 110 245 75 71 207 42 254 88 108 32 191 1 94 120 45 90 185 82 191 118 150 38 132 103 166 190 178 242 80 108 188 190 201 25 103 79 199 133 71 78 224 96 140 67 152 15 100 152 126 192 183 94 128 65 135 30 217 162 249 155 244 98 53 4 169 213)
#t
("WeakHash"))
#(30
""
#vu8(51 56 50 57 56 49 56 54 56 53)
#vu8(85 163 190 62 92 108 27 180 114 254 181 78 33 84 174 241 12 136 128 25 81 131 134 10 60 25 220 47 13 159 46 116 115 185 11 178 169 236 219 26 139 20 78 226 124 96 237 126 162 88 56 191 110 205 96 194 197 218 233 33 52 57 169 238 138 122 73 233 112 238 243 205 189 134 240 178 89 215 173 89 130 48 244 62 42 90 192 160 246 143 148 124 189 237 13 32 231 167 104 252 165 48 243 218 196 21 21 236 156 167 145 103 222 61 128 12 139 245 71 22 59 3 90 15 63 69 195 113 213 57 105 235 182 209 78 88 80 186 179 3 219 252 248 96 146 180 125 65 88 46 222 70 11 249 146 12 142 238 121 33 135 209 218 19 73 69 4 109 40 175 103 196 51 251 128 47 9 166 191 169 70 168 170 219 162 174 159 137 175 181 48 84 12 189 34 150 1 38 230 232 88 190 88 230 55 41 3 105 140 100 66 83 203 95 247 44 73 59 53 202 164 64 125 56 31 150 179 4 176 153 60 224 139 123 12 105 44 11 183 147 111 116 54 102 219 90 235 226 175 194 198 126 59 37 111 236)
#t
("WeakHash"))
#(31
""
#vu8(49 51 51 50 49 52 51 56 48 57)
#vu8(182 253 109 45 78 190 88 96 71 10 236 94 37 187 187 2 214 125 70 217 96 0 131 17 209 219 255 243 184 80 72 206 244 6 66 54 33 4 232 229 68 185 20 185 151 78 181 63 241 204 18 203 139 15 213 184 169 36 233 106 217 130 204 175 193 168 0 146 88 106 219 210 144 82 80 69 46 56 179 66 247 146 28 252 130 98 62 212 153 116 43 47 176 185 13 27 82 133 186 210 250 3 171 130 70 132 136 53 102 5 181 183 105 51 53 232 220 249 131 246 57 216 44 49 104 2 14 39 167 224 208 107 42 241 132 235 150 97 140 233 66 201 155 73 191 204 39 164 182 180 124 92 7 134 92 91 46 175 227 12 107 186 45 154 151 129 138 160 235 93 34 136 1 129 3 102 143 137 46 139 245 239 24 55 82 28 210 189 65 181 184 246 169 84 245 196 165 13 232 116 184 224 7 132 165 84 108 201 183 206 141 226 255 119 103 73 176 2 123 55 21 140 213 177 27 68 10 82 161 130 11 121 80 250 104 91 180 53 5 225 211 83 18 166 253 203 236 219 233 71 103 45 194 190 116 161)
#t
("WeakHash"))
#(32
""
#vu8(52 52 52 53 56 48 53 49 53 57)
#vu8(127 197 77 129 8 54 142 239 25 245 135 114 117 208 126 135 26 50 81 204 167 28 99 202 251 70 128 135 72 204 226 64 184 235 149 161 242 24 183 121 84 237 210 171 135 104 227 252 170 140 141 62 155 125 103 140 13 68 249 115 29 90 88 246 172 95 54 67 24 123 248 139 166 2 51 1 32 9 54 217 65 69 23 241 177 58 194 175 192 29 140 184 224 17 99 17 9 242 232 235 102 182 27 113 16 194 115 226 108 32 102 233 56 71 50 181 217 120 192 178 214 169 240 34 117 51 224 146 55 63 233 216 194 220 51 248 37 60 19 170 87 48 179 247 146 221 102 198 182 178 190 45 197 114 58 71 13 141 161 92 121 40 109 24 66 197 206 166 126 170 71 185 6 196 240 52 209 88 118 16 217 250 2 203 114 65 54 79 136 98 69 143 235 109 143 255 152 37 91 76 129 182 156 36 141 95 93 215 33 238 71 123 31 115 65 199 56 8 184 128 168 143 132 37 223 249 194 124 43 208 20 10 97 184 198 77 141 174 21 196 53 154 145 141 228 44 138 119 139 139 142 53 43 98 66 145)
#t
("WeakHash"))
#(33
""
#vu8(57 55 54 55 48 50 50 50 50 57)
#vu8(3 156 167 159 139 207 23 55 75 222 157 202 91 118 21 184 9 172 141 73 36 26 72 177 24 193 140 189 212 227 252 67 194 227 121 43 115 212 3 6 44 232 0 242 105 85 18 91 123 21 190 182 10 100 71 113 0 130 198 198 191 128 210 77 187 65 122 88 171 147 65 96 177 136 131 186 100 242 155 70 31 111 118 248 51 235 209 108 56 247 102 73 118 170 236 21 33 171 106 86 123 52 40 58 152 184 85 107 79 211 70 176 80 237 75 23 86 193 34 143 137 17 114 166 52 68 71 121 226 103 152 71 109 72 30 65 110 17 128 170 23 9 248 133 254 92 111 9 20 102 171 166 40 127 114 127 38 208 134 97 142 187 204 44 2 10 0 26 216 178 77 42 208 218 199 132 69 110 22 45 6 3 5 103 24 124 37 242 226 160 35 227 13 236 192 118 234 202 146 210 200 32 66 221 7 122 191 183 136 250 3 160 218 171 151 20 219 65 88 34 80 29 153 248 150 0 248 214 119 250 167 38 170 67 210 49 70 69 178 50 5 136 180 202 215 32 139 47 209 45 127 153 252 55 216 9)
#t
("WeakHash"))
#(34
""
#vu8(49 48 55 56 56 57 48 49 55 50 53)
#vu8(144 127 130 111 57 65 44 34 151 68 105 187 178 143 4 157 132 4 185 57 123 187 134 50 44 116 40 114 216 220 0 139 209 153 236 126 137 28 26 121 157 166 14 242 12 157 215 87 59 169 105 118 31 93 129 47 114 232 137 175 133 91 131 59 90 161 202 195 56 207 42 66 212 224 169 209 76 188 111 176 4 134 106 186 1 52 30 157 238 142 40 150 223 22 57 150 215 140 77 48 216 198 135 112 231 199 46 175 104 156 196 151 19 195 235 71 155 232 69 44 147 90 164 76 72 174 203 176 211 240 100 102 20 211 103 80 239 18 96 54 130 139 231 107 229 128 135 153 97 147 42 116 243 75 172 153 131 251 160 185 112 172 116 15 88 65 82 197 203 180 214 227 129 94 135 112 26 218 141 48 165 1 171 219 98 171 23 58 161 167 163 25 156 162 124 251 23 152 149 19 32 137 192 56 228 10 39 59 228 91 71 26 26 31 112 231 209 118 183 66 78 133 43 63 140 96 129 147 167 18 101 136 197 6 92 252 90 113 23 190 183 47 115 234 138 131 108 138 21 241 46 202 103 248 64 81)
#t
("WeakHash"))
#(35
""
#vu8(56 50 49 55 51 51 56 54 51 49)
#vu8(123 120 108 10 27 170 245 47 184 68 89 233 42 250 240 56 191 233 151 201 164 217 16 48 54 51 254 39 80 185 116 72 161 91 176 87 181 5 104 59 197 60 164 177 143 255 29 217 13 20 22 187 140 15 178 194 149 80 215 221 169 201 167 240 135 56 103 118 254 101 177 40 140 31 85 8 186 148 104 237 147 40 201 214 98 14 104 130 252 129 140 78 190 131 45 243 109 203 93 146 131 122 113 30 166 240 210 11 120 66 53 147 61 12 87 30 45 96 97 68 94 245 209 188 34 212 51 120 210 89 59 42 118 33 20 246 135 188 245 156 173 180 236 171 242 88 211 225 74 75 222 160 178 21 130 139 46 116 98 67 159 205 76 185 149 24 187 93 93 217 38 109 109 205 69 155 243 108 243 44 184 104 48 103 145 138 34 92 22 133 219 94 82 249 165 48 92 190 96 163 141 242 186 190 144 19 103 236 165 127 156 254 238 41 85 84 154 217 185 147 24 176 21 174 25 64 42 77 173 119 82 225 91 148 178 91 52 20 204 155 224 193 52 33 243 26 65 208 177 163 228 60 226 193 211 9)
#t
("WeakHash"))
#(36
""
#vu8(49 49 52 56 54 48 55 50 49 53)
#vu8(100 46 59 148 248 197 160 137 123 87 135 128 92 153 176 74 246 199 162 239 71 234 225 13 220 191 88 224 249 65 19 115 146 13 30 77 118 150 25 249 113 130 219 54 169 195 139 108 214 149 161 217 109 170 169 201 40 141 221 71 116 249 224 133 220 180 130 159 28 216 82 35 144 22 221 35 206 177 164 147 161 41 78 61 53 16 79 72 56 74 206 191 160 203 236 220 17 79 68 92 99 216 161 82 78 96 141 63 117 23 39 130 177 195 22 157 83 23 144 42 103 150 104 141 214 176 17 45 8 34 165 198 90 154 179 27 232 76 147 156 236 196 25 13 252 118 108 253 41 185 101 202 2 186 204 242 227 166 143 19 250 48 75 70 156 96 215 235 73 4 157 120 220 30 14 217 77 170 39 61 251 222 113 64 36 230 43 169 124 252 123 61 50 255 240 52 152 101 24 224 72 97 36 166 214 211 63 64 71 65 130 178 194 53 48 108 125 13 80 136 231 231 51 176 168 149 116 90 75 244 193 135 210 205 201 214 168 223 113 83 180 31 22 48 90 21 218 120 7 198 188 105 195 19 180 202)
#t
("WeakHash"))
#(37
""
#vu8(56 48 52 51 51 53 48 48 54 53)
#vu8(90 206 27 156 225 245 121 1 232 184 169 15 3 55 80 248 7 229 35 97 119 155 253 151 198 15 2 156 255 138 112 119 76 6 120 26 46 197 209 97 22 224 234 81 112 185 157 4 134 238 250 252 255 17 242 120 13 125 4 19 158 40 228 8 163 88 180 138 213 92 13 98 163 87 50 61 62 199 89 32 93 247 124 115 248 158 153 31 132 145 20 216 191 207 228 182 164 234 253 134 169 207 67 80 7 117 177 207 75 73 128 196 246 238 225 122 239 120 46 183 249 65 68 171 30 122 10 185 200 62 242 134 12 20 41 212 172 145 116 41 95 90 238 182 163 213 253 67 8 7 185 194 236 32 224 226 205 18 66 228 150 229 71 11 115 61 181 44 133 123 229 166 92 96 71 121 217 225 191 165 167 186 203 242 151 159 30 83 50 120 7 111 16 43 20 239 195 33 233 5 174 82 133 229 14 60 153 152 3 103 24 179 76 255 53 234 12 8 39 53 234 87 106 204 47 24 6 92 126 5 223 3 211 254 226 9 241 168 223 125 165 160 122 243 164 171 134 229 78 223 133 254 97 52 63 239)
#t
("WeakHash"))
#(38
""
#vu8(54 54 57 57 52 52 55 48 51 53)
#vu8(48 161 165 87 252 150 81 224 140 0 75 35 165 252 37 107 19 249 249 34 16 130 248 103 100 61 215 7 253 85 19 222 114 181 45 19 189 27 27 111 208 144 253 129 107 235 72 104 19 65 155 217 244 38 249 212 232 236 126 92 134 212 34 142 59 251 137 146 135 178 53 77 91 114 13 182 11 104 152 46 118 186 43 20 237 34 184 191 132 146 68 201 174 107 85 7 27 206 253 79 112 99 209 91 164 62 10 95 116 123 239 115 115 203 45 203 255 109 81 27 3 13 62 19 246 40 137 100 6 149 90 119 87 53 112 48 80 115 217 44 92 251 42 156 77 146 248 103 193 128 30 99 200 173 219 164 60 227 215 250 249 26 244 100 249 65 250 164 143 40 245 73 216 151 249 60 7 67 148 19 114 3 161 145 118 203 219 65 188 255 38 11 123 0 83 80 137 86 151 14 49 246 88 7 180 12 59 121 5 218 21 27 85 32 147 30 197 196 112 240 32 172 179 6 252 110 150 154 137 150 111 239 74 177 194 161 127 213 161 18 224 168 65 184 83 221 20 73 190 50 163 181 45 47 110 137)
#t
("WeakHash"))
#(39
""
#vu8(57 57 51 53 50 57 50 52 49)
#vu8(25 96 170 133 175 183 95 82 160 190 233 23 189 10 253 81 222 138 187 225 190 122 191 167 200 50 31 116 225 137 33 219 125 83 222 5 37 53 194 177 12 113 195 42 216 64 22 169 152 152 10 137 202 207 187 218 53 67 195 153 49 149 56 243 162 22 152 27 169 56 165 63 82 176 213 176 120 166 206 247 4 123 235 206 108 80 35 219 8 1 114 217 11 134 134 152 162 144 155 47 222 112 19 40 55 7 249 183 79 61 128 12 57 176 245 220 254 216 69 121 22 120 199 105 99 36 171 201 115 49 112 47 34 54 98 1 130 251 82 142 43 229 149 173 16 22 27 216 137 255 104 139 222 52 149 15 43 47 187 179 152 63 118 202 146 36 223 4 226 222 247 173 167 218 196 186 112 215 99 226 189 123 240 181 169 208 94 128 143 158 68 38 240 76 201 78 40 81 15 216 185 26 131 143 134 200 8 133 30 216 143 176 228 117 90 252 115 229 113 110 158 66 215 148 227 81 164 243 16 0 66 115 54 231 5 40 73 204 103 59 126 84 84 113 39 231 230 246 98 202 246 188 81 45 82 94)
#t
("WeakHash"))
#(40
""
#vu8(52 50 54 49 55 52 48 53 53 48)
#vu8(89 106 43 54 55 13 209 21 186 73 97 9 229 169 133 27 47 245 140 47 154 91 253 27 38 205 243 234 187 132 12 73 180 107 106 104 135 228 193 60 75 147 11 115 118 73 189 197 111 184 145 104 228 109 145 161 241 24 106 222 205 15 232 103 206 192 103 201 169 14 142 26 102 56 128 236 68 0 103 34 212 166 136 139 131 183 100 168 100 146 93 231 0 179 10 107 7 82 4 168 151 136 0 41 109 94 176 239 31 13 201 172 135 197 251 122 75 42 124 209 72 86 110 214 234 205 175 254 34 217 20 218 95 45 108 237 247 173 162 133 147 181 72 119 93 116 138 97 182 237 34 171 89 52 189 160 197 119 130 202 241 244 138 48 156 128 190 212 252 170 207 174 29 192 67 40 71 88 58 238 131 50 238 201 67 94 64 159 206 46 13 62 20 246 196 204 241 33 184 238 166 245 180 21 137 78 186 36 239 6 106 8 213 250 169 35 31 227 231 118 124 209 251 222 167 133 13 177 174 174 218 117 93 203 216 174 195 58 125 171 244 48 187 112 2 117 78 56 167 1 23 180 125 63 103 126)
#t
("WeakHash"))
#(41
"first byte of m_hash modified"
#vu8(49 50 51 52 48 48)
#vu8(184 237 252 201 255 100 81 255 88 56 196 112 35 44 77 15 53 138 136 255 99 68 230 44 244 207 145 112 87 110 101 149 251 34 246 178 243 178 25 10 111 40 103 69 227 154 48 12 253 54 143 130 248 111 18 248 26 212 248 84 108 175 237 176 10 56 188 133 248 226 64 18 127 194 50 239 130 135 199 187 211 95 218 245 92 168 73 201 116 94 242 237 19 113 168 78 119 205 176 117 19 165 232 220 72 152 231 169 200 197 42 62 53 179 104 42 187 163 181 131 18 48 38 185 132 10 226 134 20 132 38 197 155 76 0 86 106 20 124 109 137 224 57 178 128 82 168 151 79 150 108 45 119 203 210 106 217 79 84 206 152 119 72 55 78 136 183 188 196 175 210 69 130 212 8 219 156 249 73 6 174 157 0 57 225 189 34 173 138 35 168 195 121 119 126 202 201 84 84 15 27 19 24 99 105 254 52 128 149 92 190 246 9 7 84 178 134 200 233 173 170 40 139 16 36 217 75 224 41 29 32 226 10 158 235 82 93 94 154 46 14 11 92 180 65 152 2 179 8 226 117 84 202 52 16 160)
#f
("WeakHash"))
#(42
"first byte of m_hash modified"
#vu8(49 50 51 52 48 48)
#vu8(72 197 144 52 123 89 60 171 100 43 7 212 155 194 34 149 3 173 128 121 223 168 46 60 225 240 20 209 240 4 108 88 98 234 93 61 60 63 68 112 83 112 177 80 121 225 221 162 98 126 58 232 97 253 255 37 238 251 187 67 100 0 112 40 22 255 140 96 174 200 226 202 224 224 253 46 168 122 60 158 160 55 49 250 44 95 199 130 153 174 167 98 153 81 203 113 173 241 96 142 88 67 179 249 201 159 12 58 211 123 108 133 224 162 113 161 245 160 115 34 67 60 89 69 249 164 113 230 149 192 238 129 86 74 155 198 19 183 62 7 0 168 4 215 200 25 111 22 7 41 184 249 1 103 166 112 71 97 147 11 204 90 171 117 242 213 231 16 103 231 153 131 58 143 77 142 212 158 161 126 199 26 41 187 157 32 201 101 1 36 29 151 147 30 144 176 245 13 179 154 87 130 156 97 92 162 98 215 86 116 75 163 66 44 53 5 72 76 121 233 100 216 64 146 115 49 161 73 8 137 238 103 237 26 246 129 211 80 224 161 252 149 180 70 201 94 56 163 193 74 243 35 108 253 255 77)
#f
("WeakHash"))
#(43
"last byte of m_hash modified"
#vu8(49 50 51 52 48 48)
#vu8(83 219 205 198 26 202 176 217 102 100 79 96 187 168 185 199 130 97 240 26 252 190 233 94 32 111 174 102 92 7 252 105 193 48 21 148 26 247 182 132 116 81 145 251 120 56 118 128 162 116 131 141 29 154 59 212 181 245 86 64 110 209 30 24 121 222 247 194 240 24 245 123 49 115 32 1 62 157 73 149 241 97 12 179 202 187 143 140 219 247 24 213 195 4 67 23 176 0 87 66 68 213 251 159 230 100 187 212 10 235 11 208 102 212 204 250 34 74 73 195 233 227 163 174 50 54 144 229 254 119 163 199 45 93 199 82 190 125 104 236 195 137 88 162 191 168 224 201 54 91 94 84 108 161 95 185 94 32 90 48 129 139 1 182 31 191 122 103 9 40 27 156 204 201 160 193 17 156 184 193 28 79 162 229 254 164 175 252 71 123 25 53 184 186 115 140 57 8 159 21 198 254 15 236 12 120 185 116 100 110 160 235 184 12 165 232 56 109 152 3 118 71 4 231 241 97 136 168 17 222 137 55 159 171 128 71 23 54 76 249 236 57 55 30 170 65 108 98 138 85 210 220 26 91 94 217)
#f
("WeakHash"))
#(44
"last byte of m_hash modified"
#vu8(49 50 51 52 48 48)
#vu8(23 181 80 172 22 142 37 235 246 209 189 102 172 48 129 92 253 182 128 39 135 147 254 199 139 54 226 242 141 16 195 40 146 221 10 249 149 15 132 2 173 139 84 89 116 114 36 154 235 149 99 33 94 23 161 122 216 255 173 124 74 28 20 196 185 44 216 223 192 53 207 170 198 214 98 226 124 13 246 177 215 135 183 19 106 74 189 94 242 171 248 5 207 166 138 200 238 224 166 181 0 27 159 232 133 90 8 82 109 161 151 29 50 208 163 146 66 75 189 55 189 67 246 139 129 25 170 92 110 163 61 168 23 102 14 188 53 216 12 77 71 122 243 54 59 220 164 201 118 236 132 242 170 226 207 253 249 206 81 123 80 153 78 106 6 47 25 157 113 50 60 83 45 87 231 111 141 137 103 76 54 30 34 117 50 101 137 177 66 180 219 130 104 161 179 100 37 167 215 12 87 17 93 242 188 150 149 214 220 42 214 243 133 13 12 253 165 69 168 232 122 117 164 154 210 131 140 210 64 243 70 26 40 82 1 168 61 187 103 8 81 169 171 205 177 31 43 38 216 200 159 30 228 212 78 233)
#f
("WeakHash"))
#(45
"all bits in m_hash flipped"
#vu8(49 50 51 52 48 48)
#vu8(17 203 47 4 77 75 174 67 250 44 123 185 103 248 243 174 243 55 22 224 229 25 173 12 73 87 11 215 40 136 50 35 159 113 190 106 184 43 155 185 101 32 151 45 244 180 92 139 133 240 220 189 138 166 131 149 6 200 180 74 153 11 32 224 194 181 140 49 53 89 248 106 237 59 214 72 216 167 186 94 242 175 0 185 88 235 137 253 105 163 16 123 220 81 156 96 223 251 33 162 13 74 55 223 117 114 179 228 150 219 104 202 134 249 232 95 241 50 1 99 153 187 12 222 122 113 155 193 114 157 241 177 179 230 228 220 26 192 34 70 189 163 222 158 205 137 172 20 244 148 141 162 152 218 119 225 66 88 106 192 212 136 84 180 209 236 163 106 24 175 82 33 206 81 120 154 203 247 114 192 110 67 96 9 163 184 133 64 229 147 212 39 27 171 206 30 207 209 73 250 83 103 51 142 130 255 59 137 131 200 175 2 223 153 227 112 57 167 208 63 17 61 255 4 63 89 142 61 104 243 8 62 195 205 84 90 82 160 118 72 127 127 249 60 1 101 56 221 111 185 249 71 232 125 167 22)
#f
("WeakHash"))
#(46
"s_len changed to 0"
#vu8(49 50 51 52 48 48)
#vu8(13 209 108 60 204 16 178 128 188 54 192 16 78 124 95 228 113 7 193 186 81 29 25 115 87 170 122 83 126 144 240 121 160 3 133 116 74 133 160 112 128 78 145 52 167 95 167 59 241 192 83 22 46 210 230 34 239 29 58 27 159 17 124 71 167 182 143 158 16 0 191 133 21 112 152 127 187 159 139 95 210 191 192 88 249 95 43 209 44 169 119 228 79 89 109 240 161 196 141 233 208 200 64 115 45 148 172 47 17 21 108 158 115 157 232 223 137 49 239 174 138 164 44 214 37 75 63 190 20 5 49 62 139 25 202 134 4 94 223 135 99 27 210 25 246 146 59 141 253 120 58 201 231 201 19 207 115 72 199 181 2 139 71 136 152 163 102 184 147 147 138 148 210 254 169 46 120 0 26 226 186 175 93 192 195 30 155 13 70 25 224 253 228 84 20 176 197 134 60 136 38 64 109 135 180 143 190 12 82 22 77 10 141 31 208 11 136 61 218 232 225 35 92 132 109 81 229 203 32 215 36 87 109 253 250 1 209 95 71 203 172 86 177 117 67 252 223 232 29 215 13 202 84 95 253 208)
#f
("WeakHash"))
#(47
"s_len changed to 32"
#vu8(49 50 51 52 48 48)
#vu8(24 189 118 65 116 135 50 99 52 23 113 167 131 83 73 33 204 197 243 57 92 169 106 58 87 112 107 171 31 120 144 92 0 47 60 214 225 121 30 35 138 139 166 185 253 221 116 212 231 88 82 123 195 206 118 162 217 179 126 19 11 204 184 226 53 248 56 142 84 21 47 68 115 70 165 128 244 128 139 204 23 223 165 28 105 194 98 94 254 229 117 49 75 96 155 142 48 241 202 248 34 65 27 161 206 203 178 194 149 199 102 32 234 27 100 250 219 212 168 181 46 163 152 246 5 56 243 161 159 201 199 197 247 183 222 128 46 22 194 144 214 53 39 133 144 188 54 123 147 94 183 32 149 71 170 28 179 120 229 78 46 56 61 138 44 103 166 158 121 15 202 181 64 165 28 247 86 200 106 95 208 243 55 177 66 70 237 166 94 155 139 133 230 235 230 46 137 21 106 56 126 157 27 114 6 218 114 192 130 45 32 162 6 55 57 25 86 212 115 254 164 38 80 94 106 84 18 96 185 44 180 182 105 128 89 45 207 146 191 167 29 38 76 87 84 150 220 192 152 186 200 46 221 92 109 193)
#f
("WeakHash"))
#(48
"salt is all 0"
#vu8(49 50 51 52 48 48)
#vu8(96 131 226 74 203 212 151 59 142 40 189 34 233 150 146 66 82 227 6 2 156 61 181 197 53 63 62 76 80 93 54 241 251 126 88 8 35 226 25 100 249 32 111 187 21 132 101 246 75 38 8 158 31 212 184 188 178 171 204 3 132 120 27 176 5 219 156 167 20 103 102 28 199 232 230 161 198 181 220 138 230 70 240 230 128 89 32 1 98 40 244 0 120 73 6 162 51 159 94 35 133 207 41 85 6 194 35 59 102 42 14 1 96 145 131 38 17 34 179 9 161 135 75 52 204 116 36 47 54 32 227 219 198 57 162 90 158 40 197 78 77 61 176 141 106 121 62 196 104 144 44 240 223 253 195 235 203 9 130 174 122 150 149 30 191 94 118 64 69 43 160 245 51 34 115 253 155 190 77 186 38 231 235 16 108 126 209 108 139 170 31 29 126 93 22 4 130 116 30 149 18 183 138 166 42 148 44 171 187 56 120 158 123 179 128 21 123 180 46 106 113 197 128 219 162 84 203 143 89 98 15 48 172 128 157 62 216 20 197 238 15 49 6 176 56 6 153 61 121 222 217 74 180 195 180 208)
#t
("WeakHash"))
#(49
"salt is all 1"
#vu8(49 50 51 52 48 48)
#vu8(70 223 12 212 156 162 26 14 232 77 141 138 42 99 44 60 61 65 136 0 135 115 192 91 110 20 143 98 156 98 185 219 243 216 177 223 91 254 188 22 239 177 78 94 209 11 185 205 83 248 21 236 57 6 162 182 233 204 205 230 79 82 194 60 223 213 96 95 140 140 47 98 234 219 11 36 69 250 121 164 230 103 203 99 177 11 185 24 30 142 193 25 70 5 77 189 19 233 202 84 92 217 218 148 91 208 58 225 196 248 237 72 85 93 46 113 225 186 141 65 10 114 95 175 190 238 142 246 121 143 239 157 58 156 109 72 130 92 153 109 161 242 33 80 72 145 107 223 150 210 148 201 135 202 103 141 107 22 6 174 250 178 153 91 17 238 7 22 51 235 28 72 115 193 37 42 56 243 69 52 130 204 114 221 201 47 159 71 100 173 244 50 114 116 17 141 154 219 239 110 141 219 222 132 173 124 105 145 247 21 90 31 119 170 177 208 31 149 147 28 247 61 97 146 92 25 214 96 64 224 247 216 191 198 137 119 219 148 129 37 221 129 160 40 43 48 177 148 46 5 151 180 137 198 194 228)
#t
("WeakHash"))
#(50
"byte 0 in zero padding modified"
#vu8(49 50 51 52 48 48)
#vu8(33 205 125 50 201 19 98 183 9 188 98 157 158 4 178 66 96 76 50 92 149 134 223 243 220 21 46 254 58 5 177 226 241 206 133 38 92 148 172 225 240 173 60 80 211 39 202 88 46 75 153 54 60 95 194 202 64 96 54 118 199 116 179 215 6 247 224 223 195 30 3 6 248 131 82 115 250 203 138 169 198 80 59 207 246 175 71 24 117 248 164 188 181 181 182 64 94 194 46 123 202 201 251 127 162 202 132 207 172 96 241 25 15 61 171 155 163 74 177 48 78 7 226 250 154 37 206 164 196 89 231 142 5 41 157 183 73 125 67 1 224 94 186 83 143 120 69 190 244 114 15 237 226 181 65 80 26 110 188 171 98 160 74 31 253 221 221 255 129 70 81 56 2 250 73 82 119 206 95 2 68 33 55 134 222 164 213 166 208 47 205 147 205 65 73 7 197 87 16 124 197 63 165 197 64 159 47 160 213 146 203 167 146 115 201 185 212 222 184 210 49 152 144 155 113 33 152 190 131 201 85 169 21 229 82 156 99 77 131 117 220 5 89 215 46 48 234 159 71 84 127 109 45 82 82 155)
#f
("WeakHash"))
#(51
"byte 7 in zero padding modified"
#vu8(49 50 51 52 48 48)
#vu8(39 70 215 212 143 242 241 115 100 196 10 13 242 119 36 38 86 175 108 207 168 152 2 214 195 30 195 35 136 86 31 189 38 28 133 204 3 226 89 155 132 94 35 236 144 73 63 99 122 60 29 9 11 38 4 207 92 62 203 169 176 144 120 86 14 117 82 53 149 146 57 16 246 136 233 19 55 24 92 77 9 120 98 59 174 124 51 209 195 181 13 131 121 76 10 90 68 165 48 155 161 211 159 60 93 195 179 22 97 200 149 171 160 72 156 211 146 41 1 53 16 140 206 86 121 76 206 164 145 171 66 75 172 68 5 203 144 167 42 181 48 66 179 250 134 50 34 196 29 21 108 160 231 82 247 51 235 88 139 217 83 42 196 34 190 239 250 196 192 28 55 38 47 73 254 126 63 157 255 63 153 62 172 123 26 218 241 83 128 94 27 68 247 83 158 4 163 140 25 87 151 100 166 216 192 99 79 202 176 204 34 206 65 5 25 104 238 235 68 241 127 237 122 233 89 213 25 158 229 224 137 106 150 78 239 206 88 59 142 9 132 244 26 38 208 189 195 6 180 109 151 178 157 88 127 136)
#f
("WeakHash"))
#(52
"all bytes in zero padding modified"
#vu8(49 50 51 52 48 48)
#vu8(57 97 14 187 117 5 254 136 83 221 45 75 176 195 163 73 11 102 148 101 196 200 48 128 214 67 51 114 9 128 44 155 106 17 230 199 148 129 203 84 6 22 199 248 119 172 88 187 160 140 243 249 60 205 109 234 192 232 34 117 129 170 115 70 31 220 200 144 130 66 70 138 76 87 17 28 99 119 18 161 206 94 174 107 219 187 222 176 133 174 204 178 204 36 121 213 2 38 12 29 31 246 55 89 210 127 88 236 223 135 254 207 93 35 7 47 112 155 90 168 17 219 219 6 122 163 148 194 114 194 112 189 142 209 201 208 73 31 204 173 115 183 74 75 70 226 248 254 195 226 66 118 97 54 12 65 190 48 96 21 228 51 100 187 69 154 140 60 209 121 127 196 168 155 227 165 32 57 99 32 66 127 18 222 40 211 0 26 226 87 253 152 164 240 249 6 120 26 47 246 150 191 81 52 108 146 84 91 209 140 55 22 141 148 52 128 173 30 169 220 180 122 44 198 133 75 191 116 86 242 5 18 31 31 79 91 235 101 25 82 26 145 113 26 161 87 210 68 27 155 234 154 41 204 186 124)
#f
("WeakHash"))
#(53
"first byte of hash h modified"
#vu8(49 50 51 52 48 48)
#vu8(104 29 122 250 202 223 25 218 185 37 47 188 53 186 134 168 211 79 71 134 117 146 81 169 29 186 24 135 42 7 10 243 158 91 62 154 18 136 107 99 136 204 89 210 248 59 241 154 9 209 207 108 223 50 240 245 124 183 10 232 223 141 98 59 199 194 164 90 52 75 2 72 44 221 2 107 66 7 115 91 174 96 137 131 28 142 243 217 116 40 40 142 54 59 223 207 109 49 63 237 230 114 130 64 175 143 6 159 155 109 123 87 224 41 170 181 185 46 61 211 98 127 29 26 154 36 45 227 225 74 76 245 2 95 154 59 162 221 218 35 8 15 61 37 13 179 32 195 84 21 140 42 126 83 14 167 126 243 133 131 186 29 59 178 20 27 5 60 148 102 192 67 228 204 38 18 86 186 221 245 123 237 69 201 164 145 180 159 86 211 88 74 61 107 13 245 132 52 8 176 40 123 133 14 136 196 49 64 250 50 207 229 218 41 208 110 224 81 187 11 0 19 250 108 91 110 246 234 2 93 16 111 139 232 22 106 146 20 225 247 124 177 158 152 82 152 230 215 29 140 0 185 32 174 41 140)
#f
("WeakHash"))
#(54
"first byte of hash h modified"
#vu8(49 50 51 52 48 48)
#vu8(2 234 226 112 56 121 82 47 102 96 34 29 201 138 132 161 165 191 105 210 25 136 100 218 131 166 51 208 238 245 109 131 149 6 69 255 152 120 191 18 97 142 200 207 248 38 198 227 217 85 216 43 199 246 209 10 194 7 70 124 55 61 124 124 232 214 219 126 185 233 102 222 211 199 138 137 171 174 24 14 177 38 43 128 169 118 179 45 119 100 47 57 235 196 56 141 40 68 173 36 20 186 106 10 241 178 99 191 180 79 22 246 211 189 244 68 23 172 49 24 42 132 12 131 132 143 30 96 179 101 37 176 19 91 202 151 24 185 198 232 192 106 211 198 46 176 126 176 247 197 39 147 163 136 237 171 155 62 55 234 217 41 186 187 138 134 102 69 117 29 237 93 51 30 253 226 216 54 49 121 24 139 209 74 211 35 220 15 157 52 60 76 61 7 194 10 94 214 173 2 16 45 60 128 79 206 251 212 62 132 141 42 202 166 50 236 162 231 45 203 210 32 11 91 89 88 104 239 26 17 83 54 247 84 161 100 41 44 123 70 94 157 7 237 100 240 57 124 243 102 79 214 248 126 12 30)
#f
("WeakHash"))
#(55
"last byte of hash h modified"
#vu8(49 50 51 52 48 48)
#vu8(107 141 195 102 234 225 52 139 119 0 25 209 162 210 163 160 117 237 163 111 153 193 32 41 2 191 68 197 11 62 200 231 92 4 21 238 189 198 29 112 243 124 130 128 181 174 107 46 3 221 208 177 241 92 105 68 205 233 67 59 8 55 38 91 140 214 88 242 16 41 176 145 131 46 226 140 80 71 219 33 222 64 41 176 238 23 54 159 153 219 252 194 164 173 66 220 197 142 33 6 115 21 75 79 161 71 77 189 104 79 156 118 57 192 133 109 147 108 139 127 220 67 123 236 141 111 135 84 205 149 119 99 155 20 65 58 183 179 14 210 54 68 5 22 131 127 130 10 11 14 20 108 72 112 109 83 75 240 56 65 243 192 23 43 214 152 235 131 86 51 45 37 101 219 235 81 67 168 34 160 164 185 120 24 38 24 145 62 100 250 167 26 21 212 84 188 5 172 203 116 209 51 138 78 102 234 119 230 144 166 35 140 144 184 74 82 97 177 124 109 47 233 71 195 123 187 174 153 174 160 116 47 101 89 214 23 122 39 45 180 213 16 71 162 6 184 4 165 144 237 173 15 122 247 192 120)
#f
("WeakHash"))
#(56
"last byte of hash h modified"
#vu8(49 50 51 52 48 48)
#vu8(150 160 81 152 10 93 183 123 148 167 173 195 47 115 151 61 207 205 98 233 91 14 13 46 8 68 16 195 127 101 181 13 1 142 153 70 51 79 165 210 104 166 132 141 193 100 219 29 1 44 93 66 218 97 61 157 22 125 193 55 35 179 52 172 251 180 114 211 32 39 238 107 82 144 63 184 252 7 193 168 202 49 21 111 215 53 104 211 161 217 51 209 68 208 242 99 162 173 174 117 30 141 79 181 185 73 173 179 64 117 166 250 89 221 252 196 147 153 249 208 29 200 216 115 59 228 127 46 207 179 150 163 207 228 13 97 155 228 67 103 103 247 109 0 137 184 69 244 162 101 165 255 186 203 105 223 202 166 141 230 179 75 108 91 20 51 225 73 179 189 202 91 199 43 152 97 119 87 161 36 43 70 241 253 13 125 10 122 247 90 219 149 4 51 225 183 88 79 162 222 81 185 50 49 221 115 81 44 238 114 138 62 111 124 185 81 119 7 45 207 210 83 98 218 83 127 212 19 72 135 171 27 83 105 121 243 150 154 2 205 194 243 105 158 57 75 0 26 178 39 223 125 170 23 91 117)
#f
("WeakHash"))
#(57
"all bytes of h replaced by 0"
#vu8(49 50 51 52 48 48)
#vu8(91 172 49 3 6 42 87 38 165 120 118 250 188 233 209 19 249 129 111 48 240 51 10 200 191 7 151 235 212 28 83 38 234 105 62 215 163 219 10 242 81 239 38 143 169 94 225 22 94 227 213 251 162 99 15 167 92 52 106 228 34 195 209 77 37 225 110 177 195 183 98 217 172 227 121 173 80 6 232 86 139 43 73 76 124 187 144 251 117 137 182 7 218 36 203 140 214 164 216 81 202 75 198 116 24 25 221 249 172 183 179 203 80 205 67 86 182 52 173 39 120 68 97 70 180 145 43 157 164 48 146 27 255 58 140 199 227 48 232 42 56 189 159 105 234 244 120 89 181 25 156 206 234 11 157 17 29 189 229 226 10 132 81 253 152 150 133 152 97 114 228 246 155 162 152 60 48 28 81 229 125 220 69 122 248 254 172 151 9 216 77 155 60 112 251 186 66 58 187 164 204 166 234 177 255 244 42 205 238 197 236 137 147 108 78 168 248 55 176 30 255 149 77 19 251 207 232 115 26 108 124 201 39 26 128 90 152 184 135 127 54 67 53 234 35 144 3 204 98 89 174 187 146 45 47 151)
#f
("WeakHash"))
#(58
"all bits of h replaced by 1s"
#vu8(49 50 51 52 48 48)
#vu8(30 16 141 223 29 109 147 29 213 104 252 222 30 17 151 29 205 134 180 9 105 153 9 212 194 104 154 193 127 207 12 222 155 194 125 16 249 242 135 1 19 204 97 249 152 61 30 197 228 177 181 248 173 14 72 138 153 31 20 85 197 173 79 114 16 86 229 77 17 183 125 199 186 115 189 60 170 235 137 194 17 65 240 1 5 1 201 247 42 63 205 77 126 126 89 247 1 223 3 47 163 146 191 130 161 222 159 249 246 193 94 242 176 165 66 1 247 135 189 135 186 79 201 105 96 101 229 219 150 202 228 182 31 102 41 67 150 238 234 148 193 192 172 16 221 143 28 174 146 140 123 127 250 132 168 102 214 157 69 15 7 47 116 106 74 242 13 75 57 210 108 190 228 59 34 126 150 196 239 94 222 90 160 67 213 28 106 94 148 200 165 151 88 249 180 33 51 207 240 176 28 54 95 237 87 209 137 16 108 78 56 204 115 239 231 22 90 170 118 178 162 251 10 44 65 83 102 115 35 76 65 22 167 68 93 217 252 147 224 242 126 171 142 93 76 25 167 18 224 152 64 21 30 68 5 63)
#f
("WeakHash"))
#(59
"all bits in hash h flipped"
#vu8(49 50 51 52 48 48)
#vu8(72 119 8 91 196 91 78 83 138 47 37 117 92 164 16 3 42 1 175 70 5 35 190 160 238 29 167 103 215 54 136 173 240 157 139 48 12 80 0 215 68 86 165 88 6 220 250 30 27 28 120 122 105 255 242 149 33 87 114 23 54 73 251 249 108 23 200 88 212 190 154 122 185 183 179 24 146 67 237 185 151 175 106 1 0 245 84 227 104 22 155 17 92 244 77 209 180 134 101 64 125 252 203 65 237 239 163 86 194 151 49 95 229 211 42 233 30 33 112 93 96 2 196 198 36 196 184 150 221 96 36 131 155 1 19 252 113 18 144 82 51 10 48 152 146 193 60 245 198 142 247 34 214 55 233 118 97 54 109 64 248 7 156 92 120 152 87 71 29 115 251 164 244 104 166 194 108 33 230 86 89 181 254 40 254 160 227 79 212 119 101 17 158 65 211 161 42 20 129 129 167 143 133 200 4 70 226 222 91 66 196 43 53 77 113 10 79 98 55 168 48 165 158 121 82 86 10 143 252 228 2 132 92 56 233 212 160 32 46 61 77 138 3 82 152 228 180 128 37 224 62 98 188 108 31 240)
#f
("WeakHash"))
#(60
"hash of salt missing"
#vu8(49 50 51 52 48 48)
#vu8(73 98 107 217 131 119 241 210 229 113 169 217 25 59 205 225 194 154 255 225 120 6 85 73 145 104 11 234 190 244 1 44 115 253 204 213 133 75 125 214 90 58 255 134 134 136 182 212 85 63 121 234 95 233 240 77 63 106 250 239 149 102 85 2 37 75 21 40 221 53 225 74 13 51 231 16 66 16 202 145 57 122 199 102 188 127 222 26 3 11 110 45 56 173 77 105 208 85 87 70 70 2 192 64 136 143 182 241 95 70 90 97 39 110 103 48 187 49 6 144 143 96 228 49 175 168 193 18 124 130 176 242 61 222 228 16 227 197 231 54 145 251 109 118 242 182 64 83 72 114 141 120 165 32 86 31 187 49 153 41 109 200 183 212 62 1 144 22 26 40 153 35 161 23 132 9 180 56 16 229 183 16 221 116 186 93 250 214 169 163 86 117 254 209 88 71 40 249 210 34 233 177 21 248 57 0 182 234 131 62 178 139 200 86 213 183 6 188 164 127 242 202 33 19 225 167 186 150 154 13 227 49 157 159 129 86 112 87 91 133 226 22 223 248 136 76 236 32 181 106 59 245 24 54 242 6)
#f
("WeakHash"))
#(61
"first byte of ps modified"
#vu8(49 50 51 52 48 48)
#vu8(125 249 173 218 137 248 58 187 223 14 52 147 87 132 97 251 142 1 245 157 193 4 111 208 26 203 79 156 121 169 165 249 95 125 115 220 10 157 255 154 196 176 59 104 83 165 231 136 218 130 10 84 224 220 113 205 95 76 110 126 25 30 249 133 172 153 254 59 121 229 120 223 19 219 165 33 218 128 130 247 173 223 106 247 239 77 246 73 251 174 140 157 88 183 65 159 85 26 214 127 6 30 22 83 210 110 204 65 249 223 248 222 162 54 70 47 13 167 187 52 190 168 144 226 24 130 67 125 159 168 246 117 149 78 28 114 168 174 35 91 188 254 160 183 42 150 52 53 231 198 157 124 91 232 111 205 121 165 14 203 213 62 51 247 211 239 242 104 238 135 176 207 99 74 122 154 178 250 53 3 232 223 37 75 178 242 35 193 210 169 218 156 171 186 185 72 171 59 41 245 62 112 204 126 216 89 229 195 193 198 110 224 43 36 117 200 108 48 177 72 198 64 214 125 125 240 135 159 209 75 74 249 250 25 166 141 107 211 203 134 108 148 219 22 110 241 40 39 182 116 72 215 195 22 179 136)
#f
("WeakHash"))
#(62
"last byte of ps modified"
#vu8(49 50 51 52 48 48)
#vu8(135 236 106 140 60 63 93 176 216 86 48 189 118 255 10 153 0 126 235 134 117 174 104 241 57 76 37 225 175 79 52 0 81 98 109 45 164 13 246 83 220 183 24 148 180 242 146 166 192 220 50 156 154 168 245 153 65 136 57 137 0 137 8 28 163 145 15 134 14 28 223 235 154 177 37 106 15 69 255 238 234 200 97 220 100 113 169 2 55 93 228 40 123 5 204 89 216 205 91 132 255 144 233 81 208 176 197 116 243 243 214 58 97 123 161 227 234 228 28 147 26 39 106 248 119 47 208 210 9 125 74 205 28 206 143 214 46 162 149 141 36 142 250 139 150 243 170 90 251 163 150 177 126 41 14 106 153 46 228 205 1 36 129 2 85 212 68 30 182 121 164 124 114 110 183 132 32 19 149 64 43 79 20 79 72 198 251 99 172 205 37 239 171 57 182 245 115 115 40 155 51 119 76 200 175 55 203 42 75 67 206 183 42 4 252 128 242 117 112 129 234 143 39 202 234 24 97 41 104 129 189 148 139 210 68 88 137 47 92 221 27 175 183 10 228 134 152 74 248 60 190 244 253 252 12 196)
#f
("WeakHash"))
#(63
"all bytes of ps changed to 0xff"
#vu8(49 50 51 52 48 48)
#vu8(168 149 117 95 36 148 245 195 94 114 3 218 157 220 2 24 12 119 203 27 153 79 89 2 14 199 47 81 116 255 165 154 113 122 126 125 14 211 143 134 54 144 124 158 179 72 7 218 76 67 54 47 52 45 90 176 23 159 221 38 136 84 86 204 105 164 165 207 158 149 160 178 60 128 8 41 237 161 95 206 238 179 180 84 213 171 146 13 0 68 163 207 222 207 76 67 79 40 72 77 58 250 112 164 136 131 159 188 99 223 154 25 28 62 227 181 223 5 152 235 161 85 188 150 35 18 99 59 171 4 180 141 71 17 15 25 201 127 172 182 234 61 56 56 225 244 65 133 27 203 6 237 57 90 31 198 246 55 14 6 80 148 147 157 189 236 40 251 99 150 203 6 46 238 82 72 83 241 81 161 210 32 30 81 210 218 166 104 4 101 237 44 239 141 108 211 106 164 63 119 52 117 75 159 73 150 32 217 86 194 205 111 208 194 202 49 115 253 173 54 132 54 216 49 62 20 128 133 210 44 121 49 254 231 255 88 212 208 147 52 129 108 33 28 21 50 241 8 109 209 151 191 164 178 246 40)
#f
("WeakHash"))
#(64
"all bytes of ps changed to 0x80"
#vu8(49 50 51 52 48 48)
#vu8(10 232 137 135 176 1 245 165 213 215 178 87 165 127 194 195 127 100 47 19 103 23 23 31 206 40 67 4 149 222 239 185 64 121 151 185 230 72 176 170 239 245 104 172 179 229 181 62 101 123 65 126 156 216 218 82 121 165 44 3 141 150 87 67 9 108 45 83 60 37 234 152 205 116 124 165 215 25 244 60 194 218 202 66 108 247 190 226 5 191 137 194 37 160 129 125 89 7 155 129 98 198 2 42 208 41 208 148 110 185 158 142 68 236 8 152 201 137 38 20 192 196 137 6 223 153 33 146 117 160 79 193 239 233 45 93 107 249 140 144 165 172 70 154 54 244 122 15 35 136 159 209 141 161 179 142 241 18 218 251 105 111 83 107 189 4 230 201 102 169 186 50 107 189 99 141 130 182 215 102 25 22 183 189 125 61 74 196 38 233 240 253 82 121 24 80 90 96 39 184 221 113 106 57 102 251 67 156 196 161 48 161 48 20 35 140 95 16 77 117 79 191 236 47 28 120 11 73 170 248 3 97 140 42 139 105 236 125 15 9 133 92 177 1 152 120 245 45 241 60 68 146 164 128 220 231)
#f
("WeakHash"))
#(65
"ps followed by 0"
#vu8(49 50 51 52 48 48)
#vu8(58 179 200 207 139 153 162 191 136 33 83 239 26 214 219 68 158 30 223 103 58 1 224 20 180 13 26 35 252 179 143 186 33 189 99 204 217 223 154 8 73 213 156 65 82 9 70 212 111 210 111 237 158 212 189 101 186 14 0 112 92 17 158 191 205 243 28 237 52 67 62 205 249 180 23 15 153 144 194 162 108 74 253 221 40 75 126 19 75 155 168 182 208 212 22 36 161 105 184 244 235 236 122 135 208 222 14 231 135 12 153 212 208 81 70 167 183 28 148 96 111 209 120 170 101 92 62 219 160 247 100 243 41 45 118 33 125 67 73 249 13 9 25 196 44 53 190 33 97 63 202 248 36 225 106 179 244 94 241 124 20 37 89 117 203 133 247 225 245 221 188 1 81 172 73 97 246 138 51 27 151 115 123 23 30 147 192 26 15 70 5 199 37 109 233 60 225 225 204 143 81 117 131 137 153 199 52 128 155 218 248 185 94 223 172 13 95 152 195 222 51 173 99 153 232 32 122 128 21 55 62 31 94 215 110 48 75 94 42 194 96 187 237 35 198 98 195 139 111 41 220 176 31 170 72 148)
#f
("WeakHash"))
#(66
"ps followed by 0xff"
#vu8(49 50 51 52 48 48)
#vu8(90 126 84 159 153 193 56 211 250 126 222 58 214 85 71 63 120 195 168 222 101 11 248 219 106 81 22 240 128 126 93 248 68 69 237 114 234 106 130 168 21 13 179 82 184 82 16 225 32 129 141 161 61 152 0 209 88 35 245 120 11 96 81 229 27 244 72 134 84 230 169 60 149 209 155 69 55 135 68 72 59 67 179 114 0 217 51 119 93 47 132 167 113 156 223 246 218 226 225 87 22 200 106 156 90 0 66 165 38 140 220 123 94 24 96 193 80 216 82 83 87 55 135 178 131 159 237 246 77 243 213 76 151 127 99 231 191 175 49 104 240 21 62 46 240 25 36 78 92 221 155 230 155 66 22 7 254 247 39 189 84 66 173 164 186 184 2 172 159 192 192 4 78 181 180 53 169 202 242 23 115 43 103 64 87 27 249 247 177 179 253 131 218 141 76 128 106 126 34 65 227 124 208 208 106 186 226 138 197 168 58 227 178 248 31 51 116 219 234 151 228 108 102 232 33 34 111 199 207 11 10 242 220 189 183 197 207 246 65 119 92 129 254 164 200 203 147 9 233 137 188 160 74 74 93 61)
#f
("WeakHash"))
#(67
"shifted salt"
#vu8(49 50 51 52 48 48)
#vu8(73 117 195 253 99 88 152 153 56 99 61 7 207 123 240 18 28 138 140 152 127 222 28 172 64 89 36 171 136 197 163 23 93 39 32 126 187 254 66 178 68 4 34 126 56 139 17 217 43 187 172 187 207 21 45 63 172 1 102 172 184 104 249 8 81 89 3 227 125 169 142 150 174 163 103 193 121 83 10 67 247 141 135 124 240 131 131 51 252 234 48 60 246 113 15 4 101 19 240 29 88 107 197 75 66 191 207 93 212 123 26 1 234 139 149 170 251 75 148 6 136 139 50 102 68 95 116 155 28 86 69 156 228 225 10 87 237 197 159 97 11 139 116 237 249 152 124 152 136 70 1 8 161 21 37 208 231 34 139 165 235 148 114 160 250 218 29 5 108 139 13 8 239 238 39 97 16 117 149 198 178 33 113 107 103 130 194 123 215 117 95 26 35 174 246 203 150 106 49 71 25 33 89 74 29 225 126 188 126 91 82 185 51 174 82 160 121 75 244 188 209 167 146 231 138 71 240 25 105 138 55 208 211 137 202 32 64 192 211 117 142 237 240 250 129 0 65 87 75 50 147 141 41 12 251 69)
#f
("WeakHash"))
#(68
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(136 29 196 191 139 44 108 23 225 11 239 61 171 50 123 76 187 118 65 58 126 90 251 210 79 25 143 164 97 188 233 57 45 49 240 161 29 105 189 103 183 95 163 15 242 16 13 205 82 184 224 194 76 145 176 25 109 23 42 227 252 29 64 251 22 123 42 189 206 75 131 254 211 101 185 213 148 106 51 61 15 102 157 153 237 247 184 163 161 200 221 242 57 124 183 123 203 98 174 207 129 136 7 214 150 175 79 24 107 242 224 98 141 219 27 157 69 220 214 235 150 93 209 181 235 43 173 230 15 191 91 42 232 22 244 95 158 10 208 36 3 155 246 76 8 30 55 99 13 109 181 26 54 142 146 37 98 104 23 138 235 211 41 99 160 118 147 248 40 208 30 235 170 208 250 4 224 255 41 216 199 174 104 27 228 236 22 210 166 186 252 21 115 227 143 88 198 194 195 106 93 90 42 231 113 138 219 19 144 119 13 154 56 130 248 149 179 240 254 225 106 43 220 116 59 9 6 86 123 105 56 215 58 102 108 195 61 133 20 35 89 212 14 171 188 29 166 90 230 22 199 129 143 134 254 26)
#f
("WeakHash"))
#(69
"bit 7 of masked_db not cleared"
#vu8(49 50 51 52 48 48)
#vu8(21 135 34 99 248 39 14 122 233 211 18 122 155 103 120 40 202 226 7 126 83 78 163 73 7 2 137 57 77 19 89 147 146 181 248 3 248 219 254 64 165 72 114 35 221 162 163 198 243 13 220 146 196 230 217 210 46 125 13 43 96 25 126 3 47 24 141 163 84 87 39 60 229 81 139 66 97 150 201 82 208 33 159 246 25 15 206 144 93 133 109 73 27 0 153 152 33 206 141 30 164 177 143 52 35 235 173 36 43 200 70 224 175 64 143 33 205 219 244 78 158 95 93 48 13 113 163 177 4 234 162 35 14 230 51 210 234 68 1 106 247 53 205 94 217 199 180 33 243 34 120 21 71 188 187 12 217 94 71 128 65 47 115 75 246 129 187 71 171 212 107 21 141 37 30 201 32 86 85 58 192 106 89 196 186 127 210 11 254 80 204 88 56 104 50 181 46 84 141 243 69 176 134 181 117 124 76 159 46 19 49 49 190 204 144 167 46 198 195 19 231 102 77 188 146 44 135 169 3 100 191 199 70 164 37 223 119 201 185 125 194 175 236 178 204 54 254 196 21 164 225 198 169 87 180 179)
#f
("WeakHash"))
#(70
"first byte of masked_db changed to 0"
#vu8(49 50 51 52 48 48)
#vu8(109 229 10 153 17 137 53 71 171 86 6 93 41 83 3 135 104 205 6 137 166 59 7 3 192 220 153 231 205 164 18 255 73 236 165 3 103 31 6 134 53 246 155 56 192 98 116 39 240 39 133 179 135 12 103 145 173 211 125 67 106 129 83 142 111 227 221 14 175 219 80 161 141 47 45 151 227 203 160 98 252 131 67 166 223 212 72 193 25 151 209 197 191 110 24 149 224 154 180 53 235 177 96 82 194 3 71 244 208 119 198 199 119 146 151 162 158 118 228 156 223 13 16 113 63 206 32 171 81 210 115 254 186 255 208 103 154 30 213 109 165 192 67 10 144 165 252 161 236 32 16 41 59 46 184 254 52 167 50 239 70 121 49 143 197 104 44 216 121 109 87 190 9 144 64 67 150 29 81 113 250 50 48 103 69 1 84 78 61 84 130 245 16 175 235 14 228 186 159 209 207 229 186 85 39 201 195 47 240 157 245 121 136 77 74 91 3 81 206 250 7 186 244 9 97 65 35 72 182 132 111 206 91 214 214 90 84 56 130 18 24 214 119 231 116 130 129 8 173 128 95 87 76 231 181 151)
#f
("WeakHash"))
#(71
"last byte in em modified"
#vu8(49 50 51 52 48 48)
#vu8(31 71 172 127 212 88 94 164 42 176 142 16 2 245 71 220 120 219 172 218 0 235 43 62 116 208 228 109 69 255 168 250 123 53 215 175 223 96 91 45 167 114 191 84 132 63 21 41 123 204 111 82 238 236 174 254 28 38 16 140 53 249 5 156 130 35 118 124 25 89 127 68 112 222 80 40 182 197 34 174 252 91 97 213 69 235 214 211 49 44 192 146 209 252 42 112 197 36 254 2 86 2 157 61 53 121 117 33 91 43 182 35 54 196 244 146 62 170 12 196 34 163 160 136 184 111 78 13 129 182 180 224 76 33 128 138 25 172 34 159 38 87 237 212 42 108 65 232 131 230 154 145 103 23 181 159 198 152 13 121 136 78 174 94 169 24 2 45 162 140 226 248 229 42 46 93 213 13 45 41 105 116 140 45 151 82 94 103 44 18 17 63 96 91 140 75 252 191 220 160 91 216 82 133 216 254 109 34 183 61 59 4 250 253 69 60 250 114 103 206 253 181 40 25 0 56 159 245 59 180 220 59 240 220 54 109 134 145 45 130 36 16 232 247 127 51 57 44 12 39 254 211 101 157 164 99)
#f
("WeakHash"))
#(72
"last byte in em modified"
#vu8(49 50 51 52 48 48)
#vu8(121 34 191 221 77 162 34 145 140 87 49 132 177 216 26 20 254 135 236 160 163 12 85 249 22 122 216 20 78 160 106 157 34 177 8 164 20 55 180 42 160 138 250 196 78 118 97 247 180 198 41 56 151 66 108 178 233 96 175 241 99 97 51 73 179 88 28 189 58 136 79 249 137 140 69 197 194 19 217 150 205 193 204 17 157 188 215 224 233 158 208 143 153 248 182 159 138 160 121 204 109 21 0 102 151 212 167 252 91 207 211 73 252 242 111 67 182 245 7 77 184 228 72 188 146 171 132 66 178 126 130 100 58 17 132 42 13 199 11 130 44 247 174 38 233 7 145 246 125 37 163 33 174 194 76 205 117 83 230 49 188 231 72 136 196 61 158 205 24 231 127 194 70 21 236 68 91 125 126 232 58 175 99 192 115 61 162 94 205 81 47 125 199 238 198 227 251 73 157 126 238 97 101 199 138 66 117 169 230 253 203 27 150 47 56 200 19 157 165 8 149 101 179 156 109 115 115 159 132 199 14 214 14 44 131 187 79 53 29 76 135 203 162 207 108 104 185 135 158 40 59 156 94 61 225 200)
#f
("WeakHash"))
#(73
"last byte in em modified"
#vu8(49 50 51 52 48 48)
#vu8(138 126 96 10 102 117 160 110 103 127 241 52 79 213 58 141 210 185 159 204 164 12 42 183 153 99 102 99 89 74 195 254 42 81 11 241 227 236 76 169 221 40 204 237 72 180 232 69 126 215 79 78 194 173 243 27 119 255 27 250 189 15 128 201 171 70 136 241 86 48 64 109 140 163 30 218 163 163 204 121 128 186 27 118 12 251 211 255 144 22 225 243 250 12 52 203 89 55 139 15 55 69 180 81 253 62 5 60 135 17 236 196 31 234 175 53 9 128 83 42 125 182 122 252 53 240 13 161 241 145 255 79 102 184 231 226 115 104 188 38 22 15 84 10 247 132 232 236 179 142 45 173 244 190 130 228 183 97 98 108 92 6 239 224 218 218 100 46 178 111 18 209 238 150 104 74 94 248 229 254 238 176 218 158 244 50 100 115 54 228 236 113 92 250 38 10 135 39 174 196 160 128 115 128 134 173 38 181 19 85 184 191 175 27 19 94 151 209 8 179 108 115 180 54 204 92 181 149 147 167 206 15 14 116 131 21 35 25 252 235 55 71 148 81 238 234 9 138 142 235 13 238 25 117 110 3)
#f
("WeakHash"))
#(74
"signature is 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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
("WeakHash"))
#(75
"signature is 1"
#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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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)
#f
("WeakHash"))
#(76
"signature is n-1"
#vu8(49 50 51 52 48 48)
#vu8(189 49 199 160 38 145 210 217 88 126 246 169 70 255 120 133 68 204 173 212 178 152 138 214 32 134 121 42 107 249 108 134 22 180 173 19 49 125 34 112 185 1 208 252 209 216 128 203 143 82 251 135 48 74 82 88 193 27 56 223 234 232 223 103 10 238 231 234 29 13 157 248 224 14 128 132 126 65 229 152 158 212 2 212 78 120 179 15 239 23 181 103 29 58 219 248 104 94 77 194 4 73 158 205 24 99 225 213 175 242 138 124 246 110 173 243 31 236 146 54 193 32 173 209 52 81 82 44 100 124 152 50 166 114 205 100 211 40 193 195 34 24 63 70 97 208 155 218 96 184 221 95 3 40 218 84 32 130 20 36 175 218 187 26 128 197 209 39 99 161 176 35 140 216 157 7 66 191 197 11 106 47 203 112 29 130 66 24 249 130 111 79 120 162 58 43 90 164 42 206 127 23 83 118 251 108 189 178 186 210 147 186 88 61 77 49 198 184 249 2 158 70 177 54 137 36 152 85 245 5 117 110 0 226 37 166 164 90 24 118 155 216 210 179 164 172 185 241 194 61 62 81 136 37 97 228)
#f
("WeakHash"))
#(77
"signature is n"
#vu8(49 50 51 52 48 48)
#vu8(189 49 199 160 38 145 210 217 88 126 246 169 70 255 120 133 68 204 173 212 178 152 138 214 32 134 121 42 107 249 108 134 22 180 173 19 49 125 34 112 185 1 208 252 209 216 128 203 143 82 251 135 48 74 82 88 193 27 56 223 234 232 223 103 10 238 231 234 29 13 157 248 224 14 128 132 126 65 229 152 158 212 2 212 78 120 179 15 239 23 181 103 29 58 219 248 104 94 77 194 4 73 158 205 24 99 225 213 175 242 138 124 246 110 173 243 31 236 146 54 193 32 173 209 52 81 82 44 100 124 152 50 166 114 205 100 211 40 193 195 34 24 63 70 97 208 155 218 96 184 221 95 3 40 218 84 32 130 20 36 175 218 187 26 128 197 209 39 99 161 176 35 140 216 157 7 66 191 197 11 106 47 203 112 29 130 66 24 249 130 111 79 120 162 58 43 90 164 42 206 127 23 83 118 251 108 189 178 186 210 147 186 88 61 77 49 198 184 249 2 158 70 177 54 137 36 152 85 245 5 117 110 0 226 37 166 164 90 24 118 155 216 210 179 164 172 185 241 194 61 62 81 136 37 97 229)
#f
("WeakHash"))
#(78
"prepending 0's to signature"
#vu8(49 50 51 52 48 48)
#vu8(0 0 11 185 71 61 58 140 196 171 214 60 111 42 193 62 39 138 156 209 221 168 68 253 189 19 233 183 124 221 82 193 176 90 197 145 38 228 93 39 103 119 232 177 188 66 60 178 97 210 150 117 152 137 84 201 221 195 139 185 166 123 236 94 3 225 231 128 145 83 51 223 228 148 221 138 79 11 250 13 116 136 5 136 92 56 157 111 127 182 247 134 197 141 33 164 104 179 88 147 70 215 14 17 83 226 157 205 185 29 236 138 193 133 80 30 254 162 71 186 199 198 62 60 84 110 214 53 230 71 9 123 174 59 140 203 153 39 1 167 93 32 156 67 156 93 190 129 34 218 97 106 78 35 11 206 8 245 65 171 255 133 79 185 60 135 253 222 15 180 87 196 75 39 131 86 139 203 191 187 166 17 216 233 132 65 13 54 12 78 195 115 44 182 148 38 169 65 145 213 160 203 51 20 155 81 141 237 134 134 71 6 199 35 178 114 40 215 72 54 81 49 145 206 188 121 7 147 229 128 146 135 176 39 158 123 200 47 38 109 67 125 25 46 152 151 89 96 208 1 77 208 46 23 43 127 226 81)
#f
("WeakHash"))
#(79
"appending 0's to signature"
#vu8(49 50 51 52 48 48)
#vu8(11 185 71 61 58 140 196 171 214 60 111 42 193 62 39 138 156 209 221 168 68 253 189 19 233 183 124 221 82 193 176 90 197 145 38 228 93 39 103 119 232 177 188 66 60 178 97 210 150 117 152 137 84 201 221 195 139 185 166 123 236 94 3 225 231 128 145 83 51 223 228 148 221 138 79 11 250 13 116 136 5 136 92 56 157 111 127 182 247 134 197 141 33 164 104 179 88 147 70 215 14 17 83 226 157 205 185 29 236 138 193 133 80 30 254 162 71 186 199 198 62 60 84 110 214 53 230 71 9 123 174 59 140 203 153 39 1 167 93 32 156 67 156 93 190 129 34 218 97 106 78 35 11 206 8 245 65 171 255 133 79 185 60 135 253 222 15 180 87 196 75 39 131 86 139 203 191 187 166 17 216 233 132 65 13 54 12 78 195 115 44 182 148 38 169 65 145 213 160 203 51 20 155 81 141 237 134 134 71 6 199 35 178 114 40 215 72 54 81 49 145 206 188 121 7 147 229 128 146 135 176 39 158 123 200 47 38 109 67 125 25 46 152 151 89 96 208 1 77 208 46 23 43 127 226 81 0 0)
#f
("WeakHash"))
#(80
"truncated signature"
#vu8(49 50 51 52 48 48)
#vu8(11 185 71 61 58 140 196 171 214 60 111 42 193 62 39 138 156 209 221 168 68 253 189 19 233 183 124 221 82 193 176 90 197 145 38 228 93 39 103 119 232 177 188 66 60 178 97 210 150 117 152 137 84 201 221 195 139 185 166 123 236 94 3 225 231 128 145 83 51 223 228 148 221 138 79 11 250 13 116 136 5 136 92 56 157 111 127 182 247 134 197 141 33 164 104 179 88 147 70 215 14 17 83 226 157 205 185 29 236 138 193 133 80 30 254 162 71 186 199 198 62 60 84 110 214 53 230 71 9 123 174 59 140 203 153 39 1 167 93 32 156 67 156 93 190 129 34 218 97 106 78 35 11 206 8 245 65 171 255 133 79 185 60 135 253 222 15 180 87 196 75 39 131 86 139 203 191 187 166 17 216 233 132 65 13 54 12 78 195 115 44 182 148 38 169 65 145 213 160 203 51 20 155 81 141 237 134 134 71 6 199 35 178 114 40 215 72 54 81 49 145 206 188 121 7 147 229 128 146 135 176 39 158 123 200 47 38 109 67 125 25 46 152 151 89 96 208 1 77 208 46 23 43 127)
#f
("WeakHash"))
#(81
"empty signature"
#vu8(49 50 51 52 48 48)
#vu8()
#f
("WeakHash"))
#(82
"PKCS #1 v1.5 signature"
#vu8(49 50 51 52 48 48)
#vu8(53 152 248 121 22 180 94 101 125 246 58 131 156 126 84 73 83 192 3 148 119 179 150 162 118 216 223 117 43 10 152 25 42 16 253 244 49 3 51 83 248 86 92 109 225 178 104 244 204 180 76 0 206 118 12 103 233 116 9 39 28 85 5 91 62 168 133 215 66 222 242 198 205 50 245 254 208 119 25 61 18 189 72 215 129 48 53 58 212 172 163 77 145 72 191 232 13 142 164 85 195 206 75 36 247 1 49 144 142 25 71 254 174 49 30 41 224 174 157 16 116 186 115 18 69 104 70 142 52 200 176 115 40 61 22 53 156 83 14 166 19 173 180 222 43 169 78 188 71 10 87 5 85 113 239 159 87 92 6 142 0 222 9 182 209 175 32 81 185 48 121 221 198 131 9 13 68 39 132 123 75 158 214 58 52 160 29 154 238 239 0 82 66 120 255 84 183 210 149 92 202 229 202 16 1 238 117 136 245 162 17 102 221 231 178 148 26 97 54 179 141 55 74 172 115 117 43 207 211 231 0 6 107 41 114 198 108 239 118 164 141 129 129 30 38 252 118 70 151 74 20 151 8 174 45 33)
#f
("WeakHash"))))
| false |
6e4343436abf26d4bfabd80a1a4fd2f75abf0e42
|
26aaec3506b19559a353c3d316eb68f32f29458e
|
/apps/DemoUIForm/main.scm
|
899ba0987ffb37771d83f01ed18c949fd16e9cb6
|
[
"BSD-3-Clause"
] |
permissive
|
mdtsandman/lambdanative
|
f5dc42372bc8a37e4229556b55c9b605287270cd
|
584739cb50e7f1c944cb5253966c6d02cd718736
|
refs/heads/master
| 2022-12-18T06:24:29.877728 | 2020-09-20T18:47:22 | 2020-09-20T18:47:22 | 295,607,831 | 1 | 0 |
NOASSERTION
| 2020-09-15T03:48:04 | 2020-09-15T03:48:03 | null |
UTF-8
|
Scheme
| false | false | 5,324 |
scm
|
main.scm
|
#|
LambdaNative - a cross-platform Scheme framework
Copyright (c) 2009-2018, University of British Columbia
All rights reserved.
Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the
following conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials
provided with the distribution.
* Neither the name of the University of British Columbia nor
the names of its contributors may be used to endorse or
promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|#
;; UIForm helloworld example
(define demouiform:example (list->table `(
(main
"Demo UI Form"
("Widgets" widgets)
("About" about)
(spacer height 200)
(label text "Hello from LambdaNative" size header)
(spacer)
;; Show an image (file listed in EMBED)
(image file "LN_logo.png")
)
(widgets
"Widgets"
#f
("Done" main)
(spacer)
;; Make a text field where the entered number will be stored in key "someid" in the database, indent it on both sides
(textentry id someid text "Number here:" keypad numint indent 0.4 indentright 0.4)
(spacer height 10)
;; Don't store the password in the database table, just store it in the UI
(textentry id passid text "Password:" password #t location ui)
(spacer)
;; Simple radio box with a callback popup from one of the options.
(radiobox id aradio text "Pick Yes" left ("Yes" "1" #f) right ("No" "0" ("I said choose yes!" ("OK" ,(lambda ()
;; Don't allow No, set it to blank
(dbclear 'aradio)
;; Don't go to another page
#f)))))
;; Checkbox that appears only if above radiobox is Yes
,(lambda ()
(if (string=? (dbget 'aradio "") "1")
'(checkbox id checky indent 0.3 text "Visible if you said Yes")
'(spacer height 0)))
(spacer)
;; Dropdown
(dropdown id dropcolours label "Pick an option:" entries ("Option 1" "Choice B" "Alternative iii"))
(spacer)
;; Button with action callback that returns the page you want to go to
(button h 75 size header indent 0.05 rounded #t text "Go Back" action ,(lambda () 'main))
(spacer)
(label text "For more features that you can include in a script see the LNhealth app \"Demo Widgets\". Look at the main.sx file in the sandbox folder which is located at https://github.com/part-cw/LNhealth/tree/master/apps/WidgetDemo" align left size small)
)
(about
"About"
("Back" main)
#f
(spacer height 50)
(label text "This is a demo app of the uiform module in LambdaNative, a cross-platform development environment written in Scheme. See lambdanative.org")
(spacer)
(label text "Copyright (c) 2009-2018\nUniversity of British Columbia")
)
)))
(define gui #f)
(define form #f)
(main
;; initialization
(lambda (w h)
(make-window 480 800)
(glgui-orientation-set! GUI_PORTRAIT)
(set! gui (make-glgui))
(let ((aw (glgui-width-get))
(ah (glgui-height-get)))
(glgui-box gui 0 0 aw ah DarkGreen)
(set! form (glgui-uiform gui 0 0 aw ah)))
;; Set the sandbox up to be the current directory and use the above example as the script
(glgui-widget-set! gui form 'sandbox (system-directory))
(glgui-widget-set! gui form 'uiform demouiform:example)
;; Set the fonts
(glgui-widget-set! gui form 'fnt ascii_18.fnt)
(glgui-widget-set! gui form 'smlfnt ascii_14.fnt)
(glgui-widget-set! gui form 'hdfnt ascii_24.fnt)
(glgui-widget-set! gui form 'bigfnt ascii_40.fnt)
;; Create the table to store data (default location for widget values)
(glgui-widget-set! gui form 'database (make-table))
)
;; events
(lambda (t x y)
(if (= t EVENT_KEYPRESS) (begin
(if (= x EVENT_KEYESCAPE) (terminate))))
(glgui-event gui t x y))
;; termination
(lambda () #t)
;; suspend
(lambda () (glgui-suspend))
;; resume
(lambda () (glgui-resume))
)
;; eof
| false |
84213ee643cf7126476548f989569fdc9f69abc7
|
43612e5ed60c14068da312fd9d7081c1b2b7220d
|
/tools/benchtimes/bench-sav/all.scm
|
4ce193e351b4218498820d2e12712c334f3f8f77
|
[
"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 | 904,275 |
scm
|
all.scm
|
;; ALL benchmarks
;; This benchmark contains all the benchmarks (alphabetically sorted)
;; The benchmarks are slightly modified to avoid global duplicates
(define (run-single-bench name count ok? run)
(let loop ((i count) (result '(undefined)))
(if (< 0 i)
(loop (- i 1) (run))
result)))
(define (run-single-benchmark name count ok? run-maker . args)
(let ((run (apply run-maker args)))
(let ((result (run-single-bench name count ok? run)))
(if (not (ok? result))
(begin
(display "*** wrong result ***")
(newline)
(display "*** got: ")
(write result)
(newline))))))
;;; ACK -- One of the Kernighan and Van Wyk benchmarks.
(define (ack m n)
(cond ((= m 0) (+ n 1))
((= n 0) (ack (- m 1) 1))
(else (ack (- m 1) (ack m (- n 1))))))
(define (main-ack . args)
(run-single-benchmark
"ack"
ack-iters
(lambda (result) (equal? result 4093))
(lambda (m n) (lambda () (ack m n)))
3
9))
;;; ARRAY1 -- One of the Kernighan and Van Wyk benchmarks.
(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 '()))
(if (> repeat 0)
(loop (- repeat 1) (my-try n))
result)))
(define (main-array1 . args)
(run-single-benchmark
"array1"
array1-iters
(lambda (result) (equal? result 200000))
(lambda (n) (lambda () (go n)))
200000))
;;; BOYER -- Logic programming benchmark, originally written by Bob Boyer.
;;; Fairly CONS intensive.
(define (boyer-lookup key table)
(let loop ((x table))
(if (null? x)
#f
(let ((pair (car x)))
(if (eq? (car pair) key)
pair
(loop (cdr x)))))))
(define boyer-properties '())
(define (boyer-get key1 key2)
(let ((x (boyer-lookup key1 boyer-properties)))
(if x
(let ((y (boyer-lookup key2 (cdr x))))
(if y
(cdr y)
#f))
#f)))
(define (boyer-put key1 key2 val)
(let ((x (boyer-lookup key1 boyer-properties)))
(if x
(let ((y (boyer-lookup key2 (cdr x))))
(if y
(set-cdr! y val)
(set-cdr! x (cons (cons key2 val) (cdr x)))))
(set! boyer-properties
(cons (list key1 (cons key2 val)) boyer-properties)))))
(define unify-subst '())
(define (add-lemma term)
(cond ((and (pair? term)
(eq? (car term)
(quote equal))
(pair? (cadr term)))
(boyer-put (car (cadr term))
(quote lemmas)
(cons term (boyer-get (car (cadr term)) (quote lemmas)))))
(else (fatal-error "ADD-LEMMA did not like term: " term))))
(define (add-lemma-lst lst)
(cond ((null? lst)
#t)
(else (add-lemma (car lst))
(add-lemma-lst (cdr lst)))))
(define (apply-subst alist term)
(cond ((not (pair? term))
(cond ((assq term alist) => cdr)
(else term)))
(else (cons (car term)
(apply-subst-lst alist (cdr term))))))
(define (apply-subst-lst alist lst)
(cond ((null? lst)
'())
(else (cons (apply-subst alist (car lst))
(apply-subst-lst alist (cdr lst))))))
(define (falsep x lst)
(or (equal? x (quote (f)))
(member x lst)))
(define (one-way-unify term1 term2)
(begin (set! unify-subst '())
(one-way-unify1 term1 term2)))
(define (one-way-unify1 term1 term2)
(cond ((not (pair? term2))
(cond ((assq term2 unify-subst) =>
(lambda (x) (equal? term1 (cdr x))))
(else (set! unify-subst (cons (cons term2 term1)
unify-subst))
#t)))
((not (pair? term1))
#f)
((eq? (car term1)
(car term2))
(one-way-unify1-lst (cdr term1)
(cdr term2)))
(else #f)))
(define (one-way-unify1-lst lst1 lst2)
(cond ((null? lst1)
#t)
((one-way-unify1 (car lst1)
(car lst2))
(one-way-unify1-lst (cdr lst1)
(cdr lst2)))
(else #f)))
(define (rewrite term)
(cond ((not (pair? term))
term)
(else (rewrite-with-lemmas (cons (car term)
(rewrite-args (cdr term)))
(boyer-get (car term)
(quote lemmas))))))
(define (rewrite-args lst)
(cond ((null? lst)
'())
(else (cons (rewrite (car lst))
(rewrite-args (cdr lst))))))
(define (rewrite-with-lemmas term lst)
(cond ((or (not lst) (null? lst))
term)
((one-way-unify term (cadr (car lst)))
(rewrite (apply-subst unify-subst (caddr (car lst)))))
(else (rewrite-with-lemmas term (cdr lst)))))
(define (boyer-setup)
(add-lemma-lst
(quote ((equal (compile form)
(reverse (codegen (optimize form)
(nil))))
(equal (eqp x y)
(equal (fix x)
(fix y)))
(equal (greaterp x y)
(lessp y x))
(equal (lesseqp x y)
(not (lessp y x)))
(equal (greatereqp x y)
(not (lessp x y)))
(equal (boolean x)
(or (equal x (t))
(equal x (f))))
(equal (iff x y)
(and (implies x y)
(implies y x)))
(equal (even1 x)
(if (zerop x)
(t)
(odd (_1- x))))
(equal (countps- l pred)
(countps-loop l pred (zero)))
(equal (fact- i)
(fact-loop i 1))
(equal (reverse- x)
(reverse-loop x (nil)))
(equal (divides x y)
(zerop (remainder y x)))
(equal (assume-true var alist)
(cons (cons var (t))
alist))
(equal (assume-false var alist)
(cons (cons var (f))
alist))
(equal (tautology-checker x)
(tautologyp (normalize x)
(nil)))
(equal (falsify x)
(falsify1 (normalize x)
(nil)))
(equal (prime x)
(and (not (zerop x))
(not (equal x (add1 (zero))))
(prime1 x (_1- x))))
(equal (and p q)
(if p (if q (t)
(f))
(f)))
(equal (or p q)
(if p (t)
(if q (t)
(f))
(f)))
(equal (not p)
(if p (f)
(t)))
(equal (implies p q)
(if p (if q (t)
(f))
(t)))
(equal (fix x)
(if (numberp x)
x
(zero)))
(equal (if (if a b c)
d e)
(if a (if b d e)
(if c d e)))
(equal (zerop x)
(or (equal x (zero))
(not (numberp x))))
(equal (plus (plus x y)
z)
(plus x (plus y z)))
(equal (equal (plus a b)
(zero))
(and (zerop a)
(zerop b)))
(equal (difference x x)
(zero))
(equal (equal (plus a b)
(plus a c))
(equal (fix b)
(fix c)))
(equal (equal (zero)
(difference x y))
(not (lessp y x)))
(equal (equal x (difference x y))
(and (numberp x)
(or (equal x (zero))
(zerop y))))
(equal (meaning (plus-tree (append x y))
a)
(plus (meaning (plus-tree x)
a)
(meaning (plus-tree y)
a)))
(equal (meaning (plus-tree (plus-fringe x))
a)
(fix (meaning x a)))
(equal (append (append x y)
z)
(append x (append y z)))
(equal (reverse (append a b))
(append (reverse b)
(reverse a)))
(equal (times x (plus y z))
(plus (times x y)
(times x z)))
(equal (times (times x y)
z)
(times x (times y z)))
(equal (equal (times x y)
(zero))
(or (zerop x)
(zerop y)))
(equal (exec (append x y)
pds envrn)
(exec y (exec x pds envrn)
envrn))
(equal (mc-flatten x y)
(append (flatten x)
y))
(equal (member x (append a b))
(or (member x a)
(member x b)))
(equal (member x (reverse y))
(member x y))
(equal (length (reverse x))
(length x))
(equal (member a (intersect b c))
(and (member a b)
(member a c)))
(equal (nth (zero)
i)
(zero))
(equal (exp i (plus j k))
(times (exp i j)
(exp i k)))
(equal (exp i (times j k))
(exp (exp i j)
k))
(equal (reverse-loop x y)
(append (reverse x)
y))
(equal (reverse-loop x (nil))
(reverse x))
(equal (count-list z (sort-lp x y))
(plus (count-list z x)
(count-list z y)))
(equal (equal (append a b)
(append a c))
(equal b c))
(equal (plus (remainder x y)
(times y (quotient x y)))
(fix x))
(equal (power-eval (big-plus1 l i base)
base)
(plus (power-eval l base)
i))
(equal (power-eval (big-plus x y i base)
base)
(plus i (plus (power-eval x base)
(power-eval y base))))
(equal (remainder y 1)
(zero))
(equal (lessp (remainder x y)
y)
(not (zerop y)))
(equal (remainder x x)
(zero))
(equal (lessp (quotient i j)
i)
(and (not (zerop i))
(or (zerop j)
(not (equal j 1)))))
(equal (lessp (remainder x y)
x)
(and (not (zerop y))
(not (zerop x))
(not (lessp x y))))
(equal (power-eval (power-rep i base)
base)
(fix i))
(equal (power-eval (big-plus (power-rep i base)
(power-rep j base)
(zero)
base)
base)
(plus i j))
(equal (gcd x y)
(gcd y x))
(equal (nth (append a b)
i)
(append (nth a i)
(nth b (difference i (length a)))))
(equal (difference (plus x y)
x)
(fix y))
(equal (difference (plus y x)
x)
(fix y))
(equal (difference (plus x y)
(plus x z))
(difference y z))
(equal (times x (difference c w))
(difference (times c x)
(times w x)))
(equal (remainder (times x z)
z)
(zero))
(equal (difference (plus b (plus a c))
a)
(plus b c))
(equal (difference (add1 (plus y z))
z)
(add1 y))
(equal (lessp (plus x y)
(plus x z))
(lessp y z))
(equal (lessp (times x z)
(times y z))
(and (not (zerop z))
(lessp x y)))
(equal (lessp y (plus x y))
(not (zerop x)))
(equal (gcd (times x z)
(times y z))
(times z (gcd x y)))
(equal (value (normalize x)
a)
(value x a))
(equal (equal (flatten x)
(cons y (nil)))
(and (nlistp x)
(equal x y)))
(equal (listp (gopher x))
(listp x))
(equal (samefringe x y)
(equal (flatten x)
(flatten y)))
(equal (equal (greatest-factor x y)
(zero))
(and (or (zerop y)
(equal y 1))
(equal x (zero))))
(equal (equal (greatest-factor x y)
1)
(equal x 1))
(equal (numberp (greatest-factor x y))
(not (and (or (zerop y)
(equal y 1))
(not (numberp x)))))
(equal (times-list (append x y))
(times (times-list x)
(times-list y)))
(equal (prime-list (append x y))
(and (prime-list x)
(prime-list y)))
(equal (equal z (times w z))
(and (numberp z)
(or (equal z (zero))
(equal w 1))))
(equal (greatereqpr x y)
(not (lessp x y)))
(equal (equal x (times x y))
(or (equal x (zero))
(and (numberp x)
(equal y 1))))
(equal (remainder (times y x)
y)
(zero))
(equal (equal (times a b)
1)
(and (not (equal a (zero)))
(not (equal b (zero)))
(numberp a)
(numberp b)
(equal (_1- a)
(zero))
(equal (_1- b)
(zero))))
(equal (lessp (length (delete x l))
(length l))
(member x l))
(equal (sort2 (delete x l))
(delete x (sort2 l)))
(equal (dsort x)
(sort2 x))
(equal (length (cons x1
(cons x2
(cons x3 (cons x4
(cons x5
(cons x6 x7)))))))
(plus 6 (length x7)))
(equal (difference (add1 (add1 x))
2)
(fix x))
(equal (quotient (plus x (plus x y))
2)
(plus x (quotient y 2)))
(equal (sigma (zero)
i)
(quotient (times i (add1 i))
2))
(equal (plus x (add1 y))
(if (numberp y)
(add1 (plus x y))
(add1 x)))
(equal (equal (difference x y)
(difference z y))
(if (lessp x y)
(not (lessp y z))
(if (lessp z y)
(not (lessp y x))
(equal (fix x)
(fix z)))))
(equal (meaning (plus-tree (delete x y))
a)
(if (member x y)
(difference (meaning (plus-tree y)
a)
(meaning x a))
(meaning (plus-tree y)
a)))
(equal (times x (add1 y))
(if (numberp y)
(plus x (times x y))
(fix x)))
(equal (nth (nil)
i)
(if (zerop i)
(nil)
(zero)))
(equal (last (append a b))
(if (listp b)
(last b)
(if (listp a)
(cons (car (last a))
b)
b)))
(equal (equal (lessp x y)
z)
(if (lessp x y)
(equal t z)
(equal f z)))
(equal (assignment x (append a b))
(if (assignedp x a)
(assignment x a)
(assignment x b)))
(equal (car (gopher x))
(if (listp x)
(car (flatten x))
(zero)))
(equal (flatten (cdr (gopher x)))
(if (listp x)
(cdr (flatten x))
(cons (zero)
(nil))))
(equal (quotient (times y x)
y)
(if (zerop y)
(zero)
(fix x)))
(equal (get j (set i val mem))
(if (eqp j i)
val
(get j mem)))))))
(define (tautologyp x true-lst false-lst)
(cond ((truep x true-lst)
#t)
((falsep x false-lst)
#f)
((not (pair? x))
#f)
((eq? (car x)
(quote if))
(cond ((truep (cadr x)
true-lst)
(tautologyp (caddr x)
true-lst false-lst))
((falsep (cadr x)
false-lst)
(tautologyp (cadddr x)
true-lst false-lst))
(else (and (tautologyp (caddr x)
(cons (cadr x)
true-lst)
false-lst)
(tautologyp (cadddr x)
true-lst
(cons (cadr x)
false-lst))))))
(else #f)))
(define (tautp x)
(tautologyp (rewrite x)
'() '()))
(define (boyer-test alist term)
(tautp
(apply-subst alist term)))
(define (trans-of-implies n)
(list (quote implies)
(trans-of-implies1 n)
(list (quote implies)
0 n)))
(define (trans-of-implies1 n)
(cond ((equal? n 1)
(list (quote implies)
0 1))
(else (list (quote and)
(list (quote implies)
(- n 1)
n)
(trans-of-implies1 (- n 1))))))
(define (truep x lst)
(or (equal? x (quote (t)))
(member x lst)))
(boyer-setup)
(define (main-boyer . args)
(run-single-benchmark
"boyer"
boyer-iters
(lambda (result) (equal? result #t))
(lambda (alist term) (lambda () (boyer-test alist term)))
(quote ((x f (plus (plus a b)
(plus c (zero))))
(y f (times (times a b)
(plus c d)))
(z f (reverse (append (append a b)
(nil))))
(u equal (plus a b)
(difference x y))
(w lessp (remainder a b)
(member a (length b)))))
(quote (implies (and (implies x y)
(and (implies y z)
(and (implies z u)
(implies u w))))
(implies x w)))))
;;; BROWSE -- Benchmark to create and browse through
;;; an AI-like data base of units.
(define (browse-lookup key table)
(let loop ((x table))
(if (null? x)
#f
(let ((pair (car x)))
(if (eq? (car pair) key)
pair
(loop (cdr x)))))))
(define browse-properties '())
(define (browse-get key1 key2)
(let ((x (browse-lookup key1 browse-properties)))
(if x
(let ((y (browse-lookup key2 (cdr x))))
(if y
(cdr y)
#f))
#f)))
(define (browse-put key1 key2 val)
(let ((x (browse-lookup key1 browse-properties)))
(if x
(let ((y (browse-lookup key2 (cdr x))))
(if y
(set-cdr! y val)
(set-cdr! x (cons (cons key2 val) (cdr x)))))
(set! browse-properties
(cons (list key1 (cons key2 val)) browse-properties)))))
(define *current-gensym* 0)
(define (generate-symbol)
(set! *current-gensym* (+ *current-gensym* 1))
(string->symbol (number->string *current-gensym*)))
(define (append-to-tail! x y)
(if (null? x)
y
(do ((a x b)
(b (cdr x) (cdr b)))
((null? b)
(set-cdr! a y)
x))))
(define (tree-copy x)
(if (not (pair? x))
x
(cons (tree-copy (car x))
(tree-copy (cdr x)))))
;;; n is # of symbols
;;; m is maximum amount of stuff on the plist
;;; npats is the number of basic patterns on the unit
;;; ipats is the instantiated copies of the patterns
(define *rand* 21)
(define (init n m npats ipats)
(let ((ipats (tree-copy ipats)))
(do ((p ipats (cdr p)))
((null? (cdr p)) (set-cdr! p ipats)))
(do ((n n (- n 1))
(i m (cond ((zero? i) m)
(else (- i 1))))
(name (generate-symbol) (generate-symbol))
(a '()))
((= n 0) a)
(set! a (cons name a))
(do ((i i (- i 1)))
((zero? i))
(browse-put name (generate-symbol) #f))
(browse-put name
'pattern
(do ((i npats (- i 1))
(ipats ipats (cdr ipats))
(a '()))
((zero? i) a)
(set! a (cons (car ipats) a))))
(do ((j (- m i) (- j 1)))
((zero? j))
(browse-put name (generate-symbol) #f)))))
(define (browse-random)
(set! *rand* (remainder (* *rand* 17) 251))
*rand*)
(define (randomize l)
(do ((a '()))
((null? l) a)
(let ((n (remainder (browse-random) (length l))))
(cond ((zero? n)
(set! a (cons (car l) a))
(set! l (cdr l))
l)
(else
(do ((n n (- n 1))
(x l (cdr x)))
((= n 1)
(set! a (cons (cadr x) a))
(set-cdr! x (cddr x))
x)))))))
(define (my-match pat dat alist)
(cond ((null? pat)
(null? dat))
((null? dat) '())
((or (eq? (car pat) '?)
(eq? (car pat)
(car dat)))
(my-match (cdr pat) (cdr dat) alist))
((eq? (car pat) '*)
(or (my-match (cdr pat) dat alist)
(my-match (cdr pat) (cdr dat) alist)
(my-match pat (cdr dat) alist)))
(else (cond ((not (pair? (car pat)))
(cond ((eq? (string-ref (symbol->string (car pat)) 0)
#\?)
(let ((val (assq (car pat) alist)))
(cond (val (my-match (cons (cdr val)
(cdr pat))
dat alist))
(else (my-match (cdr pat)
(cdr dat)
(cons (cons (car pat)
(car dat))
alist))))))
((eq? (string-ref (symbol->string (car pat)) 0)
#\*)
(let ((val (assq (car pat) alist)))
(cond (val (my-match (append (cdr val)
(cdr pat))
dat alist))
(else
(do ((l '()
(append-to-tail!
l
(cons (if (null? d)
'()
(car d))
'())))
(e (cons '() dat) (cdr e))
(d dat (if (null? d) '() (cdr d))))
((or (null? e)
(my-match (cdr pat)
d
(cons
(cons (car pat) l)
alist)))
(if (null? e) #f #t)))))))
(else #f))) ;;;; fix suggested by Manuel Serrano (cond did not have an else clause); this changes the run time quite a bit
(else (and
(pair? (car dat))
(my-match (car pat)
(car dat) alist)
(my-match (cdr pat)
(cdr dat) alist)))))))
(define database
(randomize
(init 100 10 4 '((a a a b b b b a a a a a b b a a a)
(a a b b b b a a
(a a)(b b))
(a a a b (b a) b a b a)))))
(define (browse pats)
(investigate
database
pats))
(define (investigate units pats)
(do ((units units (cdr units)))
((null? units))
(do ((pats pats (cdr pats)))
((null? pats))
(do ((p (browse-get (car units) 'pattern)
(cdr p)))
((null? p))
(my-match (car pats) (car p) '())))))
(define (main-browse . args)
(run-single-benchmark
"browse"
browse-iters
(lambda (result) #t)
(lambda (pats) (lambda () (browse pats)))
'((*a ?b *b ?b a *a a *b *a)
(*a *b *b *a (*a) (*b))
(? ? * (b a) * ? ?))))
;; COMPILER
;(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 (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 (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 (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-compiler . args)
(run-single-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))
;;; CONFORM -- Type checker, written by Jim Miller.
;;; Functional and unstable
(define (conform-sort-list obj pred)
(define (loop l)
(if (and (pair? l) (pair? (cdr l)))
(split-list l '() '())
l))
(define (split-list l one two)
(if (pair? l)
(split-list (cdr l) two (cons (car l) one))
(merge (loop one) (loop two))))
(define (merge one two)
(cond ((null? one) two)
((pred (car two) (car one))
(cons (car two)
(merge (cdr two) one)))
(else
(cons (car one)
(merge (cdr one) two)))))
(loop obj))
;; SET OPERATIONS
; (representation as lists with distinct elements)
(define (adjoin element set)
(if (memq element set) set (cons element set)))
(define (eliminate element set)
(cond ((null? set) set)
((eq? element (car set)) (cdr set))
(else (cons (car set) (eliminate element (cdr set))))))
(define (intersect list1 list2)
(let loop ((l list1))
(cond ((null? l) '())
((memq (car l) list2) (cons (car l) (loop (cdr l))))
(else (loop (cdr l))))))
(define (union list1 list2)
(if (null? list1)
list2
(union (cdr list1)
(adjoin (car list1) list2))))
;; GRAPH NODES
(define make-internal-node vector)
(define (internal-node-name node) (vector-ref node 0))
(define (internal-node-green-edges node) (vector-ref node 1))
(define (internal-node-red-edges node) (vector-ref node 2))
(define (internal-node-blue-edges node) (vector-ref node 3))
(define (set-internal-node-name! node name) (vector-set! node 0 name))
(define (set-internal-node-green-edges! node edges) (vector-set! node 1 edges))
(define (set-internal-node-red-edges! node edges) (vector-set! node 2 edges))
(define (set-internal-node-blue-edges! node edges) (vector-set! node 3 edges))
(define (make-node name . blue-edges) ; User's constructor
(let ((name (if (symbol? name) (symbol->string name) name))
(blue-edges (if (null? blue-edges) 'NOT-A-NODE-YET (car blue-edges))))
(make-internal-node name '() '() blue-edges)))
(define (copy-node node)
(make-internal-node (name node) '() '() (blue-edges node)))
; Selectors
(define name internal-node-name)
(define (make-edge-getter selector)
(lambda (node)
(if (or (none-node? node) (any-node? node))
(fatal-error "Can't get edges from the ANY or NONE nodes")
(selector node))))
(define red-edges (make-edge-getter internal-node-red-edges))
(define green-edges (make-edge-getter internal-node-green-edges))
(define blue-edges (make-edge-getter internal-node-blue-edges))
; Mutators
(define (make-edge-setter mutator!)
(lambda (node value)
(cond ((any-node? node) (fatal-error "Can't set edges from the ANY node"))
((none-node? node) 'OK)
(else (mutator! node value)))))
(define set-red-edges! (make-edge-setter set-internal-node-red-edges!))
(define set-green-edges! (make-edge-setter set-internal-node-green-edges!))
(define set-blue-edges! (make-edge-setter set-internal-node-blue-edges!))
;; BLUE EDGES
(define make-blue-edge vector)
(define (blue-edge-operation edge) (vector-ref edge 0))
(define (blue-edge-arg-node edge) (vector-ref edge 1))
(define (blue-edge-res-node edge) (vector-ref edge 2))
(define (set-blue-edge-operation! edge value) (vector-set! edge 0 value))
(define (set-blue-edge-arg-node! edge value) (vector-set! edge 1 value))
(define (set-blue-edge-res-node! edge value) (vector-set! edge 2 value))
; Selectors
(define operation blue-edge-operation)
(define arg-node blue-edge-arg-node)
(define res-node blue-edge-res-node)
; Mutators
(define set-arg-node! set-blue-edge-arg-node!)
(define set-res-node! set-blue-edge-res-node!)
; Higher level operations on blue edges
(define (lookup-op op node)
(let loop ((edges (blue-edges node)))
(cond ((null? edges) '())
((eq? op (operation (car edges))) (car edges))
(else (loop (cdr edges))))))
(define (has-op? op node)
(not (null? (lookup-op op node))))
;; GRAPHS
(define make-internal-graph vector)
(define (internal-graph-nodes graph) (vector-ref graph 0))
(define (internal-graph-already-met graph) (vector-ref graph 1))
(define (internal-graph-already-joined graph) (vector-ref graph 2))
(define (set-internal-graph-nodes! graph nodes) (vector-set! graph 0 nodes))
; Constructor
(define (make-graph . nodes)
(make-internal-graph nodes (make-empty-table) (make-empty-table)))
; Selectors
(define graph-nodes internal-graph-nodes)
(define already-met internal-graph-already-met)
(define already-joined internal-graph-already-joined)
; Higher level functions on graphs
(define (add-graph-nodes! graph nodes)
(set-internal-graph-nodes! graph (cons nodes (graph-nodes graph))))
(define (copy-graph g)
(define (copy-list l) (vector->list (list->vector l)))
(make-internal-graph
(copy-list (graph-nodes g))
(already-met g)
(already-joined g)))
(define (clean-graph g)
(define (clean-node node)
(if (not (or (any-node? node) (none-node? node)))
(begin
(set-green-edges! node '())
(set-red-edges! node '()))))
(for-each clean-node (graph-nodes g))
g)
(define (canonicalize-graph graph classes)
(define (fix node)
(define (fix-set object selector mutator)
(mutator object
(map (lambda (node)
(find-canonical-representative node classes))
(selector object))))
(if (not (or (none-node? node) (any-node? node)))
(begin
(fix-set node green-edges set-green-edges!)
(fix-set node red-edges set-red-edges!)
(for-each
(lambda (blue-edge)
(set-arg-node! blue-edge
(find-canonical-representative (arg-node blue-edge) classes))
(set-res-node! blue-edge
(find-canonical-representative (res-node blue-edge) classes)))
(blue-edges node))))
node)
(define (fix-table table)
(define (canonical? node) (eq? node (find-canonical-representative node classes)))
(define (filter-and-fix predicate-fn update-fn list)
(let loop ((list list))
(cond ((null? list) '())
((predicate-fn (car list))
(cons (update-fn (car list)) (loop (cdr list))))
(else (loop (cdr list))))))
(define (fix-line line)
(filter-and-fix
(lambda (entry) (canonical? (car entry)))
(lambda (entry) (cons (car entry)
(find-canonical-representative (cdr entry) classes)))
line))
(if (null? table)
'()
(cons (car table)
(filter-and-fix
(lambda (entry) (canonical? (car entry)))
(lambda (entry) (cons (car entry) (fix-line (cdr entry))))
(cdr table)))))
(make-internal-graph
(map (lambda (class) (fix (car class))) classes)
(fix-table (already-met graph))
(fix-table (already-joined graph))))
;; USEFUL NODES
(define none-node (make-node 'none #t))
(define (none-node? node) (eq? node none-node))
(define any-node (make-node 'any '()))
(define (any-node? node) (eq? node any-node))
;; COLORED EDGE TESTS
(define (green-edge? from-node to-node)
(cond ((any-node? from-node) #f)
((none-node? from-node) #t)
((memq to-node (green-edges from-node)) #t)
(else #f)))
(define (red-edge? from-node to-node)
(cond ((any-node? from-node) #f)
((none-node? from-node) #t)
((memq to-node (red-edges from-node)) #t)
(else #f)))
;; SIGNATURE
; Return signature (i.e. <arg, res>) given an operation and a node
(define sig
(let ((none-comma-any (cons none-node any-node)))
(lambda (op node) ; Returns (arg, res)
(let ((the-edge (lookup-op op node)))
(if (not (null? the-edge))
(cons (arg-node the-edge) (res-node the-edge))
none-comma-any)))))
; Selectors from signature
(define (arg pair) (car pair))
(define (res pair) (cdr pair))
;; CONFORMITY
(define (conforms? t1 t2)
(define nodes-with-red-edges-out '())
(define (add-red-edge! from-node to-node)
(set-red-edges! from-node (adjoin to-node (red-edges from-node)))
(set! nodes-with-red-edges-out
(adjoin from-node nodes-with-red-edges-out)))
(define (greenify-red-edges! from-node)
(set-green-edges! from-node
(append (red-edges from-node) (green-edges from-node)))
(set-red-edges! from-node '()))
(define (delete-red-edges! from-node)
(set-red-edges! from-node '()))
(define (does-conform t1 t2)
(cond ((or (none-node? t1) (any-node? t2)) #t)
((or (any-node? t1) (none-node? t2)) #f)
((green-edge? t1 t2) #t)
((red-edge? t1 t2) #t)
(else
(add-red-edge! t1 t2)
(let loop ((blues (blue-edges t2)))
(if (null? blues)
#t
(let* ((current-edge (car blues))
(phi (operation current-edge)))
(and (has-op? phi t1)
(does-conform
(res (sig phi t1))
(res (sig phi t2)))
(does-conform
(arg (sig phi t2))
(arg (sig phi t1)))
(loop (cdr blues)))))))))
(let ((result (does-conform t1 t2)))
(for-each (if result greenify-red-edges! delete-red-edges!)
nodes-with-red-edges-out)
result))
(define (equivalent? a b)
(and (conforms? a b) (conforms? b a)))
;; EQUIVALENCE CLASSIFICATION
; Given a list of nodes, return a list of equivalence classes
(define (classify nodes)
(let node-loop ((classes '())
(nodes nodes))
(if (null? nodes)
(map (lambda (class)
(conform-sort-list class
(lambda (node1 node2)
(< (string-length (name node1))
(string-length (name node2))))))
classes)
(let ((this-node (car nodes)))
(define (add-node classes)
(cond ((null? classes) (list (list this-node)))
((equivalent? this-node (caar classes))
(cons (cons this-node (car classes))
(cdr classes)))
(else (cons (car classes)
(add-node (cdr classes))))))
(node-loop (add-node classes)
(cdr nodes))))))
; Given a node N and a classified set of nodes,
; find the canonical member corresponding to N
(define (find-canonical-representative element classification)
(let loop ((classes classification))
(cond ((null? classes) (fatal-error "Can't classify" element))
((memq element (car classes)) (car (car classes)))
(else (loop (cdr classes))))))
; Reduce a graph by taking only one member of each equivalence
; class and canonicalizing all outbound pointers
(define (reduce graph)
(let ((classes (classify (graph-nodes graph))))
(canonicalize-graph graph classes)))
;; TWO DIMENSIONAL TABLES
(define (make-empty-table) (list 'TABLE))
(define (lookup table x y)
(let ((one (assq x (cdr table))))
(if one
(let ((two (assq y (cdr one))))
(if two (cdr two) #f))
#f)))
(define (insert! table x y value)
(define (make-singleton-table x y)
(list (cons x y)))
(let ((one (assq x (cdr table))))
(if one
(set-cdr! one (cons (cons y value) (cdr one)))
(set-cdr! table (cons (cons x (make-singleton-table y value))
(cdr table))))))
;; MEET/JOIN
; These update the graph when computing the node for node1*node2
(define (blue-edge-operate arg-fn res-fn graph op sig1 sig2)
(make-blue-edge op
(arg-fn graph (arg sig1) (arg sig2))
(res-fn graph (res sig1) (res sig2))))
(define (meet graph node1 node2)
(cond ((eq? node1 node2) node1)
((or (any-node? node1) (any-node? node2)) any-node) ; canonicalize
((none-node? node1) node2)
((none-node? node2) node1)
((lookup (already-met graph) node1 node2)) ; return it if found
((conforms? node1 node2) node2)
((conforms? node2 node1) node1)
(else
(let ((result
(make-node (string-append "(" (name node1) " ^ " (name node2) ")"))))
(add-graph-nodes! graph result)
(insert! (already-met graph) node1 node2 result)
(set-blue-edges! result
(map
(lambda (op)
(blue-edge-operate join meet graph op (sig op node1) (sig op node2)))
(intersect (map operation (blue-edges node1))
(map operation (blue-edges node2)))))
result))))
(define (join graph node1 node2)
(cond ((eq? node1 node2) node1)
((any-node? node1) node2)
((any-node? node2) node1)
((or (none-node? node1) (none-node? node2)) none-node) ; canonicalize
((lookup (already-joined graph) node1 node2)) ; return it if found
((conforms? node1 node2) node1)
((conforms? node2 node1) node2)
(else
(let ((result
(make-node (string-append "(" (name node1) " v " (name node2) ")"))))
(add-graph-nodes! graph result)
(insert! (already-joined graph) node1 node2 result)
(set-blue-edges! result
(map
(lambda (op)
(blue-edge-operate meet join graph op (sig op node1) (sig op node2)))
(union (map operation (blue-edges node1))
(map operation (blue-edges node2)))))
result))))
;; MAKE A LATTICE FROM A GRAPH
(define (conform-make-lattice g print?)
(define (step g)
(let* ((copy (copy-graph g))
(nodes (graph-nodes copy)))
(for-each (lambda (first)
(for-each (lambda (second)
(meet copy first second) (join copy first second))
nodes))
nodes)
copy))
(define (loop g count)
(if print? (display count))
(let ((lattice (step g)))
(if print? (begin (display " -> ") (display (length (graph-nodes lattice)))))
(let* ((new-g (reduce lattice))
(new-count (length (graph-nodes new-g))))
(if (= new-count count)
(begin
(if print? (newline))
new-g)
(begin
(if print? (begin (display " -> ") (display new-count) (newline)))
(loop new-g new-count))))))
(let ((graph
(apply make-graph
(adjoin any-node (adjoin none-node (graph-nodes (clean-graph g)))))))
(loop graph (length (graph-nodes graph)))))
;; DEBUG and TEST
(define a '())
(define b '())
(define c '())
(define d '())
(define (setup)
(set! a (make-node 'a))
(set! b (make-node 'b))
(set-blue-edges! a (list (make-blue-edge 'phi any-node b)))
(set-blue-edges! b (list (make-blue-edge 'phi any-node a)
(make-blue-edge 'theta any-node b)))
(set! c (make-node "c"))
(set! d (make-node "d"))
(set-blue-edges! c (list (make-blue-edge 'theta any-node b)))
(set-blue-edges! d (list (make-blue-edge 'phi any-node c)
(make-blue-edge 'theta any-node d)))
'(made a b c d))
(define (conform-test)
(setup)
(map name
(graph-nodes (conform-make-lattice (make-graph a b c d any-node none-node) #f))))
(define (main-conform . args)
(run-single-benchmark
"conform"
conform-iters
(lambda (result)
(equal? (map (lambda (s)
(list->string (map char-downcase (string->list s))))
result)
'("(((b v d) ^ a) v c)"
"(c ^ d)"
"(b v (a ^ d))"
"((a v d) ^ b)"
"(b v d)"
"(b ^ (a v c))"
"(a v (c ^ d))"
"((b v d) ^ a)"
"(c v (a v d))"
"(a v c)"
"(d v (b ^ (a v c)))"
"(d ^ (a v c))"
"((a ^ d) v c)"
"((a ^ b) v d)"
"(((a v d) ^ b) v (a ^ d))"
"(b ^ d)"
"(b v (a v d))"
"(a ^ c)"
"(b ^ (c v d))"
"(a ^ b)"
"(a v b)"
"((a ^ d) ^ b)"
"(a ^ d)"
"(a v d)"
"d"
"(c v d)"
"a"
"b"
"c"
"any"
"none")))
(lambda () (lambda () (conform-test)))))
;;; CPSTAK -- A continuation-passing version of the TAK benchmark.
;;; A good test of first class procedures and tail recursion.
(define (cpstak x y z)
(define (tak x y z k)
(if (not (< y x))
(k z)
(tak (- x 1)
y
z
(lambda (v1)
(tak (- y 1)
z
x
(lambda (v2)
(tak (- z 1)
x
y
(lambda (v3)
(tak v1 v2 v3 k)))))))))
(tak x y z (lambda (a) a)))
(define (main-cpstak . args)
(run-single-benchmark
"cpstak"
cpstak-iters
(lambda (result) (equal? result 7))
(lambda (x y z) (lambda () (cpstak x y z)))
18
12
6))
;;; DDERIV -- Table-driven symbolic derivation.
;;; Returns the wrong answer for quotients.
;;; Fortunately these aren't used in the benchmark.
(define (dderiv-lookup key table)
(let loop ((x table))
(if (null? x)
#f
(let ((pair (car x)))
(if (eq? (car pair) key)
pair
(loop (cdr x)))))))
(define properties '())
(define (get key1 key2)
(let ((x (dderiv-lookup key1 properties)))
(if x
(let ((y (dderiv-lookup key2 (cdr x))))
(if y
(cdr y)
#f))
#f)))
(define (put key1 key2 val)
(let ((x (dderiv-lookup key1 properties)))
(if x
(let ((y (dderiv-lookup key2 (cdr x))))
(if y
(set-cdr! y val)
(set-cdr! x (cons (cons key2 val) (cdr x)))))
(set! properties
(cons (list key1 (cons key2 val)) properties)))))
(define (my+dderiv a)
(cons '+
(map dderiv (cdr a))))
(define (my-dderiv a)
(cons '-
(map dderiv (cdr a))))
(define (*dderiv a)
(list '*
a
(cons '+
(map (lambda (a) (list '/ (dderiv a) a)) (cdr a)))))
(define (/dderiv a)
(list '-
(list '/
(dderiv (cadr a))
(caddr a))
(list '/
(cadr a)
(list '*
(caddr a)
(caddr a)
(dderiv (caddr a))))))
(put '+ 'dderiv my+dderiv)
(put '- 'dderiv my-dderiv)
(put '* 'dderiv *dderiv)
(put '/ 'dderiv /dderiv)
(define (dderiv a)
(if (not (pair? a))
(if (eq? a 'x) 1 0)
(let ((f (get (car a) 'dderiv)))
(if f
(f a)
(fatal-error "No derivation method available")))))
(define (main-dderiv . args)
(run-single-benchmark
"dderiv"
dderiv-iters
(lambda (result)
(equal? result
'(+ (* (* 3 x x) (+ (/ 0 3) (/ 1 x) (/ 1 x)))
(* (* a x x) (+ (/ 0 a) (/ 1 x) (/ 1 x)))
(* (* b x) (+ (/ 0 b) (/ 1 x)))
0)))
(lambda (a) (lambda () (dderiv a)))
'(+ (* 3 x x) (* a x x) (* b x) 5)))
;;; DERIV -- Symbolic derivation.
;;; Returns the wrong answer for quotients.
;;; Fortunately these aren't used in the benchmark.
(define (deriv a)
(cond ((not (pair? a))
(if (eq? a 'x) 1 0))
((eq? (car a) '+)
(cons '+
(map deriv (cdr a))))
((eq? (car a) '-)
(cons '-
(map deriv (cdr a))))
((eq? (car a) '*)
(list '*
a
(cons '+
(map (lambda (a) (list '/ (deriv a) a)) (cdr a)))))
((eq? (car a) '/)
(list '-
(list '/
(deriv (cadr a))
(caddr a))
(list '/
(cadr a)
(list '*
(caddr a)
(caddr a)
(deriv (caddr a))))))
(else
(fatal-error "No derivation method available"))))
(define (main-deriv . args)
(run-single-benchmark
"deriv"
deriv-iters
(lambda (result)
(equal? result
'(+ (* (* 3 x x) (+ (/ 0 3) (/ 1 x) (/ 1 x)))
(* (* a x x) (+ (/ 0 a) (/ 1 x) (/ 1 x)))
(* (* b x) (+ (/ 0 b) (/ 1 x)))
0)))
(lambda (a) (lambda () (deriv a)))
'(+ (* 3 x x) (* a x x) (* b x) 5)))
;;; DESTRUC -- Destructive operation benchmark.
(define (destruc-append-to-tail! x y)
(if (null? x)
y
(let loop ((a x) (b (cdr x)))
(if (null? b)
(begin
(set-cdr! a y)
x)
(loop b (cdr b))))))
(define (destructive n m)
(let ((l (do ((i 10 (- i 1)) (a '() (cons '() a)))
((= i 0) a))))
(do ((i n (- i 1)))
((= i 0) l)
(cond ((null? (car l))
(do ((l l (cdr l)))
((null? l))
(if (null? (car l)) (set-car! l (cons '() '())))
(destruc-append-to-tail! (car l)
(do ((j m (- j 1)) (a '() (cons '() a)))
((= j 0) a)))))
(else
(do ((l1 l (cdr l1)) (l2 (cdr l) (cdr l2)))
((null? l2))
(set-cdr! (do ((j (quotient (length (car l2)) 2) (- j 1))
(a (car l2) (cdr a)))
((zero? j) a)
(set-car! a i))
(let ((n (quotient (length (car l1)) 2)))
(cond ((= n 0)
(set-car! l1 '())
(car l1))
(else
(do ((j n (- j 1)) (a (car l1) (cdr a)))
((= j 1)
(let ((x (cdr a)))
(set-cdr! a '())
x))
(set-car! a i))))))))))))
(define (main-destruc . args)
(run-single-benchmark
"destruc"
destruc-iters
(lambda (result)
(equal? result
'((1 1 2)
(1 1 1)
(1 1 1 2)
(1 1 1 1)
(1 1 1 1 2)
(1 1 1 1 2)
(1 1 1 1 2)
(1 1 1 1 2)
(1 1 1 1 2)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 3))))
(lambda (n m) (lambda () (destructive n m)))
600
50))
;;; DIVITER -- Benchmark which divides by 2 using lists of n ()'s.
(define (create-n n)
(do ((n n (- n 1))
(a '() (cons '() a)))
((= n 0) a)))
(define diviter-*ll* (create-n 200))
(define (iterative-div2 l)
(do ((l l (cddr l))
(a '() (cons (car l) a)))
((null? l) a)))
(define (main-diviter . args)
(run-single-benchmark
"diviter"
diviter-iters
(lambda (result)
(equal? result
'(() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ())))
(lambda (l) (lambda () (iterative-div2 l)))
diviter-*ll*))
;;; DIVREC -- Benchmark which divides by 2 using lists of n ()'s.
(define (divrec-create-n n)
(do ((n n (- n 1))
(a '() (cons '() a)))
((= n 0) a)))
(define *ll* (divrec-create-n 200))
(define (recursive-div2 l)
(cond ((null? l) '())
(else (cons (car l) (recursive-div2 (cddr l))))))
(define (main-divrec . args)
(run-single-benchmark
"divrec"
divrec-iters
(lambda (result)
(equal? result
'(() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ()
() () () () () () () () () () () () () () () () () () () ())))
(lambda (l) (lambda () (recursive-div2 l)))
*ll*))
;;; EARLEY -- Earley's parser, written by Marc Feeley.
; (make-parser grammar lexer) is used to create a parser from the grammar
; description `grammar' and the lexer function `lexer'.
;
; A grammar is a list of definitions. Each definition defines a non-terminal
; by a set of rules. Thus a definition has the form: (nt rule1 rule2...).
; A given non-terminal can only be defined once. The first non-terminal
; defined is the grammar's goal. Each rule is a possibly empty list of
; non-terminals. Thus a rule has the form: (nt1 nt2...). A non-terminal
; can be any scheme value. Note that all grammar symbols are treated as
; non-terminals. This is fine though because the lexer will be outputing
; non-terminals.
;
; The lexer defines what a token is and the mapping between tokens and
; the grammar's non-terminals. It is a function of one argument, the input,
; that returns the list of tokens corresponding to the input. Each token is
; represented by a list. The first element is some `user-defined' information
; associated with the token and the rest represents the token's class(es) (as a
; list of non-terminals that this token corresponds to).
;
; The result of `make-parser' is a function that parses the single input it
; is given into the grammar's goal. The result is a `parse' which can be
; manipulated with the procedures: `parse->parsed?', `parse->trees'
; and `parse->nb-trees' (see below).
;
; Let's assume that we want a parser for the grammar
;
; S -> x = E
; E -> E + E | V
; V -> V y |
;
; and that the input to the parser is a string of characters. Also, assume we
; would like to map the characters `x', `y', `+' and `=' into the corresponding
; non-terminals in the grammar. Such a parser could be created with
;
; (make-parser
; '(
; (s (x = e))
; (e (e + e) (v))
; (v (v y) ())
; )
; (lambda (str)
; (map (lambda (char)
; (list char ; user-info = the character itself
; (case char
; ((#\x) 'x)
; ((#\y) 'y)
; ((#\+) '+)
; ((#\=) '=)
; (else (fatal-error "lexer error")))))
; (string->list str)))
; )
;
; An alternative definition (that does not check for lexical errors) is
;
; (make-parser
; '(
; (s (#\x #\= e))
; (e (e #\+ e) (v))
; (v (v #\y) ())
; )
; (lambda (str) (map (lambda (char) (list char char)) (string->list str)))
; )
;
; To help with the rest of the discussion, here are a few definitions:
;
; An input pointer (for an input of `n' tokens) is a value between 0 and `n'.
; It indicates a point between two input tokens (0 = beginning, `n' = end).
; For example, if `n' = 4, there are 5 input pointers:
;
; input token1 token2 token3 token4
; input pointers 0 1 2 3 4
;
; A configuration indicates the extent to which a given rule is parsed (this
; is the common `dot notation'). For simplicity, a configuration is
; represented as an integer, with successive configurations in the same
; rule associated with successive integers. It is assumed that the grammar
; has been extended with rules to aid scanning. These rules are of the
; form `nt ->', and there is one such rule for every non-terminal. Note
; that these rules are special because they only apply when the corresponding
; non-terminal is returned by the lexer.
;
; A configuration set is a configuration grouped with the set of input pointers
; representing where the head non-terminal of the configuration was predicted.
;
; Here are the rules and configurations for the grammar given above:
;
; S -> . \
; 0 |
; x -> . |
; 1 |
; = -> . |
; 2 |
; E -> . |
; 3 > special rules (for scanning)
; + -> . |
; 4 |
; V -> . |
; 5 |
; y -> . |
; 6 /
; S -> . x . = . E .
; 7 8 9 10
; E -> . E . + . E .
; 11 12 13 14
; E -> . V .
; 15 16
; V -> . V . y .
; 17 18 19
; V -> .
; 20
;
; Starters of the non-terminal `nt' are configurations that are leftmost
; in a non-special rule for `nt'. Enders of the non-terminal `nt' are
; configurations that are rightmost in any rule for `nt'. Predictors of the
; non-terminal `nt' are configurations that are directly to the left of `nt'
; in any rule.
;
; For the grammar given above,
;
; Starters of V = (17 20)
; Enders of V = (5 19 20)
; Predictors of V = (15 17)
(define (make-parser grammar lexer)
(define (non-terminals grammar) ; return vector of non-terminals in grammar
(define (add-nt nt nts)
(if (member nt nts) nts (cons nt nts))) ; use equal? for equality tests
(let def-loop ((defs grammar) (nts '()))
(if (pair? defs)
(let* ((def (car defs))
(head (car def)))
(let rule-loop ((rules (cdr def))
(nts (add-nt head nts)))
(if (pair? rules)
(let ((rule (car rules)))
(let loop ((l rule) (nts nts))
(if (pair? l)
(let ((nt (car l)))
(loop (cdr l) (add-nt nt nts)))
(rule-loop (cdr rules) nts))))
(def-loop (cdr defs) nts))))
(list->vector (reverse nts))))) ; goal non-terminal must be at index 0
(define (ind nt nts) ; return index of non-terminal `nt' in `nts'
(let loop ((i (- (vector-length nts) 1)))
(if (>= i 0)
(if (equal? (vector-ref nts i) nt) i (loop (- i 1)))
#f)))
(define (nb-configurations grammar) ; return nb of configurations in grammar
(let def-loop ((defs grammar) (nb-confs 0))
(if (pair? defs)
(let ((def (car defs)))
(let rule-loop ((rules (cdr def)) (nb-confs nb-confs))
(if (pair? rules)
(let ((rule (car rules)))
(let loop ((l rule) (nb-confs nb-confs))
(if (pair? l)
(loop (cdr l) (+ nb-confs 1))
(rule-loop (cdr rules) (+ nb-confs 1)))))
(def-loop (cdr defs) nb-confs))))
nb-confs)))
; First, associate a numeric identifier to every non-terminal in the
; grammar (with the goal non-terminal associated with 0).
;
; So, for the grammar given above we get:
;
; s -> 0 x -> 1 = -> 4 e ->3 + -> 4 v -> 5 y -> 6
(let* ((nts (non-terminals grammar)) ; id map = list of non-terms
(nb-nts (vector-length nts)) ; the number of non-terms
(nb-confs (+ (nb-configurations grammar) nb-nts)) ; the nb of confs
(starters (make-vector nb-nts '())) ; starters for every non-term
(enders (make-vector nb-nts '())) ; enders for every non-term
(predictors (make-vector nb-nts '())) ; predictors for every non-term
(steps (make-vector nb-confs #f)) ; what to do in a given conf
(names (make-vector nb-confs #f))) ; name of rules
(define (setup-tables grammar nts starters enders predictors steps names)
(define (add-conf conf nt nts class)
(let ((i (ind nt nts)))
(vector-set! class i (cons conf (vector-ref class i)))))
(let ((nb-nts (vector-length nts)))
(let nt-loop ((i (- nb-nts 1)))
(if (>= i 0)
(begin
(vector-set! steps i (- i nb-nts))
(vector-set! names i (list (vector-ref nts i) 0))
(vector-set! enders i (list i))
(nt-loop (- i 1)))))
(let def-loop ((defs grammar) (conf (vector-length nts)))
(if (pair? defs)
(let* ((def (car defs))
(head (car def)))
(let rule-loop ((rules (cdr def)) (conf conf) (rule-num 1))
(if (pair? rules)
(let ((rule (car rules)))
(vector-set! names conf (list head rule-num))
(add-conf conf head nts starters)
(let loop ((l rule) (conf conf))
(if (pair? l)
(let ((nt (car l)))
(vector-set! steps conf (ind nt nts))
(add-conf conf nt nts predictors)
(loop (cdr l) (+ conf 1)))
(begin
(vector-set! steps conf (- (ind head nts) nb-nts))
(add-conf conf head nts enders)
(rule-loop (cdr rules) (+ conf 1) (+ rule-num 1))))))
(def-loop (cdr defs) conf))))))))
; Now, for each non-terminal, compute the starters, enders and predictors and
; the names and steps tables.
(setup-tables grammar nts starters enders predictors steps names)
; Build the parser description
(let ((parser-descr (vector lexer
nts
starters
enders
predictors
steps
names)))
(lambda (input)
(define (ind nt nts) ; return index of non-terminal `nt' in `nts'
(let loop ((i (- (vector-length nts) 1)))
(if (>= i 0)
(if (equal? (vector-ref nts i) nt) i (loop (- i 1)))
#f)))
(define (comp-tok tok nts) ; transform token to parsing format
(let loop ((l1 (cdr tok)) (l2 '()))
(if (pair? l1)
(let ((i (ind (car l1) nts)))
(if i
(loop (cdr l1) (cons i l2))
(loop (cdr l1) l2)))
(cons (car tok) (reverse l2)))))
(define (input->tokens input lexer nts)
(list->vector (map (lambda (tok) (comp-tok tok nts)) (lexer input))))
(define (make-states nb-toks nb-confs)
(let ((states (make-vector (+ nb-toks 1) #f)))
(let loop ((i nb-toks))
(if (>= i 0)
(let ((v (make-vector (+ nb-confs 1) #f)))
(vector-set! v 0 -1)
(vector-set! states i v)
(loop (- i 1)))
states))))
(define (conf-set-get state conf)
(vector-ref state (+ conf 1)))
(define (conf-set-get* state state-num conf)
(let ((conf-set (conf-set-get state conf)))
(if conf-set
conf-set
(let ((conf-set (make-vector (+ state-num 6) #f)))
(vector-set! conf-set 1 -3) ; old elems tail (points to head)
(vector-set! conf-set 2 -1) ; old elems head
(vector-set! conf-set 3 -1) ; new elems tail (points to head)
(vector-set! conf-set 4 -1) ; new elems head
(vector-set! state (+ conf 1) conf-set)
conf-set))))
(define (conf-set-merge-new! conf-set)
(vector-set! conf-set
(+ (vector-ref conf-set 1) 5)
(vector-ref conf-set 4))
(vector-set! conf-set 1 (vector-ref conf-set 3))
(vector-set! conf-set 3 -1)
(vector-set! conf-set 4 -1))
(define (conf-set-head conf-set)
(vector-ref conf-set 2))
(define (conf-set-next conf-set i)
(vector-ref conf-set (+ i 5)))
(define (conf-set-member? state conf i)
(let ((conf-set (vector-ref state (+ conf 1))))
(if conf-set
(conf-set-next conf-set i)
#f)))
(define (conf-set-adjoin state conf-set conf i)
(let ((tail (vector-ref conf-set 3))) ; put new element at tail
(vector-set! conf-set (+ i 5) -1)
(vector-set! conf-set (+ tail 5) i)
(vector-set! conf-set 3 i)
(if (< tail 0)
(begin
(vector-set! conf-set 0 (vector-ref state 0))
(vector-set! state 0 conf)))))
(define (conf-set-adjoin* states state-num l i)
(let ((state (vector-ref states state-num)))
(let loop ((l1 l))
(if (pair? l1)
(let* ((conf (car l1))
(conf-set (conf-set-get* state state-num conf)))
(if (not (conf-set-next conf-set i))
(begin
(conf-set-adjoin state conf-set conf i)
(loop (cdr l1)))
(loop (cdr l1))))))))
(define (conf-set-adjoin** states states* state-num conf i)
(let ((state (vector-ref states state-num)))
(if (conf-set-member? state conf i)
(let* ((state* (vector-ref states* state-num))
(conf-set* (conf-set-get* state* state-num conf)))
(if (not (conf-set-next conf-set* i))
(conf-set-adjoin state* conf-set* conf i))
#t)
#f)))
(define (conf-set-union state conf-set conf other-set)
(let loop ((i (conf-set-head other-set)))
(if (>= i 0)
(if (not (conf-set-next conf-set i))
(begin
(conf-set-adjoin state conf-set conf i)
(loop (conf-set-next other-set i)))
(loop (conf-set-next other-set i))))))
(define (forw states state-num starters enders predictors steps nts)
(define (predict state state-num conf-set conf nt starters enders)
; add configurations which start the non-terminal `nt' to the
; right of the dot
(let loop1 ((l (vector-ref starters nt)))
(if (pair? l)
(let* ((starter (car l))
(starter-set (conf-set-get* state state-num starter)))
(if (not (conf-set-next starter-set state-num))
(begin
(conf-set-adjoin state starter-set starter state-num)
(loop1 (cdr l)))
(loop1 (cdr l))))))
; check for possible completion of the non-terminal `nt' to the
; right of the dot
(let loop2 ((l (vector-ref enders nt)))
(if (pair? l)
(let ((ender (car l)))
(if (conf-set-member? state ender state-num)
(let* ((next (+ conf 1))
(next-set (conf-set-get* state state-num next)))
(conf-set-union state next-set next conf-set)
(loop2 (cdr l)))
(loop2 (cdr l)))))))
(define (reduce states state state-num conf-set head preds)
; a non-terminal is now completed so check for reductions that
; are now possible at the configurations `preds'
(let loop1 ((l preds))
(if (pair? l)
(let ((pred (car l)))
(let loop2 ((i head))
(if (>= i 0)
(let ((pred-set (conf-set-get (vector-ref states i) pred)))
(if pred-set
(let* ((next (+ pred 1))
(next-set (conf-set-get* state state-num next)))
(conf-set-union state next-set next pred-set)))
(loop2 (conf-set-next conf-set i)))
(loop1 (cdr l))))))))
(let ((state (vector-ref states state-num))
(nb-nts (vector-length nts)))
(let loop ()
(let ((conf (vector-ref state 0)))
(if (>= conf 0)
(let* ((step (vector-ref steps conf))
(conf-set (vector-ref state (+ conf 1)))
(head (vector-ref conf-set 4)))
(vector-set! state 0 (vector-ref conf-set 0))
(conf-set-merge-new! conf-set)
(if (>= step 0)
(predict state state-num conf-set conf step starters enders)
(let ((preds (vector-ref predictors (+ step nb-nts))))
(reduce states state state-num conf-set head preds)))
(loop)))))))
(define (forward starters enders predictors steps nts toks)
(let* ((nb-toks (vector-length toks))
(nb-confs (vector-length steps))
(states (make-states nb-toks nb-confs))
(goal-starters (vector-ref starters 0)))
(conf-set-adjoin* states 0 goal-starters 0) ; predict goal
(forw states 0 starters enders predictors steps nts)
(let loop ((i 0))
(if (< i nb-toks)
(let ((tok-nts (cdr (vector-ref toks i))))
(conf-set-adjoin* states (+ i 1) tok-nts i) ; scan token
(forw states (+ i 1) starters enders predictors steps nts)
(loop (+ i 1)))))
states))
(define (produce conf i j enders steps toks states states* nb-nts)
(let ((prev (- conf 1)))
(if (and (>= conf nb-nts) (>= (vector-ref steps prev) 0))
(let loop1 ((l (vector-ref enders (vector-ref steps prev))))
(if (pair? l)
(let* ((ender (car l))
(ender-set (conf-set-get (vector-ref states j)
ender)))
(if ender-set
(let loop2 ((k (conf-set-head ender-set)))
(if (>= k 0)
(begin
(and (>= k i)
(conf-set-adjoin** states states* k prev i)
(conf-set-adjoin** states states* j ender k))
(loop2 (conf-set-next ender-set k)))
(loop1 (cdr l))))
(loop1 (cdr l)))))))))
(define (back states states* state-num enders steps nb-nts toks)
(let ((state* (vector-ref states* state-num)))
(let loop1 ()
(let ((conf (vector-ref state* 0)))
(if (>= conf 0)
(let* ((conf-set (vector-ref state* (+ conf 1)))
(head (vector-ref conf-set 4)))
(vector-set! state* 0 (vector-ref conf-set 0))
(conf-set-merge-new! conf-set)
(let loop2 ((i head))
(if (>= i 0)
(begin
(produce conf i state-num enders steps
toks states states* nb-nts)
(loop2 (conf-set-next conf-set i)))
(loop1)))))))))
(define (backward states enders steps nts toks)
(let* ((nb-toks (vector-length toks))
(nb-confs (vector-length steps))
(nb-nts (vector-length nts))
(states* (make-states nb-toks nb-confs))
(goal-enders (vector-ref enders 0)))
(let loop1 ((l goal-enders))
(if (pair? l)
(let ((conf (car l)))
(conf-set-adjoin** states states* nb-toks conf 0)
(loop1 (cdr l)))))
(let loop2 ((i nb-toks))
(if (>= i 0)
(begin
(back states states* i enders steps nb-nts toks)
(loop2 (- i 1)))))
states*))
(define (parsed? nt i j nts enders states)
(let ((nt* (ind nt nts)))
(if nt*
(let ((nb-nts (vector-length nts)))
(let loop ((l (vector-ref enders nt*)))
(if (pair? l)
(let ((conf (car l)))
(if (conf-set-member? (vector-ref states j) conf i)
#t
(loop (cdr l))))
#f)))
#f)))
(define (deriv-trees conf i j enders steps names toks states nb-nts)
(let ((name (vector-ref names conf)))
(if name ; `conf' is at the start of a rule (either special or not)
(if (< conf nb-nts)
(list (list name (car (vector-ref toks i))))
(list (list name)))
(let ((prev (- conf 1)))
(let loop1 ((l1 (vector-ref enders (vector-ref steps prev)))
(l2 '()))
(if (pair? l1)
(let* ((ender (car l1))
(ender-set (conf-set-get (vector-ref states j)
ender)))
(if ender-set
(let loop2 ((k (conf-set-head ender-set)) (l2 l2))
(if (>= k 0)
(if (and (>= k i)
(conf-set-member? (vector-ref states k)
prev i))
(let ((prev-trees
(deriv-trees prev i k enders steps names
toks states nb-nts))
(ender-trees
(deriv-trees ender k j enders steps names
toks states nb-nts)))
(let loop3 ((l3 ender-trees) (l2 l2))
(if (pair? l3)
(let ((ender-tree (list (car l3))))
(let loop4 ((l4 prev-trees) (l2 l2))
(if (pair? l4)
(loop4 (cdr l4)
(cons (append (car l4)
ender-tree)
l2))
(loop3 (cdr l3) l2))))
(loop2 (conf-set-next ender-set k) l2))))
(loop2 (conf-set-next ender-set k) l2))
(loop1 (cdr l1) l2)))
(loop1 (cdr l1) l2)))
l2))))))
(define (deriv-trees* nt i j nts enders steps names toks states)
(let ((nt* (ind nt nts)))
(if nt*
(let ((nb-nts (vector-length nts)))
(let loop ((l (vector-ref enders nt*)) (trees '()))
(if (pair? l)
(let ((conf (car l)))
(if (conf-set-member? (vector-ref states j) conf i)
(loop (cdr l)
(append (deriv-trees conf i j enders steps names
toks states nb-nts)
trees))
(loop (cdr l) trees)))
trees)))
#f)))
(define (nb-deriv-trees conf i j enders steps toks states nb-nts)
(let ((prev (- conf 1)))
(if (or (< conf nb-nts) (< (vector-ref steps prev) 0))
1
(let loop1 ((l (vector-ref enders (vector-ref steps prev)))
(n 0))
(if (pair? l)
(let* ((ender (car l))
(ender-set (conf-set-get (vector-ref states j)
ender)))
(if ender-set
(let loop2 ((k (conf-set-head ender-set)) (n n))
(if (>= k 0)
(if (and (>= k i)
(conf-set-member? (vector-ref states k)
prev i))
(let ((nb-prev-trees
(nb-deriv-trees prev i k enders steps
toks states nb-nts))
(nb-ender-trees
(nb-deriv-trees ender k j enders steps
toks states nb-nts)))
(loop2 (conf-set-next ender-set k)
(+ n (* nb-prev-trees nb-ender-trees))))
(loop2 (conf-set-next ender-set k) n))
(loop1 (cdr l) n)))
(loop1 (cdr l) n)))
n)))))
(define (nb-deriv-trees* nt i j nts enders steps toks states)
(let ((nt* (ind nt nts)))
(if nt*
(let ((nb-nts (vector-length nts)))
(let loop ((l (vector-ref enders nt*)) (nb-trees 0))
(if (pair? l)
(let ((conf (car l)))
(if (conf-set-member? (vector-ref states j) conf i)
(loop (cdr l)
(+ (nb-deriv-trees conf i j enders steps
toks states nb-nts)
nb-trees))
(loop (cdr l) nb-trees)))
nb-trees)))
#f)))
(let* ((lexer (vector-ref parser-descr 0))
(nts (vector-ref parser-descr 1))
(starters (vector-ref parser-descr 2))
(enders (vector-ref parser-descr 3))
(predictors (vector-ref parser-descr 4))
(steps (vector-ref parser-descr 5))
(names (vector-ref parser-descr 6))
(toks (input->tokens input lexer nts)))
(vector nts
starters
enders
predictors
steps
names
toks
(backward (forward starters enders predictors steps nts toks)
enders steps nts toks)
parsed?
deriv-trees*
nb-deriv-trees*))))))
(define (parse->parsed? parse nt i j)
(let* ((nts (vector-ref parse 0))
(enders (vector-ref parse 2))
(states (vector-ref parse 7))
(parsed? (vector-ref parse 8)))
(parsed? nt i j nts enders states)))
(define (parse->trees parse nt i j)
(let* ((nts (vector-ref parse 0))
(enders (vector-ref parse 2))
(steps (vector-ref parse 4))
(names (vector-ref parse 5))
(toks (vector-ref parse 6))
(states (vector-ref parse 7))
(deriv-trees* (vector-ref parse 9)))
(deriv-trees* nt i j nts enders steps names toks states)))
(define (parse->nb-trees parse nt i j)
(let* ((nts (vector-ref parse 0))
(enders (vector-ref parse 2))
(steps (vector-ref parse 4))
(toks (vector-ref parse 6))
(states (vector-ref parse 7))
(nb-deriv-trees* (vector-ref parse 10)))
(nb-deriv-trees* nt i j nts enders steps toks states)))
(define (earley-test)
(let ((p (make-parser '( (s (a) (s s)) )
(lambda (l) (map (lambda (x) (list x x)) l)))))
(let ((x (p '(a a a a a a a a a))))
(length (parse->trees x 's 0 9)))))
(define (main-earley . args)
(run-single-benchmark
"earley"
earley-iters
(lambda (result) (equal? result 1430))
(lambda () (lambda () (earley-test)))))
;;; FFTRAD4
(define lut-table-size 512)
(define lut-table-size^2 262144)
(define lut-table-size^3 134217728)
(define log-lut-table-size 9)
(define low-lut
(FLOATvector-const
1. 0.
.7071067811865476 .7071067811865476
.9238795325112867 .3826834323650898
.3826834323650898 .9238795325112867
.9807852804032304 .19509032201612828
.5555702330196022 .8314696123025452
.8314696123025452 .5555702330196022
.19509032201612828 .9807852804032304
.9951847266721969 .0980171403295606
.6343932841636455 .773010453362737
.881921264348355 .47139673682599764
.2902846772544624 .9569403357322088
.9569403357322088 .2902846772544624
.47139673682599764 .881921264348355
.773010453362737 .6343932841636455
.0980171403295606 .9951847266721969
.9987954562051724 .049067674327418015
.6715589548470184 .7409511253549591
.9039892931234433 .4275550934302821
.33688985339222005 .9415440651830208
.970031253194544 .2429801799032639
.5141027441932218 .8577286100002721
.8032075314806449 .5956993044924334
.14673047445536175 .989176509964781
.989176509964781 .14673047445536175
.5956993044924334 .8032075314806449
.8577286100002721 .5141027441932218
.2429801799032639 .970031253194544
.9415440651830208 .33688985339222005
.4275550934302821 .9039892931234433
.7409511253549591 .6715589548470184
.049067674327418015 .9987954562051724
.9996988186962042 .024541228522912288
.6895405447370669 .7242470829514669
.9142097557035307 .40524131400498986
.35989503653498817 .9329927988347388
.9757021300385286 .2191012401568698
.5349976198870973 .8448535652497071
.8175848131515837 .5758081914178453
.17096188876030122 .9852776423889412
.99247953459871 .1224106751992162
.6152315905806268 .7883464276266062
.8700869911087115 .49289819222978404
.26671275747489837 .9637760657954398
.9495281805930367 .31368174039889146
.4496113296546066 .8932243011955153
.7572088465064846 .6531728429537768
.07356456359966743 .9972904566786902
.9972904566786902 .07356456359966743
.6531728429537768 .7572088465064846
.8932243011955153 .4496113296546066
.31368174039889146 .9495281805930367
.9637760657954398 .26671275747489837
.49289819222978404 .8700869911087115
.7883464276266062 .6152315905806268
.1224106751992162 .99247953459871
.9852776423889412 .17096188876030122
.5758081914178453 .8175848131515837
.8448535652497071 .5349976198870973
.2191012401568698 .9757021300385286
.9329927988347388 .35989503653498817
.40524131400498986 .9142097557035307
.7242470829514669 .6895405447370669
.024541228522912288 .9996988186962042
.9999247018391445 .012271538285719925
.6983762494089728 .7157308252838187
.9191138516900578 .3939920400610481
.37131719395183754 .9285060804732156
.9783173707196277 .20711137619221856
.5453249884220465 .8382247055548381
.8245893027850253 .5657318107836132
.18303988795514095 .9831054874312163
.9939069700023561 .11022220729388306
.6248594881423863 .7807372285720945
.8760700941954066 .4821837720791228
.2785196893850531 .9604305194155658
.9533060403541939 .3020059493192281
.46053871095824 .8876396204028539
.765167265622459 .6438315428897915
.0857973123444399 .996312612182778
.9981181129001492 .06132073630220858
.6624157775901718 .7491363945234594
.8986744656939538 .43861623853852766
.3253102921622629 .9456073253805213
.9669764710448521 .25486565960451457
.5035383837257176 .8639728561215867
.7958369046088836 .6055110414043255
.1345807085071262 .99090263542778
.9873014181578584 .15885814333386145
.5857978574564389 .8104571982525948
.8513551931052652 .524589682678469
.2310581082806711 .9729399522055602
.937339011912575 .34841868024943456
.4164295600976372 .9091679830905224
.7326542716724128 .680600997795453
.03680722294135883 .9993223845883495
.9993223845883495 .03680722294135883
.680600997795453 .7326542716724128
.9091679830905224 .4164295600976372
.34841868024943456 .937339011912575
.9729399522055602 .2310581082806711
.524589682678469 .8513551931052652
.8104571982525948 .5857978574564389
.15885814333386145 .9873014181578584
.99090263542778 .1345807085071262
.6055110414043255 .7958369046088836
.8639728561215867 .5035383837257176
.25486565960451457 .9669764710448521
.9456073253805213 .3253102921622629
.43861623853852766 .8986744656939538
.7491363945234594 .6624157775901718
.06132073630220858 .9981181129001492
.996312612182778 .0857973123444399
.6438315428897915 .765167265622459
.8876396204028539 .46053871095824
.3020059493192281 .9533060403541939
.9604305194155658 .2785196893850531
.4821837720791228 .8760700941954066
.7807372285720945 .6248594881423863
.11022220729388306 .9939069700023561
.9831054874312163 .18303988795514095
.5657318107836132 .8245893027850253
.8382247055548381 .5453249884220465
.20711137619221856 .9783173707196277
.9285060804732156 .37131719395183754
.3939920400610481 .9191138516900578
.7157308252838187 .6983762494089728
.012271538285719925 .9999247018391445
.9999811752826011 .006135884649154475
.7027547444572253 .7114321957452164
.9215140393420419 .3883450466988263
.37700741021641826 .9262102421383114
.9795697656854405 .2011046348420919
.5504579729366048 .83486287498638
.8280450452577558 .560661576197336
.18906866414980622 .9819638691095552
.9945645707342554 .10412163387205457
.629638238914927 .7768884656732324
.8790122264286335 .47679923006332214
.2844075372112718 .9587034748958716
.9551411683057707 .29615088824362384
.4659764957679662 .8847970984309378
.7691033376455796 .6391244448637757
.09190895649713272 .9957674144676598
.9984755805732948 .05519524434968994
.6669999223036375 .745057785441466
.901348847046022 .43309381885315196
.33110630575987643 .9435934581619604
.9685220942744173 .24892760574572018
.508830142543107 .8608669386377673
.799537269107905 .600616479383869
.14065823933284924 .9900582102622971
.9882575677307495 .15279718525844344
.5907597018588743 .8068475535437992
.8545579883654005 .5193559901655896
.2370236059943672 .9715038909862518
.9394592236021899 .3426607173119944
.4220002707997997 .9065957045149153
.7368165688773699 .6760927035753159
.04293825693494082 .9990777277526454
.9995294175010931 .030674803176636626
.6850836677727004 .7284643904482252
.9117060320054299 .41084317105790397
.3541635254204904 .9351835099389476
.9743393827855759 .22508391135979283
.5298036246862947 .8481203448032972
.8140363297059484 .5808139580957645
.16491312048996992 .9863080972445987
.9917097536690995 .12849811079379317
.6103828062763095 .7921065773002124
.8670462455156926 .49822766697278187
.2607941179152755 .9653944416976894
.9475855910177411 .3195020308160157
.44412214457042926 .8959662497561851
.7531867990436125 .6578066932970786
.06744391956366406 .9977230666441916
.9968202992911657 .07968243797143013
.6485144010221124 .7612023854842618
.8904487232447579 .45508358712634384
.30784964004153487 .9514350209690083
.9621214042690416 .272621355449949
.48755016014843594 .8730949784182901
.7845565971555752 .6200572117632892
.11631863091190477 .9932119492347945
.984210092386929 .17700422041214875
.5707807458869673 .8211025149911046
.8415549774368984 .5401714727298929
.21311031991609136 .9770281426577544
.9307669610789837 .36561299780477385
.39962419984564684 .9166790599210427
.7200025079613817 .693971460889654
.01840672990580482 .9998305817958234
.9998305817958234 .01840672990580482
.693971460889654 .7200025079613817
.9166790599210427 .39962419984564684
.36561299780477385 .9307669610789837
.9770281426577544 .21311031991609136
.5401714727298929 .8415549774368984
.8211025149911046 .5707807458869673
.17700422041214875 .984210092386929
.9932119492347945 .11631863091190477
.6200572117632892 .7845565971555752
.8730949784182901 .48755016014843594
.272621355449949 .9621214042690416
.9514350209690083 .30784964004153487
.45508358712634384 .8904487232447579
.7612023854842618 .6485144010221124
.07968243797143013 .9968202992911657
.9977230666441916 .06744391956366406
.6578066932970786 .7531867990436125
.8959662497561851 .44412214457042926
.3195020308160157 .9475855910177411
.9653944416976894 .2607941179152755
.49822766697278187 .8670462455156926
.7921065773002124 .6103828062763095
.12849811079379317 .9917097536690995
.9863080972445987 .16491312048996992
.5808139580957645 .8140363297059484
.8481203448032972 .5298036246862947
.22508391135979283 .9743393827855759
.9351835099389476 .3541635254204904
.41084317105790397 .9117060320054299
.7284643904482252 .6850836677727004
.030674803176636626 .9995294175010931
.9990777277526454 .04293825693494082
.6760927035753159 .7368165688773699
.9065957045149153 .4220002707997997
.3426607173119944 .9394592236021899
.9715038909862518 .2370236059943672
.5193559901655896 .8545579883654005
.8068475535437992 .5907597018588743
.15279718525844344 .9882575677307495
.9900582102622971 .14065823933284924
.600616479383869 .799537269107905
.8608669386377673 .508830142543107
.24892760574572018 .9685220942744173
.9435934581619604 .33110630575987643
.43309381885315196 .901348847046022
.745057785441466 .6669999223036375
.05519524434968994 .9984755805732948
.9957674144676598 .09190895649713272
.6391244448637757 .7691033376455796
.8847970984309378 .4659764957679662
.29615088824362384 .9551411683057707
.9587034748958716 .2844075372112718
.47679923006332214 .8790122264286335
.7768884656732324 .629638238914927
.10412163387205457 .9945645707342554
.9819638691095552 .18906866414980622
.560661576197336 .8280450452577558
.83486287498638 .5504579729366048
.2011046348420919 .9795697656854405
.9262102421383114 .37700741021641826
.3883450466988263 .9215140393420419
.7114321957452164 .7027547444572253
.006135884649154475 .9999811752826011
.9999952938095762 .003067956762965976
.7049340803759049 .7092728264388657
.9227011283338785 .38551605384391885
.37984720892405116 .9250492407826776
.9801821359681174 .1980984107179536
.5530167055800276 .8331701647019132
.829761233794523 .5581185312205561
.19208039704989244 .9813791933137546
.9948793307948056 .10106986275482782
.6320187359398091 .7749531065948739
.8804708890521608 .47410021465055
.2873474595447295 .9578264130275329
.9560452513499964 .29321916269425863
.46868882203582796 .8833633386657316
.7710605242618138 .6367618612362842
.094963495329639 .9954807554919269
.9986402181802653 .052131704680283324
.6692825883466361 .7430079521351217
.9026733182372588 .4303264813400826
.3339996514420094 .9425731976014469
.9692812353565485 .24595505033579462
.5114688504379704 .8593018183570084
.8013761717231402 .5981607069963423
.14369503315029444 .9896220174632009
.9887216919603238 .1497645346773215
.5932322950397998 .8050313311429635
.8561473283751945 .5167317990176499
.2400030224487415 .9707721407289504
.9405060705932683 .33977688440682685
.4247796812091088 .9052967593181188
.7388873244606151 .673829000378756
.04600318213091463 .9989412931868569
.9996188224951786 .027608145778965743
.6873153408917592 .726359155084346
.9129621904283982 .4080441628649787
.35703096123343003 .9340925504042589
.9750253450669941 .22209362097320354
.532403127877198 .8464909387740521
.8158144108067338 .5783137964116556
.16793829497473117 .9857975091675675
.9920993131421918 .12545498341154623
.6128100824294097 .79023022143731
.8685707059713409 .49556526182577254
.2637546789748314 .9645897932898128
.9485613499157303 .31659337555616585
.4468688401623742 .8945994856313827
.7552013768965365 .6554928529996153
.07050457338961387 .9975114561403035
.997060070339483 .07662386139203149
.6508466849963809 .7592091889783881
.8918407093923427 .4523495872337709
.3107671527496115 .9504860739494817
.9629532668736839 .2696683255729151
.49022648328829116 .8715950866559511
.7864552135990858 .617647307937804
.11936521481099137 .9928504144598651
.9847485018019042 .17398387338746382
.5732971666980422 .819347520076797
.8432082396418454 .5375870762956455
.21610679707621952 .9763697313300211
.9318842655816681 .3627557243673972
.40243465085941843 .9154487160882678
.7221281939292153 .6917592583641577
.021474080275469508 .9997694053512153
.9998823474542126 .015339206284988102
.696177131491463 .7178700450557317
.9179007756213905 .3968099874167103
.3684668299533723 .9296408958431812
.9776773578245099 .2101118368804696
.5427507848645159 .8398937941959995
.8228497813758263 .5682589526701316
.18002290140569951 .9836624192117303
.9935641355205953 .11327095217756435
.62246127937415 .7826505961665757
.8745866522781761 .4848692480007911
.27557181931095814 .9612804858113206
.9523750127197659 .30492922973540243
.45781330359887723 .8890483558546646
.7631884172633813 .6461760129833164
.08274026454937569 .9965711457905548
.997925286198596 .06438263092985747
.6601143420674205 .7511651319096864
.8973245807054183 .44137126873171667
.32240767880106985 .9466009130832835
.9661900034454125 .257831102162159
.5008853826112408 .8655136240905691
.7939754775543372 .6079497849677736
.13154002870288312 .9913108598461154
.9868094018141855 .16188639378011183
.5833086529376983 .8122505865852039
.8497417680008524 .5271991347819014
.22807208317088573 .973644249650812
.9362656671702783 .35129275608556715
.41363831223843456 .9104412922580672
.7305627692278276 .6828455463852481
.03374117185137759 .9994306045554617
.9992047586183639 .03987292758773981
.6783500431298615 .7347388780959635
.9078861164876663 .41921688836322396
.34554132496398904 .9384035340631081
.9722264970789363 .23404195858354343
.5219752929371544 .8529606049303636
.808656181588175 .5882815482226453
.15582839765426523 .9877841416445722
.9904850842564571 .13762012158648604
.6030665985403482 .7976908409433912
.8624239561110405 .5061866453451553
.25189781815421697 .9677538370934755
.9446048372614803 .32820984357909255
.4358570799222555 .9000158920161603
.7471006059801801 .6647109782033449
.05825826450043576 .9983015449338929
.996044700901252 .0888535525825246
.6414810128085832 .7671389119358204
.8862225301488806 .4632597835518602
.2990798263080405 .9542280951091057
.9595715130819845 .281464937925758
.479493757660153 .8775452902072612
.778816512381476 .6272518154951441
.10717242495680884 .9942404494531879
.9825393022874412 .18605515166344666
.5631993440138341 .8263210628456635
.836547727223512 .5478940591731002
.20410896609281687 .9789481753190622
.9273625256504011 .374164062971458
.39117038430225387 .9203182767091106
.7135848687807936 .7005687939432483
.00920375478205982 .9999576445519639
.9999576445519639 .00920375478205982
.7005687939432483 .7135848687807936
.9203182767091106 .39117038430225387
.374164062971458 .9273625256504011
.9789481753190622 .20410896609281687
.5478940591731002 .836547727223512
.8263210628456635 .5631993440138341
.18605515166344666 .9825393022874412
.9942404494531879 .10717242495680884
.6272518154951441 .778816512381476
.8775452902072612 .479493757660153
.281464937925758 .9595715130819845
.9542280951091057 .2990798263080405
.4632597835518602 .8862225301488806
.7671389119358204 .6414810128085832
.0888535525825246 .996044700901252
.9983015449338929 .05825826450043576
.6647109782033449 .7471006059801801
.9000158920161603 .4358570799222555
.32820984357909255 .9446048372614803
.9677538370934755 .25189781815421697
.5061866453451553 .8624239561110405
.7976908409433912 .6030665985403482
.13762012158648604 .9904850842564571
.9877841416445722 .15582839765426523
.5882815482226453 .808656181588175
.8529606049303636 .5219752929371544
.23404195858354343 .9722264970789363
.9384035340631081 .34554132496398904
.41921688836322396 .9078861164876663
.7347388780959635 .6783500431298615
.03987292758773981 .9992047586183639
.9994306045554617 .03374117185137759
.6828455463852481 .7305627692278276
.9104412922580672 .41363831223843456
.35129275608556715 .9362656671702783
.973644249650812 .22807208317088573
.5271991347819014 .8497417680008524
.8122505865852039 .5833086529376983
.16188639378011183 .9868094018141855
.9913108598461154 .13154002870288312
.6079497849677736 .7939754775543372
.8655136240905691 .5008853826112408
.257831102162159 .9661900034454125
.9466009130832835 .32240767880106985
.44137126873171667 .8973245807054183
.7511651319096864 .6601143420674205
.06438263092985747 .997925286198596
.9965711457905548 .08274026454937569
.6461760129833164 .7631884172633813
.8890483558546646 .45781330359887723
.30492922973540243 .9523750127197659
.9612804858113206 .27557181931095814
.4848692480007911 .8745866522781761
.7826505961665757 .62246127937415
.11327095217756435 .9935641355205953
.9836624192117303 .18002290140569951
.5682589526701316 .8228497813758263
.8398937941959995 .5427507848645159
.2101118368804696 .9776773578245099
.9296408958431812 .3684668299533723
.3968099874167103 .9179007756213905
.7178700450557317 .696177131491463
.015339206284988102 .9998823474542126
.9997694053512153 .021474080275469508
.6917592583641577 .7221281939292153
.9154487160882678 .40243465085941843
.3627557243673972 .9318842655816681
.9763697313300211 .21610679707621952
.5375870762956455 .8432082396418454
.819347520076797 .5732971666980422
.17398387338746382 .9847485018019042
.9928504144598651 .11936521481099137
.617647307937804 .7864552135990858
.8715950866559511 .49022648328829116
.2696683255729151 .9629532668736839
.9504860739494817 .3107671527496115
.4523495872337709 .8918407093923427
.7592091889783881 .6508466849963809
.07662386139203149 .997060070339483
.9975114561403035 .07050457338961387
.6554928529996153 .7552013768965365
.8945994856313827 .4468688401623742
.31659337555616585 .9485613499157303
.9645897932898128 .2637546789748314
.49556526182577254 .8685707059713409
.79023022143731 .6128100824294097
.12545498341154623 .9920993131421918
.9857975091675675 .16793829497473117
.5783137964116556 .8158144108067338
.8464909387740521 .532403127877198
.22209362097320354 .9750253450669941
.9340925504042589 .35703096123343003
.4080441628649787 .9129621904283982
.726359155084346 .6873153408917592
.027608145778965743 .9996188224951786
.9989412931868569 .04600318213091463
.673829000378756 .7388873244606151
.9052967593181188 .4247796812091088
.33977688440682685 .9405060705932683
.9707721407289504 .2400030224487415
.5167317990176499 .8561473283751945
.8050313311429635 .5932322950397998
.1497645346773215 .9887216919603238
.9896220174632009 .14369503315029444
.5981607069963423 .8013761717231402
.8593018183570084 .5114688504379704
.24595505033579462 .9692812353565485
.9425731976014469 .3339996514420094
.4303264813400826 .9026733182372588
.7430079521351217 .6692825883466361
.052131704680283324 .9986402181802653
.9954807554919269 .094963495329639
.6367618612362842 .7710605242618138
.8833633386657316 .46868882203582796
.29321916269425863 .9560452513499964
.9578264130275329 .2873474595447295
.47410021465055 .8804708890521608
.7749531065948739 .6320187359398091
.10106986275482782 .9948793307948056
.9813791933137546 .19208039704989244
.5581185312205561 .829761233794523
.8331701647019132 .5530167055800276
.1980984107179536 .9801821359681174
.9250492407826776 .37984720892405116
.38551605384391885 .9227011283338785
.7092728264388657 .7049340803759049
.003067956762965976 .9999952938095762
))
(define med-lut
(FLOATvector-const
1. 0.
.9999999999820472 5.9921124526424275e-6
.9999999999281892 1.1984224905069707e-5
.9999999998384257 1.7976337357066685e-5
.9999999997127567 2.396844980841822e-5
.9999999995511824 2.9960562258909154e-5
.9999999993537025 3.5952674708324344e-5
.9999999991203175 4.1944787156448635e-5
.9999999988510269 4.793689960306688e-5
.9999999985458309 5.3929012047963936e-5
.9999999982047294 5.992112449092465e-5
.9999999978277226 6.591323693173387e-5
.9999999974148104 7.190534937017645e-5
.9999999969659927 7.789746180603723e-5
.9999999964812697 8.388957423910108e-5
.9999999959606412 8.988168666915283e-5
.9999999954041073 9.587379909597734e-5
.999999994811668 1.0186591151935948e-4
.9999999941833233 1.0785802393908407e-4
.9999999935190732 1.1385013635493597e-4
.9999999928189177 1.1984224876670004e-4
.9999999920828567 1.2583436117416112e-4
.9999999913108903 1.3182647357710405e-4
.9999999905030187 1.3781858597531374e-4
.9999999896592414 1.4381069836857496e-4
.9999999887795589 1.498028107566726e-4
.9999999878639709 1.5579492313939151e-4
.9999999869124775 1.6178703551651655e-4
.9999999859250787 1.6777914788783258e-4
.9999999849017744 1.737712602531244e-4
.9999999838425648 1.797633726121769e-4
.9999999827474497 1.8575548496477492e-4
.9999999816164293 1.9174759731070332e-4
.9999999804495034 1.9773970964974692e-4
.9999999792466722 2.037318219816906e-4
.9999999780079355 2.0972393430631923e-4
.9999999767332933 2.1571604662341763e-4
.9999999754227459 2.2170815893277063e-4
.9999999740762929 2.2770027123416315e-4
.9999999726939346 2.3369238352737996e-4
.9999999712756709 2.3968449581220595e-4
.9999999698215016 2.45676608088426e-4
.9999999683314271 2.5166872035582493e-4
.9999999668054471 2.5766083261418755e-4
.9999999652435617 2.636529448632988e-4
.9999999636457709 2.696450571029434e-4
.9999999620120748 2.756371693329064e-4
.9999999603424731 2.8162928155297243e-4
.9999999586369661 2.876213937629265e-4
.9999999568955537 2.936135059625534e-4
.9999999551182358 2.99605618151638e-4
.9999999533050126 3.055977303299651e-4
.9999999514558838 3.115898424973196e-4
.9999999495708498 3.1758195465348636e-4
.9999999476499103 3.235740667982502e-4
.9999999456930654 3.2956617893139595e-4
.9999999437003151 3.3555829105270853e-4
.9999999416716594 3.4155040316197275e-4
.9999999396070982 3.475425152589734e-4
.9999999375066316 3.535346273434955e-4
.9999999353702598 3.595267394153237e-4
.9999999331979824 3.6551885147424295e-4
.9999999309897996 3.7151096352003814e-4
.9999999287457114 3.7750307555249406e-4
.9999999264657179 3.8349518757139556e-4
.9999999241498189 3.8948729957652753e-4
.9999999217980144 3.954794115676748e-4
.9999999194103046 4.0147152354462224e-4
.9999999169866894 4.0746363550715466e-4
.9999999145271687 4.134557474550569e-4
.9999999120317428 4.194478593881139e-4
.9999999095004113 4.2543997130611036e-4
.9999999069331744 4.314320832088313e-4
.9999999043300322 4.3742419509606144e-4
.9999999016909845 4.4341630696758576e-4
.9999998990160315 4.4940841882318896e-4
.9999998963051729 4.55400530662656e-4
.999999893558409 4.613926424857717e-4
.9999998907757398 4.673847542923209e-4
.9999998879571651 4.7337686608208844e-4
.9999998851026849 4.793689778548592e-4
.9999998822122994 4.8536108961041806e-4
.9999998792860085 4.913532013485497e-4
.9999998763238122 4.973453130690393e-4
.9999998733257104 5.033374247716714e-4
.9999998702917032 5.09329536456231e-4
.9999998672217907 5.153216481225028e-4
.9999998641159727 5.213137597702719e-4
.9999998609742493 5.27305871399323e-4
.9999998577966206 5.332979830094408e-4
.9999998545830864 5.392900946004105e-4
.9999998513336468 5.452822061720168e-4
.9999998480483018 5.512743177240444e-4
.9999998447270514 5.572664292562783e-4
.9999998413698955 5.632585407685033e-4
.9999998379768343 5.692506522605043e-4
.9999998345478677 5.752427637320661e-4
.9999998310829956 5.812348751829735e-4
.9999998275822183 5.872269866130116e-4
.9999998240455354 5.93219098021965e-4
.9999998204729471 5.992112094096185e-4
.9999998168644535 6.052033207757572e-4
.9999998132200545 6.111954321201659e-4
.99999980953975 6.171875434426292e-4
.9999998058235401 6.231796547429323e-4
.9999998020714248 6.291717660208597e-4
.9999997982834041 6.351638772761965e-4
.9999997944594781 6.411559885087275e-4
.9999997905996466 6.471480997182375e-4
.9999997867039097 6.531402109045114e-4
.9999997827722674 6.591323220673341e-4
.9999997788047197 6.651244332064902e-4
.9999997748012666 6.711165443217649e-4
.9999997707619082 6.771086554129428e-4
.9999997666866443 6.83100766479809e-4
.9999997625754748 6.89092877522148e-4
.9999997584284002 6.950849885397449e-4
.9999997542454201 7.010770995323844e-4
.9999997500265345 7.070692104998515e-4
.9999997457717437 7.130613214419311e-4
.9999997414810473 7.190534323584079e-4
.9999997371544456 7.250455432490666e-4
.9999997327919384 7.310376541136925e-4
.9999997283935259 7.3702976495207e-4
.999999723959208 7.430218757639842e-4
.9999997194889846 7.490139865492199e-4
.9999997149828559 7.55006097307562e-4
.9999997104408218 7.609982080387952e-4
.9999997058628822 7.669903187427045e-4
.9999997012490373 7.729824294190747e-4
.9999996965992869 7.789745400676906e-4
.9999996919136313 7.849666506883372e-4
.99999968719207 7.909587612807992e-4
.9999996824346035 7.969508718448614e-4
.9999996776412315 8.029429823803089e-4
.9999996728119542 8.089350928869263e-4
.9999996679467715 8.149272033644986e-4
.9999996630456833 8.209193138128106e-4
.9999996581086897 8.269114242316472e-4
.9999996531357909 8.329035346207931e-4
.9999996481269865 8.388956449800333e-4
.9999996430822767 8.448877553091527e-4
.9999996380016616 8.508798656079359e-4
.999999632885141 8.56871975876168e-4
.9999996277327151 8.628640861136338e-4
.9999996225443838 8.68856196320118e-4
.9999996173201471 8.748483064954056e-4
.999999612060005 8.808404166392814e-4
.9999996067639574 8.868325267515304e-4
.9999996014320045 8.928246368319371e-4
.9999995960641462 8.988167468802867e-4
.9999995906603825 9.048088568963639e-4
.9999995852207133 9.108009668799535e-4
.9999995797451389 9.167930768308405e-4
.9999995742336589 9.227851867488095e-4
.9999995686862736 9.287772966336457e-4
.9999995631029829 9.347694064851338e-4
.9999995574837868 9.407615163030585e-4
.9999995518286853 9.467536260872047e-4
.9999995461376784 9.527457358373575e-4
.9999995404107661 9.587378455533015e-4
.9999995346479484 9.647299552348216e-4
.9999995288492254 9.707220648817027e-4
.9999995230145969 9.767141744937296e-4
.9999995171440631 9.827062840706872e-4
.9999995112376238 9.886983936123602e-4
.9999995052952791 9.946905031185337e-4
.9999994993170291 .0010006826125889925
.9999994933028736 .0010066747220235214
.9999994872528128 .001012666831421905
.9999994811668466 .0010186589407839286
.999999475044975 .0010246510501093766
.9999994688871979 .0010306431593980344
.9999994626935156 .0010366352686496862
.9999994564639277 .0010426273778641173
.9999994501984345 .0010486194870411127
.999999443897036 .0010546115961804568
.999999437559732 .0010606037052819344
.9999994311865227 .0010665958143453308
.9999994247774079 .0010725879233704307
.9999994183323877 .0010785800323570187
.9999994118514622 .0010845721413048801
.9999994053346313 .0010905642502137994
.9999993987818949 .0010965563590835613
.9999993921932533 .0011025484679139511
.9999993855687062 .0011085405767047535
.9999993789082536 .0011145326854557532
.9999993722118957 .001120524794166735
.9999993654796325 .0011265169028374842
.9999993587114638 .0011325090114677853
.9999993519073898 .001138501120057423
.9999993450674104 .0011444932286061825
.9999993381915255 .0011504853371138485
.9999993312797354 .0011564774455802057
.9999993243320398 .0011624695540050393
.9999993173484387 .001168461662388134
.9999993103289324 .0011744537707292742
.9999993032735206 .0011804458790282454
.9999992961822035 .0011864379872848323
.9999992890549809 .0011924300954988195
.999999281891853 .001198422203669992
.9999992746928197 .0012044143117981348
.999999267457881 .0012104064198830327
.999999260187037 .0012163985279244702
.9999992528802875 .0012223906359222325
.9999992455376326 .0012283827438761045
.9999992381590724 .0012343748517858707
.9999992307446068 .0012403669596513162
.9999992232942359 .001246359067472226
.9999992158079595 .0012523511752483847
.9999992082857777 .001258343282979577
.9999992007276906 .001264335390665588
.999999193133698 .0012703274983062026
.9999991855038001 .0012763196059012057
.9999991778379967 .001282311713450382
.9999991701362881 .0012883038209535163
.999999162398674 .0012942959284103935
.9999991546251547 .0013002880358207985
.9999991468157298 .001306280143184516
.9999991389703996 .001312272250501331
.999999131089164 .0013182643577710285
.999999123172023 .0013242564649933932
.9999991152189767 .0013302485721682098
.9999991072300249 .001336240679295263
.9999990992051678 .0013422327863743383
.9999990911444054 .0013482248934052201
.9999990830477375 .0013542170003876934
.9999990749151643 .001360209107321543
.9999990667466857 .0013662012142065536
.9999990585423016 .0013721933210425101
.9999990503020123 .0013781854278291975
.9999990420258176 .0013841775345664006
.9999990337137175 .0013901696412539043
.999999025365712 .0013961617478914935
.999999016981801 .0014021538544789526
.9999990085619848 .001408145961016067
.9999990001062631 .0014141380675026214
.9999989916146361 .0014201301739384005
.9999989830871038 .0014261222803231893
.9999989745236659 .0014321143866567725
.9999989659243228 .001438106492938935
.9999989572890743 .0014440985991694619
.9999989486179204 .0014500907053481378
.9999989399108612 .0014560828114747475
.9999989311678965 .0014620749175490758
.9999989223890265 .001468067023570908
.9999989135742512 .0014740591295400284
.9999989047235704 .0014800512354562223
.9999988958369843 .0014860433413192743
.9999988869144928 .0014920354471289693
.9999988779560959 .0014980275528850922
.9999988689617937 .0015040196585874275
.9999988599315861 .0015100117642357607
.999998850865473 .0015160038698298762
.9999988417634548 .001521995975369559
.999998832625531 .0015279880808545937
.9999988234517019 .0015339801862847657
.9999988142419675 .0015399722916598592
.9999988049963277 .0015459643969796596
.9999987957147825 .0015519565022439512
.9999987863973319 .0015579486074525195
.9999987770439759 .001563940712605149
.9999987676547146 .0015699328177016243
.999998758229548 .0015759249227417307
.9999987487684759 .0015819170277252528
.9999987392714985 .0015879091326519755
.9999987297386157 .0015939012375216837
.9999987201698276 .0015998933423341623
.9999987105651341 .001605885447089196
.9999987009245352 .0016118775517865696
.999998691248031 .0016178696564260683
.9999986815356214 .0016238617610074765
.9999986717873064 .0016298538655305794
.9999986620030861 .0016358459699951618
.9999986521829605 .0016418380744010084
.9999986423269294 .0016478301787479041
.999998632434993 .0016538222830356339
.9999986225071512 .0016598143872639823
.999998612543404 .0016658064914327345
.9999986025437515 .0016717985955416754
.9999985925081937 .0016777906995905894
.9999985824367305 .0016837828035792617
.9999985723293618 .0016897749075074774
.999998562186088 .0016957670113750207
.9999985520069086 .0017017591151816769
.9999985417918239 .0017077512189272307
.999998531540834 .001713743322611467
.9999985212539385 .0017197354262341706
.9999985109311378 .0017257275297951264
.9999985005724317 .0017317196332941192
.9999984901778203 .0017377117367309341
.9999984797473034 .0017437038401053556
.9999984692808812 .0017496959434171687
.9999984587785538 .0017556880466661582
.9999984482403208 .001761680149852109
.9999984376661826 .0017676722529748061
.999998427056139 .0017736643560340342
.99999841641019 .001779656459029578
.9999984057283358 .0017856485619612225
.9999983950105761 .0017916406648287528
.999998384256911 .0017976327676319532
.9999983734673407 .001803624870370609
.9999983626418649 .0018096169730445048
.9999983517804839 .0018156090756534257
.9999983408831975 .0018216011781971562
.9999983299500057 .0018275932806754815
.9999983189809085 .0018335853830881864
.999998307975906 .0018395774854350557
.9999982969349982 .001845569587715874
.9999982858581851 .0018515616899304264
.9999982747454665 .001857553792078498
.9999982635968426 .001863545894159873
.9999982524123134 .0018695379961743367
.9999982411918789 .001875530098121674
.9999982299355389 .0018815222000016696
.9999982186432936 .0018875143018141083
.999998207315143 .0018935064035587748
.999998195951087 .0018994985052354545
.9999981845511257 .0019054906068439318
.9999981731152591 .0019114827083839918
.999998161643487 .001917474809855419
.9999981501358096 .0019234669112579987
.999998138592227 .0019294590125915154
.9999981270127389 .0019354511138557542
.9999981153973455 .0019414432150504997
.9999981037460468 .0019474353161755369
.9999980920588427 .001953427417230651
.9999980803357332 .001959419518215626
.9999980685767185 .0019654116191302473
.9999980567817984 .0019714037199743
.9999980449509729 .0019773958207475683
.9999980330842422 .0019833879214498375
.999998021181606 .001989380022080892
.9999980092430646 .0019953721226405176
.9999979972686177 .002001364223128498
.9999979852582656 .002007356323544619
.9999979732120081 .002013348423888665
.9999979611298453 .002019340524160421
.9999979490117771 .0020253326243596715
.9999979368578036 .0020313247244862017
.9999979246679247 .002037316824539796
.9999979124421405 .00204330892452024
.999997900180451 .002049301024427318
.9999978878828562 .0020552931242608153
.9999978755493559 .002061285224020516
.9999978631799504 .0020672773237062057
.9999978507746395 .002073269423317669
.9999978383334234 .0020792615228546903
.9999978258563018 .002085253622317055
.999997813343275 .0020912457217045484
.9999978007943428 .002097237821016954
.9999977882095052 .0021032299202540577
.9999977755887623 .0021092220194156444
.9999977629321142 .0021152141185014984
.9999977502395607 .0021212062175114043
.9999977375111019 .002127198316445148
.9999977247467376 .0021331904153025134
.9999977119464681 .002139182514083286
.9999976991102932 .0021451746127872503
.9999976862382131 .002151166711414191
.9999976733302276 .0021571588099638934
.9999976603863368 .0021631509084361423
.9999976474065406 .002169143006830722
.9999976343908391 .002175135105147418
.9999976213392323 .0021811272033860148
.9999976082517201 .002187119301546297
.9999975951283027 .00219311139962805
.9999975819689799 .0021991034976310588
.9999975687737518 .0022050955955551076
.9999975555426184 .0022110876933999816
.9999975422755796 .0022170797911654654
.9999975289726355 .002223071888851344
.9999975156337861 .0022290639864574026
.9999975022590314 .0022350560839834253
.9999974888483714 .002241048181429198
.999997475401806 .0022470402787945045
.9999974619193353 .00225303237607913
.9999974484009593 .0022590244732828596
.9999974348466779 .0022650165704054784
.9999974212564913 .0022710086674467703
.9999974076303992 .002277000764406521
.9999973939684019 .002282992861284515
.9999973802704993 .0022889849580805368
.9999973665366915 .0022949770547943723
.9999973527669782 .0023009691514258054
.9999973389613596 .002306961247974621
.9999973251198357 .0023129533444406045
.9999973112424065 .0023189454408235406
.999997297329072 .0023249375371232135
.9999972833798322 .002330929633339409
.999997269394687 .0023369217294719113
.9999972553736366 .0023429138255205055
.9999972413166809 .0023489059214849765
.9999972272238198 .002354898017365109
.9999972130950534 .0023608901131606883
.9999971989303816 .0023668822088714985
.9999971847298047 .0023728743044973246
.9999971704933224 .0023788664000379523
.9999971562209347 .0023848584954931653
.9999971419126418 .0023908505908627493
.9999971275684435 .0023968426861464883
.99999711318834 .002402834781344168
.9999970987723311 .0024088268764555732
.9999970843204169 .002414818971480488
.9999970698325974 .002420811066418698
.9999970553088726 .0024268031612699878
.9999970407492426 .002432795256034142
.9999970261537071 .002438787350710946
.9999970115222664 .002444779445300184
.9999969968549204 .0024507715398016418
.9999969821516691 .002456763634215103
.9999969674125124 .002462755728540353
.9999969526374506 .0024687478227771774
.9999969378264834 .00247473991692536
.9999969229796108 .002480732010984686
.999996908096833 .0024867241049549406
.9999968931781499 .002492716198835908
.9999968782235614 .0024987082926273734
.9999968632330677 .002504700386329122
.9999968482066687 .002510692479940938
.9999968331443644 .0025166845734626068
.9999968180461547 .0025226766668939127
.9999968029120399 .002528668760234641
.9999967877420196 .002534660853484576
.9999967725360941 .0025406529466435036
.9999967572942633 .002546645039711208
.9999967420165272 .002552637132687474
.9999967267028858 .002558629225572086
.9999967113533391 .0025646213183648297
.9999966959678871 .0025706134110654896
.9999966805465298 .002576605503673851
.9999966650892672 .0025825975961896977
.9999966495960994 .0025885896886128153
.9999966340670262 .0025945817809429885
.9999966185020478 .0026005738731800024
.9999966029011641 .0026065659653236417
.999996587264375 .002612558057373691
.9999965715916808 .002618550149329935
.9999965558830811 .0026245422411921592
.9999965401385762 .002630534332960148
.9999965243581661 .002636526424633687
.9999965085418506 .0026425185162125596
.9999964926896299 .0026485106076965517
.9999964768015038 .0026545026990854484
.9999964608774725 .0026604947903790337
.9999964449175359 .0026664868815770926
.999996428921694 .0026724789726794104
.9999964128899468 .002678471063685772
.9999963968222944 .0026844631545959617
.9999963807187366 .002690455245409765
.9999963645792737 .002696447336126966
.9999963484039053 .00270243942674735
.9999963321926317 .002708431517270702
.9999963159454529 .0027144236076968066
.9999962996623687 .0027204156980254485
.9999962833433793 .002726407788256413
.9999962669884847 .002732399878389485
.9999962505976846 .0027383919684244484
.9999962341709794 .002744384058361089
.9999962177083689 .0027503761481991913
.999996201209853 .0027563682379385403
.9999961846754319 .0027623603275789207
.9999961681051056 .0027683524171201175
.999996151498874 .002774344506561915
.9999961348567371 .002780336595904099
.9999961181786949 .0027863286851464537
.9999961014647475 .0027923207742887642
.9999960847148948 .0027983128633308155
.9999960679291368 .002804304952272392
.9999960511074735 .002810297041113279
.9999960342499049 .0028162891298532606
.9999960173564312 .0028222812184921227
.9999960004270521 .002828273307029649
.9999959834617678 .002834265395465626
.9999959664605781 .0028402574837998367
.9999959494234832 .002846249572032067
.9999959323504831 .0028522416601621014
.9999959152415777 .002858233748189725
.999995898096767 .002864225836114723
.9999958809160512 .0028702179239368793
.9999958636994299 .0028762100116559793
.9999958464469034 .0028822020992718077
.9999958291584717 .0028881941867841495
.9999958118341348 .0028941862741927895
.9999957944738925 .0029001783614975127
.999995777077745 .002906170448698104
.9999957596456922 .0029121625357943475
.9999957421777342 .002918154622786029
.999995724673871 .0029241467096729327
.9999957071341024 .002930138796454844
.9999956895584287 .0029361308831315474
.9999956719468496 .0029421229697028273
.9999956542993652 .0029481150561684695
.9999956366159757 .0029541071425282584
.9999956188966809 .002960099228781979
.9999956011414808 .002966091314929416
.9999955833503754 .002972083400970354
.9999955655233649 .0029780754869045785
.9999955476604491 .0029840675727318736
.999995529761628 .002990059658452025
.9999955118269016 .0029960517440648163
.99999549385627 .0030020438295700336
.9999954758497331 .0030080359149674612
.999995457807291 .003014028000256884
.9999954397289438 .003020020085438087
.9999954216146911 .0030260121705108552
.9999954034645333 .003032004255474973
.9999953852784702 .003037996340330225
.9999953670565019 .003043988425076397
.9999953487986284 .003049980509713273
.9999953305048496 .0030559725942406386
.9999953121751655 .003061964678658278
))
(define high-lut
(FLOATvector-const
1. 0.
.9999999999999999 1.1703344634137277e-8
.9999999999999998 2.3406689268274554e-8
.9999999999999993 3.5110033902411824e-8
.9999999999999989 4.6813378536549095e-8
.9999999999999983 5.851672317068635e-8
.9999999999999976 7.022006780482361e-8
.9999999999999967 8.192341243896085e-8
.9999999999999957 9.362675707309808e-8
.9999999999999944 1.0533010170723531e-7
.9999999999999931 1.170334463413725e-7
.9999999999999917 1.287367909755097e-7
.9999999999999901 1.4044013560964687e-7
.9999999999999885 1.5214348024378403e-7
.9999999999999866 1.6384682487792116e-7
.9999999999999846 1.7555016951205827e-7
.9999999999999825 1.8725351414619535e-7
.9999999999999802 1.989568587803324e-7
.9999999999999778 2.1066020341446942e-7
.9999999999999752 2.2236354804860645e-7
.9999999999999726 2.3406689268274342e-7
.9999999999999698 2.4577023731688034e-7
.9999999999999668 2.5747358195101726e-7
.9999999999999638 2.6917692658515413e-7
.9999999999999606 2.8088027121929094e-7
.9999999999999571 2.9258361585342776e-7
.9999999999999537 3.042869604875645e-7
.99999999999995 3.159903051217012e-7
.9999999999999463 3.276936497558379e-7
.9999999999999424 3.3939699438997453e-7
.9999999999999384 3.5110033902411114e-7
.9999999999999342 3.6280368365824763e-7
.9999999999999298 3.7450702829238413e-7
.9999999999999254 3.8621037292652057e-7
.9999999999999208 3.979137175606569e-7
.9999999999999161 4.0961706219479325e-7
.9999999999999113 4.2132040682892953e-7
.9999999999999063 4.330237514630657e-7
.9999999999999011 4.447270960972019e-7
.9999999999998959 4.5643044073133796e-7
.9999999999998904 4.68133785365474e-7
.9999999999998849 4.7983712999961e-7
.9999999999998792 4.915404746337459e-7
.9999999999998733 5.032438192678817e-7
.9999999999998674 5.149471639020175e-7
.9999999999998613 5.266505085361531e-7
.9999999999998551 5.383538531702888e-7
.9999999999998487 5.500571978044243e-7
.9999999999998422 5.617605424385598e-7
.9999999999998356 5.734638870726952e-7
.9999999999998288 5.851672317068305e-7
.9999999999998219 5.968705763409657e-7
.9999999999998148 6.085739209751009e-7
.9999999999998076 6.202772656092359e-7
.9999999999998003 6.319806102433709e-7
.9999999999997928 6.436839548775058e-7
.9999999999997853 6.553872995116406e-7
.9999999999997775 6.670906441457753e-7
.9999999999997696 6.7879398877991e-7
.9999999999997616 6.904973334140445e-7
.9999999999997534 7.02200678048179e-7
.9999999999997452 7.139040226823132e-7
.9999999999997368 7.256073673164475e-7
.9999999999997282 7.373107119505817e-7
.9999999999997194 7.490140565847157e-7
.9999999999997107 7.607174012188497e-7
.9999999999997017 7.724207458529835e-7
.9999999999996926 7.841240904871172e-7
.9999999999996834 7.958274351212508e-7
.9999999999996739 8.075307797553844e-7
.9999999999996644 8.192341243895178e-7
.9999999999996547 8.309374690236511e-7
.999999999999645 8.426408136577842e-7
.9999999999996351 8.543441582919173e-7
.999999999999625 8.660475029260503e-7
.9999999999996148 8.777508475601831e-7
.9999999999996044 8.894541921943158e-7
.999999999999594 9.011575368284484e-7
.9999999999995833 9.128608814625808e-7
.9999999999995726 9.245642260967132e-7
.9999999999995617 9.362675707308454e-7
.9999999999995507 9.479709153649775e-7
.9999999999995395 9.596742599991095e-7
.9999999999995283 9.713776046332412e-7
.9999999999995168 9.83080949267373e-7
.9999999999995052 9.947842939015044e-7
.9999999999994935 1.006487638535636e-6
.9999999999994816 1.0181909831697673e-6
.9999999999994696 1.0298943278038984e-6
.9999999999994575 1.0415976724380293e-6
.9999999999994453 1.0533010170721601e-6
.9999999999994329 1.065004361706291e-6
.9999999999994204 1.0767077063404215e-6
.9999999999994077 1.088411050974552e-6
.9999999999993949 1.1001143956086822e-6
.9999999999993819 1.1118177402428122e-6
.9999999999993688 1.1235210848769423e-6
.9999999999993556 1.135224429511072e-6
.9999999999993423 1.1469277741452017e-6
.9999999999993288 1.1586311187793313e-6
.9999999999993151 1.1703344634134605e-6
.9999999999993014 1.1820378080475897e-6
.9999999999992875 1.1937411526817187e-6
.9999999999992735 1.2054444973158477e-6
.9999999999992593 1.2171478419499764e-6
.9999999999992449 1.2288511865841048e-6
.9999999999992305 1.2405545312182331e-6
.999999999999216 1.2522578758523615e-6
.9999999999992012 1.2639612204864894e-6
.9999999999991863 1.2756645651206173e-6
.9999999999991713 1.287367909754745e-6
.9999999999991562 1.2990712543888725e-6
.9999999999991409 1.3107745990229998e-6
.9999999999991255 1.3224779436571269e-6
.9999999999991099 1.3341812882912537e-6
.9999999999990943 1.3458846329253806e-6
.9999999999990785 1.3575879775595072e-6
.9999999999990625 1.3692913221936337e-6
.9999999999990464 1.3809946668277597e-6
.9999999999990302 1.3926980114618857e-6
.9999999999990138 1.4044013560960117e-6
.9999999999989974 1.4161047007301373e-6
.9999999999989807 1.4278080453642627e-6
.9999999999989639 1.439511389998388e-6
.999999999998947 1.451214734632513e-6
.99999999999893 1.462918079266638e-6
.9999999999989128 1.4746214239007625e-6
.9999999999988954 1.486324768534887e-6
.999999999998878 1.4980281131690111e-6
.9999999999988604 1.5097314578031353e-6
.9999999999988426 1.5214348024372591e-6
.9999999999988247 1.5331381470713828e-6
.9999999999988067 1.544841491705506e-6
.9999999999987886 1.5565448363396294e-6
.9999999999987703 1.5682481809737524e-6
.9999999999987519 1.579951525607875e-6
.9999999999987333 1.5916548702419977e-6
.9999999999987146 1.60335821487612e-6
.9999999999986958 1.615061559510242e-6
.9999999999986768 1.626764904144364e-6
.9999999999986577 1.6384682487784858e-6
.9999999999986384 1.6501715934126072e-6
.9999999999986191 1.6618749380467283e-6
.9999999999985996 1.6735782826808495e-6
.9999999999985799 1.6852816273149702e-6
.9999999999985602 1.6969849719490907e-6
.9999999999985402 1.708688316583211e-6
.9999999999985201 1.720391661217331e-6
.9999999999985 1.732095005851451e-6
.9999999999984795 1.7437983504855706e-6
.9999999999984591 1.7555016951196899e-6
.9999999999984385 1.767205039753809e-6
.9999999999984177 1.778908384387928e-6
.9999999999983968 1.7906117290220465e-6
.9999999999983759 1.802315073656165e-6
.9999999999983546 1.814018418290283e-6
.9999999999983333 1.825721762924401e-6
.9999999999983119 1.8374251075585186e-6
.9999999999982904 1.8491284521926361e-6
.9999999999982686 1.8608317968267533e-6
.9999999999982468 1.8725351414608702e-6
.9999999999982249 1.8842384860949866e-6
.9999999999982027 1.8959418307291031e-6
.9999999999981805 1.9076451753632194e-6
.999999999998158 1.919348519997335e-6
.9999999999981355 1.9310518646314507e-6
.9999999999981128 1.942755209265566e-6
.9999999999980901 1.954458553899681e-6
.9999999999980671 1.966161898533796e-6
.999999999998044 1.9778652431679103e-6
.9999999999980208 1.9895685878020246e-6
.9999999999979975 2.0012719324361386e-6
.999999999997974 2.012975277070252e-6
.9999999999979503 2.0246786217043656e-6
.9999999999979265 2.0363819663384787e-6
.9999999999979027 2.048085310972592e-6
.9999999999978786 2.0597886556067045e-6
.9999999999978545 2.0714920002408167e-6
.9999999999978302 2.0831953448749286e-6
.9999999999978058 2.0948986895090404e-6
.9999999999977811 2.106602034143152e-6
.9999999999977564 2.118305378777263e-6
.9999999999977315 2.1300087234113738e-6
.9999999999977065 2.1417120680454843e-6
.9999999999976814 2.153415412679595e-6
.9999999999976561 2.1651187573137046e-6
.9999999999976307 2.1768221019478143e-6
.9999999999976051 2.188525446581924e-6
.9999999999975795 2.200228791216033e-6
.9999999999975536 2.2119321358501417e-6
.9999999999975278 2.22363548048425e-6
.9999999999975017 2.2353388251183586e-6
.9999999999974754 2.247042169752466e-6
.999999999997449 2.2587455143865738e-6
.9999999999974225 2.2704488590206814e-6
.9999999999973959 2.282152203654788e-6
.9999999999973691 2.293855548288895e-6
.9999999999973422 2.305558892923001e-6
.9999999999973151 2.317262237557107e-6
.999999999997288 2.328965582191213e-6
.9999999999972606 2.340668926825318e-6
.9999999999972332 2.352372271459423e-6
.9999999999972056 2.364075616093528e-6
.9999999999971778 2.3757789607276323e-6
.99999999999715 2.3874823053617365e-6
.999999999997122 2.3991856499958403e-6
.9999999999970938 2.4108889946299437e-6
.9999999999970656 2.4225923392640466e-6
.9999999999970371 2.4342956838981495e-6
.9999999999970085 2.445999028532252e-6
.9999999999969799 2.457702373166354e-6
.999999999996951 2.4694057178004558e-6
.999999999996922 2.4811090624345574e-6
.9999999999968929 2.4928124070686583e-6
.9999999999968637 2.504515751702759e-6
.9999999999968343 2.5162190963368595e-6
.9999999999968048 2.5279224409709594e-6
.9999999999967751 2.5396257856050594e-6
.9999999999967454 2.5513291302391585e-6
.9999999999967154 2.5630324748732576e-6
.9999999999966853 2.5747358195073563e-6
.9999999999966551 2.5864391641414546e-6
.9999999999966248 2.5981425087755525e-6
.9999999999965944 2.6098458534096503e-6
.9999999999965637 2.6215491980437473e-6
.999999999996533 2.6332525426778443e-6
.9999999999965021 2.644955887311941e-6
.999999999996471 2.656659231946037e-6
.99999999999644 2.6683625765801328e-6
.9999999999964087 2.680065921214228e-6
.9999999999963772 2.6917692658483234e-6
.9999999999963456 2.703472610482418e-6
.999999999996314 2.7151759551165123e-6
.9999999999962821 2.7268792997506064e-6
.9999999999962501 2.7385826443846996e-6
.9999999999962179 2.750285989018793e-6
.9999999999961857 2.761989333652886e-6
.9999999999961533 2.7736926782869783e-6
.9999999999961208 2.78539602292107e-6
.9999999999960881 2.797099367555162e-6
.9999999999960553 2.808802712189253e-6
.9999999999960224 2.8205060568233443e-6
.9999999999959893 2.832209401457435e-6
.9999999999959561 2.8439127460915247e-6
.9999999999959227 2.8556160907256145e-6
.9999999999958893 2.867319435359704e-6
.9999999999958556 2.879022779993793e-6
.9999999999958219 2.8907261246278814e-6
.9999999999957879 2.90242946926197e-6
.999999999995754 2.9141328138960576e-6
.9999999999957198 2.925836158530145e-6
.9999999999956855 2.9375395031642317e-6
.999999999995651 2.9492428477983186e-6
.9999999999956164 2.9609461924324046e-6
.9999999999955816 2.9726495370664905e-6
.9999999999955468 2.9843528817005757e-6
.9999999999955118 2.996056226334661e-6
.9999999999954767 3.007759570968745e-6
.9999999999954414 3.0194629156028294e-6
.999999999995406 3.0311662602369133e-6
.9999999999953705 3.0428696048709963e-6
.9999999999953348 3.0545729495050794e-6
.999999999995299 3.066276294139162e-6
.999999999995263 3.0779796387732437e-6
.9999999999952269 3.0896829834073255e-6
.9999999999951907 3.101386328041407e-6
.9999999999951543 3.1130896726754873e-6
.9999999999951178 3.1247930173095678e-6
.9999999999950812 3.136496361943648e-6
.9999999999950444 3.148199706577727e-6
.9999999999950075 3.1599030512118063e-6
.9999999999949705 3.171606395845885e-6
.9999999999949333 3.183309740479963e-6
.999999999994896 3.195013085114041e-6
.9999999999948584 3.206716429748118e-6
.9999999999948209 3.218419774382195e-6
.9999999999947832 3.2301231190162714e-6
.9999999999947453 3.2418264636503477e-6
.9999999999947072 3.253529808284423e-6
.9999999999946692 3.265233152918498e-6
.9999999999946309 3.276936497552573e-6
.9999999999945924 3.288639842186647e-6
.9999999999945539 3.300343186820721e-6
.9999999999945152 3.312046531454794e-6
.9999999999944763 3.323749876088867e-6
.9999999999944373 3.3354532207229395e-6
.9999999999943983 3.3471565653570115e-6
.9999999999943591 3.358859909991083e-6
.9999999999943197 3.370563254625154e-6
.9999999999942801 3.3822665992592245e-6
.9999999999942405 3.3939699438932944e-6
.9999999999942008 3.4056732885273643e-6
.9999999999941608 3.4173766331614334e-6
.9999999999941207 3.429079977795502e-6
.9999999999940805 3.4407833224295702e-6
.9999999999940402 3.452486667063638e-6
.9999999999939997 3.4641900116977054e-6
.999999999993959 3.4758933563317723e-6
.9999999999939183 3.4875967009658384e-6
.9999999999938775 3.4993000455999045e-6
.9999999999938364 3.5110033902339697e-6
.9999999999937953 3.5227067348680345e-6
.999999999993754 3.534410079502099e-6
.9999999999937126 3.546113424136163e-6
.999999999993671 3.5578167687702264e-6
.9999999999936293 3.5695201134042896e-6
.9999999999935875 3.581223458038352e-6
.9999999999935454 3.592926802672414e-6
.9999999999935033 3.6046301473064755e-6
.9999999999934611 3.6163334919405365e-6
.9999999999934187 3.628036836574597e-6
.9999999999933762 3.639740181208657e-6
.9999999999933334 3.6514435258427166e-6
.9999999999932907 3.6631468704767755e-6
.9999999999932477 3.674850215110834e-6
.9999999999932047 3.686553559744892e-6
.9999999999931615 3.6982569043789496e-6
.9999999999931181 3.7099602490130064e-6
.9999999999930747 3.7216635936470627e-6
.999999999993031 3.733366938281119e-6
.9999999999929873 3.745070282915174e-6
.9999999999929433 3.756773627549229e-6
.9999999999928992 3.768476972183284e-6
.9999999999928552 3.7801803168173377e-6
.9999999999928109 3.791883661451391e-6
.9999999999927663 3.803587006085444e-6
.9999999999927218 3.8152903507194965e-6
.9999999999926771 3.826993695353548e-6
.9999999999926322 3.838697039987599e-6
.9999999999925873 3.85040038462165e-6
.9999999999925421 3.862103729255701e-6
.9999999999924968 3.87380707388975e-6
.9999999999924514 3.885510418523799e-6
.9999999999924059 3.897213763157848e-6
.9999999999923602 3.9089171077918965e-6
.9999999999923144 3.9206204524259435e-6
.9999999999922684 3.9323237970599905e-6
.9999999999922223 3.9440271416940376e-6
.9999999999921761 3.955730486328084e-6
.9999999999921297 3.967433830962129e-6
.9999999999920832 3.9791371755961736e-6
.9999999999920366 3.990840520230218e-6
.9999999999919899 4.002543864864262e-6
.9999999999919429 4.014247209498305e-6
.9999999999918958 4.025950554132348e-6
.9999999999918486 4.03765389876639e-6
.9999999999918013 4.049357243400431e-6
.9999999999917539 4.061060588034472e-6
.9999999999917063 4.072763932668513e-6
.9999999999916586 4.084467277302553e-6
.9999999999916107 4.096170621936592e-6
.9999999999915626 4.107873966570632e-6
.9999999999915146 4.119577311204669e-6
.9999999999914663 4.131280655838707e-6
.9999999999914179 4.142984000472745e-6
.9999999999913692 4.154687345106781e-6
.9999999999913206 4.166390689740817e-6
.9999999999912718 4.178094034374852e-6
.9999999999912228 4.189797379008887e-6
.9999999999911737 4.201500723642921e-6
.9999999999911244 4.213204068276955e-6
.999999999991075 4.224907412910988e-6
.9999999999910255 4.236610757545021e-6
.9999999999909759 4.248314102179053e-6
.9999999999909261 4.260017446813084e-6
.9999999999908762 4.271720791447115e-6
.9999999999908261 4.283424136081145e-6
.9999999999907759 4.295127480715175e-6
.9999999999907256 4.306830825349204e-6
.9999999999906751 4.3185341699832325e-6
.9999999999906245 4.33023751461726e-6
.9999999999905738 4.3419408592512875e-6
.9999999999905229 4.353644203885314e-6
.9999999999904718 4.36534754851934e-6
.9999999999904207 4.377050893153365e-6
.9999999999903694 4.38875423778739e-6
.999999999990318 4.400457582421414e-6
.9999999999902665 4.4121609270554384e-6
.9999999999902147 4.423864271689461e-6
.9999999999901629 4.435567616323483e-6
.9999999999901109 4.447270960957506e-6
.9999999999900587 4.458974305591527e-6
.9999999999900065 4.470677650225547e-6
.9999999999899541 4.482380994859567e-6
.9999999999899016 4.494084339493587e-6
.9999999999898489 4.5057876841276054e-6
.9999999999897962 4.517491028761624e-6
.9999999999897432 4.529194373395641e-6
.9999999999896901 4.5408977180296584e-6
.999999999989637 4.552601062663675e-6
.9999999999895836 4.564304407297691e-6
.99999999998953 4.5760077519317055e-6
.9999999999894764 4.5877110965657195e-6
.9999999999894227 4.5994144411997335e-6
.9999999999893688 4.611117785833747e-6
.9999999999893148 4.622821130467759e-6
.9999999999892606 4.634524475101771e-6
.9999999999892063 4.646227819735783e-6
.9999999999891518 4.657931164369793e-6
.9999999999890973 4.669634509003803e-6
.9999999999890425 4.681337853637813e-6
.9999999999889877 4.693041198271821e-6
.9999999999889327 4.704744542905829e-6
.9999999999888776 4.716447887539837e-6
.9999999999888223 4.728151232173843e-6
.9999999999887669 4.73985457680785e-6
.9999999999887114 4.751557921441855e-6
.9999999999886556 4.76326126607586e-6
.9999999999885999 4.774964610709864e-6
.9999999999885439 4.786667955343868e-6
.9999999999884878 4.798371299977871e-6
.9999999999884316 4.810074644611873e-6
.9999999999883752 4.821777989245874e-6
.9999999999883187 4.833481333879875e-6
.9999999999882621 4.845184678513876e-6
.9999999999882053 4.856888023147875e-6
.9999999999881484 4.868591367781874e-6
.9999999999880914 4.880294712415872e-6
.9999999999880341 4.89199805704987e-6
.9999999999879768 4.903701401683867e-6
.9999999999879194 4.915404746317863e-6
.9999999999878618 4.9271080909518585e-6
.9999999999878041 4.938811435585853e-6
.9999999999877462 4.9505147802198475e-6
.9999999999876882 4.962218124853841e-6
.99999999998763 4.973921469487834e-6
.9999999999875717 4.985624814121826e-6
.9999999999875133 4.997328158755817e-6
.9999999999874548 5.009031503389808e-6
.9999999999873961 5.0207348480237985e-6
.9999999999873372 5.032438192657788e-6
.9999999999872783 5.0441415372917765e-6
.9999999999872192 5.055844881925764e-6
.9999999999871599 5.067548226559752e-6
.9999999999871007 5.079251571193739e-6
.9999999999870411 5.090954915827725e-6
.9999999999869814 5.10265826046171e-6
.9999999999869217 5.1143616050956945e-6
.9999999999868617 5.126064949729678e-6
.9999999999868017 5.1377682943636615e-6
.9999999999867415 5.149471638997644e-6
.9999999999866811 5.161174983631626e-6
.9999999999866207 5.172878328265607e-6
.9999999999865601 5.184581672899587e-6
.9999999999864994 5.196285017533567e-6
.9999999999864384 5.2079883621675455e-6
.9999999999863775 5.219691706801524e-6
.9999999999863163 5.2313950514355015e-6
.999999999986255 5.243098396069478e-6
.9999999999861935 5.254801740703454e-6
.999999999986132 5.266505085337429e-6
.9999999999860703 5.278208429971404e-6
.9999999999860084 5.289911774605378e-6
.9999999999859465 5.301615119239351e-6
.9999999999858843 5.313318463873323e-6
.9999999999858221 5.325021808507295e-6
.9999999999857597 5.336725153141267e-6
.9999999999856971 5.3484284977752366e-6
.9999999999856345 5.360131842409206e-6
.9999999999855717 5.371835187043175e-6
.9999999999855087 5.383538531677143e-6
.9999999999854456 5.3952418763111104e-6
.9999999999853825 5.406945220945077e-6
.9999999999853191 5.418648565579043e-6
.9999999999852557 5.4303519102130076e-6
.9999999999851921 5.4420552548469724e-6
.9999999999851282 5.453758599480936e-6
.9999999999850644 5.465461944114899e-6
.9999999999850003 5.47716528874886e-6
.9999999999849362 5.488868633382822e-6
.9999999999848719 5.500571978016782e-6
.9999999999848074 5.512275322650742e-6
.9999999999847429 5.523978667284702e-6
.9999999999846781 5.53568201191866e-6
.9999999999846133 5.547385356552617e-6
.9999999999845482 5.5590887011865745e-6
.9999999999844832 5.57079204582053e-6
.9999999999844179 5.582495390454486e-6
.9999999999843525 5.59419873508844e-6
.9999999999842869 5.605902079722394e-6
.9999999999842213 5.617605424356347e-6
.9999999999841555 5.629308768990299e-6
.9999999999840895 5.641012113624251e-6
.9999999999840234 5.652715458258201e-6
.9999999999839572 5.664418802892152e-6
.9999999999838908 5.6761221475261e-6
.9999999999838243 5.687825492160048e-6
.9999999999837577 5.699528836793996e-6
.9999999999836909 5.711232181427943e-6
.999999999983624 5.722935526061889e-6
.9999999999835569 5.734638870695834e-6
.9999999999834898 5.746342215329779e-6
.9999999999834225 5.758045559963722e-6
.999999999983355 5.769748904597665e-6
.9999999999832874 5.781452249231607e-6
.9999999999832196 5.793155593865548e-6
.9999999999831518 5.804858938499489e-6
.9999999999830838 5.816562283133429e-6
.9999999999830157 5.8282656277673675e-6
.9999999999829474 5.839968972401306e-6
.9999999999828789 5.851672317035243e-6
.9999999999828104 5.86337566166918e-6
.9999999999827417 5.875079006303115e-6
.9999999999826729 5.88678235093705e-6
.9999999999826039 5.898485695570985e-6
.9999999999825349 5.910189040204917e-6
.9999999999824656 5.92189238483885e-6
.9999999999823962 5.933595729472782e-6
.9999999999823267 5.945299074106713e-6
.9999999999822571 5.957002418740643e-6
.9999999999821872 5.9687057633745715e-6
.9999999999821173 5.9804091080085e-6
))
(define (make-w log-n)
(let* ((n (expt 2 log-n)) ;; number of complexes
(result (FLOATmake-vector (* 2 n))))
(define (copy-low-lut)
(do ((i 0 (+ i 1)))
((= i lut-table-size))
(let ((index (* i 2)))
(FLOATvector-set!
result
index
(FLOATvector-ref low-lut index))
(FLOATvector-set!
result
(+ index 1)
(FLOATvector-ref low-lut (+ index 1))))))
(define (extend-lut multiplier-lut
bit-reverse-size
bit-reverse-multiplier
start
end)
(define (bit-reverse x n)
(do ((i 0 (+ i 1))
(x x (arithmetic-shift x -1))
(result 0 (+ (* result 2)
(bitwise-and x 1))))
((= i n) result)))
(let loop ((i start)
(j 1))
(if (< i end)
(let* ((multiplier-index
(* 2
(* (bit-reverse j bit-reverse-size)
bit-reverse-multiplier)))
(multiplier-real
(FLOATvector-ref multiplier-lut multiplier-index))
(multiplier-imag
(FLOATvector-ref multiplier-lut (+ multiplier-index 1))))
(let inner ((i i)
(k 0))
;; we copy complex multiples of all entries below
;; start to entries starting at start
(if (< k start)
(let* ((index
(* k 2))
(real
(FLOATvector-ref result index))
(imag
(FLOATvector-ref result (+ index 1)))
(result-real
(FLOAT- (FLOAT* multiplier-real real)
(FLOAT* multiplier-imag imag)))
(result-imag
(FLOAT+ (FLOAT* multiplier-real imag)
(FLOAT* multiplier-imag real)))
(result-index (* i 2)))
(FLOATvector-set! result result-index result-real)
(FLOATvector-set! result (+ result-index 1) result-imag)
(inner (+ i 1)
(+ k 1)))
(loop i
(+ j 1)))))
result)))
(cond ((<= n lut-table-size)
low-lut)
((<= n lut-table-size^2)
(copy-low-lut)
(extend-lut med-lut
(- log-n log-lut-table-size)
(arithmetic-shift 1 (- (* 2 log-lut-table-size) log-n))
lut-table-size
n))
((<= n lut-table-size^3)
(copy-low-lut)
(extend-lut med-lut
log-lut-table-size
1
lut-table-size
lut-table-size^2)
(extend-lut high-lut
(- log-n (* 2 log-lut-table-size))
(arithmetic-shift 1 (- (* 3 log-lut-table-size) log-n))
lut-table-size^2
n))
(else
(error "asking for too large a table")))))
(define (direct-fft-recursive-4 a W-table)
;; This is a direcct complex fft, using a decimation-in-time
;; algorithm with inputs in natural order and outputs in
;; bit-reversed order. The table of "twiddle" factors is in
;; bit-reversed order.
;; this is from page 66 of Chu and George, except that we have
;; combined passes in pairs to cut the number of passes through
;; the vector a
(let ((W (FLOATvector 0. 0. 0. 0.)))
(define (main-loop M N K SizeOfGroup)
(let inner-loop ((K K)
(JFirst M))
(if (< JFirst N)
(let* ((JLast (+ JFirst SizeOfGroup)))
(if (even? K)
(begin
(FLOATvector-set! W 0 (FLOATvector-ref W-table K))
(FLOATvector-set! W 1 (FLOATvector-ref W-table (+ K 1))))
(begin
(FLOATvector-set! W 0 (FLOAT- 0. (FLOATvector-ref W-table K)))
(FLOATvector-set! W 1 (FLOATvector-ref W-table (- K 1)))))
;; we know the that the next two complex roots of
;; unity have index 2K and 2K+1 so that the 2K+1
;; index root can be gotten from the 2K index root
;; in the same way that we get W_0 and W_1 from the
;; table depending on whether K is even or not
(FLOATvector-set! W 2 (FLOATvector-ref W-table (* K 2)))
(FLOATvector-set! W 3 (FLOATvector-ref W-table (+ (* K 2) 1)))
(let J-loop ((J0 JFirst))
(if (< J0 JLast)
(let* ((J0 J0)
(J1 (+ J0 1))
(J2 (+ J0 SizeOfGroup))
(J3 (+ J2 1))
(J4 (+ J2 SizeOfGroup))
(J5 (+ J4 1))
(J6 (+ J4 SizeOfGroup))
(J7 (+ J6 1)))
(let ((W_0 (FLOATvector-ref W 0))
(W_1 (FLOATvector-ref W 1))
(W_2 (FLOATvector-ref W 2))
(W_3 (FLOATvector-ref W 3))
(a_J0 (FLOATvector-ref a J0))
(a_J1 (FLOATvector-ref a J1))
(a_J2 (FLOATvector-ref a J2))
(a_J3 (FLOATvector-ref a J3))
(a_J4 (FLOATvector-ref a J4))
(a_J5 (FLOATvector-ref a J5))
(a_J6 (FLOATvector-ref a J6))
(a_J7 (FLOATvector-ref a J7)))
;; first we do the (overlapping) pairs of
;; butterflies with entries 2*SizeOfGroup
;; apart.
(let ((Temp_0 (FLOAT- (FLOAT* W_0 a_J4)
(FLOAT* W_1 a_J5)))
(Temp_1 (FLOAT+ (FLOAT* W_0 a_J5)
(FLOAT* W_1 a_J4)))
(Temp_2 (FLOAT- (FLOAT* W_0 a_J6)
(FLOAT* W_1 a_J7)))
(Temp_3 (FLOAT+ (FLOAT* W_0 a_J7)
(FLOAT* W_1 a_J6))))
(let ((a_J0 (FLOAT+ a_J0 Temp_0))
(a_J1 (FLOAT+ a_J1 Temp_1))
(a_J2 (FLOAT+ a_J2 Temp_2))
(a_J3 (FLOAT+ a_J3 Temp_3))
(a_J4 (FLOAT- a_J0 Temp_0))
(a_J5 (FLOAT- a_J1 Temp_1))
(a_J6 (FLOAT- a_J2 Temp_2))
(a_J7 (FLOAT- a_J3 Temp_3)))
;; now we do the two (disjoint) pairs
;; of butterflies distance SizeOfGroup
;; apart, the first pair with W2+W3i,
;; the second with -W3+W2i
;; we rewrite the multipliers so I
;; don't hurt my head too much when
;; thinking about them.
(let ((W_0 W_2)
(W_1 W_3)
(W_2 (FLOAT- 0. W_3))
(W_3 W_2))
(let ((Temp_0
(FLOAT- (FLOAT* W_0 a_J2)
(FLOAT* W_1 a_J3)))
(Temp_1
(FLOAT+ (FLOAT* W_0 a_J3)
(FLOAT* W_1 a_J2)))
(Temp_2
(FLOAT- (FLOAT* W_2 a_J6)
(FLOAT* W_3 a_J7)))
(Temp_3
(FLOAT+ (FLOAT* W_2 a_J7)
(FLOAT* W_3 a_J6))))
(let ((a_J0 (FLOAT+ a_J0 Temp_0))
(a_J1 (FLOAT+ a_J1 Temp_1))
(a_J2 (FLOAT- a_J0 Temp_0))
(a_J3 (FLOAT- a_J1 Temp_1))
(a_J4 (FLOAT+ a_J4 Temp_2))
(a_J5 (FLOAT+ a_J5 Temp_3))
(a_J6 (FLOAT- a_J4 Temp_2))
(a_J7 (FLOAT- a_J5 Temp_3)))
(FLOATvector-set! a J0 a_J0)
(FLOATvector-set! a J1 a_J1)
(FLOATvector-set! a J2 a_J2)
(FLOATvector-set! a J3 a_J3)
(FLOATvector-set! a J4 a_J4)
(FLOATvector-set! a J5 a_J5)
(FLOATvector-set! a J6 a_J6)
(FLOATvector-set! a J7 a_J7)
(J-loop (+ J0 2)))))))))
(inner-loop (+ K 1)
(+ JFirst (* SizeOfGroup 4)))))))))
(define (recursive-bit M N K SizeOfGroup)
(if (<= 2 SizeOfGroup)
(begin
(main-loop M N K SizeOfGroup)
(if (< 2048 (- N M))
(let ((new-size (arithmetic-shift (- N M) -2)))
(recursive-bit M
(+ M new-size)
(* K 4)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M new-size)
(+ M (* new-size 2))
(+ (* K 4) 1)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M (* new-size 2))
(+ M (* new-size 3))
(+ (* K 4) 2)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M (* new-size 3))
N
(+ (* K 4) 3)
(arithmetic-shift SizeOfGroup -2)))
(recursive-bit M
N
(* K 4)
(arithmetic-shift SizeOfGroup -2))))))
(define (radix-2-pass a)
;; If we're here, the size of our (conceptually complex)
;; array is not a power of 4, so we need to do a basic radix
;; two pass with w=1 (so W[0]=1.0 and W[1] = 0.) and then
;; call recursive-bit appropriately on the two half arrays.
(let ((SizeOfGroup
(arithmetic-shift (FLOATvector-length a) -1)))
(let loop ((J0 0))
(if (< J0 SizeOfGroup)
(let ((J0 J0)
(J2 (+ J0 SizeOfGroup)))
(let ((J1 (+ J0 1))
(J3 (+ J2 1)))
(let ((a_J0 (FLOATvector-ref a J0))
(a_J1 (FLOATvector-ref a J1))
(a_J2 (FLOATvector-ref a J2))
(a_J3 (FLOATvector-ref a J3)))
(let ((a_J0 (FLOAT+ a_J0 a_J2))
(a_J1 (FLOAT+ a_J1 a_J3))
(a_J2 (FLOAT- a_J0 a_J2))
(a_J3 (FLOAT- a_J1 a_J3)))
(FLOATvector-set! a J0 a_J0)
(FLOATvector-set! a J1 a_J1)
(FLOATvector-set! a J2 a_J2)
(FLOATvector-set! a J3 a_J3)
(loop (+ J0 2))))))))))
(let* ((n (FLOATvector-length a))
(log_n (two^p>=m n)))
;; there are n/2 complex entries in a; if n/2 is not a power
;; of 4, then do a single radix-2 pass and do the rest of
;; the passes as radix-4 passes
(if (odd? log_n)
(recursive-bit 0 n 0 (arithmetic-shift n -2))
(let ((n/2 (arithmetic-shift n -1))
(n/8 (arithmetic-shift n -3)))
(radix-2-pass a)
(recursive-bit 0 n/2 0 n/8)
(recursive-bit n/2 n 1 n/8))))))
(define (inverse-fft-recursive-4 a W-table)
;; This is an complex fft, using a decimation-in-frequency algorithm
;; with inputs in bit-reversed order and outputs in natural order.
;; The organization of the algorithm has little to do with the the
;; associated algorithm on page 41 of Chu and George,
;; I just reversed the operations of the direct algorithm given
;; above (without dividing by 2 each time, so that this has to
;; be "normalized" by dividing by N/2 at the end.
;; The table of "twiddle" factors is in bit-reversed order.
(let ((W (FLOATvector 0. 0. 0. 0.)))
(define (main-loop M N K SizeOfGroup)
(let inner-loop ((K K)
(JFirst M))
(if (< JFirst N)
(let* ((JLast (+ JFirst SizeOfGroup)))
(if (even? K)
(begin
(FLOATvector-set! W 0 (FLOATvector-ref W-table K))
(FLOATvector-set! W 1 (FLOATvector-ref W-table (+ K 1))))
(begin
(FLOATvector-set! W 0 (FLOAT- 0. (FLOATvector-ref W-table K)))
(FLOATvector-set! W 1 (FLOATvector-ref W-table (- K 1)))))
(FLOATvector-set! W 2 (FLOATvector-ref W-table (* K 2)))
(FLOATvector-set! W 3 (FLOATvector-ref W-table (+ (* K 2) 1)))
(let J-loop ((J0 JFirst))
(if (< J0 JLast)
(let* ((J0 J0)
(J1 (+ J0 1))
(J2 (+ J0 SizeOfGroup))
(J3 (+ J2 1))
(J4 (+ J2 SizeOfGroup))
(J5 (+ J4 1))
(J6 (+ J4 SizeOfGroup))
(J7 (+ J6 1)))
(let ((W_0 (FLOATvector-ref W 0))
(W_1 (FLOATvector-ref W 1))
(W_2 (FLOATvector-ref W 2))
(W_3 (FLOATvector-ref W 3))
(a_J0 (FLOATvector-ref a J0))
(a_J1 (FLOATvector-ref a J1))
(a_J2 (FLOATvector-ref a J2))
(a_J3 (FLOATvector-ref a J3))
(a_J4 (FLOATvector-ref a J4))
(a_J5 (FLOATvector-ref a J5))
(a_J6 (FLOATvector-ref a J6))
(a_J7 (FLOATvector-ref a J7)))
(let ((W_00 W_2)
(W_01 W_3)
(W_02 (FLOAT- 0. W_3))
(W_03 W_2))
(let ((Temp_0 (FLOAT- a_J0 a_J2))
(Temp_1 (FLOAT- a_J1 a_J3))
(Temp_2 (FLOAT- a_J4 a_J6))
(Temp_3 (FLOAT- a_J5 a_J7)))
(let ((a_J0 (FLOAT+ a_J0 a_J2))
(a_J1 (FLOAT+ a_J1 a_J3))
(a_J4 (FLOAT+ a_J4 a_J6))
(a_J5 (FLOAT+ a_J5 a_J7))
(a_J2 (FLOAT+ (FLOAT* W_00 Temp_0)
(FLOAT* W_01 Temp_1)))
(a_J3 (FLOAT- (FLOAT* W_00 Temp_1)
(FLOAT* W_01 Temp_0)))
(a_J6 (FLOAT+ (FLOAT* W_02 Temp_2)
(FLOAT* W_03 Temp_3)))
(a_J7 (FLOAT- (FLOAT* W_02 Temp_3)
(FLOAT* W_03 Temp_2))))
(let ((Temp_0 (FLOAT- a_J0 a_J4))
(Temp_1 (FLOAT- a_J1 a_J5))
(Temp_2 (FLOAT- a_J2 a_J6))
(Temp_3 (FLOAT- a_J3 a_J7)))
(let ((a_J0 (FLOAT+ a_J0 a_J4))
(a_J1 (FLOAT+ a_J1 a_J5))
(a_J2 (FLOAT+ a_J2 a_J6))
(a_J3 (FLOAT+ a_J3 a_J7))
(a_J4 (FLOAT+ (FLOAT* W_0 Temp_0)
(FLOAT* W_1 Temp_1)))
(a_J5 (FLOAT- (FLOAT* W_0 Temp_1)
(FLOAT* W_1 Temp_0)))
(a_J6 (FLOAT+ (FLOAT* W_0 Temp_2)
(FLOAT* W_1 Temp_3)))
(a_J7 (FLOAT- (FLOAT* W_0 Temp_3)
(FLOAT* W_1 Temp_2))))
(FLOATvector-set! a J0 a_J0)
(FLOATvector-set! a J1 a_J1)
(FLOATvector-set! a J2 a_J2)
(FLOATvector-set! a J3 a_J3)
(FLOATvector-set! a J4 a_J4)
(FLOATvector-set! a J5 a_J5)
(FLOATvector-set! a J6 a_J6)
(FLOATvector-set! a J7 a_J7)
(J-loop (+ J0 2)))))))))
(inner-loop (+ K 1)
(+ JFirst (* SizeOfGroup 4)))))))))
(define (recursive-bit M N K SizeOfGroup)
(if (<= 2 SizeOfGroup)
(begin
(if (< 2048 (- N M))
(let ((new-size (arithmetic-shift (- N M) -2)))
(recursive-bit M
(+ M new-size)
(* K 4)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M new-size)
(+ M (* new-size 2))
(+ (* K 4) 1)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M (* new-size 2))
(+ M (* new-size 3))
(+ (* K 4) 2)
(arithmetic-shift SizeOfGroup -2))
(recursive-bit (+ M (* new-size 3))
N
(+ (* K 4) 3)
(arithmetic-shift SizeOfGroup -2)))
(recursive-bit M
N
(* K 4)
(arithmetic-shift SizeOfGroup -2)))
(main-loop M N K SizeOfGroup))))
(define (radix-2-pass a)
(let ((SizeOfGroup
(arithmetic-shift (FLOATvector-length a) -1)))
(let loop ((J0 0))
(if (< J0 SizeOfGroup)
(let ((J0 J0)
(J2 (+ J0 SizeOfGroup)))
(let ((J1 (+ J0 1))
(J3 (+ J2 1)))
(let ((a_J0 (FLOATvector-ref a J0))
(a_J1 (FLOATvector-ref a J1))
(a_J2 (FLOATvector-ref a J2))
(a_J3 (FLOATvector-ref a J3)))
(let ((a_J0 (FLOAT+ a_J0 a_J2))
(a_J1 (FLOAT+ a_J1 a_J3))
(a_J2 (FLOAT- a_J0 a_J2))
(a_J3 (FLOAT- a_J1 a_J3)))
(FLOATvector-set! a J0 a_J0)
(FLOATvector-set! a J1 a_J1)
(FLOATvector-set! a J2 a_J2)
(FLOATvector-set! a J3 a_J3)
(loop (+ J0 2))))))))))
(let* ((n (FLOATvector-length a))
(log_n (two^p>=m n)))
(if (odd? log_n)
(recursive-bit 0 n 0 (arithmetic-shift n -2))
(let ((n/2 (arithmetic-shift n -1))
(n/8 (arithmetic-shift n -3)))
(recursive-bit 0 n/2 0 n/8)
(recursive-bit n/2 n 1 n/8)
(radix-2-pass a))))))
(define (two^p>=m m)
;; returns smallest p, assumes fixnum m >= 0
(do ((p 0 (+ p 1))
(two^p 1 (* two^p 2)))
((<= m two^p) p)))
(define n 18) ;; Works on 2^n complex doubles.
(define two^n+1 (expt 2 (+ n 1)))
(define inexact-two^-n (FLOAT/ (exact->inexact (expt 2 n))))
(define data
;; A float vector with data[i]=i
(let ((result (FLOATmake-vector two^n+1)))
(do ((i 0 (+ i 1)))
((= i two^n+1) result)
(FLOATvector-set! result i (exact->inexact i)))))
(define (run-fftrad4 data)
(let ((table (make-w (- n 1))))
(direct-fft-recursive-4 data table)
(inverse-fft-recursive-4 data table)
(do ((j 0 (+ j 1)))
((= j two^n+1))
(FLOATvector-set! data j (FLOAT* (FLOATvector-ref data j) inexact-two^-n)))
(FLOATvector-ref data 3)))
(define (main-fftrad4 . args)
(run-single-benchmark
"fftrad4"
fftrad4-iters
(lambda (result) (FLOAT<= (FLOATabs (FLOAT- result 3.0)) 1e-4))
(lambda (data) (lambda () (run-fftrad4 data)))
data))
;;; FFT - Fast Fourier Transform, translated from "Numerical Recipes in C"
(define (four1 data)
(let ((n (FLOATvector-length data))
(pi*2 6.28318530717959)) ; to compute the inverse, negate this value
; bit-reversal section
(let loop1 ((i 0) (j 0))
(if (< i n)
(begin
(if (< i j)
(begin
(let ((temp (FLOATvector-ref data i)))
(FLOATvector-set! data i (FLOATvector-ref data j))
(FLOATvector-set! data j temp))
(let ((temp (FLOATvector-ref data (+ i 1))))
(FLOATvector-set! data (+ i 1) (FLOATvector-ref data (+ j 1)))
(FLOATvector-set! data (+ j 1) temp))))
(let loop2 ((m (quotient n 2)) (j j))
(if (and (>= m 2) (>= j m))
(loop2 (quotient m 2) (- j m))
(loop1 (+ i 2) (+ j m)))))))
; Danielson-Lanczos section
(let loop3 ((mmax 2))
(if (< mmax n)
(let* ((theta
(FLOAT/ pi*2 (exact->inexact mmax)))
(wpr
(let ((x (FLOATsin (FLOAT* 0.5 theta))))
(FLOAT* -2.0 (FLOAT* x x))))
(wpi
(FLOATsin theta)))
(let loop4 ((wr 1.0) (wi 0.0) (m 0))
(if (< m mmax)
(begin
(let loop5 ((i m))
(if (< i n)
(let* ((j
(+ i mmax))
(tempr
(FLOAT-
(FLOAT* wr (FLOATvector-ref data j))
(FLOAT* wi (FLOATvector-ref data (+ j 1)))))
(tempi
(FLOAT+
(FLOAT* wr (FLOATvector-ref data (+ j 1)))
(FLOAT* wi (FLOATvector-ref data j)))))
(FLOATvector-set! data j
(FLOAT- (FLOATvector-ref data i) tempr))
(FLOATvector-set! data (+ j 1)
(FLOAT- (FLOATvector-ref data (+ i 1)) tempi))
(FLOATvector-set! data i
(FLOAT+ (FLOATvector-ref data i) tempr))
(FLOATvector-set! data (+ i 1)
(FLOAT+ (FLOATvector-ref data (+ i 1)) tempi))
(loop5 (+ j mmax)));***))
(loop4 (FLOAT+ (FLOAT- (FLOAT* wr wpr) (FLOAT* wi wpi)) wr)
(FLOAT+ (FLOAT+ (FLOAT* wi wpr) (FLOAT* wr wpi)) wi)
(+ m 2)))))
));******
(loop3 (* mmax 2)))))))
(define data-fft
(FLOATmake-vector 1024 0.0))
(define (run-fft data)
(four1 data)
(FLOATvector-ref data 0))
(define (main-fft . args)
(run-single-benchmark
"fft"
fft-iters
(lambda (result) (equal? result 0.0))
(lambda (data) (lambda () (run-fft data)))
data-fft))
;;; FIBFP -- Computes fib(35) using floating point
(define (fibfp n)
(if (FLOAT< n 2.)
n
(FLOAT+ (fibfp (FLOAT- n 1.))
(fibfp (FLOAT- n 2.)))))
(define (main-fibfp . args)
(run-single-benchmark
"fibfp"
fibfp-iters
(lambda (result) (equal? result 9227465.))
(lambda (n) (lambda () (fibfp n)))
35.))
;;; FIB -- A classic benchmark, computes fib(35) inefficiently.
(define (fib n)
(if (< n 2)
n
(+ (fib (- n 1))
(fib (- n 2)))))
(define (main-fib . args)
(run-single-benchmark
"fib"
fib-iters
(lambda (result) (equal? result 9227465))
(lambda (n) (lambda () (fib n)))
35))
;;; GRAPHS -- Obtained from Andrew Wright.
;;; ==== util.ss ====
; Fold over list elements, associating to the left.
(define fold
(lambda (lst folder state)
; (assert (list? lst)
; lst)
; (assert (procedure? folder)
; folder)
(do ((lst lst
(cdr lst))
(state state
(folder (car lst)
state)))
((null? lst)
state))))
; Given the size of a vector and a procedure which
; sends indicies to desired vector elements, create
; and return the vector.
(define proc->vector
(lambda (size f)
; (assert (and (integer? size)
; (exact? size)
; (>= size 0))
; size)
; (assert (procedure? f)
; f)
(if (zero? size)
(vector)
(let ((x (make-vector size (f 0))))
(let loop ((i 1))
(if (< i size)
(begin
(vector-set! x i (f i))
(loop (+ i 1)))))
x))))
(define vector-fold
(lambda (vec folder state)
; (assert (vector? vec)
; vec)
; (assert (procedure? folder)
; folder)
(let ((len
(vector-length vec)))
(do ((i 0
(+ i 1))
(state state
(folder (vector-ref vec i)
state)))
((= i len)
state)))))
(define vector-map
(lambda (vec proc)
(proc->vector (vector-length vec)
(lambda (i)
(proc (vector-ref vec i))))))
; Given limit, return the list 0, 1, ..., limit-1.
(define giota
(lambda (limit)
; (assert (and (integer? limit)
; (exact? limit)
; (>= limit 0))
; limit)
(let _-*-
((limit
limit)
(res
'()))
(if (zero? limit)
res
(let ((limit
(- limit 1)))
(_-*- limit
(cons limit res)))))))
; Fold over the integers [0, limit).
(define gnatural-fold
(lambda (limit folder state)
; (assert (and (integer? limit)
; (exact? limit)
; (>= limit 0))
; limit)
; (assert (procedure? folder)
; folder)
(do ((i 0
(+ i 1))
(state state
(folder i state)))
((= i limit)
state))))
; Iterate over the integers [0, limit).
(define gnatural-for-each
(lambda (limit proc!)
; (assert (and (integer? limit)
; (exact? limit)
; (>= limit 0))
; limit)
; (assert (procedure? proc!)
; proc!)
(do ((i 0
(+ i 1)))
((= i limit))
(proc! i))))
(define natural-for-all?
(lambda (limit ok?)
; (assert (and (integer? limit)
; (exact? limit)
; (>= limit 0))
; limit)
; (assert (procedure? ok?)
; ok?)
(let _-*-
((i 0))
(or (= i limit)
(and (ok? i)
(_-*- (+ i 1)))))))
(define natural-there-exists?
(lambda (limit ok?)
; (assert (and (integer? limit)
; (exact? limit)
; (>= limit 0))
; limit)
; (assert (procedure? ok?)
; ok?)
(let _-*-
((i 0))
(and (not (= i limit))
(or (ok? i)
(_-*- (+ i 1)))))))
(define there-exists?
(lambda (lst ok?)
; (assert (list? lst)
; lst)
; (assert (procedure? ok?)
; ok?)
(let _-*-
((lst lst))
(and (not (null? lst))
(or (ok? (car lst))
(_-*- (cdr lst)))))))
;;; ==== ptfold.ss ====
; Fold over the tree of permutations of a universe.
; Each branch (from the root) is a permutation of universe.
; Each node at depth d corresponds to all permutations which pick the
; elements spelled out on the branch from the root to that node as
; the first d elements.
; Their are two components to the state:
; The b-state is only a function of the branch from the root.
; The t-state is a function of all nodes seen so far.
; At each node, b-folder is called via
; (b-folder elem b-state t-state deeper accross)
; where elem is the next element of the universe picked.
; If b-folder can determine the result of the total tree fold at this stage,
; it should simply return the result.
; If b-folder can determine the result of folding over the sub-tree
; rooted at the resulting node, it should call accross via
; (accross new-t-state)
; where new-t-state is that result.
; Otherwise, b-folder should call deeper via
; (deeper new-b-state new-t-state)
; where new-b-state is the b-state for the new node and new-t-state is
; the new folded t-state.
; At the leaves of the tree, t-folder is called via
; (t-folder b-state t-state accross)
; If t-folder can determine the result of the total tree fold at this stage,
; it should simply return that result.
; If not, it should call accross via
; (accross new-t-state)
; Note, fold-over-perm-tree always calls b-folder in depth-first order.
; I.e., when b-folder is called at depth d, the branch leading to that
; node is the most recent calls to b-folder at all the depths less than d.
; This is a gross efficiency hack so that b-folder can use mutation to
; keep the current branch.
(define fold-over-perm-tree
(lambda (universe b-folder b-state t-folder t-state)
; (assert (list? universe)
; universe)
; (assert (procedure? b-folder)
; b-folder)
; (assert (procedure? t-folder)
; t-folder)
(let _-*-
((universe
universe)
(b-state
b-state)
(t-state
t-state)
(accross
(lambda (final-t-state)
final-t-state)))
(if (null? universe)
(t-folder b-state t-state accross)
(let _-**-
((in
universe)
(out
'())
(t-state
t-state))
(let* ((first
(car in))
(rest
(cdr in))
(accross
(if (null? rest)
accross
(lambda (new-t-state)
(_-**- rest
(cons first out)
new-t-state)))))
(b-folder first
b-state
t-state
(lambda (new-b-state new-t-state)
(_-*- (fold out cons rest)
new-b-state
new-t-state
accross))
accross)))))))
;;; ==== minimal.ss ====
; A directed graph is stored as a connection matrix (vector-of-vectors)
; where the first index is the `from' vertex and the second is the `to'
; vertex. Each entry is a bool indicating if the edge exists.
; The diagonal of the matrix is never examined.
; Make-minimal? returns a procedure which tests if a labelling
; of the verticies is such that the matrix is minimal.
; If it is, then the procedure returns the result of folding over
; the elements of the automoriphism group. If not, it returns #f.
; The folding is done by calling folder via
; (folder perm state accross)
; If the folder wants to continue, it should call accross via
; (accross new-state)
; If it just wants the entire minimal? procedure to return something,
; it should return that.
; The ordering used is lexicographic (with #t > #f) and entries
; are examined in the following order:
; 1->0, 0->1
;
; 2->0, 0->2
; 2->1, 1->2
;
; 3->0, 0->3
; 3->1, 1->3
; 3->2, 2->3
; ...
(define make-minimal?
(lambda (max-size)
; (assert (and (integer? max-size)
; (exact? max-size)
; (>= max-size 0))
; max-size)
(let ((iotas
(proc->vector (+ max-size 1)
giota))
(perm
(make-vector max-size 0)))
(lambda (size graph folder state)
; (assert (and (integer? size)
; (exact? size)
; (<= 0 size max-size))
; size
; max-size)
; (assert (vector? graph)
; graph)
; (assert (procedure? folder)
; folder)
(fold-over-perm-tree (vector-ref iotas size)
(lambda (perm-x x state deeper accross)
(case (cmp-next-vertex graph perm x perm-x)
((less)
#f)
((equal)
(vector-set! perm x perm-x)
(deeper (+ x 1)
state))
((more)
(accross state))
(else
; (assert #f)
(fatal-error "???"))))
0
(lambda (leaf-depth state accross)
; (assert (eqv? leaf-depth size)
; leaf-depth
; size)
(folder perm state accross))
state)))))
; Given a graph, a partial permutation vector, the next input and the next
; output, return 'less, 'equal or 'more depending on the lexicographic
; comparison between the permuted and un-permuted graph.
(define cmp-next-vertex
(lambda (graph perm x perm-x)
(let ((from-x
(vector-ref graph x))
(from-perm-x
(vector-ref graph perm-x)))
(let _-*-
((y
0))
(if (= x y)
'equal
(let ((x->y?
(vector-ref from-x y))
(perm-y
(vector-ref perm y)))
(cond ((eq? x->y?
(vector-ref from-perm-x perm-y))
(let ((y->x?
(vector-ref (vector-ref graph y)
x)))
(cond ((eq? y->x?
(vector-ref (vector-ref graph perm-y)
perm-x))
(_-*- (+ y 1)))
(y->x?
'less)
(else
'more))))
(x->y?
'less)
(else
'more))))))))
;;; ==== rdg.ss ====
; Fold over rooted directed graphs with bounded out-degree.
; Size is the number of verticies (including the root). Max-out is the
; maximum out-degree for any vertex. Folder is called via
; (folder edges state)
; where edges is a list of length size. The ith element of the list is
; a list of the verticies j for which there is an edge from i to j.
; The last vertex is the root.
(define fold-over-rdg
(lambda (size max-out folder state)
; (assert (and (exact? size)
; (integer? size)
; (> size 0))
; size)
; (assert (and (exact? max-out)
; (integer? max-out)
; (>= max-out 0))
; max-out)
; (assert (procedure? folder)
; folder)
(let* ((root
(- size 1))
(edge?
(proc->vector size
(lambda (from)
(make-vector size #f))))
(edges
(make-vector size '()))
(out-degrees
(make-vector size 0))
(minimal-folder
(make-minimal? root))
(non-root-minimal?
(let ((cont
(lambda (perm state accross)
; (assert (eq? state #t)
; state)
(accross #t))))
(lambda (size)
(minimal-folder size
edge?
cont
#t))))
(root-minimal?
(let ((cont
(lambda (perm state accross)
; (assert (eq? state #t)
; state)
(case (cmp-next-vertex edge? perm root root)
((less)
#f)
((equal more)
(accross #t))
(else
; (assert #f)
(fatal-error "???"))))))
(lambda ()
(minimal-folder root
edge?
cont
#t)))))
(let _-*-
((vertex
0)
(state
state))
(cond ((not (non-root-minimal? vertex))
state)
((= vertex root)
; (assert
; (begin
; (gnatural-for-each root
; (lambda (v)
; (assert (= (vector-ref out-degrees v)
; (length (vector-ref edges v)))
; v
; (vector-ref out-degrees v)
; (vector-ref edges v))))
; #t))
(let ((reach?
(make-reach? root edges))
(from-root
(vector-ref edge? root)))
(let _-*-
((v
0)
(outs
0)
(efr
'())
(efrr
'())
(state
state))
(cond ((not (or (= v root)
(= outs max-out)))
(vector-set! from-root v #t)
(let ((state
(_-*- (+ v 1)
(+ outs 1)
(cons v efr)
(cons (vector-ref reach? v)
efrr)
state)))
(vector-set! from-root v #f)
(_-*- (+ v 1)
outs
efr
efrr
state)))
((and (natural-for-all? root
(lambda (v)
(there-exists? efrr
(lambda (r)
(vector-ref r v)))))
(root-minimal?))
(vector-set! edges root efr)
(folder
(proc->vector size
(lambda (i)
(vector-ref edges i)))
state))
(else
state)))))
(else
(let ((from-vertex
(vector-ref edge? vertex)))
(let _-**-
((sv
0)
(outs
0)
(state
state))
(if (= sv vertex)
(begin
(vector-set! out-degrees vertex outs)
(_-*- (+ vertex 1)
state))
(let* ((state
; no sv->vertex, no vertex->sv
(_-**- (+ sv 1)
outs
state))
(from-sv
(vector-ref edge? sv))
(sv-out
(vector-ref out-degrees sv))
(state
(if (= sv-out max-out)
state
(begin
(vector-set! edges
sv
(cons vertex
(vector-ref edges sv)))
(vector-set! from-sv vertex #t)
(vector-set! out-degrees sv (+ sv-out 1))
(let* ((state
; sv->vertex, no vertex->sv
(_-**- (+ sv 1)
outs
state))
(state
(if (= outs max-out)
state
(begin
(vector-set! from-vertex sv #t)
(vector-set! edges
vertex
(cons sv
(vector-ref edges vertex)))
(let ((state
; sv->vertex, vertex->sv
(_-**- (+ sv 1)
(+ outs 1)
state)))
(vector-set! edges
vertex
(cdr (vector-ref edges vertex)))
(vector-set! from-vertex sv #f)
state)))))
(vector-set! out-degrees sv sv-out)
(vector-set! from-sv vertex #f)
(vector-set! edges
sv
(cdr (vector-ref edges sv)))
state)))))
(if (= outs max-out)
state
(begin
(vector-set! edges
vertex
(cons sv
(vector-ref edges vertex)))
(vector-set! from-vertex sv #t)
(let ((state
; no sv->vertex, vertex->sv
(_-**- (+ sv 1)
(+ outs 1)
state)))
(vector-set! from-vertex sv #f)
(vector-set! edges
vertex
(cdr (vector-ref edges vertex)))
state)))))))))))))
; Given a vector which maps vertex to out-going-edge list,
; return a vector which gives reachability.
(define make-reach?
(lambda (size vertex->out)
(let ((res
(proc->vector size
(lambda (v)
(let ((from-v
(make-vector size #f)))
(vector-set! from-v v #t)
(for-each
(lambda (x)
(vector-set! from-v x #t))
(vector-ref vertex->out v))
from-v)))))
(gnatural-for-each size
(lambda (m)
(let ((from-m
(vector-ref res m)))
(gnatural-for-each size
(lambda (f)
(let ((from-f
(vector-ref res f)))
(if (vector-ref from-f m)
(gnatural-for-each size
(lambda (t)
(if (vector-ref from-m t)
(vector-set! from-f t #t)))))))))))
res)))
;;; ==== test input ====
; Produces all directed graphs with N verticies, distinguished root,
; and out-degree bounded by 2, upto isomorphism.
(define (run n)
(fold-over-rdg n
2
cons
'()))
(define (main-graphs)
(run-single-benchmark
"graphs"
graphs-iters
(lambda (result) (equal? (length result) 596))
(lambda (n) (lambda () (run n)))
5))
;;; LATTICE -- Obtained from Andrew Wright.
; Given a comparison routine that returns one of
; less
; more
; equal
; uncomparable
; return a new comparison routine that applies to sequences.
(define lexico
(lambda (base)
(define lex-fixed
(lambda (fixed lhs rhs)
(define check
(lambda (lhs rhs)
(if (null? lhs)
fixed
(let ((probe
(base (car lhs)
(car rhs))))
(if (or (eq? probe 'equal)
(eq? probe fixed))
(check (cdr lhs)
(cdr rhs))
'uncomparable)))))
(check lhs rhs)))
(define lex-first
(lambda (lhs rhs)
(if (null? lhs)
'equal
(let ((probe
(base (car lhs)
(car rhs))))
(case probe
((less more)
(lex-fixed probe
(cdr lhs)
(cdr rhs)))
((equal)
(lex-first (cdr lhs)
(cdr rhs)))
((uncomparable)
'uncomparable))))))
lex-first))
(define (make-lattice elem-list cmp-func)
(cons elem-list cmp-func))
(define lattice->elements car)
(define lattice->cmp cdr)
; Select elements of a list which pass some test.
(define zulu-select
(lambda (test lst)
(define select-a
(lambda (ac lst)
(if (null? lst)
(reverse! ac)
(select-a
(let ((head (car lst)))
(if (test head)
(cons head ac)
ac))
(cdr lst)))))
(select-a '() lst)))
(define reverse!
(letrec ((rotate
(lambda (fo fum)
(let ((next (cdr fo)))
(set-cdr! fo fum)
(if (null? next)
fo
(rotate next fo))))))
(lambda (lst)
(if (null? lst)
'()
(rotate lst '())))))
; Select elements of a list which pass some test and map a function
; over the result. Note, only efficiency prevents this from being the
; composition of select and map.
(define select-map
(lambda (test func lst)
(define select-a
(lambda (ac lst)
(if (null? lst)
(reverse! ac)
(select-a
(let ((head (car lst)))
(if (test head)
(cons (func head)
ac)
ac))
(cdr lst)))))
(select-a '() lst)))
; This version of map-and tail-recurses on the last test.
(define map-and
(lambda (proc lst)
(if (null? lst)
#t
(letrec ((drudge
(lambda (lst)
(let ((rest (cdr lst)))
(if (null? rest)
(proc (car lst))
(and (proc (car lst))
(drudge rest)))))))
(drudge lst)))))
(define (maps-1 source target pas new)
(let ((scmp (lattice->cmp source))
(tcmp (lattice->cmp target)))
(let ((less
(select-map
(lambda (p)
(eq? 'less
(scmp (car p) new)))
cdr
pas))
(more
(select-map
(lambda (p)
(eq? 'more
(scmp (car p) new)))
cdr
pas)))
(zulu-select
(lambda (t)
(and
(map-and
(lambda (t2)
(memq (tcmp t2 t) '(less equal)))
less)
(map-and
(lambda (t2)
(memq (tcmp t2 t) '(more equal)))
more)))
(lattice->elements target)))))
(define (maps-rest source target pas rest to-1 to-collect)
(if (null? rest)
(to-1 pas)
(let ((next (car rest))
(rest (cdr rest)))
(to-collect
(map
(lambda (x)
(maps-rest source target
(cons
(cons next x)
pas)
rest
to-1
to-collect))
(maps-1 source target pas next))))))
(define (maps source target)
(make-lattice
(maps-rest source
target
'()
(lattice->elements source)
(lambda (x) (list (map cdr x)))
(lambda (x) (apply append x)))
(lexico (lattice->cmp target))))
(define (count-maps source target)
(maps-rest source
target
'()
(lattice->elements source)
(lambda (x) 1)
sum))
(define (sum lst)
(if (null? lst)
0
(+ (car lst) (sum (cdr lst)))))
(define (lattice-run)
(let* ((l2
(make-lattice '(low high)
(lambda (lhs rhs)
(case lhs
((low)
(case rhs
((low)
'equal)
((high)
'less)
(else
(fatal-error 'make-lattice "base" rhs))))
((high)
(case rhs
((low)
'more)
((high)
'equal)
(else
(fatal-error 'make-lattice "base" rhs))))
(else
(fatal-error 'make-lattice "base" lhs))))))
(l3 (maps l2 l2))
(l4 (maps l3 l3)))
(count-maps l2 l2)
(count-maps l3 l3)
(count-maps l2 l3)
(count-maps l3 l2)
(count-maps l4 l4)))
(define (main-lattice)
(run-single-benchmark
"lattice"
lattice-iters
(lambda (result) (equal? result 120549))
(lambda () (lambda () (lattice-run)))))
;;; MAZEFUN -- Constructs a maze in a purely functional way,
;;; written by Marc Feeley.
(define foldr
(lambda (f base lst)
(define foldr-aux
(lambda (lst)
(if (null? lst)
base
(f (car lst) (foldr-aux (cdr lst))))))
(foldr-aux lst)))
(define foldl
(lambda (f base lst)
(define 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)
(define for-aux
(lambda (lo)
(if (< lo hi)
(cons (f lo) (for-aux (+ lo 1)))
'())))
(for-aux lo)))
(define concat
(lambda (lists)
(foldr append '() 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 duplicates?
(lambda (lst)
(if (null? lst)
#f
(or (member (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)
(remainder (+ (* current-random 3581) 12751) 131072)))
(define shuffle
(lambda (lst)
(shuffle-aux lst initial-random)))
(define shuffle-aux
(lambda (lst current-random)
(if (null? lst)
'()
(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 make-maze
(lambda (n m) ; n and m must be odd
(if (not (and (odd? n) (odd? m)))
'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 (cons i j)))))))))))
(cave-to-maze (pierce-randomly (shuffle possible-holes) cave))))))
(define cave-to-maze
(lambda (cave)
(matrix-map (lambda (x) (if x '_ '*)) cave)))
(define pierce
(lambda (pos cave)
(let ((i (car pos)) (j (cdr pos)))
(matrix-write cave i j pos))))
(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 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 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 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 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))
'())
(if (and (< i (- n 1)) (matrix-read cave (+ i 1) j))
(list (cons (+ i 1) j))
'())
(if (and (> j 0) (matrix-read cave i (- j 1)))
(list (cons i (- j 1)))
'())
(if (and (< j (- m 1)) (matrix-read cave i (+ j 1)))
(list (cons i (+ j 1)))
'())))))))
(define expected-result
'((_ * _ _ _ _ _ _ _ _ _)
(_ * * * * * * * _ * *)
(_ _ _ * _ _ _ * _ _ _)
(_ * _ * _ * _ * _ * _)
(_ * _ _ _ * _ * _ * _)
(* * _ * * * * * _ * _)
(_ * _ _ _ _ _ _ _ * _)
(_ * _ * _ * * * * * *)
(_ _ _ * _ _ _ _ _ _ _)
(_ * * * * * * * _ * *)
(_ * _ _ _ _ _ _ _ _ _)))
(define (main-mazefun . args)
(run-single-benchmark
"mazefun"
mazefun-iters
(lambda (result)
(equal? result expected-result))
(lambda (n m) (lambda () (make-maze n m)))
11
11))
;;; MBROT -- Generation of Mandelbrot set fractal.
(define (count r i step x y)
(let ((max-count 64)
(radius^2 16.0))
(let ((cr (FLOAT+ r (FLOAT* (exact->inexact x) step)))
(ci (FLOAT+ i (FLOAT* (exact->inexact y) step))))
(let loop ((zr cr)
(zi ci)
(c 0))
(if (= c max-count)
c
(let ((zr^2 (FLOAT* zr zr))
(zi^2 (FLOAT* zi zi)))
(if (FLOAT> (FLOAT+ zr^2 zi^2) radius^2)
c
(let ((new-zr (FLOAT+ (FLOAT- zr^2 zi^2) cr))
(new-zi (FLOAT+ (FLOAT* 2.0 (FLOAT* zr zi)) ci)))
(loop new-zr new-zi (+ c 1))))))))))
(define (mbrot matrix r i step n)
(let loop1 ((y (- n 1)))
(if (>= y 0)
(let loop2 ((x (- n 1)))
(if (>= x 0)
(begin
(vector-set! (vector-ref matrix x) y (count r i step x y))
(loop2 (- x 1)))
(loop1 (- y 1)))))))
(define (mbrot-test n)
(let ((matrix (make-vector n)))
(let loop ((i (- n 1)))
(if (>= i 0)
(begin
(vector-set! matrix i (make-vector n))
(loop (- i 1)))))
(mbrot matrix -1.0 -0.5 0.005 n)
(vector-ref (vector-ref matrix 0) 0)))
(define (main-mbrot . args)
(run-single-benchmark
"mbrot"
mbrot-iters
(lambda (result) (equal? result 5))
(lambda (n) (lambda () (mbrot-test n)))
75))
;; NBODY
;;; The Computer Language Benchmarks Game
;;; http://shootout.alioth.debian.org/
;;;
;;; contributed by Anthony Borla
;;; modified by Graham Fawcett
;;-----------------------------------------------------------------------------
;; use vector to implement body type instead of record for LC
(define (make-body x y z vx vy vz mass) (FLOATvector x y z vx vy vz mass))
(define (body-x body) (FLOATvector-ref body 0))
(define (body-y body) (FLOATvector-ref body 1))
(define (body-z body) (FLOATvector-ref body 2))
(define (body-vx body) (FLOATvector-ref body 3))
(define (body-vy body) (FLOATvector-ref body 4))
(define (body-vz body) (FLOATvector-ref body 5))
(define (body-mass body) (FLOATvector-ref body 6))
(define (body-x-set! body v) (FLOATvector-set! body 0 v))
(define (body-y-set! body v) (FLOATvector-set! body 1 v))
(define (body-z-set! body v) (FLOATvector-set! body 2 v))
(define (body-vx-set! body v) (FLOATvector-set! body 3 v))
(define (body-vy-set! body v) (FLOATvector-set! body 4 v))
(define (body-vz-set! body v) (FLOATvector-set! body 5 v))
(define (body-mass-set! body v) (FLOATvector-set! body 6 v))
;;-----------------------------------------------------------------------------
;; define planetary masses, initial positions & velocity
(define +pi+ 3.141592653589793)
(define +days-per-year+ 365.24)
(define +solar-mass+ (* 4 +pi+ +pi+))
;(define-record body x y z vx vy vz mass)
(define *sun*
(make-body 0.0 0.0 0.0 0.0 0.0 0.0 +solar-mass+))
(define *jupiter*
(make-body 4.84143144246472090
-1.16032004402742839
-1.03622044471123109e-1
(* 1.66007664274403694e-3 +days-per-year+)
(* 7.69901118419740425e-3 +days-per-year+)
(* -6.90460016972063023e-5 +days-per-year+)
(* 9.54791938424326609e-4 +solar-mass+)))
(define *saturn*
(make-body 8.34336671824457987
4.12479856412430479
-4.03523417114321381e-1
(* -2.76742510726862411e-3 +days-per-year+)
(* 4.99852801234917238e-3 +days-per-year+)
(* 2.30417297573763929e-5 +days-per-year+)
(* 2.85885980666130812e-4 +solar-mass+)))
(define *uranus*
(make-body 1.28943695621391310e1
-1.51111514016986312e1
-2.23307578892655734e-1
(* 2.96460137564761618e-03 +days-per-year+)
(* 2.37847173959480950e-03 +days-per-year+)
(* -2.96589568540237556e-05 +days-per-year+)
(* 4.36624404335156298e-05 +solar-mass+)))
(define *neptune*
(make-body 1.53796971148509165e+01
-2.59193146099879641e+01
1.79258772950371181e-01
(* 2.68067772490389322e-03 +days-per-year+)
(* 1.62824170038242295e-03 +days-per-year+)
(* -9.51592254519715870e-05 +days-per-year+)
(* 5.15138902046611451e-05 +solar-mass+)))
;; -------------------------------
(define (offset-momentum system)
(let loop-i ((i system) (px 0.0) (py 0.0) (pz 0.0))
(if (null? i)
(begin
(body-vx-set! (car system) (/ (- px) +solar-mass+))
(body-vy-set! (car system) (/ (- py) +solar-mass+))
(body-vz-set! (car system) (/ (- pz) +solar-mass+)))
(loop-i (cdr i)
(+ px (* (body-vx (car i)) (body-mass (car i))))
(+ py (* (body-vy (car i)) (body-mass (car i))))
(+ pz (* (body-vz (car i)) (body-mass (car i))))))))
;; -------------------------------
(define (energy system)
(let loop-o ((o system) (e 0.0))
(if (null? o)
e
(let ((e (+ e (* 0.5 (body-mass (car o))
(+ (* (body-vx (car o)) (body-vx (car o)))
(* (body-vy (car o)) (body-vy (car o)))
(* (body-vz (car o)) (body-vz (car o))))))))
(let loop-i ((i (cdr o)) (e e))
(if (null? i)
(loop-o (cdr o) e)
(let* ((dx (- (body-x (car o)) (body-x (car i))))
(dy (- (body-y (car o)) (body-y (car i))))
(dz (- (body-z (car o)) (body-z (car i))))
(distance (sqrt (+ (* dx dx) (* dy dy) (* dz dz)))))
(let ((e (- e (/ (* (body-mass (car o)) (body-mass (car i))) distance))))
(loop-i (cdr i) e)))))))))
;; -------------------------------
(define (advance system dt)
(let loop-o ((o system))
(if (not (null? o))
(begin
(let loop-i ((i (cdr o)))
(if (not (null? i))
(let* ((o1 (car o))
(i1 (car i))
(dx (- (body-x o1) (body-x i1)))
(dy (- (body-y o1) (body-y i1)))
(dz (- (body-z o1) (body-z i1)))
(distance (sqrt (+ (* dx dx) (* dy dy) (* dz dz))))
(mag (/ dt (* distance distance distance)))
(dxmag (* dx mag))
(dymag (* dy mag))
(dzmag (* dz mag))
(om (body-mass o1))
(im (body-mass i1)))
(body-vx-set! o1 (- (body-vx o1) (* dxmag im)))
(body-vy-set! o1 (- (body-vy o1) (* dymag im)))
(body-vz-set! o1 (- (body-vz o1) (* dzmag im)))
(body-vx-set! i1 (+ (body-vx i1) (* dxmag om)))
(body-vy-set! i1 (+ (body-vy i1) (* dymag om)))
(body-vz-set! i1 (+ (body-vz i1) (* dzmag om)))
(loop-i (cdr i)))))
(loop-o (cdr o)))))
(let loop-o ((o system))
(if (not (null? o))
(let ((o1 (car o)))
(body-x-set! o1 (+ (body-x o1) (* dt (body-vx o1))))
(body-y-set! o1 (+ (body-y o1) (* dt (body-vy o1))))
(body-z-set! o1 (+ (body-z o1) (* dt (body-vz o1))))
(loop-o (cdr o))))))
;; -------------------------------
(define (run-nbody n)
(let ((system (list *sun* *jupiter* *saturn* *uranus* *neptune*)))
(offset-momentum system)
(let ((before (energy system)))
(do ((i 1 (+ i 1)))
((< n i))
(advance system 0.01))
(let ((after (energy system)))
(cons before after)))))
(define (main-nbody . args)
(run-single-benchmark
"nbody"
nbody-iters
(lambda (result)
(and (< (+ 0.169075164 (car result)) 0.000000001)
(< (+ 0.169086185 (cdr result)) 0.000000001)))
(lambda (data) (lambda () (run-nbody data)))
1000000))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; File: nboyer.sch
; Description: The Boyer benchmark
; Author: Bob Boyer
; Created: 5-Apr-85
; Modified: 10-Apr-85 14:52:20 (Bob Shaw)
; 22-Jul-87 (Will Clinger)
; 2-Jul-88 (Will Clinger -- distinguished #f and the empty list)
; 13-Feb-97 (Will Clinger -- fixed bugs in unifier and rules,
; rewrote to eliminate property lists, and added
; a scaling parameter suggested by Bob Boyer)
; 19-Mar-99 (Will Clinger -- cleaned up comments)
; Language: Scheme
; Status: Public Domain
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; NBOYER -- Logic programming benchmark, originally written by Bob Boyer.
;;; Fairly CONS intensive.
; Note: The version of this benchmark that appears in Dick Gabriel's book
; contained several bugs that are corrected here. These bugs are discussed
; by Henry Baker, "The Boyer Benchmark Meets Linear Logic", ACM SIGPLAN Lisp
; Pointers 6(4), October-December 1993, pages 3-10. The fixed bugs are:
;
; The benchmark now returns a boolean result.
; FALSEP and TRUEP use TERM-MEMBER? rather than MEMV (which is called MEMBER
; in Common Lisp)
; ONE-WAY-UNIFY1 now treats numbers correctly
; ONE-WAY-UNIFY1-LST now treats empty lists correctly
; Rule 19 has been corrected (this rule was not touched by the original
; benchmark, but is used by this version)
; Rules 84 and 101 have been corrected (but these rules are never touched
; by the benchmark)
;
; According to Baker, these bug fixes make the benchmark 10-25% slower.
; Please do not compare the timings from this benchmark against those of
; the original benchmark.
;
; This version of the benchmark also prints the number of rewrites as a sanity
; check, because it is too easy for a buggy version to return the correct
; boolean result. The correct number of rewrites is
;
; n rewrites peak live storage (approximate, in bytes)
; 0 95024 520,000
; 1 591777 2,085,000
; 2 1813975 5,175,000
; 3 5375678
; 4 16445406
; 5 51507739
; Nboyer is a 2-phase benchmark.
; The first phase attaches lemmas to symbols. This phase is not timed,
; but it accounts for very little of the runtime anyway.
; The second phase creates the test problem, and tests to see
; whether it is implied by the lemmas.
(define (main-nboyer . args)
(let ((n (if (null? args) 0 (car args))))
(setup-nboyer)
(run-single-benchmark
(string-append "nboyer"
(number->string n))
nboyer-iters
(lambda (rewrites)
(and (number? rewrites)
(case n
((0) (= rewrites 95024))
((1) (= rewrites 591777))
((2) (= rewrites 1813975))
((3) (= rewrites 5375678))
((4) (= rewrites 16445406))
((5) (= rewrites 51507739))
; If it works for n <= 5, assume it works.
(else #t))))
(lambda (alist term n) (lambda () (test-nboyer alist term n)))
(quote ((x f (plus (plus a b)
(plus c (zero))))
(y f (times (times a b)
(plus c d)))
(z f (reverse (append (append a b)
(nil))))
(u equal (plus a b)
(difference x y))
(w lessp (remainder a b)
(member a (length b)))))
(quote (implies (and (implies x y)
(and (implies y z)
(and (implies z u)
(implies u w))))
(implies x w)))
n)))
(define (setup-nboyer) #t) ; assigned below
(define (test-nboyer) #t) ; assigned below
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; The first phase.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; In the original benchmark, it stored a list of lemmas on the
; property lists of symbols.
; In the new benchmark, it maintains an association list of
; symbols and symbol-records, and stores the list of lemmas
; within the symbol-records.
(let ()
(define (setup)
(add-lemma-lst
(quote ((equal (compile form)
(reverse (codegen (optimize form)
(nil))))
(equal (eqp x y)
(equal (fix x)
(fix y)))
(equal (greaterp x y)
(lessp y x))
(equal (lesseqp x y)
(not (lessp y x)))
(equal (greatereqp x y)
(not (lessp x y)))
(equal (boolean x)
(or (equal x (t))
(equal x (f))))
(equal (iff x y)
(and (implies x y)
(implies y x)))
(equal (even1 x)
(if (zerop x)
(t)
(odd (_1- x))))
(equal (countps- l pred)
(countps-loop l pred (zero)))
(equal (fact- i)
(fact-loop i 1))
(equal (reverse- x)
(reverse-loop x (nil)))
(equal (divides x y)
(zerop (remainder y x)))
(equal (assume-true var alist)
(cons (cons var (t))
alist))
(equal (assume-false var alist)
(cons (cons var (f))
alist))
(equal (tautology-checker x)
(tautologyp (normalize x)
(nil)))
(equal (falsify x)
(falsify1 (normalize x)
(nil)))
(equal (prime x)
(and (not (zerop x))
(not (equal x (add1 (zero))))
(prime1 x (_1- x))))
(equal (and p q)
(if p (if q (t)
(f))
(f)))
(equal (or p q)
(if p (t)
(if q (t)
(f))))
(equal (not p)
(if p (f)
(t)))
(equal (implies p q)
(if p (if q (t)
(f))
(t)))
(equal (fix x)
(if (numberp x)
x
(zero)))
(equal (if (if a b c)
d e)
(if a (if b d e)
(if c d e)))
(equal (zerop x)
(or (equal x (zero))
(not (numberp x))))
(equal (plus (plus x y)
z)
(plus x (plus y z)))
(equal (equal (plus a b)
(zero))
(and (zerop a)
(zerop b)))
(equal (difference x x)
(zero))
(equal (equal (plus a b)
(plus a c))
(equal (fix b)
(fix c)))
(equal (equal (zero)
(difference x y))
(not (lessp y x)))
(equal (equal x (difference x y))
(and (numberp x)
(or (equal x (zero))
(zerop y))))
(equal (meaning (plus-tree (append x y))
a)
(plus (meaning (plus-tree x)
a)
(meaning (plus-tree y)
a)))
(equal (meaning (plus-tree (plus-fringe x))
a)
(fix (meaning x a)))
(equal (append (append x y)
z)
(append x (append y z)))
(equal (reverse (append a b))
(append (reverse b)
(reverse a)))
(equal (times x (plus y z))
(plus (times x y)
(times x z)))
(equal (times (times x y)
z)
(times x (times y z)))
(equal (equal (times x y)
(zero))
(or (zerop x)
(zerop y)))
(equal (exec (append x y)
pds envrn)
(exec y (exec x pds envrn)
envrn))
(equal (mc-flatten x y)
(append (flatten x)
y))
(equal (member x (append a b))
(or (member x a)
(member x b)))
(equal (member x (reverse y))
(member x y))
(equal (length (reverse x))
(length x))
(equal (member a (intersect b c))
(and (member a b)
(member a c)))
(equal (nth (zero)
i)
(zero))
(equal (exp i (plus j k))
(times (exp i j)
(exp i k)))
(equal (exp i (times j k))
(exp (exp i j)
k))
(equal (reverse-loop x y)
(append (reverse x)
y))
(equal (reverse-loop x (nil))
(reverse x))
(equal (count-list z (sort-lp x y))
(plus (count-list z x)
(count-list z y)))
(equal (equal (append a b)
(append a c))
(equal b c))
(equal (plus (remainder x y)
(times y (quotient x y)))
(fix x))
(equal (power-eval (big-plus1 l i base)
base)
(plus (power-eval l base)
i))
(equal (power-eval (big-plus x y i base)
base)
(plus i (plus (power-eval x base)
(power-eval y base))))
(equal (remainder y 1)
(zero))
(equal (lessp (remainder x y)
y)
(not (zerop y)))
(equal (remainder x x)
(zero))
(equal (lessp (quotient i j)
i)
(and (not (zerop i))
(or (zerop j)
(not (equal j 1)))))
(equal (lessp (remainder x y)
x)
(and (not (zerop y))
(not (zerop x))
(not (lessp x y))))
(equal (power-eval (power-rep i base)
base)
(fix i))
(equal (power-eval (big-plus (power-rep i base)
(power-rep j base)
(zero)
base)
base)
(plus i j))
(equal (gcd x y)
(gcd y x))
(equal (nth (append a b)
i)
(append (nth a i)
(nth b (difference i (length a)))))
(equal (difference (plus x y)
x)
(fix y))
(equal (difference (plus y x)
x)
(fix y))
(equal (difference (plus x y)
(plus x z))
(difference y z))
(equal (times x (difference c w))
(difference (times c x)
(times w x)))
(equal (remainder (times x z)
z)
(zero))
(equal (difference (plus b (plus a c))
a)
(plus b c))
(equal (difference (add1 (plus y z))
z)
(add1 y))
(equal (lessp (plus x y)
(plus x z))
(lessp y z))
(equal (lessp (times x z)
(times y z))
(and (not (zerop z))
(lessp x y)))
(equal (lessp y (plus x y))
(not (zerop x)))
(equal (gcd (times x z)
(times y z))
(times z (gcd x y)))
(equal (value (normalize x)
a)
(value x a))
(equal (equal (flatten x)
(cons y (nil)))
(and (nlistp x)
(equal x y)))
(equal (listp (gopher x))
(listp x))
(equal (samefringe x y)
(equal (flatten x)
(flatten y)))
(equal (equal (greatest-factor x y)
(zero))
(and (or (zerop y)
(equal y 1))
(equal x (zero))))
(equal (equal (greatest-factor x y)
1)
(equal x 1))
(equal (numberp (greatest-factor x y))
(not (and (or (zerop y)
(equal y 1))
(not (numberp x)))))
(equal (times-list (append x y))
(times (times-list x)
(times-list y)))
(equal (prime-list (append x y))
(and (prime-list x)
(prime-list y)))
(equal (equal z (times w z))
(and (numberp z)
(or (equal z (zero))
(equal w 1))))
(equal (greatereqp x y)
(not (lessp x y)))
(equal (equal x (times x y))
(or (equal x (zero))
(and (numberp x)
(equal y 1))))
(equal (remainder (times y x)
y)
(zero))
(equal (equal (times a b)
1)
(and (not (equal a (zero)))
(not (equal b (zero)))
(numberp a)
(numberp b)
(equal (_1- a)
(zero))
(equal (_1- b)
(zero))))
(equal (lessp (length (delete x l))
(length l))
(member x l))
(equal (sort2 (delete x l))
(delete x (sort2 l)))
(equal (dsort x)
(sort2 x))
(equal (length (cons x1
(cons x2
(cons x3 (cons x4
(cons x5
(cons x6 x7)))))))
(plus 6 (length x7)))
(equal (difference (add1 (add1 x))
2)
(fix x))
(equal (quotient (plus x (plus x y))
2)
(plus x (quotient y 2)))
(equal (sigma (zero)
i)
(quotient (times i (add1 i))
2))
(equal (plus x (add1 y))
(if (numberp y)
(add1 (plus x y))
(add1 x)))
(equal (equal (difference x y)
(difference z y))
(if (lessp x y)
(not (lessp y z))
(if (lessp z y)
(not (lessp y x))
(equal (fix x)
(fix z)))))
(equal (meaning (plus-tree (delete x y))
a)
(if (member x y)
(difference (meaning (plus-tree y)
a)
(meaning x a))
(meaning (plus-tree y)
a)))
(equal (times x (add1 y))
(if (numberp y)
(plus x (times x y))
(fix x)))
(equal (nth (nil)
i)
(if (zerop i)
(nil)
(zero)))
(equal (last (append a b))
(if (listp b)
(last b)
(if (listp a)
(cons (car (last a))
b)
b)))
(equal (equal (lessp x y)
z)
(if (lessp x y)
(equal (t) z)
(equal (f) z)))
(equal (assignment x (append a b))
(if (assignedp x a)
(assignment x a)
(assignment x b)))
(equal (car (gopher x))
(if (listp x)
(car (flatten x))
(zero)))
(equal (flatten (cdr (gopher x)))
(if (listp x)
(cdr (flatten x))
(cons (zero)
(nil))))
(equal (quotient (times y x)
y)
(if (zerop y)
(zero)
(fix x)))
(equal (get j (set i val mem))
(if (eqp j i)
val
(get j mem)))))))
(define (add-lemma-lst lst)
(cond ((null? lst)
#t)
(else (add-lemma (car lst))
(add-lemma-lst (cdr lst)))))
(define (add-lemma term)
(cond ((and (pair? term)
(eq? (car term)
(quote equal))
(pair? (cadr term)))
(put (car (cadr term))
(quote lemmas)
(cons
(translate-term term)
(get (car (cadr term)) (quote lemmas)))))
(else (fatal-error "ADD-LEMMA did not like term: " term))))
; Translates a term by replacing its constructor symbols by symbol-records.
(define (translate-term term)
(cond ((not (pair? term))
term)
(else (cons (symbol->symbol-record (car term))
(translate-args (cdr term))))))
(define (translate-args lst)
(cond ((null? lst)
'())
(else (cons (translate-term (car lst))
(translate-args (cdr lst))))))
; For debugging only, so the use of MAP does not change
; the first-order character of the benchmark.
(define (untranslate-term term)
(cond ((not (pair? term))
term)
(else (cons (get-name (car term))
(map untranslate-term (cdr term))))))
; A symbol-record is represented as a vector with two fields:
; the symbol (for debugging) and
; the list of lemmas associated with the symbol.
(define (put sym property value)
(put-lemmas! (symbol->symbol-record sym) value))
(define (get sym property)
(get-lemmas (symbol->symbol-record sym)))
(define (symbol->symbol-record sym)
(let ((x (assq sym *symbol-records-alist*)))
(if x
(cdr x)
(let ((r (make-symbol-record sym)))
(set! *symbol-records-alist*
(cons (cons sym r)
*symbol-records-alist*))
r))))
; Association list of symbols and symbol-records.
(define *symbol-records-alist* '())
; A symbol-record is represented as a vector with two fields:
; the symbol (for debugging) and
; the list of lemmas associated with the symbol.
(define (make-symbol-record sym)
(vector sym '()))
(define (put-lemmas! symbol-record lemmas)
(vector-set! symbol-record 1 lemmas))
(define (get-lemmas symbol-record)
(vector-ref symbol-record 1))
(define (get-name symbol-record)
(vector-ref symbol-record 0))
(define (symbol-record-equal? r1 r2)
(eq? r1 r2))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; The second phase.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (test alist term n)
(let ((term
(apply-subst
(translate-alist alist)
(translate-term
(do ((term term (list 'or term '(f)))
(n n (- n 1)))
((zero? n) term))))))
(tautp term)))
(define (translate-alist alist)
(cond ((null? alist)
'())
(else (cons (cons (caar alist)
(translate-term (cdar alist)))
(translate-alist (cdr alist))))))
(define (apply-subst alist term)
(cond ((not (pair? term))
(let ((temp-temp (assq term alist)))
(if temp-temp
(cdr temp-temp)
term)))
(else (cons (car term)
(apply-subst-lst alist (cdr term))))))
(define (apply-subst-lst alist lst)
(cond ((null? lst)
'())
(else (cons (apply-subst alist (car lst))
(apply-subst-lst alist (cdr lst))))))
(define (tautp x)
(tautologyp (rewrite x)
'() '()))
(define (tautologyp x true-lst false-lst)
(cond ((truep x true-lst)
#t)
((falsep x false-lst)
#f)
((not (pair? x))
#f)
((eq? (car x) if-constructor)
(cond ((truep (cadr x)
true-lst)
(tautologyp (caddr x)
true-lst false-lst))
((falsep (cadr x)
false-lst)
(tautologyp (cadddr x)
true-lst false-lst))
(else (and (tautologyp (caddr x)
(cons (cadr x)
true-lst)
false-lst)
(tautologyp (cadddr x)
true-lst
(cons (cadr x)
false-lst))))))
(else #f)))
(define if-constructor '*) ; becomes (symbol->symbol-record 'if)
(define rewrite-count 0) ; sanity check
(define (rewrite term)
(set! rewrite-count (+ rewrite-count 1))
(cond ((not (pair? term))
term)
(else (rewrite-with-lemmas (cons (car term)
(rewrite-args (cdr term)))
(get-lemmas (car term))))))
(define (rewrite-args lst)
(cond ((null? lst)
'())
(else (cons (rewrite (car lst))
(rewrite-args (cdr lst))))))
(define (rewrite-with-lemmas term lst)
(cond ((null? lst)
term)
((one-way-unify term (cadr (car lst)))
(rewrite (apply-subst unify-subst (caddr (car lst)))))
(else (rewrite-with-lemmas term (cdr lst)))))
(define unify-subst '*)
(define (one-way-unify term1 term2)
(begin (set! unify-subst '())
(one-way-unify1 term1 term2)))
(define (one-way-unify1 term1 term2)
(cond ((not (pair? term2))
(let ((temp-temp (assq term2 unify-subst)))
(cond (temp-temp
(term-equal? term1 (cdr temp-temp)))
((number? term2) ; This bug fix makes
(equal? term1 term2)) ; nboyer 10-25% slower!
(else
(set! unify-subst (cons (cons term2 term1)
unify-subst))
#t))))
((not (pair? term1))
#f)
((eq? (car term1)
(car term2))
(one-way-unify1-lst (cdr term1)
(cdr term2)))
(else #f)))
(define (one-way-unify1-lst lst1 lst2)
(cond ((null? lst1)
(null? lst2))
((null? lst2)
#f)
((one-way-unify1 (car lst1)
(car lst2))
(one-way-unify1-lst (cdr lst1)
(cdr lst2)))
(else #f)))
(define (falsep x lst)
(or (term-equal? x false-term)
(term-member? x lst)))
(define (truep x lst)
(or (term-equal? x true-term)
(term-member? x lst)))
(define false-term '*) ; becomes (translate-term '(f))
(define true-term '*) ; becomes (translate-term '(t))
; The next two procedures were in the original benchmark
; but were never used.
(define (trans-of-implies n)
(translate-term
(list (quote implies)
(trans-of-implies1 n)
(list (quote implies)
0 n))))
(define (trans-of-implies1 n)
(cond ((equal? n 1)
(list (quote implies)
0 1))
(else (list (quote and)
(list (quote implies)
(- n 1)
n)
(trans-of-implies1 (- n 1))))))
; Translated terms can be circular structures, which can't be
; compared using Scheme's equal? and member procedures, so we
; use these instead.
(define (term-equal? x y)
(cond ((pair? x)
(and (pair? y)
(symbol-record-equal? (car x) (car y))
(term-args-equal? (cdr x) (cdr y))))
(else (equal? x y))))
(define (term-args-equal? lst1 lst2)
(cond ((null? lst1)
(null? lst2))
((null? lst2)
#f)
((term-equal? (car lst1) (car lst2))
(term-args-equal? (cdr lst1) (cdr lst2)))
(else #f)))
(define (term-member? x lst)
(cond ((null? lst)
#f)
((term-equal? x (car lst))
#t)
(else (term-member? x (cdr lst)))))
(set! setup-nboyer
(lambda ()
(set! *symbol-records-alist* '())
(set! if-constructor (symbol->symbol-record 'if))
(set! false-term (translate-term '(f)))
(set! true-term (translate-term '(t)))
(setup)))
(set! test-nboyer
(lambda (alist term n)
(set! rewrite-count 0)
(let ((answer (test alist term n)))
; (write rewrite-count)
; (display " rewrites")
; (newline)
(if answer
rewrite-count
#f)))))
;;; NQUEENS -- Compute number of solutions to 8-queens problem.
(define trace? #f)
(define (nqueens n)
(define (_1-to n)
(let loop ((i n) (l '()))
(if (= i 0) l (loop (- i 1) (cons i l)))))
(define (my-try x y z)
(if (null? x)
(if (null? y)
(begin (if trace? (begin (write z) (newline))) 1)
0)
(+ (if (ok? (car x) 1 z)
(my-try (append (cdr x) y) '() (cons (car x) z))
0)
(my-try (cdr x) (cons (car x) y) z))))
(define (ok? row dist placed)
(if (null? placed)
#t
(and (not (= (car placed) (+ row dist)))
(not (= (car placed) (- row dist)))
(ok? row (+ dist 1) (cdr placed)))))
(my-try (_1-to n) '() '()))
(define (main-nqueens)
(run-single-benchmark
"nqueens"
nqueens-iters
(lambda (result) (equal? result 92))
(lambda (n) (lambda () (nqueens n)))
8))
;;; NUCLEIC -- 3D structure determination of a nucleic acid.
; Author: Marc Feeley ([email protected])
;
; Last modified: January 27, 1996
;
; This program is a modified version of the program described in the paper:
;
; M. Feeley, M. Turcotte, G. Lapalme, "Using Multilisp for Solving
; Constraint Satisfaction Problems: an Application to Nucleic Acid 3D
; Structure Determination" published in the journal "Lisp and Symbolic
; Computation".
;
; The differences between this program and the original are described in
; the paper:
;
; "???" published in the "Journal of Functional Programming".
; -- MATH UTILITIES -----------------------------------------------------------
(define constant-pi 3.14159265358979323846)
(define constant-minus-pi -3.14159265358979323846)
(define constant-pi/2 1.57079632679489661923)
(define constant-minus-pi/2 -1.57079632679489661923)
(define (math-atan2 y x)
(cond ((FLOAT> x 0.0)
(FLOATatan (FLOAT/ y x)))
((FLOAT< y 0.0)
(if (FLOAT= x 0.0)
constant-minus-pi/2
(FLOAT+ (FLOATatan (FLOAT/ y x)) constant-minus-pi)))
(else
(if (FLOAT= x 0.0)
constant-pi/2
(FLOAT+ (FLOATatan (FLOAT/ y x)) constant-pi)))))
; -- POINTS -------------------------------------------------------------------
(define (make-pt x y z)
(FLOATvector x y z))
(define (pt-x pt) (FLOATvector-ref pt 0))
(define (pt-x-set! pt val) (FLOATvector-set! pt 0 val))
(define (pt-y pt) (FLOATvector-ref pt 1))
(define (pt-y-set! pt val) (FLOATvector-set! pt 1 val))
(define (pt-z pt) (FLOATvector-ref pt 2))
(define (pt-z-set! pt val) (FLOATvector-set! pt 2 val))
(define (pt-sub p1 p2)
(make-pt (FLOAT- (pt-x p1) (pt-x p2))
(FLOAT- (pt-y p1) (pt-y p2))
(FLOAT- (pt-z p1) (pt-z p2))))
(define (pt-dist p1 p2)
(let ((dx (FLOAT- (pt-x p1) (pt-x p2)))
(dy (FLOAT- (pt-y p1) (pt-y p2)))
(dz (FLOAT- (pt-z p1) (pt-z p2))))
(FLOATsqrt (FLOAT+ (FLOAT* dx dx) (FLOAT* dy dy) (FLOAT* dz dz)))))
(define (pt-phi p)
(let* ((x (pt-x p))
(y (pt-y p))
(z (pt-z p))
(b (math-atan2 x z)))
(math-atan2 (FLOAT+ (FLOAT* (FLOATcos b) z) (FLOAT* (FLOATsin b) x)) y)))
(define (pt-theta p)
(math-atan2 (pt-x p) (pt-z p)))
; -- COORDINATE TRANSFORMATIONS -----------------------------------------------
; The notation for the transformations follows "Paul, R.P. (1981) Robot
; Manipulators. MIT Press." with the exception that our transformation
; matrices don't have the perspective terms and are the transpose of
; Paul's one. See also "M\"antyl\"a, M. (1985) An Introduction to
; Solid Modeling, Computer Science Press" Appendix A.
;
; The components of a transformation matrix are named like this:
;
; a b c
; d e f
; g h i
; tx ty tz
;
; The components tx, ty, and tz are the translation vector.
(define (make-tfo a b c d e f g h i tx ty tz)
(FLOATvector a b c d e f g h i tx ty tz))
(define (tfo-a tfo) (FLOATvector-ref tfo 0))
(define (tfo-a-set! tfo val) (FLOATvector-set! tfo 0 val))
(define (tfo-b tfo) (FLOATvector-ref tfo 1))
(define (tfo-b-set! tfo val) (FLOATvector-set! tfo 1 val))
(define (tfo-c tfo) (FLOATvector-ref tfo 2))
(define (tfo-c-set! tfo val) (FLOATvector-set! tfo 2 val))
(define (tfo-d tfo) (FLOATvector-ref tfo 3))
(define (tfo-d-set! tfo val) (FLOATvector-set! tfo 3 val))
(define (tfo-e tfo) (FLOATvector-ref tfo 4))
(define (tfo-e-set! tfo val) (FLOATvector-set! tfo 4 val))
(define (tfo-f tfo) (FLOATvector-ref tfo 5))
(define (tfo-f-set! tfo val) (FLOATvector-set! tfo 5 val))
(define (tfo-g tfo) (FLOATvector-ref tfo 6))
(define (tfo-g-set! tfo val) (FLOATvector-set! tfo 6 val))
(define (tfo-h tfo) (FLOATvector-ref tfo 7))
(define (tfo-h-set! tfo val) (FLOATvector-set! tfo 7 val))
(define (tfo-i tfo) (FLOATvector-ref tfo 8))
(define (tfo-i-set! tfo val) (FLOATvector-set! tfo 8 val))
(define (tfo-tx tfo) (FLOATvector-ref tfo 9))
(define (tfo-tx-set! tfo val) (FLOATvector-set! tfo 9 val))
(define (tfo-ty tfo) (FLOATvector-ref tfo 10))
(define (tfo-ty-set! tfo val) (FLOATvector-set! tfo 10 val))
(define (tfo-tz tfo) (FLOATvector-ref tfo 11))
(define (tfo-tz-set! tfo val) (FLOATvector-set! tfo 11 val))
(define tfo-id ; the identity transformation matrix
(FLOATvector-const
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
0.0 0.0 0.0))
; The function "tfo-apply" multiplies a transformation matrix, tfo, by a
; point vector, p. The result is a new point.
(define (tfo-apply tfo p)
(let ((x (pt-x p))
(y (pt-y p))
(z (pt-z p)))
(make-pt
(FLOAT+ (FLOAT* x (tfo-a tfo))
(FLOAT* y (tfo-d tfo))
(FLOAT* z (tfo-g tfo))
(tfo-tx tfo))
(FLOAT+ (FLOAT* x (tfo-b tfo))
(FLOAT* y (tfo-e tfo))
(FLOAT* z (tfo-h tfo))
(tfo-ty tfo))
(FLOAT+ (FLOAT* x (tfo-c tfo))
(FLOAT* y (tfo-f tfo))
(FLOAT* z (tfo-i tfo))
(tfo-tz tfo)))))
; The function "tfo-combine" multiplies two transformation matrices A and B.
; The result is a new matrix which cumulates the transformations described
; by A and B.
(define (tfo-combine A B)
(make-tfo
(FLOAT+ (FLOAT* (tfo-a A) (tfo-a B))
(FLOAT* (tfo-b A) (tfo-d B))
(FLOAT* (tfo-c A) (tfo-g B)))
(FLOAT+ (FLOAT* (tfo-a A) (tfo-b B))
(FLOAT* (tfo-b A) (tfo-e B))
(FLOAT* (tfo-c A) (tfo-h B)))
(FLOAT+ (FLOAT* (tfo-a A) (tfo-c B))
(FLOAT* (tfo-b A) (tfo-f B))
(FLOAT* (tfo-c A) (tfo-i B)))
(FLOAT+ (FLOAT* (tfo-d A) (tfo-a B))
(FLOAT* (tfo-e A) (tfo-d B))
(FLOAT* (tfo-f A) (tfo-g B)))
(FLOAT+ (FLOAT* (tfo-d A) (tfo-b B))
(FLOAT* (tfo-e A) (tfo-e B))
(FLOAT* (tfo-f A) (tfo-h B)))
(FLOAT+ (FLOAT* (tfo-d A) (tfo-c B))
(FLOAT* (tfo-e A) (tfo-f B))
(FLOAT* (tfo-f A) (tfo-i B)))
(FLOAT+ (FLOAT* (tfo-g A) (tfo-a B))
(FLOAT* (tfo-h A) (tfo-d B))
(FLOAT* (tfo-i A) (tfo-g B)))
(FLOAT+ (FLOAT* (tfo-g A) (tfo-b B))
(FLOAT* (tfo-h A) (tfo-e B))
(FLOAT* (tfo-i A) (tfo-h B)))
(FLOAT+ (FLOAT* (tfo-g A) (tfo-c B))
(FLOAT* (tfo-h A) (tfo-f B))
(FLOAT* (tfo-i A) (tfo-i B)))
(FLOAT+ (FLOAT* (tfo-tx A) (tfo-a B))
(FLOAT* (tfo-ty A) (tfo-d B))
(FLOAT* (tfo-tz A) (tfo-g B))
(tfo-tx B))
(FLOAT+ (FLOAT* (tfo-tx A) (tfo-b B))
(FLOAT* (tfo-ty A) (tfo-e B))
(FLOAT* (tfo-tz A) (tfo-h B))
(tfo-ty B))
(FLOAT+ (FLOAT* (tfo-tx A) (tfo-c B))
(FLOAT* (tfo-ty A) (tfo-f B))
(FLOAT* (tfo-tz A) (tfo-i B))
(tfo-tz B))))
; The function "tfo-inv-ortho" computes the inverse of a homogeneous
; transformation matrix.
(define (tfo-inv-ortho tfo)
(let* ((tx (tfo-tx tfo))
(ty (tfo-ty tfo))
(tz (tfo-tz tfo)))
(make-tfo
(tfo-a tfo) (tfo-d tfo) (tfo-g tfo)
(tfo-b tfo) (tfo-e tfo) (tfo-h tfo)
(tfo-c tfo) (tfo-f tfo) (tfo-i tfo)
(FLOAT- (FLOAT+ (FLOAT* (tfo-a tfo) tx)
(FLOAT* (tfo-b tfo) ty)
(FLOAT* (tfo-c tfo) tz)))
(FLOAT- (FLOAT+ (FLOAT* (tfo-d tfo) tx)
(FLOAT* (tfo-e tfo) ty)
(FLOAT* (tfo-f tfo) tz)))
(FLOAT- (FLOAT+ (FLOAT* (tfo-g tfo) tx)
(FLOAT* (tfo-h tfo) ty)
(FLOAT* (tfo-i tfo) tz))))))
; Given three points p1, p2, and p3, the function "tfo-align" computes
; a transformation matrix such that point p1 gets mapped to (0,0,0), p2 gets
; mapped to the Y axis and p3 gets mapped to the YZ plane.
(define (tfo-align p1 p2 p3)
(let* ((x1 (pt-x p1)) (y1 (pt-y p1)) (z1 (pt-z p1))
(x3 (pt-x p3)) (y3 (pt-y p3)) (z3 (pt-z p3))
(x31 (FLOAT- x3 x1)) (y31 (FLOAT- y3 y1)) (z31 (FLOAT- z3 z1))
(rotpY (pt-sub p2 p1))
(Phi (pt-phi rotpY))
(Theta (pt-theta rotpY))
(sinP (FLOATsin Phi))
(sinT (FLOATsin Theta))
(cosP (FLOATcos Phi))
(cosT (FLOATcos Theta))
(sinPsinT (FLOAT* sinP sinT))
(sinPcosT (FLOAT* sinP cosT))
(cosPsinT (FLOAT* cosP sinT))
(cosPcosT (FLOAT* cosP cosT))
(rotpZ
(make-pt
(FLOAT- (FLOAT* cosT x31)
(FLOAT* sinT z31))
(FLOAT+ (FLOAT* sinPsinT x31)
(FLOAT* cosP y31)
(FLOAT* sinPcosT z31))
(FLOAT+ (FLOAT* cosPsinT x31)
(FLOAT- (FLOAT* sinP y31))
(FLOAT* cosPcosT z31))))
(Rho (pt-theta rotpZ))
(cosR (FLOATcos Rho))
(sinR (FLOATsin Rho))
(x (FLOAT+ (FLOAT- (FLOAT* x1 cosT))
(FLOAT* z1 sinT)))
(y (FLOAT- (FLOAT- (FLOAT- (FLOAT* x1 sinPsinT))
(FLOAT* y1 cosP))
(FLOAT* z1 sinPcosT)))
(z (FLOAT- (FLOAT+ (FLOAT- (FLOAT* x1 cosPsinT))
(FLOAT* y1 sinP))
(FLOAT* z1 cosPcosT))))
(make-tfo
(FLOAT- (FLOAT* cosT cosR) (FLOAT* cosPsinT sinR))
sinPsinT
(FLOAT+ (FLOAT* cosT sinR) (FLOAT* cosPsinT cosR))
(FLOAT* sinP sinR)
cosP
(FLOAT- (FLOAT* sinP cosR))
(FLOAT- (FLOAT- (FLOAT* sinT cosR)) (FLOAT* cosPcosT sinR))
sinPcosT
(FLOAT+ (FLOAT- (FLOAT* sinT sinR)) (FLOAT* cosPcosT cosR))
(FLOAT- (FLOAT* x cosR) (FLOAT* z sinR))
y
(FLOAT+ (FLOAT* x sinR) (FLOAT* z cosR)))))
; -- NUCLEIC ACID CONFORMATIONS DATA BASE -------------------------------------
; Numbering of atoms follows the paper:
;
; IUPAC-IUB Joint Commission on Biochemical Nomenclature (JCBN)
; (1983) Abbreviations and Symbols for the Description of
; Conformations of Polynucleotide Chains. Eur. J. Biochem 131,
; 9-15.
;
; In the atom names, we have used "*" instead of "'".
; Define part common to all 4 nucleotide types.
(define (nuc-dgf-base-tfo nuc) (vector-ref nuc 0))
(define (nuc-dgf-base-tfo-set! nuc val) (vector-set! nuc 0 val))
(define (nuc-P-O3*-275-tfo nuc) (vector-ref nuc 1))
(define (nuc-P-O3*-275-tfo-set! nuc val) (vector-set! nuc 1 val))
(define (nuc-P-O3*-180-tfo nuc) (vector-ref nuc 2))
(define (nuc-P-O3*-180-tfo-set! nuc val) (vector-set! nuc 2 val))
(define (nuc-P-O3*-60-tfo nuc) (vector-ref nuc 3))
(define (nuc-P-O3*-60-tfo-set! nuc val) (vector-set! nuc 3 val))
(define (nuc-P nuc) (vector-ref nuc 4))
(define (nuc-P-set! nuc val) (vector-set! nuc 4 val))
(define (nuc-O1P nuc) (vector-ref nuc 5))
(define (nuc-O1P-set! nuc val) (vector-set! nuc 5 val))
(define (nuc-O2P nuc) (vector-ref nuc 6))
(define (nuc-O2P-set! nuc val) (vector-set! nuc 6 val))
(define (nuc-O5* nuc) (vector-ref nuc 7))
(define (nuc-O5*-set! nuc val) (vector-set! nuc 7 val))
(define (nuc-C5* nuc) (vector-ref nuc 8))
(define (nuc-C5*-set! nuc val) (vector-set! nuc 8 val))
(define (nuc-H5* nuc) (vector-ref nuc 9))
(define (nuc-H5*-set! nuc val) (vector-set! nuc 9 val))
(define (nuc-H5** nuc) (vector-ref nuc 10))
(define (nuc-H5**-set! nuc val) (vector-set! nuc 10 val))
(define (nuc-C4* nuc) (vector-ref nuc 11))
(define (nuc-C4*-set! nuc val) (vector-set! nuc 11 val))
(define (nuc-H4* nuc) (vector-ref nuc 12))
(define (nuc-H4*-set! nuc val) (vector-set! nuc 12 val))
(define (nuc-O4* nuc) (vector-ref nuc 13))
(define (nuc-O4*-set! nuc val) (vector-set! nuc 13 val))
(define (nuc-C1* nuc) (vector-ref nuc 14))
(define (nuc-C1*-set! nuc val) (vector-set! nuc 14 val))
(define (nuc-H1* nuc) (vector-ref nuc 15))
(define (nuc-H1*-set! nuc val) (vector-set! nuc 15 val))
(define (nuc-C2* nuc) (vector-ref nuc 16))
(define (nuc-C2*-set! nuc val) (vector-set! nuc 16 val))
(define (nuc-H2** nuc) (vector-ref nuc 17))
(define (nuc-H2**-set! nuc val) (vector-set! nuc 17 val))
(define (nuc-O2* nuc) (vector-ref nuc 18))
(define (nuc-O2*-set! nuc val) (vector-set! nuc 18 val))
(define (nuc-H2* nuc) (vector-ref nuc 19))
(define (nuc-H2*-set! nuc val) (vector-set! nuc 19 val))
(define (nuc-C3* nuc) (vector-ref nuc 20))
(define (nuc-C3*-set! nuc val) (vector-set! nuc 20 val))
(define (nuc-H3* nuc) (vector-ref nuc 21))
(define (nuc-H3*-set! nuc val) (vector-set! nuc 21 val))
(define (nuc-O3* nuc) (vector-ref nuc 22))
(define (nuc-O3*-set! nuc val) (vector-set! nuc 22 val))
(define (nuc-N1 nuc) (vector-ref nuc 23))
(define (nuc-N1-set! nuc val) (vector-set! nuc 23 val))
(define (nuc-N3 nuc) (vector-ref nuc 24))
(define (nuc-N3-set! nuc val) (vector-set! nuc 24 val))
(define (nuc-C2 nuc) (vector-ref nuc 25))
(define (nuc-C2-set! nuc val) (vector-set! nuc 25 val))
(define (nuc-C4 nuc) (vector-ref nuc 26))
(define (nuc-C4-set! nuc val) (vector-set! nuc 26 val))
(define (nuc-C5 nuc) (vector-ref nuc 27))
(define (nuc-C5-set! nuc val) (vector-set! nuc 27 val))
(define (nuc-C6 nuc) (vector-ref nuc 28))
(define (nuc-C6-set! nuc val) (vector-set! nuc 28 val))
; Define remaining atoms for each nucleotide type.
(define (make-rA dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
N6 N7 N9 C8 H2 H61 H62 H8)
(vector dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
'rA N6 N7 N9 C8 H2 H61 H62 H8))
(define (rA? nuc) (eq? (vector-ref nuc 29) 'rA))
(define (rA-N6 nuc) (vector-ref nuc 30))
(define (rA-N6-set! nuc val) (vector-set! nuc 30 val))
(define (rA-N7 nuc) (vector-ref nuc 31))
(define (rA-N7-set! nuc val) (vector-set! nuc 31 val))
(define (rA-N9 nuc) (vector-ref nuc 32))
(define (rA-N9-set! nuc val) (vector-set! nuc 32 val))
(define (rA-C8 nuc) (vector-ref nuc 33))
(define (rA-C8-set! nuc val) (vector-set! nuc 33 val))
(define (rA-H2 nuc) (vector-ref nuc 34))
(define (rA-H2-set! nuc val) (vector-set! nuc 34 val))
(define (rA-H61 nuc) (vector-ref nuc 35))
(define (rA-H61-set! nuc val) (vector-set! nuc 35 val))
(define (rA-H62 nuc) (vector-ref nuc 36))
(define (rA-H62-set! nuc val) (vector-set! nuc 36 val))
(define (rA-H8 nuc) (vector-ref nuc 37))
(define (rA-H8-set! nuc val) (vector-set! nuc 37 val))
(define (make-rC dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
N4 O2 H41 H42 H5 H6)
(vector dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
'rC N4 O2 H41 H42 H5 H6))
(define (rC? nuc) (eq? (vector-ref nuc 29) 'rC))
(define (rC-N4 nuc) (vector-ref nuc 30))
(define (rC-N4-set! nuc val) (vector-set! nuc 30 val))
(define (rC-O2 nuc) (vector-ref nuc 31))
(define (rC-O2-set! nuc val) (vector-set! nuc 31 val))
(define (rC-H41 nuc) (vector-ref nuc 32))
(define (rC-H41-set! nuc val) (vector-set! nuc 32 val))
(define (rC-H42 nuc) (vector-ref nuc 33))
(define (rC-H42-set! nuc val) (vector-set! nuc 33 val))
(define (rC-H5 nuc) (vector-ref nuc 34))
(define (rC-H5-set! nuc val) (vector-set! nuc 34 val))
(define (rC-H6 nuc) (vector-ref nuc 35))
(define (rC-H6-set! nuc val) (vector-set! nuc 35 val))
(define (make-rG dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
N2 N7 N9 C8 O6 H1 H21 H22 H8)
(vector dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
'rG N2 N7 N9 C8 O6 H1 H21 H22 H8))
(define (rG? nuc) (eq? (vector-ref nuc 29) 'rG))
(define (rG-N2 nuc) (vector-ref nuc 30))
(define (rG-N2-set! nuc val) (vector-set! nuc 30 val))
(define (rG-N7 nuc) (vector-ref nuc 31))
(define (rG-N7-set! nuc val) (vector-set! nuc 31 val))
(define (rG-N9 nuc) (vector-ref nuc 32))
(define (rG-N9-set! nuc val) (vector-set! nuc 32 val))
(define (rG-C8 nuc) (vector-ref nuc 33))
(define (rG-C8-set! nuc val) (vector-set! nuc 33 val))
(define (rG-O6 nuc) (vector-ref nuc 34))
(define (rG-O6-set! nuc val) (vector-set! nuc 34 val))
(define (rG-H1 nuc) (vector-ref nuc 35))
(define (rG-H1-set! nuc val) (vector-set! nuc 35 val))
(define (rG-H21 nuc) (vector-ref nuc 36))
(define (rG-H21-set! nuc val) (vector-set! nuc 36 val))
(define (rG-H22 nuc) (vector-ref nuc 37))
(define (rG-H22-set! nuc val) (vector-set! nuc 37 val))
(define (rG-H8 nuc) (vector-ref nuc 38))
(define (rG-H8-set! nuc val) (vector-set! nuc 38 val))
(define (make-rU dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
O2 O4 H3 H5 H6)
(vector dgf-base-tfo P-O3*-275-tfo P-O3*-180-tfo P-O3*-60-tfo
P O1P O2P O5* C5* H5* H5** C4* H4* O4* C1* H1* C2*
H2** O2* H2* C3* H3* O3* N1 N3 C2 C4 C5 C6
'rU O2 O4 H3 H5 H6))
(define (rU? nuc) (eq? (vector-ref nuc 29) 'rU))
(define (rU-O2 nuc) (vector-ref nuc 30))
(define (rU-O2-set! nuc val) (vector-set! nuc 30 val))
(define (rU-O4 nuc) (vector-ref nuc 31))
(define (rU-O4-set! nuc val) (vector-set! nuc 31 val))
(define (rU-H3 nuc) (vector-ref nuc 32))
(define (rU-H3-set! nuc val) (vector-set! nuc 32 val))
(define (rU-H5 nuc) (vector-ref nuc 33))
(define (rU-H5-set! nuc val) (vector-set! nuc 33 val))
(define (rU-H6 nuc) (vector-ref nuc 34))
(define (rU-H6-set! nuc val) (vector-set! nuc 34 val))
; Database of nucleotide conformations:
(define rA
(nuc-const
#( -0.0018 -0.8207 0.5714 ; dgf-base-tfo
0.2679 -0.5509 -0.7904
0.9634 0.1517 0.2209
0.0073 8.4030 0.6232)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4550 8.2120 -2.8810) ; C5*
#( 5.4546 8.8508 -1.9978) ; H5*
#( 5.7588 8.6625 -3.8259) ; H5**
#( 6.4970 7.1480 -2.5980) ; C4*
#( 7.4896 7.5919 -2.5214) ; H4*
#( 6.1630 6.4860 -1.3440) ; O4*
#( 6.5400 5.1200 -1.4190) ; C1*
#( 7.2763 4.9681 -0.6297) ; H1*
#( 7.1940 4.8830 -2.7770) ; C2*
#( 6.8667 3.9183 -3.1647) ; H2**
#( 8.5860 5.0910 -2.6140) ; O2*
#( 8.9510 4.7626 -1.7890) ; H2*
#( 6.5720 6.0040 -3.6090) ; C3*
#( 5.5636 5.7066 -3.8966) ; H3*
#( 7.3801 6.3562 -4.7350) ; O3*
#( 4.7150 0.4910 -0.1360) ; N1
#( 6.3490 2.1730 -0.6020) ; N3
#( 5.9530 0.9650 -0.2670) ; C2
#( 5.2900 2.9790 -0.8260) ; C4
#( 3.9720 2.6390 -0.7330) ; C5
#( 3.6770 1.3160 -0.3660) ; C6
rA
#( 2.4280 0.8450 -0.2360) ; N6
#( 3.1660 3.7290 -1.0360) ; N7
#( 5.3170 4.2990 -1.1930) ; N9
#( 4.0100 4.6780 -1.2990) ; C8
#( 6.6890 0.1903 -0.0518) ; H2
#( 1.6470 1.4460 -0.4040) ; H61
#( 2.2780 -0.1080 -0.0280) ; H62
#( 3.4421 5.5744 -1.5482) ; H8
))
(define rA01
(nuc-const
#( -0.0043 -0.8175 0.5759 ; dgf-base-tfo
0.2617 -0.5567 -0.7884
0.9651 0.1473 0.2164
0.0359 8.3929 0.5532)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4352 8.2183 -2.7757) ; C5*
#( 5.3830 8.7883 -1.8481) ; H5*
#( 5.7729 8.7436 -3.6691) ; H5**
#( 6.4830 7.1518 -2.5252) ; C4*
#( 7.4749 7.5972 -2.4482) ; H4*
#( 6.1626 6.4620 -1.2827) ; O4*
#( 6.5431 5.0992 -1.3905) ; C1*
#( 7.2871 4.9328 -0.6114) ; H1*
#( 7.1852 4.8935 -2.7592) ; C2*
#( 6.8573 3.9363 -3.1645) ; H2**
#( 8.5780 5.1025 -2.6046) ; O2*
#( 8.9516 4.7577 -1.7902) ; H2*
#( 6.5522 6.0300 -3.5612) ; C3*
#( 5.5420 5.7356 -3.8459) ; H3*
#( 7.3487 6.4089 -4.6867) ; O3*
#( 4.7442 0.4514 -0.1390) ; N1
#( 6.3687 2.1459 -0.5926) ; N3
#( 5.9795 0.9335 -0.2657) ; C2
#( 5.3052 2.9471 -0.8125) ; C4
#( 3.9891 2.5987 -0.7230) ; C5
#( 3.7016 1.2717 -0.3647) ; C6
rA
#( 2.4553 0.7925 -0.2390) ; N6
#( 3.1770 3.6859 -1.0198) ; N7
#( 5.3247 4.2695 -1.1710) ; N9
#( 4.0156 4.6415 -1.2759) ; C8
#( 6.7198 0.1618 -0.0547) ; H2
#( 1.6709 1.3900 -0.4039) ; H61
#( 2.3107 -0.1627 -0.0373) ; H62
#( 3.4426 5.5361 -1.5199) ; H8
))
(define rA02
(nuc-const
#( 0.5566 0.0449 0.8296 ; dgf-base-tfo
0.5125 0.7673 -0.3854
-0.6538 0.6397 0.4041
-9.1161 -3.7679 -2.9968)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.5778 6.6594 -4.0364) ; C5*
#( 4.9220 7.1963 -4.9204) ; H5*
#( 3.7996 5.9091 -4.1764) ; H5**
#( 5.7873 5.8869 -3.5482) ; C4*
#( 6.0405 5.0875 -4.2446) ; H4*
#( 6.9135 6.8036 -3.4310) ; O4*
#( 7.7293 6.4084 -2.3392) ; C1*
#( 8.7078 6.1815 -2.7624) ; H1*
#( 7.1305 5.1418 -1.7347) ; C2*
#( 7.2040 5.1982 -0.6486) ; H2**
#( 7.7417 4.0392 -2.3813) ; O2*
#( 8.6785 4.1443 -2.5630) ; H2*
#( 5.6666 5.2728 -2.1536) ; C3*
#( 5.1747 5.9805 -1.4863) ; H3*
#( 4.9997 4.0086 -2.1973) ; O3*
#( 10.3245 8.5459 1.5467) ; N1
#( 9.8051 6.9432 -0.1497) ; N3
#( 10.5175 7.4328 0.8408) ; C2
#( 8.7523 7.7422 -0.4228) ; C4
#( 8.4257 8.9060 0.2099) ; C5
#( 9.2665 9.3242 1.2540) ; C6
rA
#( 9.0664 10.4462 1.9610) ; N6
#( 7.2750 9.4537 -0.3428) ; N7
#( 7.7962 7.5519 -1.3859) ; N9
#( 6.9479 8.6157 -1.2771) ; C8
#( 11.4063 6.9047 1.1859) ; H2
#( 8.2845 11.0341 1.7552) ; H61
#( 9.6584 10.6647 2.7198) ; H62
#( 6.0430 8.9853 -1.7594) ; H8
))
(define rA03
(nuc-const
#( -0.5021 0.0731 0.8617 ; dgf-base-tfo
-0.8112 0.3054 -0.4986
-0.2996 -0.9494 -0.0940
6.4273 -5.1944 -3.7807)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.1214 6.7116 -1.9049) ; C5*
#( 3.3465 5.9610 -2.0607) ; H5*
#( 4.0789 7.2928 -0.9837) ; H5**
#( 5.4170 5.9293 -1.8186) ; C4*
#( 5.4506 5.3400 -0.9023) ; H4*
#( 5.5067 5.0417 -2.9703) ; O4*
#( 6.8650 4.9152 -3.3612) ; C1*
#( 7.1090 3.8577 -3.2603) ; H1*
#( 7.7152 5.7282 -2.3894) ; C2*
#( 8.5029 6.2356 -2.9463) ; H2**
#( 8.1036 4.8568 -1.3419) ; O2*
#( 8.3270 3.9651 -1.6184) ; H2*
#( 6.7003 6.7565 -1.8911) ; C3*
#( 6.5898 7.5329 -2.6482) ; H3*
#( 7.0505 7.2878 -0.6105) ; O3*
#( 9.6740 4.7656 -7.6614) ; N1
#( 9.0739 4.3013 -5.3941) ; N3
#( 9.8416 4.2192 -6.4581) ; C2
#( 7.9885 5.0632 -5.6446) ; C4
#( 7.6822 5.6856 -6.8194) ; C5
#( 8.5831 5.5215 -7.8840) ; C6
rA
#( 8.4084 6.0747 -9.0933) ; N6
#( 6.4857 6.3816 -6.7035) ; N7
#( 6.9740 5.3703 -4.7760) ; N9
#( 6.1133 6.1613 -5.4808) ; C8
#( 10.7627 3.6375 -6.4220) ; H2
#( 7.6031 6.6390 -9.2733) ; H61
#( 9.1004 5.9708 -9.7893) ; H62
#( 5.1705 6.6830 -5.3167) ; H8
))
(define rA04
(nuc-const
#( -0.5426 -0.8175 0.1929 ; dgf-base-tfo
0.8304 -0.5567 -0.0237
0.1267 0.1473 0.9809
-0.5075 8.3929 0.2229)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4352 8.2183 -2.7757) ; C5*
#( 5.3830 8.7883 -1.8481) ; H5*
#( 5.7729 8.7436 -3.6691) ; H5**
#( 6.4830 7.1518 -2.5252) ; C4*
#( 7.4749 7.5972 -2.4482) ; H4*
#( 6.1626 6.4620 -1.2827) ; O4*
#( 6.5431 5.0992 -1.3905) ; C1*
#( 7.2871 4.9328 -0.6114) ; H1*
#( 7.1852 4.8935 -2.7592) ; C2*
#( 6.8573 3.9363 -3.1645) ; H2**
#( 8.5780 5.1025 -2.6046) ; O2*
#( 8.9516 4.7577 -1.7902) ; H2*
#( 6.5522 6.0300 -3.5612) ; C3*
#( 5.5420 5.7356 -3.8459) ; H3*
#( 7.3487 6.4089 -4.6867) ; O3*
#( 3.6343 2.6680 2.0783) ; N1
#( 5.4505 3.9805 1.2446) ; N3
#( 4.7540 3.3816 2.1851) ; C2
#( 4.8805 3.7951 0.0354) ; C4
#( 3.7416 3.0925 -0.2305) ; C5
#( 3.0873 2.4980 0.8606) ; C6
rA
#( 1.9600 1.7805 0.7462) ; N6
#( 3.4605 3.1184 -1.5906) ; N7
#( 5.3247 4.2695 -1.1710) ; N9
#( 4.4244 3.8244 -2.0953) ; C8
#( 5.0814 3.4352 3.2234) ; H2
#( 1.5423 1.6454 -0.1520) ; H61
#( 1.5716 1.3398 1.5392) ; H62
#( 4.2675 3.8876 -3.1721) ; H8
))
(define rA05
(nuc-const
#( -0.5891 0.0449 0.8068 ; dgf-base-tfo
0.5375 0.7673 0.3498
-0.6034 0.6397 -0.4762
-0.3019 -3.7679 -9.5913)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.5778 6.6594 -4.0364) ; C5*
#( 4.9220 7.1963 -4.9204) ; H5*
#( 3.7996 5.9091 -4.1764) ; H5**
#( 5.7873 5.8869 -3.5482) ; C4*
#( 6.0405 5.0875 -4.2446) ; H4*
#( 6.9135 6.8036 -3.4310) ; O4*
#( 7.7293 6.4084 -2.3392) ; C1*
#( 8.7078 6.1815 -2.7624) ; H1*
#( 7.1305 5.1418 -1.7347) ; C2*
#( 7.2040 5.1982 -0.6486) ; H2**
#( 7.7417 4.0392 -2.3813) ; O2*
#( 8.6785 4.1443 -2.5630) ; H2*
#( 5.6666 5.2728 -2.1536) ; C3*
#( 5.1747 5.9805 -1.4863) ; H3*
#( 4.9997 4.0086 -2.1973) ; O3*
#( 10.2594 10.6774 -1.0056) ; N1
#( 9.7528 8.7080 -2.2631) ; N3
#( 10.4471 9.7876 -1.9791) ; C2
#( 8.7271 8.5575 -1.3991) ; C4
#( 8.4100 9.3803 -0.3580) ; C5
#( 9.2294 10.5030 -0.1574) ; C6
rA
#( 9.0349 11.3951 0.8250) ; N6
#( 7.2891 8.9068 0.3121) ; N7
#( 7.7962 7.5519 -1.3859) ; N9
#( 6.9702 7.8292 -0.3353) ; C8
#( 11.3132 10.0537 -2.5851) ; H2
#( 8.2741 11.2784 1.4629) ; H61
#( 9.6733 12.1368 0.9529) ; H62
#( 6.0888 7.3990 0.1403) ; H8
))
(define rA06
(nuc-const
#( -0.9815 0.0731 -0.1772 ; dgf-base-tfo
0.1912 0.3054 -0.9328
-0.0141 -0.9494 -0.3137
5.7506 -5.1944 4.7470)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.1214 6.7116 -1.9049) ; C5*
#( 3.3465 5.9610 -2.0607) ; H5*
#( 4.0789 7.2928 -0.9837) ; H5**
#( 5.4170 5.9293 -1.8186) ; C4*
#( 5.4506 5.3400 -0.9023) ; H4*
#( 5.5067 5.0417 -2.9703) ; O4*
#( 6.8650 4.9152 -3.3612) ; C1*
#( 7.1090 3.8577 -3.2603) ; H1*
#( 7.7152 5.7282 -2.3894) ; C2*
#( 8.5029 6.2356 -2.9463) ; H2**
#( 8.1036 4.8568 -1.3419) ; O2*
#( 8.3270 3.9651 -1.6184) ; H2*
#( 6.7003 6.7565 -1.8911) ; C3*
#( 6.5898 7.5329 -2.6482) ; H3*
#( 7.0505 7.2878 -0.6105) ; O3*
#( 6.6624 3.5061 -8.2986) ; N1
#( 6.5810 3.2570 -5.9221) ; N3
#( 6.5151 2.8263 -7.1625) ; C2
#( 6.8364 4.5817 -5.8882) ; C4
#( 7.0116 5.4064 -6.9609) ; C5
#( 6.9173 4.8260 -8.2361) ; C6
rA
#( 7.0668 5.5163 -9.3763) ; N6
#( 7.2573 6.7070 -6.5394) ; N7
#( 6.9740 5.3703 -4.7760) ; N9
#( 7.2238 6.6275 -5.2453) ; C8
#( 6.3146 1.7741 -7.3641) ; H2
#( 7.2568 6.4972 -9.3456) ; H61
#( 7.0437 5.0478 -10.2446) ; H62
#( 7.4108 7.6227 -4.8418) ; H8
))
(define rA07
(nuc-const
#( 0.2379 0.1310 -0.9624 ; dgf-base-tfo
-0.5876 -0.7696 -0.2499
-0.7734 0.6249 -0.1061
30.9870 -26.9344 42.6416)
#( 0.7529 0.1548 0.6397 ; P-O3*-275-tfo
0.2952 -0.9481 -0.1180
0.5882 0.2777 -0.7595
-58.8919 -11.3095 6.0866)
#( -0.0239 0.9667 -0.2546 ; P-O3*-180-tfo
0.9731 -0.0359 -0.2275
-0.2290 -0.2532 -0.9399
3.5401 -29.7913 52.2796)
#( -0.8912 -0.4531 0.0242 ; P-O3*-60-tfo
-0.1183 0.1805 -0.9764
0.4380 -0.8730 -0.2145
19.9023 54.8054 15.2799)
#( 41.8210 8.3880 43.5890) ; P
#( 42.5400 8.0450 44.8330) ; O1P
#( 42.2470 9.6920 42.9910) ; O2P
#( 40.2550 8.2030 43.7340) ; O5*
#( 39.3505 8.4697 42.6565) ; C5*
#( 39.1377 7.5433 42.1230) ; H5*
#( 39.7203 9.3119 42.0717) ; H5**
#( 38.0405 8.9195 43.2869) ; C4*
#( 37.3687 9.3036 42.5193) ; H4*
#( 37.4319 7.8146 43.9387) ; O4*
#( 37.1959 8.1354 45.3237) ; C1*
#( 36.1788 8.5202 45.3970) ; H1*
#( 38.1721 9.2328 45.6504) ; C2*
#( 39.1555 8.7939 45.8188) ; H2**
#( 37.7862 10.0617 46.7013) ; O2*
#( 37.3087 9.6229 47.4092) ; H2*
#( 38.1844 10.0268 44.3367) ; C3*
#( 39.1578 10.5054 44.2289) ; H3*
#( 37.0547 10.9127 44.3441) ; O3*
#( 34.8811 4.2072 47.5784) ; N1
#( 35.1084 6.1336 46.1818) ; N3
#( 34.4108 5.1360 46.7207) ; C2
#( 36.3908 6.1224 46.6053) ; C4
#( 36.9819 5.2334 47.4697) ; C5
#( 36.1786 4.1985 48.0035) ; C6
rA
#( 36.6103 3.2749 48.8452) ; N6
#( 38.3236 5.5522 47.6595) ; N7
#( 37.3887 7.0024 46.2437) ; N9
#( 38.5055 6.6096 46.9057) ; C8
#( 33.3553 5.0152 46.4771) ; H2
#( 37.5730 3.2804 49.1507) ; H61
#( 35.9775 2.5638 49.1828) ; H62
#( 39.5461 6.9184 47.0041) ; H8
))
(define rA08
(nuc-const
#( 0.1084 -0.0895 -0.9901 ; dgf-base-tfo
0.9789 -0.1638 0.1220
-0.1731 -0.9824 0.0698
-2.9039 47.2655 33.0094)
#( 0.7529 0.1548 0.6397 ; P-O3*-275-tfo
0.2952 -0.9481 -0.1180
0.5882 0.2777 -0.7595
-58.8919 -11.3095 6.0866)
#( -0.0239 0.9667 -0.2546 ; P-O3*-180-tfo
0.9731 -0.0359 -0.2275
-0.2290 -0.2532 -0.9399
3.5401 -29.7913 52.2796)
#( -0.8912 -0.4531 0.0242 ; P-O3*-60-tfo
-0.1183 0.1805 -0.9764
0.4380 -0.8730 -0.2145
19.9023 54.8054 15.2799)
#( 41.8210 8.3880 43.5890) ; P
#( 42.5400 8.0450 44.8330) ; O1P
#( 42.2470 9.6920 42.9910) ; O2P
#( 40.2550 8.2030 43.7340) ; O5*
#( 39.4850 8.9301 44.6977) ; C5*
#( 39.0638 9.8199 44.2296) ; H5*
#( 40.0757 9.0713 45.6029) ; H5**
#( 38.3102 8.0414 45.0789) ; C4*
#( 37.7842 8.4637 45.9351) ; H4*
#( 37.4200 7.9453 43.9769) ; O4*
#( 37.2249 6.5609 43.6273) ; C1*
#( 36.3360 6.2168 44.1561) ; H1*
#( 38.4347 5.8414 44.1590) ; C2*
#( 39.2688 5.9974 43.4749) ; H2**
#( 38.2344 4.4907 44.4348) ; O2*
#( 37.6374 4.0386 43.8341) ; H2*
#( 38.6926 6.6079 45.4637) ; C3*
#( 39.7585 6.5640 45.6877) ; H3*
#( 37.8238 6.0705 46.4723) ; O3*
#( 33.9162 6.2598 39.7758) ; N1
#( 34.6709 6.5759 42.0215) ; N3
#( 33.7257 6.5186 41.0858) ; C2
#( 35.8935 6.3324 41.5018) ; C4
#( 36.2105 6.0601 40.1932) ; C5
#( 35.1538 6.0151 39.2537) ; C6
rA
#( 35.3088 5.7642 37.9649) ; N6
#( 37.5818 5.8677 40.0507) ; N7
#( 37.0932 6.3197 42.1810) ; N9
#( 38.0509 6.0354 41.2635) ; C8
#( 32.6830 6.6898 41.3532) ; H2
#( 36.2305 5.5855 37.5925) ; H61
#( 34.5056 5.7512 37.3528) ; H62
#( 39.1318 5.8993 41.2285) ; H8
))
(define rA09
(nuc-const
#( 0.8467 0.4166 -0.3311 ; dgf-base-tfo
-0.3962 0.9089 0.1303
0.3552 0.0209 0.9346
-42.7319 -26.6223 -29.8163)
#( 0.7529 0.1548 0.6397 ; P-O3*-275-tfo
0.2952 -0.9481 -0.1180
0.5882 0.2777 -0.7595
-58.8919 -11.3095 6.0866)
#( -0.0239 0.9667 -0.2546 ; P-O3*-180-tfo
0.9731 -0.0359 -0.2275
-0.2290 -0.2532 -0.9399
3.5401 -29.7913 52.2796)
#( -0.8912 -0.4531 0.0242 ; P-O3*-60-tfo
-0.1183 0.1805 -0.9764
0.4380 -0.8730 -0.2145
19.9023 54.8054 15.2799)
#( 41.8210 8.3880 43.5890) ; P
#( 42.5400 8.0450 44.8330) ; O1P
#( 42.2470 9.6920 42.9910) ; O2P
#( 40.2550 8.2030 43.7340) ; O5*
#( 39.3505 8.4697 42.6565) ; C5*
#( 39.1377 7.5433 42.1230) ; H5*
#( 39.7203 9.3119 42.0717) ; H5**
#( 38.0405 8.9195 43.2869) ; C4*
#( 37.6479 8.1347 43.9335) ; H4*
#( 38.2691 10.0933 44.0524) ; O4*
#( 37.3999 11.1488 43.5973) ; C1*
#( 36.5061 11.1221 44.2206) ; H1*
#( 37.0364 10.7838 42.1836) ; C2*
#( 37.8636 11.0489 41.5252) ; H2**
#( 35.8275 11.3133 41.7379) ; O2*
#( 35.6214 12.1896 42.0714) ; H2*
#( 36.9316 9.2556 42.2837) ; C3*
#( 37.1778 8.8260 41.3127) ; H3*
#( 35.6285 8.9334 42.7926) ; O3*
#( 38.1482 15.2833 46.4641) ; N1
#( 37.3641 13.0968 45.9007) ; N3
#( 37.5032 14.1288 46.7300) ; C2
#( 37.9570 13.3377 44.7113) ; C4
#( 38.6397 14.4660 44.3267) ; C5
#( 38.7473 15.5229 45.2609) ; C6
rA
#( 39.3720 16.6649 45.0297) ; N6
#( 39.1079 14.3351 43.0223) ; N7
#( 38.0132 12.4868 43.6280) ; N9
#( 38.7058 13.1402 42.6620) ; C8
#( 37.0731 14.0857 47.7306) ; H2
#( 39.8113 16.8281 44.1350) ; H61
#( 39.4100 17.3741 45.7478) ; H62
#( 39.0412 12.9660 41.6397) ; H8
))
(define rA10
(nuc-const
#( 0.7063 0.6317 -0.3196 ; dgf-base-tfo
-0.0403 -0.4149 -0.9090
-0.7068 0.6549 -0.2676
6.4402 -52.1496 30.8246)
#( 0.7529 0.1548 0.6397 ; P-O3*-275-tfo
0.2952 -0.9481 -0.1180
0.5882 0.2777 -0.7595
-58.8919 -11.3095 6.0866)
#( -0.0239 0.9667 -0.2546 ; P-O3*-180-tfo
0.9731 -0.0359 -0.2275
-0.2290 -0.2532 -0.9399
3.5401 -29.7913 52.2796)
#( -0.8912 -0.4531 0.0242 ; P-O3*-60-tfo
-0.1183 0.1805 -0.9764
0.4380 -0.8730 -0.2145
19.9023 54.8054 15.2799)
#( 41.8210 8.3880 43.5890) ; P
#( 42.5400 8.0450 44.8330) ; O1P
#( 42.2470 9.6920 42.9910) ; O2P
#( 40.2550 8.2030 43.7340) ; O5*
#( 39.4850 8.9301 44.6977) ; C5*
#( 39.0638 9.8199 44.2296) ; H5*
#( 40.0757 9.0713 45.6029) ; H5**
#( 38.3102 8.0414 45.0789) ; C4*
#( 37.7099 7.8166 44.1973) ; H4*
#( 38.8012 6.8321 45.6380) ; O4*
#( 38.2431 6.6413 46.9529) ; C1*
#( 37.3505 6.0262 46.8385) ; H1*
#( 37.8484 8.0156 47.4214) ; C2*
#( 38.7381 8.5406 47.7690) ; H2**
#( 36.8286 8.0368 48.3701) ; O2*
#( 36.8392 7.3063 48.9929) ; H2*
#( 37.3576 8.6512 46.1132) ; C3*
#( 37.5207 9.7275 46.1671) ; H3*
#( 35.9985 8.2392 45.9032) ; O3*
#( 39.9117 2.2278 48.8527) ; N1
#( 38.6207 3.6941 47.4757) ; N3
#( 38.9872 2.4888 47.9057) ; C2
#( 39.2961 4.6720 48.1174) ; C4
#( 40.2546 4.5307 49.0912) ; C5
#( 40.5932 3.2189 49.4985) ; C6
rA
#( 41.4938 2.9317 50.4229) ; N6
#( 40.7195 5.7755 49.5060) ; N7
#( 39.1730 6.0305 47.9170) ; N9
#( 40.0413 6.6250 48.7728) ; C8
#( 38.5257 1.5960 47.4838) ; H2
#( 41.9907 3.6753 50.8921) ; H61
#( 41.6848 1.9687 50.6599) ; H62
#( 40.3571 7.6321 49.0452) ; H8
))
(define rAs
(list rA01 rA02 rA03 rA04 rA05 rA06 rA07 rA08 rA09 rA10))
(define rC
(nuc-const
#( -0.0359 -0.8071 0.5894 ; dgf-base-tfo
-0.2669 0.5761 0.7726
-0.9631 -0.1296 -0.2361
0.1584 8.3434 0.5434)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2430 -8.2420 2.8260) ; C5*
#( 5.1974 -8.8497 1.9223) ; H5*
#( 5.5548 -8.7348 3.7469) ; H5**
#( 6.3140 -7.2060 2.5510) ; C4*
#( 7.2954 -7.6762 2.4898) ; H4*
#( 6.0140 -6.5420 1.2890) ; O4*
#( 6.4190 -5.1840 1.3620) ; C1*
#( 7.1608 -5.0495 0.5747) ; H1*
#( 7.0760 -4.9560 2.7270) ; C2*
#( 6.7770 -3.9803 3.1099) ; H2**
#( 8.4500 -5.1930 2.5810) ; O2*
#( 8.8309 -4.8755 1.7590) ; H2*
#( 6.4060 -6.0590 3.5580) ; C3*
#( 5.4021 -5.7313 3.8281) ; H3*
#( 7.1570 -6.4240 4.7070) ; O3*
#( 5.2170 -4.3260 1.1690) ; N1
#( 4.2960 -2.2560 0.6290) ; N3
#( 5.4330 -3.0200 0.7990) ; C2
#( 2.9930 -2.6780 0.7940) ; C4
#( 2.8670 -4.0630 1.1830) ; C5
#( 3.9570 -4.8300 1.3550) ; C6
rC
#( 2.0187 -1.8047 0.5874) ; N4
#( 6.5470 -2.5560 0.6290) ; O2
#( 1.0684 -2.1236 0.7109) ; H41
#( 2.2344 -0.8560 0.3162) ; H42
#( 1.8797 -4.4972 1.3404) ; H5
#( 3.8479 -5.8742 1.6480) ; H6
))
(define rC01
(nuc-const
#( -0.0137 -0.8012 0.5983 ; dgf-base-tfo
-0.2523 0.5817 0.7733
-0.9675 -0.1404 -0.2101
0.2031 8.3874 0.4228)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2416 -8.2422 2.8181) ; C5*
#( 5.2050 -8.8128 1.8901) ; H5*
#( 5.5368 -8.7738 3.7227) ; H5**
#( 6.3232 -7.2037 2.6002) ; C4*
#( 7.3048 -7.6757 2.5577) ; H4*
#( 6.0635 -6.5092 1.3456) ; O4*
#( 6.4697 -5.1547 1.4629) ; C1*
#( 7.2354 -5.0043 0.7018) ; H1*
#( 7.0856 -4.9610 2.8521) ; C2*
#( 6.7777 -3.9935 3.2487) ; H2**
#( 8.4627 -5.1992 2.7423) ; O2*
#( 8.8693 -4.8638 1.9399) ; H2*
#( 6.3877 -6.0809 3.6362) ; C3*
#( 5.3770 -5.7562 3.8834) ; H3*
#( 7.1024 -6.4754 4.7985) ; O3*
#( 5.2764 -4.2883 1.2538) ; N1
#( 4.3777 -2.2062 0.7229) ; N3
#( 5.5069 -2.9779 0.9088) ; C2
#( 3.0693 -2.6246 0.8500) ; C4
#( 2.9279 -4.0146 1.2149) ; C5
#( 4.0101 -4.7892 1.4017) ; C6
rC
#( 2.1040 -1.7437 0.6331) ; N4
#( 6.6267 -2.5166 0.7728) ; O2
#( 1.1496 -2.0600 0.7287) ; H41
#( 2.3303 -0.7921 0.3815) ; H42
#( 1.9353 -4.4465 1.3419) ; H5
#( 3.8895 -5.8371 1.6762) ; H6
))
(define rC02
(nuc-const
#( 0.5141 0.0246 0.8574 ; dgf-base-tfo
-0.5547 -0.7529 0.3542
0.6542 -0.6577 -0.3734
-9.1111 -3.4598 -3.2939)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 4.3825 -6.6585 4.0489) ; C5*
#( 4.6841 -7.2019 4.9443) ; H5*
#( 3.6189 -5.8889 4.1625) ; H5**
#( 5.6255 -5.9175 3.5998) ; C4*
#( 5.8732 -5.1228 4.3034) ; H4*
#( 6.7337 -6.8605 3.5222) ; O4*
#( 7.5932 -6.4923 2.4548) ; C1*
#( 8.5661 -6.2983 2.9064) ; H1*
#( 7.0527 -5.2012 1.8322) ; C2*
#( 7.1627 -5.2525 0.7490) ; H2**
#( 7.6666 -4.1249 2.4880) ; O2*
#( 8.5944 -4.2543 2.6981) ; H2*
#( 5.5661 -5.3029 2.2009) ; C3*
#( 5.0841 -6.0018 1.5172) ; H3*
#( 4.9062 -4.0452 2.2042) ; O3*
#( 7.6298 -7.6136 1.4752) ; N1
#( 8.6945 -8.7046 -0.2857) ; N3
#( 8.6943 -7.6514 0.6066) ; C2
#( 7.7426 -9.6987 -0.3801) ; C4
#( 6.6642 -9.5742 0.5722) ; C5
#( 6.6391 -8.5592 1.4526) ; C6
rC
#( 7.9033 -10.6371 -1.3010) ; N4
#( 9.5840 -6.8186 0.6136) ; O2
#( 7.2009 -11.3604 -1.3619) ; H41
#( 8.7058 -10.6168 -1.9140) ; H42
#( 5.8585 -10.3083 0.5822) ; H5
#( 5.8197 -8.4773 2.1667) ; H6
))
(define rC03
(nuc-const
#( -0.4993 0.0476 0.8651 ; dgf-base-tfo
0.8078 -0.3353 0.4847
0.3132 0.9409 0.1290
6.2989 -5.2303 -3.8577)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 3.9938 -6.7042 1.9023) ; C5*
#( 3.2332 -5.9343 2.0319) ; H5*
#( 3.9666 -7.2863 0.9812) ; H5**
#( 5.3098 -5.9546 1.8564) ; C4*
#( 5.3863 -5.3702 0.9395) ; H4*
#( 5.3851 -5.0642 3.0076) ; O4*
#( 6.7315 -4.9724 3.4462) ; C1*
#( 7.0033 -3.9202 3.3619) ; H1*
#( 7.5997 -5.8018 2.4948) ; C2*
#( 8.3627 -6.3254 3.0707) ; H2**
#( 8.0410 -4.9501 1.4724) ; O2*
#( 8.2781 -4.0644 1.7570) ; H2*
#( 6.5701 -6.8129 1.9714) ; C3*
#( 6.4186 -7.5809 2.7299) ; H3*
#( 6.9357 -7.3841 0.7235) ; O3*
#( 6.8024 -5.4718 4.8475) ; N1
#( 7.9218 -5.5700 6.8877) ; N3
#( 7.8908 -5.0886 5.5944) ; C2
#( 6.9789 -6.3827 7.4823) ; C4
#( 5.8742 -6.7319 6.6202) ; C5
#( 5.8182 -6.2769 5.3570) ; C6
rC
#( 7.1702 -6.7511 8.7402) ; N4
#( 8.7747 -4.3728 5.1568) ; O2
#( 6.4741 -7.3461 9.1662) ; H41
#( 7.9889 -6.4396 9.2429) ; H42
#( 5.0736 -7.3713 6.9922) ; H5
#( 4.9784 -6.5473 4.7170) ; H6
))
(define rC04
(nuc-const
#( -0.5669 -0.8012 0.1918 ; dgf-base-tfo
-0.8129 0.5817 0.0273
-0.1334 -0.1404 -0.9811
-0.3279 8.3874 0.3355)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2416 -8.2422 2.8181) ; C5*
#( 5.2050 -8.8128 1.8901) ; H5*
#( 5.5368 -8.7738 3.7227) ; H5**
#( 6.3232 -7.2037 2.6002) ; C4*
#( 7.3048 -7.6757 2.5577) ; H4*
#( 6.0635 -6.5092 1.3456) ; O4*
#( 6.4697 -5.1547 1.4629) ; C1*
#( 7.2354 -5.0043 0.7018) ; H1*
#( 7.0856 -4.9610 2.8521) ; C2*
#( 6.7777 -3.9935 3.2487) ; H2**
#( 8.4627 -5.1992 2.7423) ; O2*
#( 8.8693 -4.8638 1.9399) ; H2*
#( 6.3877 -6.0809 3.6362) ; C3*
#( 5.3770 -5.7562 3.8834) ; H3*
#( 7.1024 -6.4754 4.7985) ; O3*
#( 5.2764 -4.2883 1.2538) ; N1
#( 3.8961 -3.0896 -0.1893) ; N3
#( 5.0095 -3.8907 -0.0346) ; C2
#( 3.0480 -2.6632 0.8116) ; C4
#( 3.4093 -3.1310 2.1292) ; C5
#( 4.4878 -3.9124 2.3088) ; C6
rC
#( 2.0216 -1.8941 0.4804) ; N4
#( 5.7005 -4.2164 -0.9842) ; O2
#( 1.4067 -1.5873 1.2205) ; H41
#( 1.8721 -1.6319 -0.4835) ; H42
#( 2.8048 -2.8507 2.9918) ; H5
#( 4.7491 -4.2593 3.3085) ; H6
))
(define rC05
(nuc-const
#( -0.6298 0.0246 0.7763 ; dgf-base-tfo
-0.5226 -0.7529 -0.4001
0.5746 -0.6577 0.4870
-0.0208 -3.4598 -9.6882)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 4.3825 -6.6585 4.0489) ; C5*
#( 4.6841 -7.2019 4.9443) ; H5*
#( 3.6189 -5.8889 4.1625) ; H5**
#( 5.6255 -5.9175 3.5998) ; C4*
#( 5.8732 -5.1228 4.3034) ; H4*
#( 6.7337 -6.8605 3.5222) ; O4*
#( 7.5932 -6.4923 2.4548) ; C1*
#( 8.5661 -6.2983 2.9064) ; H1*
#( 7.0527 -5.2012 1.8322) ; C2*
#( 7.1627 -5.2525 0.7490) ; H2**
#( 7.6666 -4.1249 2.4880) ; O2*
#( 8.5944 -4.2543 2.6981) ; H2*
#( 5.5661 -5.3029 2.2009) ; C3*
#( 5.0841 -6.0018 1.5172) ; H3*
#( 4.9062 -4.0452 2.2042) ; O3*
#( 7.6298 -7.6136 1.4752) ; N1
#( 8.5977 -9.5977 0.7329) ; N3
#( 8.5951 -8.5745 1.6594) ; C2
#( 7.7372 -9.7371 -0.3364) ; C4
#( 6.7596 -8.6801 -0.4476) ; C5
#( 6.7338 -7.6721 0.4408) ; C6
rC
#( 7.8849 -10.7881 -1.1289) ; N4
#( 9.3993 -8.5377 2.5743) ; O2
#( 7.2499 -10.8809 -1.9088) ; H41
#( 8.6122 -11.4649 -0.9468) ; H42
#( 6.0317 -8.6941 -1.2588) ; H5
#( 5.9901 -6.8809 0.3459) ; H6
))
(define rC06
(nuc-const
#( -0.9837 0.0476 -0.1733 ; dgf-base-tfo
-0.1792 -0.3353 0.9249
-0.0141 0.9409 0.3384
5.7793 -5.2303 4.5997)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 3.9938 -6.7042 1.9023) ; C5*
#( 3.2332 -5.9343 2.0319) ; H5*
#( 3.9666 -7.2863 0.9812) ; H5**
#( 5.3098 -5.9546 1.8564) ; C4*
#( 5.3863 -5.3702 0.9395) ; H4*
#( 5.3851 -5.0642 3.0076) ; O4*
#( 6.7315 -4.9724 3.4462) ; C1*
#( 7.0033 -3.9202 3.3619) ; H1*
#( 7.5997 -5.8018 2.4948) ; C2*
#( 8.3627 -6.3254 3.0707) ; H2**
#( 8.0410 -4.9501 1.4724) ; O2*
#( 8.2781 -4.0644 1.7570) ; H2*
#( 6.5701 -6.8129 1.9714) ; C3*
#( 6.4186 -7.5809 2.7299) ; H3*
#( 6.9357 -7.3841 0.7235) ; O3*
#( 6.8024 -5.4718 4.8475) ; N1
#( 6.6920 -5.0495 7.1354) ; N3
#( 6.6201 -4.5500 5.8506) ; C2
#( 6.9254 -6.3614 7.4926) ; C4
#( 7.1046 -7.2543 6.3718) ; C5
#( 7.0391 -6.7951 5.1106) ; C6
rC
#( 6.9614 -6.6648 8.7815) ; N4
#( 6.4083 -3.3696 5.6340) ; O2
#( 7.1329 -7.6280 9.0324) ; H41
#( 6.8204 -5.9469 9.4777) ; H42
#( 7.2954 -8.3135 6.5440) ; H5
#( 7.1753 -7.4798 4.2735) ; H6
))
(define rC07
(nuc-const
#( 0.0033 0.2720 -0.9623 ; dgf-base-tfo
0.3013 -0.9179 -0.2584
-0.9535 -0.2891 -0.0850
43.0403 13.7233 34.5710)
#( 0.9187 0.2887 0.2694 ; P-O3*-275-tfo
0.0302 -0.7316 0.6811
0.3938 -0.6176 -0.6808
-48.4330 26.3254 13.6383)
#( -0.1504 0.7744 -0.6145 ; P-O3*-180-tfo
0.7581 0.4893 0.4311
0.6345 -0.4010 -0.6607
-31.9784 -13.4285 44.9650)
#( -0.6236 -0.7810 -0.0337 ; P-O3*-60-tfo
-0.6890 0.5694 -0.4484
0.3694 -0.2564 -0.8932
12.1105 30.8774 46.0946)
#( 33.3400 11.0980 46.1750) ; P
#( 34.5130 10.2320 46.4660) ; O1P
#( 33.4130 12.3960 46.9340) ; O2P
#( 31.9810 10.3390 46.4820) ; O5*
#( 30.8152 11.1619 46.2003) ; C5*
#( 30.4519 10.9454 45.1957) ; H5*
#( 31.0379 12.2016 46.4400) ; H5**
#( 29.7081 10.7448 47.1428) ; C4*
#( 28.8710 11.4416 47.0982) ; H4*
#( 29.2550 9.4394 46.8162) ; O4*
#( 29.3907 8.5625 47.9460) ; C1*
#( 28.4416 8.5669 48.4819) ; H1*
#( 30.4468 9.2031 48.7952) ; C2*
#( 31.4222 8.9651 48.3709) ; H2**
#( 30.3701 8.9157 50.1624) ; O2*
#( 30.0652 8.0304 50.3740) ; H2*
#( 30.1622 10.6879 48.6120) ; C3*
#( 31.0952 11.2399 48.7254) ; H3*
#( 29.1076 11.1535 49.4702) ; O3*
#( 29.7883 7.2209 47.5235) ; N1
#( 29.1825 5.0438 46.8275) ; N3
#( 28.8008 6.2912 47.2263) ; C2
#( 30.4888 4.6890 46.7186) ; C4
#( 31.5034 5.6405 47.0249) ; C5
#( 31.1091 6.8691 47.4156) ; C6
rC
#( 30.8109 3.4584 46.3336) ; N4
#( 27.6171 6.5989 47.3189) ; O2
#( 31.7923 3.2301 46.2638) ; H41
#( 30.0880 2.7857 46.1215) ; H42
#( 32.5542 5.3634 46.9395) ; H5
#( 31.8523 7.6279 47.6603) ; H6
))
(define rC08
(nuc-const
#( 0.0797 -0.6026 -0.7941 ; dgf-base-tfo
0.7939 0.5201 -0.3150
0.6028 -0.6054 0.5198
-36.8341 41.5293 1.6628)
#( 0.9187 0.2887 0.2694 ; P-O3*-275-tfo
0.0302 -0.7316 0.6811
0.3938 -0.6176 -0.6808
-48.4330 26.3254 13.6383)
#( -0.1504 0.7744 -0.6145 ; P-O3*-180-tfo
0.7581 0.4893 0.4311
0.6345 -0.4010 -0.6607
-31.9784 -13.4285 44.9650)
#( -0.6236 -0.7810 -0.0337 ; P-O3*-60-tfo
-0.6890 0.5694 -0.4484
0.3694 -0.2564 -0.8932
12.1105 30.8774 46.0946)
#( 33.3400 11.0980 46.1750) ; P
#( 34.5130 10.2320 46.4660) ; O1P
#( 33.4130 12.3960 46.9340) ; O2P
#( 31.9810 10.3390 46.4820) ; O5*
#( 31.8779 9.9369 47.8760) ; C5*
#( 31.3239 10.6931 48.4322) ; H5*
#( 32.8647 9.6624 48.2489) ; H5**
#( 31.0429 8.6773 47.9401) ; C4*
#( 31.0779 8.2331 48.9349) ; H4*
#( 29.6956 8.9669 47.5983) ; O4*
#( 29.2784 8.1700 46.4782) ; C1*
#( 28.8006 7.2731 46.8722) ; H1*
#( 30.5544 7.7940 45.7875) ; C2*
#( 30.8837 8.6410 45.1856) ; H2**
#( 30.5100 6.6007 45.0582) ; O2*
#( 29.6694 6.4168 44.6326) ; H2*
#( 31.5146 7.5954 46.9527) ; C3*
#( 32.5255 7.8261 46.6166) ; H3*
#( 31.3876 6.2951 47.5516) ; O3*
#( 28.3976 8.9302 45.5933) ; N1
#( 26.2155 9.6135 44.9910) ; N3
#( 27.0281 8.8961 45.8192) ; C2
#( 26.7044 10.3489 43.9595) ; C4
#( 28.1088 10.3837 43.7247) ; C5
#( 28.8978 9.6708 44.5535) ; C6
rC
#( 25.8715 11.0249 43.1749) ; N4
#( 26.5733 8.2371 46.7484) ; O2
#( 26.2707 11.5609 42.4177) ; H41
#( 24.8760 10.9939 43.3427) ; H42
#( 28.5089 10.9722 42.8990) ; H5
#( 29.9782 9.6687 44.4097) ; H6
))
(define rC09
(nuc-const
#( 0.8727 0.4760 -0.1091 ; dgf-base-tfo
-0.4188 0.6148 -0.6682
-0.2510 0.6289 0.7359
-8.1687 -52.0761 -25.0726)
#( 0.9187 0.2887 0.2694 ; P-O3*-275-tfo
0.0302 -0.7316 0.6811
0.3938 -0.6176 -0.6808
-48.4330 26.3254 13.6383)
#( -0.1504 0.7744 -0.6145 ; P-O3*-180-tfo
0.7581 0.4893 0.4311
0.6345 -0.4010 -0.6607
-31.9784 -13.4285 44.9650)
#( -0.6236 -0.7810 -0.0337 ; P-O3*-60-tfo
-0.6890 0.5694 -0.4484
0.3694 -0.2564 -0.8932
12.1105 30.8774 46.0946)
#( 33.3400 11.0980 46.1750) ; P
#( 34.5130 10.2320 46.4660) ; O1P
#( 33.4130 12.3960 46.9340) ; O2P
#( 31.9810 10.3390 46.4820) ; O5*
#( 30.8152 11.1619 46.2003) ; C5*
#( 30.4519 10.9454 45.1957) ; H5*
#( 31.0379 12.2016 46.4400) ; H5**
#( 29.7081 10.7448 47.1428) ; C4*
#( 29.4506 9.6945 47.0059) ; H4*
#( 30.1045 10.9634 48.4885) ; O4*
#( 29.1794 11.8418 49.1490) ; C1*
#( 28.4388 11.2210 49.6533) ; H1*
#( 28.5211 12.6008 48.0367) ; C2*
#( 29.1947 13.3949 47.7147) ; H2**
#( 27.2316 13.0683 48.3134) ; O2*
#( 27.0851 13.3391 49.2227) ; H2*
#( 28.4131 11.5507 46.9391) ; C3*
#( 28.4451 12.0512 45.9713) ; H3*
#( 27.2707 10.6955 47.1097) ; O3*
#( 29.8751 12.7405 50.0682) ; N1
#( 30.7172 13.1841 52.2328) ; N3
#( 30.0617 12.3404 51.3847) ; C2
#( 31.1834 14.3941 51.8297) ; C4
#( 30.9913 14.8074 50.4803) ; C5
#( 30.3434 13.9610 49.6548) ; C6
rC
#( 31.8090 15.1847 52.6957) ; N4
#( 29.6470 11.2494 51.7616) ; O2
#( 32.1422 16.0774 52.3606) ; H41
#( 31.9392 14.8893 53.6527) ; H42
#( 31.3632 15.7771 50.1491) ; H5
#( 30.1742 14.2374 48.6141) ; H6
))
(define rC10
(nuc-const
#( 0.1549 0.8710 -0.4663 ; dgf-base-tfo
0.6768 -0.4374 -0.5921
-0.7197 -0.2239 -0.6572
25.2447 -14.1920 50.3201)
#( 0.9187 0.2887 0.2694 ; P-O3*-275-tfo
0.0302 -0.7316 0.6811
0.3938 -0.6176 -0.6808
-48.4330 26.3254 13.6383)
#( -0.1504 0.7744 -0.6145 ; P-O3*-180-tfo
0.7581 0.4893 0.4311
0.6345 -0.4010 -0.6607
-31.9784 -13.4285 44.9650)
#( -0.6236 -0.7810 -0.0337 ; P-O3*-60-tfo
-0.6890 0.5694 -0.4484
0.3694 -0.2564 -0.8932
12.1105 30.8774 46.0946)
#( 33.3400 11.0980 46.1750) ; P
#( 34.5130 10.2320 46.4660) ; O1P
#( 33.4130 12.3960 46.9340) ; O2P
#( 31.9810 10.3390 46.4820) ; O5*
#( 31.8779 9.9369 47.8760) ; C5*
#( 31.3239 10.6931 48.4322) ; H5*
#( 32.8647 9.6624 48.2489) ; H5**
#( 31.0429 8.6773 47.9401) ; C4*
#( 30.0440 8.8473 47.5383) ; H4*
#( 31.6749 7.6351 47.2119) ; O4*
#( 31.9159 6.5022 48.0616) ; C1*
#( 31.0691 5.8243 47.9544) ; H1*
#( 31.9300 7.0685 49.4493) ; C2*
#( 32.9024 7.5288 49.6245) ; H2**
#( 31.5672 6.1750 50.4632) ; O2*
#( 31.8416 5.2663 50.3200) ; H2*
#( 30.8618 8.1514 49.3749) ; C3*
#( 31.1122 8.9396 50.0850) ; H3*
#( 29.5351 7.6245 49.5409) ; O3*
#( 33.1890 5.8629 47.7343) ; N1
#( 34.4004 4.2636 46.4828) ; N3
#( 33.2062 4.8497 46.7851) ; C2
#( 35.5600 4.6374 47.0822) ; C4
#( 35.5444 5.6751 48.0577) ; C5
#( 34.3565 6.2450 48.3432) ; C6
rC
#( 36.6977 4.0305 46.7598) ; N4
#( 32.1661 4.5034 46.2348) ; O2
#( 37.5405 4.3347 47.2259) ; H41
#( 36.7033 3.2923 46.0706) ; H42
#( 36.4713 5.9811 48.5428) ; H5
#( 34.2986 7.0426 49.0839) ; H6
))
(define rCs
(list rC01 rC02 rC03 rC04 rC05 rC06 rC07 rC08 rC09 rC10))
(define rG
(nuc-const
#( -0.0018 -0.8207 0.5714 ; dgf-base-tfo
0.2679 -0.5509 -0.7904
0.9634 0.1517 0.2209
0.0073 8.4030 0.6232)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4550 8.2120 -2.8810) ; C5*
#( 5.4546 8.8508 -1.9978) ; H5*
#( 5.7588 8.6625 -3.8259) ; H5**
#( 6.4970 7.1480 -2.5980) ; C4*
#( 7.4896 7.5919 -2.5214) ; H4*
#( 6.1630 6.4860 -1.3440) ; O4*
#( 6.5400 5.1200 -1.4190) ; C1*
#( 7.2763 4.9681 -0.6297) ; H1*
#( 7.1940 4.8830 -2.7770) ; C2*
#( 6.8667 3.9183 -3.1647) ; H2**
#( 8.5860 5.0910 -2.6140) ; O2*
#( 8.9510 4.7626 -1.7890) ; H2*
#( 6.5720 6.0040 -3.6090) ; C3*
#( 5.5636 5.7066 -3.8966) ; H3*
#( 7.3801 6.3562 -4.7350) ; O3*
#( 4.7150 0.4910 -0.1360) ; N1
#( 6.3490 2.1730 -0.6020) ; N3
#( 5.9530 0.9650 -0.2670) ; C2
#( 5.2900 2.9790 -0.8260) ; C4
#( 3.9720 2.6390 -0.7330) ; C5
#( 3.6770 1.3160 -0.3660) ; C6
rG
#( 6.8426 0.0056 -0.0019) ; N2
#( 3.1660 3.7290 -1.0360) ; N7
#( 5.3170 4.2990 -1.1930) ; N9
#( 4.0100 4.6780 -1.2990) ; C8
#( 2.4280 0.8450 -0.2360) ; O6
#( 4.6151 -0.4677 0.1305) ; H1
#( 6.6463 -0.9463 0.2729) ; H21
#( 7.8170 0.2642 -0.0640) ; H22
#( 3.4421 5.5744 -1.5482) ; H8
))
(define rG01
(nuc-const
#( -0.0043 -0.8175 0.5759 ; dgf-base-tfo
0.2617 -0.5567 -0.7884
0.9651 0.1473 0.2164
0.0359 8.3929 0.5532)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4352 8.2183 -2.7757) ; C5*
#( 5.3830 8.7883 -1.8481) ; H5*
#( 5.7729 8.7436 -3.6691) ; H5**
#( 6.4830 7.1518 -2.5252) ; C4*
#( 7.4749 7.5972 -2.4482) ; H4*
#( 6.1626 6.4620 -1.2827) ; O4*
#( 6.5431 5.0992 -1.3905) ; C1*
#( 7.2871 4.9328 -0.6114) ; H1*
#( 7.1852 4.8935 -2.7592) ; C2*
#( 6.8573 3.9363 -3.1645) ; H2**
#( 8.5780 5.1025 -2.6046) ; O2*
#( 8.9516 4.7577 -1.7902) ; H2*
#( 6.5522 6.0300 -3.5612) ; C3*
#( 5.5420 5.7356 -3.8459) ; H3*
#( 7.3487 6.4089 -4.6867) ; O3*
#( 4.7442 0.4514 -0.1390) ; N1
#( 6.3687 2.1459 -0.5926) ; N3
#( 5.9795 0.9335 -0.2657) ; C2
#( 5.3052 2.9471 -0.8125) ; C4
#( 3.9891 2.5987 -0.7230) ; C5
#( 3.7016 1.2717 -0.3647) ; C6
rG
#( 6.8745 -0.0224 -0.0058) ; N2
#( 3.1770 3.6859 -1.0198) ; N7
#( 5.3247 4.2695 -1.1710) ; N9
#( 4.0156 4.6415 -1.2759) ; C8
#( 2.4553 0.7925 -0.2390) ; O6
#( 4.6497 -0.5095 0.1212) ; H1
#( 6.6836 -0.9771 0.2627) ; H21
#( 7.8474 0.2424 -0.0653) ; H22
#( 3.4426 5.5361 -1.5199) ; H8
))
(define rG02
(nuc-const
#( 0.5566 0.0449 0.8296 ; dgf-base-tfo
0.5125 0.7673 -0.3854
-0.6538 0.6397 0.4041
-9.1161 -3.7679 -2.9968)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.5778 6.6594 -4.0364) ; C5*
#( 4.9220 7.1963 -4.9204) ; H5*
#( 3.7996 5.9091 -4.1764) ; H5**
#( 5.7873 5.8869 -3.5482) ; C4*
#( 6.0405 5.0875 -4.2446) ; H4*
#( 6.9135 6.8036 -3.4310) ; O4*
#( 7.7293 6.4084 -2.3392) ; C1*
#( 8.7078 6.1815 -2.7624) ; H1*
#( 7.1305 5.1418 -1.7347) ; C2*
#( 7.2040 5.1982 -0.6486) ; H2**
#( 7.7417 4.0392 -2.3813) ; O2*
#( 8.6785 4.1443 -2.5630) ; H2*
#( 5.6666 5.2728 -2.1536) ; C3*
#( 5.1747 5.9805 -1.4863) ; H3*
#( 4.9997 4.0086 -2.1973) ; O3*
#( 10.3245 8.5459 1.5467) ; N1
#( 9.8051 6.9432 -0.1497) ; N3
#( 10.5175 7.4328 0.8408) ; C2
#( 8.7523 7.7422 -0.4228) ; C4
#( 8.4257 8.9060 0.2099) ; C5
#( 9.2665 9.3242 1.2540) ; C6
rG
#( 11.6077 6.7966 1.2752) ; N2
#( 7.2750 9.4537 -0.3428) ; N7
#( 7.7962 7.5519 -1.3859) ; N9
#( 6.9479 8.6157 -1.2771) ; C8
#( 9.0664 10.4462 1.9610) ; O6
#( 10.9838 8.7524 2.2697) ; H1
#( 12.2274 7.0896 2.0170) ; H21
#( 11.8502 5.9398 0.7984) ; H22
#( 6.0430 8.9853 -1.7594) ; H8
))
(define rG03
(nuc-const
#( -0.5021 0.0731 0.8617 ; dgf-base-tfo
-0.8112 0.3054 -0.4986
-0.2996 -0.9494 -0.0940
6.4273 -5.1944 -3.7807)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.1214 6.7116 -1.9049) ; C5*
#( 3.3465 5.9610 -2.0607) ; H5*
#( 4.0789 7.2928 -0.9837) ; H5**
#( 5.4170 5.9293 -1.8186) ; C4*
#( 5.4506 5.3400 -0.9023) ; H4*
#( 5.5067 5.0417 -2.9703) ; O4*
#( 6.8650 4.9152 -3.3612) ; C1*
#( 7.1090 3.8577 -3.2603) ; H1*
#( 7.7152 5.7282 -2.3894) ; C2*
#( 8.5029 6.2356 -2.9463) ; H2**
#( 8.1036 4.8568 -1.3419) ; O2*
#( 8.3270 3.9651 -1.6184) ; H2*
#( 6.7003 6.7565 -1.8911) ; C3*
#( 6.5898 7.5329 -2.6482) ; H3*
#( 7.0505 7.2878 -0.6105) ; O3*
#( 9.6740 4.7656 -7.6614) ; N1
#( 9.0739 4.3013 -5.3941) ; N3
#( 9.8416 4.2192 -6.4581) ; C2
#( 7.9885 5.0632 -5.6446) ; C4
#( 7.6822 5.6856 -6.8194) ; C5
#( 8.5831 5.5215 -7.8840) ; C6
rG
#( 10.9733 3.5117 -6.4286) ; N2
#( 6.4857 6.3816 -6.7035) ; N7
#( 6.9740 5.3703 -4.7760) ; N9
#( 6.1133 6.1613 -5.4808) ; C8
#( 8.4084 6.0747 -9.0933) ; O6
#( 10.3759 4.5855 -8.3504) ; H1
#( 11.6254 3.3761 -7.1879) ; H21
#( 11.1917 3.0460 -5.5593) ; H22
#( 5.1705 6.6830 -5.3167) ; H8
))
(define rG04
(nuc-const
#( -0.5426 -0.8175 0.1929 ; dgf-base-tfo
0.8304 -0.5567 -0.0237
0.1267 0.1473 0.9809
-0.5075 8.3929 0.2229)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 5.4352 8.2183 -2.7757) ; C5*
#( 5.3830 8.7883 -1.8481) ; H5*
#( 5.7729 8.7436 -3.6691) ; H5**
#( 6.4830 7.1518 -2.5252) ; C4*
#( 7.4749 7.5972 -2.4482) ; H4*
#( 6.1626 6.4620 -1.2827) ; O4*
#( 6.5431 5.0992 -1.3905) ; C1*
#( 7.2871 4.9328 -0.6114) ; H1*
#( 7.1852 4.8935 -2.7592) ; C2*
#( 6.8573 3.9363 -3.1645) ; H2**
#( 8.5780 5.1025 -2.6046) ; O2*
#( 8.9516 4.7577 -1.7902) ; H2*
#( 6.5522 6.0300 -3.5612) ; C3*
#( 5.5420 5.7356 -3.8459) ; H3*
#( 7.3487 6.4089 -4.6867) ; O3*
#( 3.6343 2.6680 2.0783) ; N1
#( 5.4505 3.9805 1.2446) ; N3
#( 4.7540 3.3816 2.1851) ; C2
#( 4.8805 3.7951 0.0354) ; C4
#( 3.7416 3.0925 -0.2305) ; C5
#( 3.0873 2.4980 0.8606) ; C6
rG
#( 5.1433 3.4373 3.4609) ; N2
#( 3.4605 3.1184 -1.5906) ; N7
#( 5.3247 4.2695 -1.1710) ; N9
#( 4.4244 3.8244 -2.0953) ; C8
#( 1.9600 1.7805 0.7462) ; O6
#( 3.2489 2.2879 2.9191) ; H1
#( 4.6785 3.0243 4.2568) ; H21
#( 5.9823 3.9654 3.6539) ; H22
#( 4.2675 3.8876 -3.1721) ; H8
))
(define rG05
(nuc-const
#( -0.5891 0.0449 0.8068 ; dgf-base-tfo
0.5375 0.7673 0.3498
-0.6034 0.6397 -0.4762
-0.3019 -3.7679 -9.5913)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.5778 6.6594 -4.0364) ; C5*
#( 4.9220 7.1963 -4.9204) ; H5*
#( 3.7996 5.9091 -4.1764) ; H5**
#( 5.7873 5.8869 -3.5482) ; C4*
#( 6.0405 5.0875 -4.2446) ; H4*
#( 6.9135 6.8036 -3.4310) ; O4*
#( 7.7293 6.4084 -2.3392) ; C1*
#( 8.7078 6.1815 -2.7624) ; H1*
#( 7.1305 5.1418 -1.7347) ; C2*
#( 7.2040 5.1982 -0.6486) ; H2**
#( 7.7417 4.0392 -2.3813) ; O2*
#( 8.6785 4.1443 -2.5630) ; H2*
#( 5.6666 5.2728 -2.1536) ; C3*
#( 5.1747 5.9805 -1.4863) ; H3*
#( 4.9997 4.0086 -2.1973) ; O3*
#( 10.2594 10.6774 -1.0056) ; N1
#( 9.7528 8.7080 -2.2631) ; N3
#( 10.4471 9.7876 -1.9791) ; C2
#( 8.7271 8.5575 -1.3991) ; C4
#( 8.4100 9.3803 -0.3580) ; C5
#( 9.2294 10.5030 -0.1574) ; C6
rG
#( 11.5110 10.1256 -2.7114) ; N2
#( 7.2891 8.9068 0.3121) ; N7
#( 7.7962 7.5519 -1.3859) ; N9
#( 6.9702 7.8292 -0.3353) ; C8
#( 9.0349 11.3951 0.8250) ; O6
#( 10.9013 11.4422 -0.9512) ; H1
#( 12.1031 10.9341 -2.5861) ; H21
#( 11.7369 9.5180 -3.4859) ; H22
#( 6.0888 7.3990 0.1403) ; H8
))
(define rG06
(nuc-const
#( -0.9815 0.0731 -0.1772 ; dgf-base-tfo
0.1912 0.3054 -0.9328
-0.0141 -0.9494 -0.3137
5.7506 -5.1944 4.7470)
#( -0.8143 -0.5091 -0.2788 ; P-O3*-275-tfo
-0.0433 -0.4257 0.9038
-0.5788 0.7480 0.3246
1.5227 6.9114 -7.0765)
#( 0.3822 -0.7477 0.5430 ; P-O3*-180-tfo
0.4552 0.6637 0.5935
-0.8042 0.0203 0.5941
-6.9472 -4.1186 -5.9108)
#( 0.5640 0.8007 -0.2022 ; P-O3*-60-tfo
-0.8247 0.5587 -0.0878
0.0426 0.2162 0.9754
6.2694 -7.0540 3.3316)
#( 2.8930 8.5380 -3.3280) ; P
#( 1.6980 7.6960 -3.5570) ; O1P
#( 3.2260 9.5010 -4.4020) ; O2P
#( 4.1590 7.6040 -3.0340) ; O5*
#( 4.1214 6.7116 -1.9049) ; C5*
#( 3.3465 5.9610 -2.0607) ; H5*
#( 4.0789 7.2928 -0.9837) ; H5**
#( 5.4170 5.9293 -1.8186) ; C4*
#( 5.4506 5.3400 -0.9023) ; H4*
#( 5.5067 5.0417 -2.9703) ; O4*
#( 6.8650 4.9152 -3.3612) ; C1*
#( 7.1090 3.8577 -3.2603) ; H1*
#( 7.7152 5.7282 -2.3894) ; C2*
#( 8.5029 6.2356 -2.9463) ; H2**
#( 8.1036 4.8568 -1.3419) ; O2*
#( 8.3270 3.9651 -1.6184) ; H2*
#( 6.7003 6.7565 -1.8911) ; C3*
#( 6.5898 7.5329 -2.6482) ; H3*
#( 7.0505 7.2878 -0.6105) ; O3*
#( 6.6624 3.5061 -8.2986) ; N1
#( 6.5810 3.2570 -5.9221) ; N3
#( 6.5151 2.8263 -7.1625) ; C2
#( 6.8364 4.5817 -5.8882) ; C4
#( 7.0116 5.4064 -6.9609) ; C5
#( 6.9173 4.8260 -8.2361) ; C6
rG
#( 6.2717 1.5402 -7.4250) ; N2
#( 7.2573 6.7070 -6.5394) ; N7
#( 6.9740 5.3703 -4.7760) ; N9
#( 7.2238 6.6275 -5.2453) ; C8
#( 7.0668 5.5163 -9.3763) ; O6
#( 6.5754 2.9964 -9.1545) ; H1
#( 6.1908 1.1105 -8.3354) ; H21
#( 6.1346 0.9352 -6.6280) ; H22
#( 7.4108 7.6227 -4.8418) ; H8
))
(define rG07
(nuc-const
#( 0.0894 -0.6059 0.7905 ; dgf-base-tfo
-0.6810 0.5420 0.4924
-0.7268 -0.5824 -0.3642
34.1424 45.9610 -11.8600)
#( -0.8644 -0.4956 -0.0851 ; P-O3*-275-tfo
-0.0427 0.2409 -0.9696
0.5010 -0.8345 -0.2294
4.0167 54.5377 12.4779)
#( 0.3706 -0.6167 0.6945 ; P-O3*-180-tfo
-0.2867 -0.7872 -0.5460
0.8834 0.0032 -0.4686
-52.9020 18.6313 -0.6709)
#( 0.4155 0.9025 -0.1137 ; P-O3*-60-tfo
0.9040 -0.4236 -0.0582
-0.1007 -0.0786 -0.9918
-7.6624 -25.2080 49.5181)
#( 31.3810 0.1400 47.5810) ; P
#( 29.9860 0.6630 47.6290) ; O1P
#( 31.7210 -0.6460 48.8090) ; O2P
#( 32.4940 1.2540 47.2740) ; O5*
#( 33.8709 0.7918 47.2113) ; C5*
#( 34.1386 0.5870 46.1747) ; H5*
#( 34.0186 -0.0095 47.9353) ; H5**
#( 34.7297 1.9687 47.6685) ; C4*
#( 35.7723 1.6845 47.8113) ; H4*
#( 34.6455 2.9768 46.6660) ; O4*
#( 34.1690 4.1829 47.2627) ; C1*
#( 35.0437 4.7633 47.5560) ; H1*
#( 33.4145 3.7532 48.4954) ; C2*
#( 32.4340 3.3797 48.2001) ; H2**
#( 33.3209 4.6953 49.5217) ; O2*
#( 33.2374 5.6059 49.2295) ; H2*
#( 34.2724 2.5970 48.9773) ; C3*
#( 33.6373 1.8935 49.5157) ; H3*
#( 35.3453 3.1884 49.7285) ; O3*
#( 34.0511 7.8930 43.7791) ; N1
#( 34.9937 6.3369 45.3199) ; N3
#( 35.0882 7.3126 44.4200) ; C2
#( 33.7190 5.9650 45.5374) ; C4
#( 32.5845 6.4770 44.9458) ; C5
#( 32.7430 7.5179 43.9914) ; C6
rG
#( 36.3030 7.7827 44.1036) ; N2
#( 31.4499 5.8335 45.4368) ; N7
#( 33.2760 4.9817 46.4043) ; N9
#( 31.9235 4.9639 46.2934) ; C8
#( 31.8602 8.1000 43.3695) ; O6
#( 34.2623 8.6223 43.1283) ; H1
#( 36.5188 8.5081 43.4347) ; H21
#( 37.0888 7.3524 44.5699) ; H22
#( 31.0815 4.4201 46.7218) ; H8
))
(define rG08
(nuc-const
#( 0.2224 0.6335 0.7411 ; dgf-base-tfo
-0.3644 -0.6510 0.6659
0.9043 -0.4181 0.0861
-47.6824 -0.5823 -31.7554)
#( -0.8644 -0.4956 -0.0851 ; P-O3*-275-tfo
-0.0427 0.2409 -0.9696
0.5010 -0.8345 -0.2294
4.0167 54.5377 12.4779)
#( 0.3706 -0.6167 0.6945 ; P-O3*-180-tfo
-0.2867 -0.7872 -0.5460
0.8834 0.0032 -0.4686
-52.9020 18.6313 -0.6709)
#( 0.4155 0.9025 -0.1137 ; P-O3*-60-tfo
0.9040 -0.4236 -0.0582
-0.1007 -0.0786 -0.9918
-7.6624 -25.2080 49.5181)
#( 31.3810 0.1400 47.5810) ; P
#( 29.9860 0.6630 47.6290) ; O1P
#( 31.7210 -0.6460 48.8090) ; O2P
#( 32.4940 1.2540 47.2740) ; O5*
#( 32.5924 2.3488 48.2255) ; C5*
#( 33.3674 2.1246 48.9584) ; H5*
#( 31.5994 2.5917 48.6037) ; H5**
#( 33.0722 3.5577 47.4258) ; C4*
#( 33.0310 4.4778 48.0089) ; H4*
#( 34.4173 3.3055 47.0316) ; O4*
#( 34.5056 3.3910 45.6094) ; C1*
#( 34.7881 4.4152 45.3663) ; H1*
#( 33.1122 3.1198 45.1010) ; C2*
#( 32.9230 2.0469 45.1369) ; H2**
#( 32.7946 3.6590 43.8529) ; O2*
#( 33.5170 3.6707 43.2207) ; H2*
#( 32.2730 3.8173 46.1566) ; C3*
#( 31.3094 3.3123 46.2244) ; H3*
#( 32.2391 5.2039 45.7807) ; O3*
#( 39.3337 2.7157 44.1441) ; N1
#( 37.4430 3.8242 45.0824) ; N3
#( 38.7276 3.7646 44.7403) ; C2
#( 36.7791 2.6963 44.7704) ; C4
#( 37.2860 1.5653 44.1678) ; C5
#( 38.6647 1.5552 43.8235) ; C6
rG
#( 39.5123 4.8216 44.9936) ; N2
#( 36.2829 0.6110 44.0078) ; N7
#( 35.4394 2.4314 44.9931) ; N9
#( 35.2180 1.1815 44.5128) ; C8
#( 39.2907 0.6514 43.2796) ; O6
#( 40.3076 2.8048 43.9352) ; H1
#( 40.4994 4.9066 44.7977) ; H21
#( 39.0738 5.6108 45.4464) ; H22
#( 34.3856 0.4842 44.4185) ; H8
))
(define rG09
(nuc-const
#( -0.9699 -0.1688 -0.1753 ; dgf-base-tfo
-0.1050 -0.3598 0.9271
-0.2196 0.9176 0.3312
45.6217 -38.9484 -12.3208)
#( -0.8644 -0.4956 -0.0851 ; P-O3*-275-tfo
-0.0427 0.2409 -0.9696
0.5010 -0.8345 -0.2294
4.0167 54.5377 12.4779)
#( 0.3706 -0.6167 0.6945 ; P-O3*-180-tfo
-0.2867 -0.7872 -0.5460
0.8834 0.0032 -0.4686
-52.9020 18.6313 -0.6709)
#( 0.4155 0.9025 -0.1137 ; P-O3*-60-tfo
0.9040 -0.4236 -0.0582
-0.1007 -0.0786 -0.9918
-7.6624 -25.2080 49.5181)
#( 31.3810 0.1400 47.5810) ; P
#( 29.9860 0.6630 47.6290) ; O1P
#( 31.7210 -0.6460 48.8090) ; O2P
#( 32.4940 1.2540 47.2740) ; O5*
#( 33.8709 0.7918 47.2113) ; C5*
#( 34.1386 0.5870 46.1747) ; H5*
#( 34.0186 -0.0095 47.9353) ; H5**
#( 34.7297 1.9687 47.6685) ; C4*
#( 34.5880 2.8482 47.0404) ; H4*
#( 34.3575 2.2770 49.0081) ; O4*
#( 35.5157 2.1993 49.8389) ; C1*
#( 35.9424 3.2010 49.8893) ; H1*
#( 36.4701 1.2820 49.1169) ; C2*
#( 36.1545 0.2498 49.2683) ; H2**
#( 37.8262 1.4547 49.4008) ; O2*
#( 38.0227 1.6945 50.3094) ; H2*
#( 36.2242 1.6797 47.6725) ; C3*
#( 36.4297 0.8197 47.0351) ; H3*
#( 37.0289 2.8480 47.4426) ; O3*
#( 34.3005 3.5042 54.6070) ; N1
#( 34.7693 3.7936 52.2874) ; N3
#( 34.4484 4.2541 53.4939) ; C2
#( 34.9354 2.4584 52.2785) ; C4
#( 34.8092 1.5915 53.3422) ; C5
#( 34.4646 2.1367 54.6085) ; C6
rG
#( 34.2514 5.5708 53.6503) ; N2
#( 35.0641 0.2835 52.9337) ; N7
#( 35.2669 1.6690 51.1915) ; N9
#( 35.3288 0.3954 51.6563) ; C8
#( 34.3151 1.5317 55.6650) ; O6
#( 34.0623 3.9797 55.4539) ; H1
#( 33.9950 6.0502 54.5016) ; H21
#( 34.3512 6.1432 52.8242) ; H22
#( 35.5414 -0.6006 51.2679) ; H8
))
(define rG10
(nuc-const
#( -0.0980 -0.9723 0.2122 ; dgf-base-tfo
-0.9731 0.1383 0.1841
-0.2083 -0.1885 -0.9597
17.8469 38.8265 37.0475)
#( -0.8644 -0.4956 -0.0851 ; P-O3*-275-tfo
-0.0427 0.2409 -0.9696
0.5010 -0.8345 -0.2294
4.0167 54.5377 12.4779)
#( 0.3706 -0.6167 0.6945 ; P-O3*-180-tfo
-0.2867 -0.7872 -0.5460
0.8834 0.0032 -0.4686
-52.9020 18.6313 -0.6709)
#( 0.4155 0.9025 -0.1137 ; P-O3*-60-tfo
0.9040 -0.4236 -0.0582
-0.1007 -0.0786 -0.9918
-7.6624 -25.2080 49.5181)
#( 31.3810 0.1400 47.5810) ; P
#( 29.9860 0.6630 47.6290) ; O1P
#( 31.7210 -0.6460 48.8090) ; O2P
#( 32.4940 1.2540 47.2740) ; O5*
#( 32.5924 2.3488 48.2255) ; C5*
#( 33.3674 2.1246 48.9584) ; H5*
#( 31.5994 2.5917 48.6037) ; H5**
#( 33.0722 3.5577 47.4258) ; C4*
#( 34.0333 3.3761 46.9447) ; H4*
#( 32.0890 3.8338 46.4332) ; O4*
#( 31.6377 5.1787 46.5914) ; C1*
#( 32.2499 5.8016 45.9392) ; H1*
#( 31.9167 5.5319 48.0305) ; C2*
#( 31.1507 5.0820 48.6621) ; H2**
#( 32.0865 6.8890 48.3114) ; O2*
#( 31.5363 7.4819 47.7942) ; H2*
#( 33.2398 4.8224 48.2563) ; C3*
#( 33.3166 4.5570 49.3108) ; H3*
#( 34.2528 5.7056 47.7476) ; O3*
#( 28.2782 6.3049 42.9364) ; N1
#( 30.4001 5.8547 43.9258) ; N3
#( 29.6195 6.1568 42.8913) ; C2
#( 29.7005 5.7006 45.0649) ; C4
#( 28.3383 5.8221 45.2343) ; C5
#( 27.5519 6.1461 44.0958) ; C6
rG
#( 30.1838 6.3385 41.6890) ; N2
#( 27.9936 5.5926 46.5651) ; N7
#( 30.2046 5.3825 46.3136) ; N9
#( 29.1371 5.3398 47.1506) ; C8
#( 26.3361 6.3024 44.0495) ; O6
#( 27.8122 6.5394 42.0833) ; H1
#( 29.7125 6.5595 40.8235) ; H21
#( 31.1859 6.2231 41.6389) ; H22
#( 28.9406 5.1504 48.2059) ; H8
))
(define rGs
(list rG01 rG02 rG03 rG04 rG05 rG06 rG07 rG08 rG09 rG10))
(define rU
(nuc-const
#( -0.0359 -0.8071 0.5894 ; dgf-base-tfo
-0.2669 0.5761 0.7726
-0.9631 -0.1296 -0.2361
0.1584 8.3434 0.5434)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2430 -8.2420 2.8260) ; C5*
#( 5.1974 -8.8497 1.9223) ; H5*
#( 5.5548 -8.7348 3.7469) ; H5**
#( 6.3140 -7.2060 2.5510) ; C4*
#( 7.2954 -7.6762 2.4898) ; H4*
#( 6.0140 -6.5420 1.2890) ; O4*
#( 6.4190 -5.1840 1.3620) ; C1*
#( 7.1608 -5.0495 0.5747) ; H1*
#( 7.0760 -4.9560 2.7270) ; C2*
#( 6.7770 -3.9803 3.1099) ; H2**
#( 8.4500 -5.1930 2.5810) ; O2*
#( 8.8309 -4.8755 1.7590) ; H2*
#( 6.4060 -6.0590 3.5580) ; C3*
#( 5.4021 -5.7313 3.8281) ; H3*
#( 7.1570 -6.4240 4.7070) ; O3*
#( 5.2170 -4.3260 1.1690) ; N1
#( 4.2960 -2.2560 0.6290) ; N3
#( 5.4330 -3.0200 0.7990) ; C2
#( 2.9930 -2.6780 0.7940) ; C4
#( 2.8670 -4.0630 1.1830) ; C5
#( 3.9570 -4.8300 1.3550) ; C6
rU
#( 6.5470 -2.5560 0.6290) ; O2
#( 2.0540 -1.9000 0.6130) ; O4
#( 4.4300 -1.3020 0.3600) ; H3
#( 1.9590 -4.4570 1.3250) ; H5
#( 3.8460 -5.7860 1.6240) ; H6
))
(define rU01
(nuc-const
#( -0.0137 -0.8012 0.5983 ; dgf-base-tfo
-0.2523 0.5817 0.7733
-0.9675 -0.1404 -0.2101
0.2031 8.3874 0.4228)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2416 -8.2422 2.8181) ; C5*
#( 5.2050 -8.8128 1.8901) ; H5*
#( 5.5368 -8.7738 3.7227) ; H5**
#( 6.3232 -7.2037 2.6002) ; C4*
#( 7.3048 -7.6757 2.5577) ; H4*
#( 6.0635 -6.5092 1.3456) ; O4*
#( 6.4697 -5.1547 1.4629) ; C1*
#( 7.2354 -5.0043 0.7018) ; H1*
#( 7.0856 -4.9610 2.8521) ; C2*
#( 6.7777 -3.9935 3.2487) ; H2**
#( 8.4627 -5.1992 2.7423) ; O2*
#( 8.8693 -4.8638 1.9399) ; H2*
#( 6.3877 -6.0809 3.6362) ; C3*
#( 5.3770 -5.7562 3.8834) ; H3*
#( 7.1024 -6.4754 4.7985) ; O3*
#( 5.2764 -4.2883 1.2538) ; N1
#( 4.3777 -2.2062 0.7229) ; N3
#( 5.5069 -2.9779 0.9088) ; C2
#( 3.0693 -2.6246 0.8500) ; C4
#( 2.9279 -4.0146 1.2149) ; C5
#( 4.0101 -4.7892 1.4017) ; C6
rU
#( 6.6267 -2.5166 0.7728) ; O2
#( 2.1383 -1.8396 0.6581) ; O4
#( 4.5223 -1.2489 0.4716) ; H3
#( 2.0151 -4.4065 1.3290) ; H5
#( 3.8886 -5.7486 1.6535) ; H6
))
(define rU02
(nuc-const
#( 0.5141 0.0246 0.8574 ; dgf-base-tfo
-0.5547 -0.7529 0.3542
0.6542 -0.6577 -0.3734
-9.1111 -3.4598 -3.2939)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 4.3825 -6.6585 4.0489) ; C5*
#( 4.6841 -7.2019 4.9443) ; H5*
#( 3.6189 -5.8889 4.1625) ; H5**
#( 5.6255 -5.9175 3.5998) ; C4*
#( 5.8732 -5.1228 4.3034) ; H4*
#( 6.7337 -6.8605 3.5222) ; O4*
#( 7.5932 -6.4923 2.4548) ; C1*
#( 8.5661 -6.2983 2.9064) ; H1*
#( 7.0527 -5.2012 1.8322) ; C2*
#( 7.1627 -5.2525 0.7490) ; H2**
#( 7.6666 -4.1249 2.4880) ; O2*
#( 8.5944 -4.2543 2.6981) ; H2*
#( 5.5661 -5.3029 2.2009) ; C3*
#( 5.0841 -6.0018 1.5172) ; H3*
#( 4.9062 -4.0452 2.2042) ; O3*
#( 7.6298 -7.6136 1.4752) ; N1
#( 8.6945 -8.7046 -0.2857) ; N3
#( 8.6943 -7.6514 0.6066) ; C2
#( 7.7426 -9.6987 -0.3801) ; C4
#( 6.6642 -9.5742 0.5722) ; C5
#( 6.6391 -8.5592 1.4526) ; C6
rU
#( 9.5840 -6.8186 0.6136) ; O2
#( 7.8505 -10.5925 -1.2223) ; O4
#( 9.4601 -8.7514 -0.9277) ; H3
#( 5.9281 -10.2509 0.5782) ; H5
#( 5.8831 -8.4931 2.1028) ; H6
))
(define rU03
(nuc-const
#( -0.4993 0.0476 0.8651 ; dgf-base-tfo
0.8078 -0.3353 0.4847
0.3132 0.9409 0.1290
6.2989 -5.2303 -3.8577)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 3.9938 -6.7042 1.9023) ; C5*
#( 3.2332 -5.9343 2.0319) ; H5*
#( 3.9666 -7.2863 0.9812) ; H5**
#( 5.3098 -5.9546 1.8564) ; C4*
#( 5.3863 -5.3702 0.9395) ; H4*
#( 5.3851 -5.0642 3.0076) ; O4*
#( 6.7315 -4.9724 3.4462) ; C1*
#( 7.0033 -3.9202 3.3619) ; H1*
#( 7.5997 -5.8018 2.4948) ; C2*
#( 8.3627 -6.3254 3.0707) ; H2**
#( 8.0410 -4.9501 1.4724) ; O2*
#( 8.2781 -4.0644 1.7570) ; H2*
#( 6.5701 -6.8129 1.9714) ; C3*
#( 6.4186 -7.5809 2.7299) ; H3*
#( 6.9357 -7.3841 0.7235) ; O3*
#( 6.8024 -5.4718 4.8475) ; N1
#( 7.9218 -5.5700 6.8877) ; N3
#( 7.8908 -5.0886 5.5944) ; C2
#( 6.9789 -6.3827 7.4823) ; C4
#( 5.8742 -6.7319 6.6202) ; C5
#( 5.8182 -6.2769 5.3570) ; C6
rU
#( 8.7747 -4.3728 5.1568) ; O2
#( 7.1154 -6.7509 8.6509) ; O4
#( 8.7055 -5.3037 7.4491) ; H3
#( 5.1416 -7.3178 6.9665) ; H5
#( 5.0441 -6.5310 4.7784) ; H6
))
(define rU04
(nuc-const
#( -0.5669 -0.8012 0.1918 ; dgf-base-tfo
-0.8129 0.5817 0.0273
-0.1334 -0.1404 -0.9811
-0.3279 8.3874 0.3355)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2416 -8.2422 2.8181) ; C5*
#( 5.2050 -8.8128 1.8901) ; H5*
#( 5.5368 -8.7738 3.7227) ; H5**
#( 6.3232 -7.2037 2.6002) ; C4*
#( 7.3048 -7.6757 2.5577) ; H4*
#( 6.0635 -6.5092 1.3456) ; O4*
#( 6.4697 -5.1547 1.4629) ; C1*
#( 7.2354 -5.0043 0.7018) ; H1*
#( 7.0856 -4.9610 2.8521) ; C2*
#( 6.7777 -3.9935 3.2487) ; H2**
#( 8.4627 -5.1992 2.7423) ; O2*
#( 8.8693 -4.8638 1.9399) ; H2*
#( 6.3877 -6.0809 3.6362) ; C3*
#( 5.3770 -5.7562 3.8834) ; H3*
#( 7.1024 -6.4754 4.7985) ; O3*
#( 5.2764 -4.2883 1.2538) ; N1
#( 3.8961 -3.0896 -0.1893) ; N3
#( 5.0095 -3.8907 -0.0346) ; C2
#( 3.0480 -2.6632 0.8116) ; C4
#( 3.4093 -3.1310 2.1292) ; C5
#( 4.4878 -3.9124 2.3088) ; C6
rU
#( 5.7005 -4.2164 -0.9842) ; O2
#( 2.0800 -1.9458 0.5503) ; O4
#( 3.6834 -2.7882 -1.1190) ; H3
#( 2.8508 -2.8721 2.9172) ; H5
#( 4.7188 -4.2247 3.2295) ; H6
))
(define rU05
(nuc-const
#( -0.6298 0.0246 0.7763 ; dgf-base-tfo
-0.5226 -0.7529 -0.4001
0.5746 -0.6577 0.4870
-0.0208 -3.4598 -9.6882)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 4.3825 -6.6585 4.0489) ; C5*
#( 4.6841 -7.2019 4.9443) ; H5*
#( 3.6189 -5.8889 4.1625) ; H5**
#( 5.6255 -5.9175 3.5998) ; C4*
#( 5.8732 -5.1228 4.3034) ; H4*
#( 6.7337 -6.8605 3.5222) ; O4*
#( 7.5932 -6.4923 2.4548) ; C1*
#( 8.5661 -6.2983 2.9064) ; H1*
#( 7.0527 -5.2012 1.8322) ; C2*
#( 7.1627 -5.2525 0.7490) ; H2**
#( 7.6666 -4.1249 2.4880) ; O2*
#( 8.5944 -4.2543 2.6981) ; H2*
#( 5.5661 -5.3029 2.2009) ; C3*
#( 5.0841 -6.0018 1.5172) ; H3*
#( 4.9062 -4.0452 2.2042) ; O3*
#( 7.6298 -7.6136 1.4752) ; N1
#( 8.5977 -9.5977 0.7329) ; N3
#( 8.5951 -8.5745 1.6594) ; C2
#( 7.7372 -9.7371 -0.3364) ; C4
#( 6.7596 -8.6801 -0.4476) ; C5
#( 6.7338 -7.6721 0.4408) ; C6
rU
#( 9.3993 -8.5377 2.5743) ; O2
#( 7.8374 -10.6990 -1.1008) ; O4
#( 9.2924 -10.3081 0.8477) ; H3
#( 6.0932 -8.6982 -1.1929) ; H5
#( 6.0481 -6.9515 0.3446) ; H6
))
(define rU06
(nuc-const
#( -0.9837 0.0476 -0.1733 ; dgf-base-tfo
-0.1792 -0.3353 0.9249
-0.0141 0.9409 0.3384
5.7793 -5.2303 4.5997)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 3.9938 -6.7042 1.9023) ; C5*
#( 3.2332 -5.9343 2.0319) ; H5*
#( 3.9666 -7.2863 0.9812) ; H5**
#( 5.3098 -5.9546 1.8564) ; C4*
#( 5.3863 -5.3702 0.9395) ; H4*
#( 5.3851 -5.0642 3.0076) ; O4*
#( 6.7315 -4.9724 3.4462) ; C1*
#( 7.0033 -3.9202 3.3619) ; H1*
#( 7.5997 -5.8018 2.4948) ; C2*
#( 8.3627 -6.3254 3.0707) ; H2**
#( 8.0410 -4.9501 1.4724) ; O2*
#( 8.2781 -4.0644 1.7570) ; H2*
#( 6.5701 -6.8129 1.9714) ; C3*
#( 6.4186 -7.5809 2.7299) ; H3*
#( 6.9357 -7.3841 0.7235) ; O3*
#( 6.8024 -5.4718 4.8475) ; N1
#( 6.6920 -5.0495 7.1354) ; N3
#( 6.6201 -4.5500 5.8506) ; C2
#( 6.9254 -6.3614 7.4926) ; C4
#( 7.1046 -7.2543 6.3718) ; C5
#( 7.0391 -6.7951 5.1106) ; C6
rU
#( 6.4083 -3.3696 5.6340) ; O2
#( 6.9679 -6.6901 8.6800) ; O4
#( 6.5626 -4.3957 7.8812) ; H3
#( 7.2781 -8.2254 6.5350) ; H5
#( 7.1657 -7.4312 4.3503) ; H6
))
(define rU07
(nuc-const
#( -0.9434 0.3172 0.0971 ; dgf-base-tfo
0.2294 0.4125 0.8816
0.2396 0.8539 -0.4619
8.3625 -52.7147 1.3745)
#( 0.2765 -0.1121 -0.9545 ; P-O3*-275-tfo
-0.8297 0.4733 -0.2959
0.4850 0.8737 0.0379
-14.7774 -45.2464 21.9088)
#( 0.1063 -0.6334 -0.7665 ; P-O3*-180-tfo
-0.5932 -0.6591 0.4624
-0.7980 0.4055 -0.4458
43.7634 4.3296 28.4890)
#( 0.7136 -0.5032 -0.4873 ; P-O3*-60-tfo
0.6803 0.3317 0.6536
-0.1673 -0.7979 0.5791
-17.1858 41.4390 -27.0751)
#( 21.3880 15.0780 45.5770) ; P
#( 21.9980 14.5500 46.8210) ; O1P
#( 21.1450 14.0270 44.5420) ; O2P
#( 22.1250 16.3600 44.9460) ; O5*
#( 21.5037 16.8594 43.7323) ; C5*
#( 20.8147 17.6663 43.9823) ; H5*
#( 21.1086 16.0230 43.1557) ; H5**
#( 22.5654 17.4874 42.8616) ; C4*
#( 22.1584 17.7243 41.8785) ; H4*
#( 23.0557 18.6826 43.4751) ; O4*
#( 24.4788 18.6151 43.6455) ; C1*
#( 24.9355 19.0840 42.7739) ; H1*
#( 24.7958 17.1427 43.6474) ; C2*
#( 24.5652 16.7400 44.6336) ; H2**
#( 26.1041 16.8773 43.2455) ; O2*
#( 26.7516 17.5328 43.5149) ; H2*
#( 23.8109 16.5979 42.6377) ; C3*
#( 23.5756 15.5686 42.9084) ; H3*
#( 24.2890 16.7447 41.2729) ; O3*
#( 24.9420 19.2174 44.8923) ; N1
#( 25.2655 20.5636 44.8883) ; N3
#( 25.1663 21.2219 43.8561) ; C2
#( 25.6911 21.1219 46.0494) ; C4
#( 25.8051 20.4068 47.2048) ; C5
#( 26.2093 20.9962 48.2534) ; C6
rU
#( 25.4692 19.0221 47.2053) ; O2
#( 25.0502 18.4827 46.0370) ; O4
#( 25.9599 22.1772 46.0966) ; H3
#( 25.5545 18.4409 48.1234) ; H5
#( 24.7854 17.4265 45.9883) ; H6
))
(define rU08
(nuc-const
#( -0.0080 -0.7928 0.6094 ; dgf-base-tfo
-0.7512 0.4071 0.5197
-0.6601 -0.4536 -0.5988
44.1482 30.7036 2.1088)
#( 0.2765 -0.1121 -0.9545 ; P-O3*-275-tfo
-0.8297 0.4733 -0.2959
0.4850 0.8737 0.0379
-14.7774 -45.2464 21.9088)
#( 0.1063 -0.6334 -0.7665 ; P-O3*-180-tfo
-0.5932 -0.6591 0.4624
-0.7980 0.4055 -0.4458
43.7634 4.3296 28.4890)
#( 0.7136 -0.5032 -0.4873 ; P-O3*-60-tfo
0.6803 0.3317 0.6536
-0.1673 -0.7979 0.5791
-17.1858 41.4390 -27.0751)
#( 21.3880 15.0780 45.5770) ; P
#( 21.9980 14.5500 46.8210) ; O1P
#( 21.1450 14.0270 44.5420) ; O2P
#( 22.1250 16.3600 44.9460) ; O5*
#( 23.5096 16.1227 44.5783) ; C5*
#( 23.5649 15.8588 43.5222) ; H5*
#( 23.9621 15.4341 45.2919) ; H5**
#( 24.2805 17.4138 44.7151) ; C4*
#( 25.3492 17.2309 44.6030) ; H4*
#( 23.8497 18.3471 43.7208) ; O4*
#( 23.4090 19.5681 44.3321) ; C1*
#( 24.2595 20.2496 44.3524) ; H1*
#( 23.0418 19.1813 45.7407) ; C2*
#( 22.0532 18.7224 45.7273) ; H2**
#( 23.1307 20.2521 46.6291) ; O2*
#( 22.8888 21.1051 46.2611) ; H2*
#( 24.0799 18.1326 46.0700) ; C3*
#( 23.6490 17.4370 46.7900) ; H3*
#( 25.3329 18.7227 46.5109) ; O3*
#( 22.2515 20.1624 43.6698) ; N1
#( 22.4760 21.0609 42.6406) ; N3
#( 23.6229 21.3462 42.3061) ; C2
#( 21.3986 21.6081 42.0236) ; C4
#( 20.1189 21.3012 42.3804) ; C5
#( 19.1599 21.8516 41.7578) ; C6
rU
#( 19.8919 20.3745 43.4387) ; O2
#( 20.9790 19.8423 44.0440) ; O4
#( 21.5235 22.3222 41.2097) ; H3
#( 18.8732 20.1200 43.7312) ; H5
#( 20.8545 19.1313 44.8608) ; H6
))
(define rU09
(nuc-const
#( -0.0317 0.1374 0.9900 ; dgf-base-tfo
-0.3422 -0.9321 0.1184
0.9391 -0.3351 0.0765
-32.1929 25.8198 -28.5088)
#( 0.2765 -0.1121 -0.9545 ; P-O3*-275-tfo
-0.8297 0.4733 -0.2959
0.4850 0.8737 0.0379
-14.7774 -45.2464 21.9088)
#( 0.1063 -0.6334 -0.7665 ; P-O3*-180-tfo
-0.5932 -0.6591 0.4624
-0.7980 0.4055 -0.4458
43.7634 4.3296 28.4890)
#( 0.7136 -0.5032 -0.4873 ; P-O3*-60-tfo
0.6803 0.3317 0.6536
-0.1673 -0.7979 0.5791
-17.1858 41.4390 -27.0751)
#( 21.3880 15.0780 45.5770) ; P
#( 21.9980 14.5500 46.8210) ; O1P
#( 21.1450 14.0270 44.5420) ; O2P
#( 22.1250 16.3600 44.9460) ; O5*
#( 21.5037 16.8594 43.7323) ; C5*
#( 20.8147 17.6663 43.9823) ; H5*
#( 21.1086 16.0230 43.1557) ; H5**
#( 22.5654 17.4874 42.8616) ; C4*
#( 23.0565 18.3036 43.3915) ; H4*
#( 23.5375 16.5054 42.4925) ; O4*
#( 23.6574 16.4257 41.0649) ; C1*
#( 24.4701 17.0882 40.7671) ; H1*
#( 22.3525 16.9643 40.5396) ; C2*
#( 21.5993 16.1799 40.6133) ; H2**
#( 22.4693 17.4849 39.2515) ; O2*
#( 23.0899 17.0235 38.6827) ; H2*
#( 22.0341 18.0633 41.5279) ; C3*
#( 20.9509 18.1709 41.5846) ; H3*
#( 22.7249 19.3020 41.2100) ; O3*
#( 23.8580 15.0648 40.5757) ; N1
#( 25.1556 14.5982 40.4523) ; N3
#( 26.1047 15.3210 40.7448) ; C2
#( 25.3391 13.3315 40.0020) ; C4
#( 24.2974 12.5148 39.6749) ; C5
#( 24.5450 11.3410 39.2610) ; C6
rU
#( 22.9633 12.9979 39.8053) ; O2
#( 22.8009 14.2648 40.2524) ; O4
#( 26.3414 12.9194 39.8855) ; H3
#( 22.1227 12.3533 39.5486) ; H5
#( 21.7989 14.6788 40.3650) ; H6
))
(define rU10
(nuc-const
#( -0.9674 0.1021 -0.2318 ; dgf-base-tfo
-0.2514 -0.2766 0.9275
0.0306 0.9555 0.2933
27.8571 -42.1305 -24.4563)
#( 0.2765 -0.1121 -0.9545 ; P-O3*-275-tfo
-0.8297 0.4733 -0.2959
0.4850 0.8737 0.0379
-14.7774 -45.2464 21.9088)
#( 0.1063 -0.6334 -0.7665 ; P-O3*-180-tfo
-0.5932 -0.6591 0.4624
-0.7980 0.4055 -0.4458
43.7634 4.3296 28.4890)
#( 0.7136 -0.5032 -0.4873 ; P-O3*-60-tfo
0.6803 0.3317 0.6536
-0.1673 -0.7979 0.5791
-17.1858 41.4390 -27.0751)
#( 21.3880 15.0780 45.5770) ; P
#( 21.9980 14.5500 46.8210) ; O1P
#( 21.1450 14.0270 44.5420) ; O2P
#( 22.1250 16.3600 44.9460) ; O5*
#( 23.5096 16.1227 44.5783) ; C5*
#( 23.5649 15.8588 43.5222) ; H5*
#( 23.9621 15.4341 45.2919) ; H5**
#( 24.2805 17.4138 44.7151) ; C4*
#( 23.8509 18.1819 44.0720) ; H4*
#( 24.2506 17.8583 46.0741) ; O4*
#( 25.5830 18.0320 46.5775) ; C1*
#( 25.8569 19.0761 46.4256) ; H1*
#( 26.4410 17.1555 45.7033) ; C2*
#( 26.3459 16.1253 46.0462) ; H2**
#( 27.7649 17.5888 45.6478) ; O2*
#( 28.1004 17.9719 46.4616) ; H2*
#( 25.7796 17.2997 44.3513) ; C3*
#( 25.9478 16.3824 43.7871) ; H3*
#( 26.2154 18.4984 43.6541) ; O3*
#( 25.7321 17.6281 47.9726) ; N1
#( 25.5136 18.5779 48.9560) ; N3
#( 25.2079 19.7276 48.6503) ; C2
#( 25.6482 18.1987 50.2518) ; C4
#( 25.9847 16.9266 50.6092) ; C5
#( 26.0918 16.6439 51.8416) ; C6
rU
#( 26.2067 15.9515 49.5943) ; O2
#( 26.0713 16.3497 48.3080) ; O4
#( 25.4890 18.9105 51.0618) ; H3
#( 26.4742 14.9310 49.8682) ; H5
#( 26.2346 15.6394 47.4975) ; H6
))
(define rUs
(list rU01 rU02 rU03 rU04 rU05 rU06 rU07 rU08 rU09 rU10))
(define rG*
(nuc-const
#( -0.2067 -0.0264 0.9780 ; dgf-base-tfo
0.9770 -0.0586 0.2049
0.0519 0.9979 0.0379
1.0331 -46.8078 -36.4742)
#( -0.8644 -0.4956 -0.0851 ; P-O3*-275-tfo
-0.0427 0.2409 -0.9696
0.5010 -0.8345 -0.2294
4.0167 54.5377 12.4779)
#( 0.3706 -0.6167 0.6945 ; P-O3*-180-tfo
-0.2867 -0.7872 -0.5460
0.8834 0.0032 -0.4686
-52.9020 18.6313 -0.6709)
#( 0.4155 0.9025 -0.1137 ; P-O3*-60-tfo
0.9040 -0.4236 -0.0582
-0.1007 -0.0786 -0.9918
-7.6624 -25.2080 49.5181)
#( 31.3810 0.1400 47.5810) ; P
#( 29.9860 0.6630 47.6290) ; O1P
#( 31.7210 -0.6460 48.8090) ; O2P
#( 32.4940 1.2540 47.2740) ; O5*
#( 32.1610 2.2370 46.2560) ; C5*
#( 31.2986 2.8190 46.5812) ; H5*
#( 32.0980 1.7468 45.2845) ; H5**
#( 33.3476 3.1959 46.1947) ; C4*
#( 33.2668 3.8958 45.3630) ; H4*
#( 33.3799 3.9183 47.4216) ; O4*
#( 34.6515 3.7222 48.0398) ; C1*
#( 35.2947 4.5412 47.7180) ; H1*
#( 35.1756 2.4228 47.4827) ; C2*
#( 34.6778 1.5937 47.9856) ; H2**
#( 36.5631 2.2672 47.4798) ; O2*
#( 37.0163 2.6579 48.2305) ; H2*
#( 34.6953 2.5043 46.0448) ; C3*
#( 34.5444 1.4917 45.6706) ; H3*
#( 35.6679 3.3009 45.3487) ; O3*
#( 37.4804 4.0914 52.2559) ; N1
#( 36.9670 4.1312 49.9281) ; N3
#( 37.8045 4.2519 50.9550) ; C2
#( 35.7171 3.8264 50.3222) ; C4
#( 35.2668 3.6420 51.6115) ; C5
#( 36.2037 3.7829 52.6706) ; C6
rG
#( 39.0869 4.5552 50.7092) ; N2
#( 33.9075 3.3338 51.6102) ; N7
#( 34.6126 3.6358 49.5108) ; N9
#( 33.5805 3.3442 50.3425) ; C8
#( 35.9958 3.6512 53.8724) ; O6
#( 38.2106 4.2053 52.9295) ; H1
#( 39.8218 4.6863 51.3896) ; H21
#( 39.3420 4.6857 49.7407) ; H22
#( 32.5194 3.1070 50.2664) ; H8
))
(define rU*
(nuc-const
#( -0.0109 0.5907 0.8068 ; dgf-base-tfo
0.2217 -0.7853 0.5780
0.9751 0.1852 -0.1224
-1.4225 -11.0956 -2.5217)
#( -0.8313 -0.4738 -0.2906 ; P-O3*-275-tfo
0.0649 0.4366 -0.8973
0.5521 -0.7648 -0.3322
1.6833 6.8060 -7.0011)
#( 0.3445 -0.7630 0.5470 ; P-O3*-180-tfo
-0.4628 -0.6450 -0.6082
0.8168 -0.0436 -0.5753
-6.8179 -3.9778 -5.9887)
#( 0.5855 0.7931 -0.1682 ; P-O3*-60-tfo
0.8103 -0.5790 0.0906
-0.0255 -0.1894 -0.9816
6.1203 -7.1051 3.1984)
#( 2.6760 -8.4960 3.2880) ; P
#( 1.4950 -7.6230 3.4770) ; O1P
#( 2.9490 -9.4640 4.3740) ; O2P
#( 3.9730 -7.5950 3.0340) ; O5*
#( 5.2430 -8.2420 2.8260) ; C5*
#( 5.1974 -8.8497 1.9223) ; H5*
#( 5.5548 -8.7348 3.7469) ; H5**
#( 6.3140 -7.2060 2.5510) ; C4*
#( 5.8744 -6.2116 2.4731) ; H4*
#( 7.2798 -7.2260 3.6420) ; O4*
#( 8.5733 -6.9410 3.1329) ; C1*
#( 8.9047 -6.0374 3.6446) ; H1*
#( 8.4429 -6.6596 1.6327) ; C2*
#( 9.2880 -7.1071 1.1096) ; H2**
#( 8.2502 -5.2799 1.4754) ; O2*
#( 8.7676 -4.7284 2.0667) ; H2*
#( 7.1642 -7.4416 1.3021) ; C3*
#( 7.4125 -8.5002 1.2260) ; H3*
#( 6.5160 -6.9772 0.1267) ; O3*
#( 9.4531 -8.1107 3.4087) ; N1
#( 11.5931 -9.0015 3.6357) ; N3
#( 10.8101 -7.8950 3.3748) ; C2
#( 11.1439 -10.2744 3.9206) ; C4
#( 9.7056 -10.4026 3.9332) ; C5
#( 8.9192 -9.3419 3.6833) ; C6
rU
#( 11.3013 -6.8063 3.1326) ; O2
#( 11.9431 -11.1876 4.1375) ; O4
#( 12.5840 -8.8673 3.6158) ; H3
#( 9.2891 -11.2898 4.1313) ; H5
#( 7.9263 -9.4537 3.6977) ; H6
))
; -- PARTIAL INSTANTIATIONS ---------------------------------------------------
(define (nuc-make-var id tfo nuc)
(vector id tfo nuc))
(define (var-id var) (vector-ref var 0))
(define (var-id-set! var val) (vector-set! var 0 val))
(define (var-tfo var) (vector-ref var 1))
(define (var-tfo-set! var val) (vector-set! var 1 val))
(define (var-nuc var) (vector-ref var 2))
(define (var-nuc-set! var val) (vector-set! var 2 val))
(define (atom-pos atom var)
(tfo-apply (var-tfo var) (atom (var-nuc var))))
(define (nuc-get-var id lst)
(let ((v (car lst)))
(if (= id (var-id v))
v
(nuc-get-var id (cdr lst)))))
(define (make-relative-nuc tfo n)
(cond ((rA? n)
(make-rA
(nuc-dgf-base-tfo n)
(nuc-P-O3*-275-tfo n)
(nuc-P-O3*-180-tfo n)
(nuc-P-O3*-60-tfo n)
(tfo-apply tfo (nuc-P n))
(tfo-apply tfo (nuc-O1P n))
(tfo-apply tfo (nuc-O2P n))
(tfo-apply tfo (nuc-O5* n))
(tfo-apply tfo (nuc-C5* n))
(tfo-apply tfo (nuc-H5* n))
(tfo-apply tfo (nuc-H5** n))
(tfo-apply tfo (nuc-C4* n))
(tfo-apply tfo (nuc-H4* n))
(tfo-apply tfo (nuc-O4* n))
(tfo-apply tfo (nuc-C1* n))
(tfo-apply tfo (nuc-H1* n))
(tfo-apply tfo (nuc-C2* n))
(tfo-apply tfo (nuc-H2** n))
(tfo-apply tfo (nuc-O2* n))
(tfo-apply tfo (nuc-H2* n))
(tfo-apply tfo (nuc-C3* n))
(tfo-apply tfo (nuc-H3* n))
(tfo-apply tfo (nuc-O3* n))
(tfo-apply tfo (nuc-N1 n))
(tfo-apply tfo (nuc-N3 n))
(tfo-apply tfo (nuc-C2 n))
(tfo-apply tfo (nuc-C4 n))
(tfo-apply tfo (nuc-C5 n))
(tfo-apply tfo (nuc-C6 n))
(tfo-apply tfo (rA-N6 n))
(tfo-apply tfo (rA-N7 n))
(tfo-apply tfo (rA-N9 n))
(tfo-apply tfo (rA-C8 n))
(tfo-apply tfo (rA-H2 n))
(tfo-apply tfo (rA-H61 n))
(tfo-apply tfo (rA-H62 n))
(tfo-apply tfo (rA-H8 n))))
((rC? n)
(make-rC
(nuc-dgf-base-tfo n)
(nuc-P-O3*-275-tfo n)
(nuc-P-O3*-180-tfo n)
(nuc-P-O3*-60-tfo n)
(tfo-apply tfo (nuc-P n))
(tfo-apply tfo (nuc-O1P n))
(tfo-apply tfo (nuc-O2P n))
(tfo-apply tfo (nuc-O5* n))
(tfo-apply tfo (nuc-C5* n))
(tfo-apply tfo (nuc-H5* n))
(tfo-apply tfo (nuc-H5** n))
(tfo-apply tfo (nuc-C4* n))
(tfo-apply tfo (nuc-H4* n))
(tfo-apply tfo (nuc-O4* n))
(tfo-apply tfo (nuc-C1* n))
(tfo-apply tfo (nuc-H1* n))
(tfo-apply tfo (nuc-C2* n))
(tfo-apply tfo (nuc-H2** n))
(tfo-apply tfo (nuc-O2* n))
(tfo-apply tfo (nuc-H2* n))
(tfo-apply tfo (nuc-C3* n))
(tfo-apply tfo (nuc-H3* n))
(tfo-apply tfo (nuc-O3* n))
(tfo-apply tfo (nuc-N1 n))
(tfo-apply tfo (nuc-N3 n))
(tfo-apply tfo (nuc-C2 n))
(tfo-apply tfo (nuc-C4 n))
(tfo-apply tfo (nuc-C5 n))
(tfo-apply tfo (nuc-C6 n))
(tfo-apply tfo (rC-N4 n))
(tfo-apply tfo (rC-O2 n))
(tfo-apply tfo (rC-H41 n))
(tfo-apply tfo (rC-H42 n))
(tfo-apply tfo (rC-H5 n))
(tfo-apply tfo (rC-H6 n))))
((rG? n)
(make-rG
(nuc-dgf-base-tfo n)
(nuc-P-O3*-275-tfo n)
(nuc-P-O3*-180-tfo n)
(nuc-P-O3*-60-tfo n)
(tfo-apply tfo (nuc-P n))
(tfo-apply tfo (nuc-O1P n))
(tfo-apply tfo (nuc-O2P n))
(tfo-apply tfo (nuc-O5* n))
(tfo-apply tfo (nuc-C5* n))
(tfo-apply tfo (nuc-H5* n))
(tfo-apply tfo (nuc-H5** n))
(tfo-apply tfo (nuc-C4* n))
(tfo-apply tfo (nuc-H4* n))
(tfo-apply tfo (nuc-O4* n))
(tfo-apply tfo (nuc-C1* n))
(tfo-apply tfo (nuc-H1* n))
(tfo-apply tfo (nuc-C2* n))
(tfo-apply tfo (nuc-H2** n))
(tfo-apply tfo (nuc-O2* n))
(tfo-apply tfo (nuc-H2* n))
(tfo-apply tfo (nuc-C3* n))
(tfo-apply tfo (nuc-H3* n))
(tfo-apply tfo (nuc-O3* n))
(tfo-apply tfo (nuc-N1 n))
(tfo-apply tfo (nuc-N3 n))
(tfo-apply tfo (nuc-C2 n))
(tfo-apply tfo (nuc-C4 n))
(tfo-apply tfo (nuc-C5 n))
(tfo-apply tfo (nuc-C6 n))
(tfo-apply tfo (rG-N2 n))
(tfo-apply tfo (rG-N7 n))
(tfo-apply tfo (rG-N9 n))
(tfo-apply tfo (rG-C8 n))
(tfo-apply tfo (rG-O6 n))
(tfo-apply tfo (rG-H1 n))
(tfo-apply tfo (rG-H21 n))
(tfo-apply tfo (rG-H22 n))
(tfo-apply tfo (rG-H8 n))))
(else
(make-rU
(nuc-dgf-base-tfo n)
(nuc-P-O3*-275-tfo n)
(nuc-P-O3*-180-tfo n)
(nuc-P-O3*-60-tfo n)
(tfo-apply tfo (nuc-P n))
(tfo-apply tfo (nuc-O1P n))
(tfo-apply tfo (nuc-O2P n))
(tfo-apply tfo (nuc-O5* n))
(tfo-apply tfo (nuc-C5* n))
(tfo-apply tfo (nuc-H5* n))
(tfo-apply tfo (nuc-H5** n))
(tfo-apply tfo (nuc-C4* n))
(tfo-apply tfo (nuc-H4* n))
(tfo-apply tfo (nuc-O4* n))
(tfo-apply tfo (nuc-C1* n))
(tfo-apply tfo (nuc-H1* n))
(tfo-apply tfo (nuc-C2* n))
(tfo-apply tfo (nuc-H2** n))
(tfo-apply tfo (nuc-O2* n))
(tfo-apply tfo (nuc-H2* n))
(tfo-apply tfo (nuc-C3* n))
(tfo-apply tfo (nuc-H3* n))
(tfo-apply tfo (nuc-O3* n))
(tfo-apply tfo (nuc-N1 n))
(tfo-apply tfo (nuc-N3 n))
(tfo-apply tfo (nuc-C2 n))
(tfo-apply tfo (nuc-C4 n))
(tfo-apply tfo (nuc-C5 n))
(tfo-apply tfo (nuc-C6 n))
(tfo-apply tfo (rU-O2 n))
(tfo-apply tfo (rU-O4 n))
(tfo-apply tfo (rU-H3 n))
(tfo-apply tfo (rU-H5 n))
(tfo-apply tfo (rU-H6 n))))))
; -- SEARCH -------------------------------------------------------------------
; Sequential backtracking algorithm
(define (search partial-inst domains constraint?)
(if (null? domains)
(list partial-inst)
(let ((remaining-domains (cdr domains)))
(define (try-assignments lst)
(if (null? lst)
'()
(let ((var (car lst)))
(if (constraint? var partial-inst)
(let* ((subsols1
(search
(cons var partial-inst)
remaining-domains
constraint?))
(subsols2
(try-assignments (cdr lst))))
(append subsols1 subsols2))
(try-assignments (cdr lst))))))
(try-assignments ((car domains) partial-inst)))))
; -- DOMAINS ------------------------------------------------------------------
; Primary structure: strand A CUGCCACGUCUG, strand B CAGACGUGGCAG
;
; Secondary structure: strand A CUGCCACGUCUG
; ||||||||||||
; GACGGUGCAGAC strand B
;
; Tertiary structure:
;
; 5' end of strand A C1----G12 3' end of strand B
; U2-------A11
; G3-------C10
; C4-----G9
; C5---G8
; A6
; G6-C7
; C5----G8
; A4-------U9
; G3--------C10
; A2-------U11
; 5' end of strand B C1----G12 3' end of strand A
;
; "helix", "stacked" and "connected" describe the spatial relationship
; between two consecutive nucleotides. E.g. the nucleotides C1 and U2
; from the strand A.
;
; "wc" (stands for Watson-Crick and is a type of base-pairing),
; and "wc-dumas" describe the spatial relationship between
; nucleotides from two chains that are growing in opposite directions.
; E.g. the nucleotides C1 from strand A and G12 from strand B.
; Dynamic Domains
; Given,
; "ref" a nucleotide which is already positioned,
; "nuc" the nucleotide to be placed,
; and "tfo" a transformation matrix which expresses the desired
; relationship between "ref" and "nuc",
; the function "dgf-base" computes the transformation matrix that
; places the nucleotide "nuc" in the given relationship to "ref".
(define (dgf-base tfo ref nuc)
(let* ((ref-nuc (var-nuc ref))
(align
(tfo-inv-ortho
(cond ((rA? ref-nuc)
(tfo-align (atom-pos nuc-C1* ref)
(atom-pos rA-N9 ref)
(atom-pos nuc-C4 ref)))
((rC? ref-nuc)
(tfo-align (atom-pos nuc-C1* ref)
(atom-pos nuc-N1 ref)
(atom-pos nuc-C2 ref)))
((rG? ref-nuc)
(tfo-align (atom-pos nuc-C1* ref)
(atom-pos rG-N9 ref)
(atom-pos nuc-C4 ref)))
(else
(tfo-align (atom-pos nuc-C1* ref)
(atom-pos nuc-N1 ref)
(atom-pos nuc-C2 ref)))))))
(tfo-combine (nuc-dgf-base-tfo nuc)
(tfo-combine tfo align))))
; Placement of first nucleotide.
(define (reference nuc i)
(lambda (partial-inst)
(list (nuc-make-var i tfo-id nuc))))
; The transformation matrix for wc is from:
;
; Chandrasekaran R. et al (1989) A Re-Examination of the Crystal
; Structure of A-DNA Using Fiber Diffraction Data. J. Biomol.
; Struct. & Dynamics 6(6):1189-1202.
(define wc-tfo
(FLOATvector-const
-1.0000 0.0028 -0.0019
0.0028 0.3468 -0.9379
-0.0019 -0.9379 -0.3468
-0.0080 6.0730 8.7208))
(define (wc nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base wc-tfo ref nuc)))
(list (nuc-make-var i tfo nuc)))))
(define wc-Dumas-tfo
(FLOATvector-const
-0.9737 -0.1834 0.1352
-0.1779 0.2417 -0.9539
0.1422 -0.9529 -0.2679
0.4837 6.2649 8.0285))
(define (wc-Dumas nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base wc-Dumas-tfo ref nuc)))
(list (nuc-make-var i tfo nuc)))))
(define helix5*-tfo
(FLOATvector-const
0.9886 -0.0961 0.1156
0.1424 0.8452 -0.5152
-0.0482 0.5258 0.8492
-3.8737 0.5480 3.8024))
(define (helix5* nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base helix5*-tfo ref nuc)))
(list (nuc-make-var i tfo nuc)))))
(define helix3*-tfo
(FLOATvector-const
0.9886 0.1424 -0.0482
-0.0961 0.8452 0.5258
0.1156 -0.5152 0.8492
3.4426 2.0474 -3.7042))
(define (helix3* nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base helix3*-tfo ref nuc)))
(list (nuc-make-var i tfo nuc)))))
(define G37-A38-tfo
(FLOATvector-const
0.9991 0.0164 -0.0387
-0.0375 0.7616 -0.6470
0.0189 0.6478 0.7615
-3.3018 0.9975 2.5585))
(define (G37-A38 nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base G37-A38-tfo ref nuc)))
(nuc-make-var i tfo nuc))))
(define (stacked5* nuc i j)
(lambda (partial-inst)
(cons ((G37-A38 nuc i j) partial-inst)
((helix5* nuc i j) partial-inst))))
(define A38-G37-tfo
(FLOATvector-const
0.9991 -0.0375 0.0189
0.0164 0.7616 0.6478
-0.0387 -0.6470 0.7615
3.3819 0.7718 -2.5321))
(define (A38-G37 nuc i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(tfo (dgf-base A38-G37-tfo ref nuc)))
(nuc-make-var i tfo nuc))))
(define (stacked3* nuc i j)
(lambda (partial-inst)
(cons ((A38-G37 nuc i j) partial-inst)
((helix3* nuc i j) partial-inst))))
(define (P-O3* nucs i j)
(lambda (partial-inst)
(let* ((ref (nuc-get-var j partial-inst))
(align
(tfo-inv-ortho
(tfo-align (atom-pos nuc-O3* ref)
(atom-pos nuc-C3* ref)
(atom-pos nuc-C4* ref)))))
(let loop ((lst nucs) (domains '()))
(if (null? lst)
domains
(let ((nuc (car lst)))
(let ((tfo-60 (tfo-combine (nuc-P-O3*-60-tfo nuc) align))
(tfo-180 (tfo-combine (nuc-P-O3*-180-tfo nuc) align))
(tfo-275 (tfo-combine (nuc-P-O3*-275-tfo nuc) align)))
(loop (cdr lst)
(cons (nuc-make-var i tfo-60 nuc)
(cons (nuc-make-var i tfo-180 nuc)
(cons (nuc-make-var i tfo-275 nuc) domains)))))))))))
; -- PROBLEM STATEMENT --------------------------------------------------------
; Define anticodon problem -- Science 253:1255 Figure 3a, 3b and 3c
(define anticodon-domains
(list
(reference rC 27 )
(helix5* rC 28 27)
(helix5* rA 29 28)
(helix5* rG 30 29)
(helix5* rA 31 30)
(wc rU 39 31)
(helix5* rC 40 39)
(helix5* rU 41 40)
(helix5* rG 42 41)
(helix5* rG 43 42)
(stacked3* rA 38 39)
(stacked3* rG 37 38)
(stacked3* rA 36 37)
(stacked3* rA 35 36)
(stacked3* rG 34 35);<-. Distance
(P-O3* rCs 32 31); | Constraint
(P-O3* rUs 33 32);<-' 3.0 Angstroms
))
; Anticodon constraint
(define (anticodon-constraint? v partial-inst)
(if (= (var-id v) 33)
(let ((p (atom-pos nuc-P (nuc-get-var 34 partial-inst))) ; P in nucleotide 34
(o3* (atom-pos nuc-O3* v))) ; O3' in nucl. 33
(FLOAT<= (pt-dist p o3*) 3.0)) ; check distance
#t))
(define (anticodon)
(search '() anticodon-domains anticodon-constraint?))
; Define pseudoknot problem -- Science 253:1255 Figure 4a and 4b
(define pseudoknot-domains
(list
(reference rA 23 )
(wc-Dumas rU 8 23)
(helix3* rG 22 23)
(wc-Dumas rC 9 22)
(helix3* rG 21 22)
(wc-Dumas rC 10 21)
(helix3* rC 20 21)
(wc-Dumas rG 11 20)
(helix3* rU* 19 20);<-.
(wc-Dumas rA 12 19); | Distance
; ; | Constraint
; Helix 1 ; | 4.0 Angstroms
(helix3* rC 3 19); |
(wc-Dumas rG 13 3); |
(helix3* rC 2 3); |
(wc-Dumas rG 14 2); |
(helix3* rC 1 2); |
(wc-Dumas rG* 15 1); |
; ; |
; L2 LOOP ; |
(P-O3* rUs 16 15); |
(P-O3* rCs 17 16); |
(P-O3* rAs 18 17);<-'
;
; L1 LOOP
(helix3* rU 7 8);<-.
(P-O3* rCs 4 3); | Constraint
(stacked5* rU 5 4); | 4.5 Angstroms
(stacked5* rC 6 5);<-'
))
; Pseudoknot constraint
(define (pseudoknot-constraint? v partial-inst)
(case (var-id v)
((18)
(let ((p (atom-pos nuc-P (nuc-get-var 19 partial-inst)))
(o3* (atom-pos nuc-O3* v)))
(FLOAT<= (pt-dist p o3*) 4.0)))
((6)
(let ((p (atom-pos nuc-P (nuc-get-var 7 partial-inst)))
(o3* (atom-pos nuc-O3* v)))
(FLOAT<= (pt-dist p o3*) 4.5)))
(else
#t)))
(define (pseudoknot)
(search '() pseudoknot-domains pseudoknot-constraint?))
; -- TESTING -----------------------------------------------------------------
(define (list-of-atoms n)
(append (list-of-common-atoms n)
(list-of-specific-atoms n)))
(define (list-of-common-atoms n)
(list
(nuc-P n)
(nuc-O1P n)
(nuc-O2P n)
(nuc-O5* n)
(nuc-C5* n)
(nuc-H5* n)
(nuc-H5** n)
(nuc-C4* n)
(nuc-H4* n)
(nuc-O4* n)
(nuc-C1* n)
(nuc-H1* n)
(nuc-C2* n)
(nuc-H2** n)
(nuc-O2* n)
(nuc-H2* n)
(nuc-C3* n)
(nuc-H3* n)
(nuc-O3* n)
(nuc-N1 n)
(nuc-N3 n)
(nuc-C2 n)
(nuc-C4 n)
(nuc-C5 n)
(nuc-C6 n)))
(define (list-of-specific-atoms n)
(cond ((rA? n)
(list
(rA-N6 n)
(rA-N7 n)
(rA-N9 n)
(rA-C8 n)
(rA-H2 n)
(rA-H61 n)
(rA-H62 n)
(rA-H8 n)))
((rC? n)
(list
(rC-N4 n)
(rC-O2 n)
(rC-H41 n)
(rC-H42 n)
(rC-H5 n)
(rC-H6 n)))
((rG? n)
(list
(rG-N2 n)
(rG-N7 n)
(rG-N9 n)
(rG-C8 n)
(rG-O6 n)
(rG-H1 n)
(rG-H21 n)
(rG-H22 n)
(rG-H8 n)))
(else
(list
(rU-O2 n)
(rU-O4 n)
(rU-H3 n)
(rU-H5 n)
(rU-H6 n)))))
(define (var-most-distant-atom v)
(define (distance pos)
(let ((abs-pos (tfo-apply (var-tfo v) pos)))
(let ((x (pt-x abs-pos)) (y (pt-y abs-pos)) (z (pt-z abs-pos)))
(FLOATsqrt (FLOAT+ (FLOAT* x x) (FLOAT* y y) (FLOAT* z z))))))
(maximum (map distance (list-of-atoms (var-nuc v)))))
(define (sol-most-distant-atom s)
(maximum (map var-most-distant-atom s)))
(define (most-distant-atom sols)
(maximum (map sol-most-distant-atom sols)))
(define (maximum lst)
(let loop ((m (car lst)) (l (cdr lst)))
(if (null? l)
m
(let ((x (car l)))
(loop (if (FLOAT> x m) x m) (cdr l))))))
(define (run-nucleic)
(most-distant-atom (pseudoknot)))
(define (main-nucleic . args)
(run-single-benchmark
"nucleic"
nucleic-iters
(lambda (result)
(and (number? result)
(let ((x (FLOAT/ result 33.797594890762724)))
(and (FLOAT> x 0.999999) (FLOAT< x 1.000001)))))
(lambda () (lambda () (run-nucleic)))))
;;; PARAFFINS -- Compute how many paraffins exist with N carbon atoms.
(define (gen n)
(let* ((n/2 (quotient n 2))
(radicals (make-vector (+ n/2 1) '(H))))
(define (rads-of-size n)
(let loop1 ((ps
(three-partitions (- n 1)))
(lst
'()))
(if (null? ps)
lst
(let* ((p (car ps))
(nc1 (vector-ref p 0))
(nc2 (vector-ref p 1))
(nc3 (vector-ref p 2)))
(let loop2 ((rads1
(vector-ref radicals nc1))
(lst
(loop1 (cdr ps)
lst)))
(if (null? rads1)
lst
(let loop3 ((rads2
(if (= nc1 nc2)
rads1
(vector-ref radicals nc2)))
(lst
(loop2 (cdr rads1)
lst)))
(if (null? rads2)
lst
(let loop4 ((rads3
(if (= nc2 nc3)
rads2
(vector-ref radicals nc3)))
(lst
(loop3 (cdr rads2)
lst)))
(if (null? rads3)
lst
(cons (vector 'C
(car rads1)
(car rads2)
(car rads3))
(loop4 (cdr rads3)
lst))))))))))))
(define (bcp-generator j)
(if (odd? j)
'()
(let loop1 ((rads1
(vector-ref radicals (quotient j 2)))
(lst
'()))
(if (null? rads1)
lst
(let loop2 ((rads2
rads1)
(lst
(loop1 (cdr rads1)
lst)))
(if (null? rads2)
lst
(cons (vector 'BCP
(car rads1)
(car rads2))
(loop2 (cdr rads2)
lst))))))))
(define (ccp-generator j)
(let loop1 ((ps
(four-partitions (- j 1)))
(lst
'()))
(if (null? ps)
lst
(let* ((p (car ps))
(nc1 (vector-ref p 0))
(nc2 (vector-ref p 1))
(nc3 (vector-ref p 2))
(nc4 (vector-ref p 3)))
(let loop2 ((rads1
(vector-ref radicals nc1))
(lst
(loop1 (cdr ps)
lst)))
(if (null? rads1)
lst
(let loop3 ((rads2
(if (= nc1 nc2)
rads1
(vector-ref radicals nc2)))
(lst
(loop2 (cdr rads1)
lst)))
(if (null? rads2)
lst
(let loop4 ((rads3
(if (= nc2 nc3)
rads2
(vector-ref radicals nc3)))
(lst
(loop3 (cdr rads2)
lst)))
(if (null? rads3)
lst
(let loop5 ((rads4
(if (= nc3 nc4)
rads3
(vector-ref radicals nc4)))
(lst
(loop4 (cdr rads3)
lst)))
(if (null? rads4)
lst
(cons (vector 'CCP
(car rads1)
(car rads2)
(car rads3)
(car rads4))
(loop5 (cdr rads4)
lst))))))))))))))
(let loop ((i 1))
(if (> i n/2)
(vector (bcp-generator n)
(ccp-generator n))
(begin
(vector-set! radicals i (rads-of-size i))
(loop (+ i 1)))))))
(define (three-partitions m)
(let loop1 ((lst '())
(nc1 (quotient m 3)))
(if (< nc1 0)
lst
(let loop2 ((lst lst)
(nc2 (quotient (- m nc1) 2)))
(if (< nc2 nc1)
(loop1 lst
(- nc1 1))
(loop2 (cons (vector nc1 nc2 (- m (+ nc1 nc2))) lst)
(- nc2 1)))))))
(define (four-partitions m)
(let loop1 ((lst '())
(nc1 (quotient m 4)))
(if (< nc1 0)
lst
(let loop2 ((lst lst)
(nc2 (quotient (- m nc1) 3)))
(if (< nc2 nc1)
(loop1 lst
(- nc1 1))
(let ((start (max nc2 (- (quotient (+ m 1) 2) (+ nc1 nc2)))))
(let loop3 ((lst lst)
(nc3 (quotient (- m (+ nc1 nc2)) 2)))
(if (< nc3 start)
(loop2 lst (- nc2 1))
(loop3 (cons (vector nc1 nc2 nc3 (- m (+ nc1 (+ nc2 nc3)))) lst)
(- nc3 1))))))))))
(define (nb n)
(let ((x (gen n)))
(+ (length (vector-ref x 0))
(length (vector-ref x 1)))))
(define (main-paraffins . args)
(run-single-benchmark
"paraffins"
paraffins-iters
(lambda (result) (equal? result 24894))
(lambda (n) (lambda () (nb n)))
17))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; File: perm9.sch
; Description: memory system benchmark using Zaks's permutation generator
; Author: Lars Hansen, Will Clinger, and Gene Luks
; Created: 18-Mar-94
; Language: Scheme
; Status: Public Domain
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 940720 / lth Added some more benchmarks for the thesis paper.
; 970215 / wdc Increased problem size from 8 to 9; improved tenperm9-benchmark.
; 970531 / wdc Cleaned up for public release.
; 981116 / wdc Simplified to fit in with Feeley's benchmark suite.
; The perm9 benchmark generates a list of all 362880 permutations of
; the first 9 integers, allocating 1349288 pairs (typically 10,794,304
; bytes), all of which goes into the generated list. (That is, the
; perm9 benchmark generates absolutely no garbage.) This represents
; a savings of about 63% over the storage that would be required by
; an unshared list of permutations. The generated permutations are
; in order of a grey code that bears no obvious relationship to a
; lexicographic order.
;
; The 10perm9 benchmark repeats the perm9 benchmark 10 times, so it
; allocates and reclaims 13492880 pairs (typically 107,943,040 bytes).
; The live storage peaks at twice the storage that is allocated by the
; perm9 benchmark. At the end of each iteration, the oldest half of
; the live storage becomes garbage. Object lifetimes are distributed
; uniformly between 10.3 and 20.6 megabytes.
; Date: Thu, 17 Mar 94 19:43:32 -0800
; From: [email protected]
; To: will
; Subject: Pancake flips
;
; Procedure P_n generates a grey code of all perms of n elements
; on top of stack ending with reversal of starting sequence
;
; F_n is flip of top n elements.
;
;
; procedure P_n
;
; if n>1 then
; begin
; repeat P_{n-1},F_n n-1 times;
; P_{n-1}
; end
;
(define (permutations x)
(let ((x x)
(perms (list x)))
(define (P n)
(if (> n 1)
(do ((j (- n 1) (- j 1)))
((zero? j)
(P (- n 1)))
(P (- n 1))
(F n))))
(define (F n)
(set! x (revloop x n (list-tail x n)))
(set! perms (cons x perms)))
(define (revloop x n y)
(if (zero? n)
y
(revloop (cdr x)
(- n 1)
(cons (car x) y))))
(define (list-tail x n)
(if (zero? n)
x
(list-tail (cdr x) (- n 1))))
(P (length x))
perms))
; Given a list of lists of numbers, returns the sum of the sums
; of those lists.
;
; for (; x != NULL; x = x->rest)
; for (y = x->first; y != NULL; y = y->rest)
; sum = sum + y->first;
(define (sumlists x)
(do ((x x (cdr x))
(sum 0 (do ((y (car x) (cdr y))
(sum sum (+ sum (car y))))
((null? y) sum))))
((null? x) sum)))
(define (one..n n)
(do ((n n (- n 1))
(p '() (cons n p)))
((zero? n) p)))
(define (main-perm9 . args)
(let ((n 9))
(define (factorial n)
(if (zero? n)
1
(* n (factorial (- n 1)))))
(run-single-benchmark
(string-append "perm" (number->string n))
perm9-iters
(lambda (result)
(= (sumlists result)
(* (quotient (* n (+ n 1)) 2) (factorial n))))
(lambda (lst)
(lambda ()
(permutations lst)))
(one..n n))))
;;; PEVAL -- A simple partial evaluator for Scheme, written by Marc Feeley.
;------------------------------------------------------------------------------
; Utilities
(define (every? pred? l)
(let loop ((l l))
(or (null? l) (and (pred? (car l)) (loop (cdr l))))))
(define (some? pred? l)
(let loop ((l l))
(if (null? l) #f (or (pred? (car l)) (loop (cdr l))))))
(define (map2 f l1 l2)
(let loop ((l1 l1) (l2 l2))
(if (pair? l1)
(cons (f (car l1) (car l2)) (loop (cdr l1) (cdr l2)))
'())))
(define (get-last-pair l)
(let loop ((l l))
(let ((x (cdr l))) (if (pair? x) (loop x) l))))
;------------------------------------------------------------------------------
;
; The partial evaluator.
(define (peval-partial-evaluate proc args)
(peval (alphatize proc '()) args))
(define (alphatize exp env) ; return a copy of 'exp' where each bound var has
(define (alpha exp) ; been renamed (to prevent aliasing problems)
(cond ((const-expr? exp)
(quot (const-value exp)))
((symbol? exp)
(let ((x (assq exp env))) (if x (cdr x) exp)))
((or (eq? (car exp) 'if) (eq? (car exp) 'begin))
(cons (car exp) (map alpha (cdr exp))))
((or (eq? (car exp) 'let) (eq? (car exp) 'letrec))
(let ((new-env (peval-new-variables (map car (cadr exp)) env)))
(list (car exp)
(map (lambda (x)
(list (cdr (assq (car x) new-env))
(if (eq? (car exp) 'let)
(alpha (cadr x))
(alphatize (cadr x) new-env))))
(cadr exp))
(alphatize (caddr exp) new-env))))
((eq? (car exp) 'lambda)
(let ((new-env (peval-new-variables (cadr exp) env)))
(list 'lambda
(map (lambda (x) (cdr (assq x new-env))) (cadr exp))
(alphatize (caddr exp) new-env))))
(else
(map alpha exp))))
(alpha exp))
(define (const-expr? expr) ; is 'expr' a constant expression?
(and (not (symbol? expr))
(or (not (pair? expr))
(eq? (car expr) 'quote))))
(define (const-value expr) ; return the value of a constant expression
(if (pair? expr) ; then it must be a quoted constant
(cadr expr)
expr))
(define (quot val) ; make a quoted constant whose value is 'val'
(list 'quote val))
(define (peval-new-variables parms env)
(append (map (lambda (x) (cons x (new-variable x))) parms) env))
(define *current-num* 0)
(define (new-variable name)
(set! *current-num* (+ *current-num* 1))
(string->symbol
(string-append (symbol->string name)
"_"
(number->string *current-num*))))
;------------------------------------------------------------------------------
;
; (peval proc args) will transform a procedure that is known to be called
; with constants as some of its arguments into a specialized procedure that
; is 'equivalent' but accepts only the non-constant parameters. 'proc' is the
; list representation of a lambda-expression and 'args' is a list of values,
; one for each parameter of the lambda-expression. A special value (i.e.
; 'not-constant') is used to indicate an argument that is not a constant.
; The returned procedure is one that has as parameters the parameters of the
; original procedure which are NOT passed constants. Constants will have been
; substituted for the constant parameters that are referenced in the body
; of the procedure.
;
; For example:
;
; (peval
; '(lambda (x y z) (f z x y)) ; the procedure
; (list 1 not-constant #t)) ; the knowledge about x, y and z
;
; will return: (lambda (y) (f '#t '1 y))
(define (peval proc args)
(simplify!
(let ((parms (cadr proc)) ; get the parameter list
(body (caddr proc))) ; get the body of the procedure
(list 'lambda
(remove-constant parms args) ; remove the constant parameters
(beta-subst ; in the body, replace variable refs to the constant
body ; parameters by the corresponding constant
(map2 (lambda (x y) (if (not-constant? y) '(()) (cons x (quot y))))
parms
args))))))
(define not-constant (list '?)) ; special value indicating non-constant parms.
(define (not-constant? x) (eq? x not-constant))
(define (remove-constant l a) ; remove from list 'l' all elements whose
(cond ((null? l) ; corresponding element in 'a' is a constant
'())
((not-constant? (car a))
(cons (car l) (remove-constant (cdr l) (cdr a))))
(else
(remove-constant (cdr l) (cdr a)))))
(define (extract-constant l a) ; extract from list 'l' all elements whose
(cond ((null? l) ; corresponding element in 'a' is a constant
'())
((not-constant? (car a))
(extract-constant (cdr l) (cdr a)))
(else
(cons (car l) (extract-constant (cdr l) (cdr a))))))
(define (beta-subst exp env) ; return a modified 'exp' where each var named in
(define (bs exp) ; 'env' is replaced by the corresponding expr (it
(cond ((const-expr? exp) ; is assumed that the code has been alphatized)
(quot (const-value exp)))
((symbol? exp)
(let ((x (assq exp env)))
(if x (cdr x) exp)))
((or (eq? (car exp) 'if) (eq? (car exp) 'begin))
(cons (car exp) (map bs (cdr exp))))
((or (eq? (car exp) 'let) (eq? (car exp) 'letrec))
(list (car exp)
(map (lambda (x) (list (car x) (bs (cadr x)))) (cadr exp))
(bs (caddr exp))))
((eq? (car exp) 'lambda)
(list 'lambda
(cadr exp)
(bs (caddr exp))))
(else
(map bs exp))))
(bs exp))
;------------------------------------------------------------------------------
;
; The expression simplifier.
(define (simplify! exp) ; simplify the expression 'exp' destructively (it
; is assumed that the code has been alphatized)
(define (simp! where env)
(define (s! where)
(let ((exp (car where)))
(cond ((const-expr? exp)) ; leave constants the way they are
((symbol? exp)) ; leave variable references the way they are
((eq? (car exp) 'if) ; dead code removal for conditionals
(s! (cdr exp)) ; simplify the predicate
(if (const-expr? (cadr exp)) ; is the predicate a constant?
(begin
(set-car! where
(if (memq (const-value (cadr exp)) '(#f ())) ; false?
(if (= (length exp) 3) ''() (cadddr exp))
(caddr exp)))
(s! where))
(for-each! s! (cddr exp)))) ; simplify consequent and alt.
((eq? (car exp) 'begin)
(for-each! s! (cdr exp))
(let loop ((exps exp)) ; remove all useless expressions
(if (not (null? (cddr exps))) ; not last expression?
(let ((x (cadr exps)))
(loop (if (or (const-expr? x)
(symbol? x)
(and (pair? x) (eq? (car x) 'lambda)))
(begin (set-cdr! exps (cddr exps)) exps)
(cdr exps))))))
(if (null? (cddr exp)) ; only one expression in the begin?
(set-car! where (cadr exp))))
((or (eq? (car exp) 'let) (eq? (car exp) 'letrec))
(let ((new-env (cons exp env)))
(define (keep i)
(if (>= i (length (cadar where)))
'()
(let* ((var (car (list-ref (cadar where) i)))
(val (cadr (assq var (cadar where))))
(refs (ref-count (car where) var))
(self-refs (ref-count val var))
(total-refs (- (car refs) (car self-refs)))
(oper-refs (- (cadr refs) (cadr self-refs))))
(cond ((= total-refs 0)
(keep (+ i 1)))
((or (const-expr? val)
(symbol? val)
(and (pair? val)
(eq? (car val) 'lambda)
(= total-refs 1)
(= oper-refs 1)
(= (car self-refs) 0))
(and (caddr refs)
(= total-refs 1)))
(set-car! where
(beta-subst (car where)
(list (cons var val))))
(keep (+ i 1)))
(else
(cons var (keep (+ i 1))))))))
(simp! (cddr exp) new-env)
(for-each! (lambda (x) (simp! (cdar x) new-env)) (cadr exp))
(let ((to-keep (keep 0)))
(if (< (length to-keep) (length (cadar where)))
(begin
(if (null? to-keep)
(set-car! where (caddar where))
(set-car! (cdar where)
(map (lambda (v) (assq v (cadar where))) to-keep)))
(s! where))
(if (null? to-keep)
(set-car! where (caddar where)))))))
((eq? (car exp) 'lambda)
(simp! (cddr exp) (cons exp env)))
(else
(for-each! s! exp)
(cond ((symbol? (car exp)) ; is the operator position a var ref?
(let ((frame (binding-frame (car exp) env)))
(if frame ; is it a bound variable?
(let ((proc (bound-expr (car exp) frame)))
(if (and (pair? proc)
(eq? (car proc) 'lambda)
(some? const-expr? (cdr exp)))
(let* ((args (arg-pattern (cdr exp)))
(new-proc (peval proc args))
(new-args (remove-constant (cdr exp) args)))
(set-car! where
(cons (add-binding new-proc frame (car exp))
new-args)))))
(set-car! where
(constant-fold-global (car exp) (cdr exp))))))
((not (pair? (car exp))))
((eq? (caar exp) 'lambda)
(set-car! where
(list 'let
(map2 list (cadar exp) (cdr exp))
(caddar exp)))
(s! where)))))))
(s! where))
(define (remove-empty-calls! where env)
(define (rec! where)
(let ((exp (car where)))
(cond ((const-expr? exp))
((symbol? exp))
((eq? (car exp) 'if)
(rec! (cdr exp))
(rec! (cddr exp))
(rec! (cdddr exp)))
((eq? (car exp) 'begin)
(for-each! rec! (cdr exp)))
((or (eq? (car exp) 'let) (eq? (car exp) 'letrec))
(let ((new-env (cons exp env)))
(remove-empty-calls! (cddr exp) new-env)
(for-each! (lambda (x) (remove-empty-calls! (cdar x) new-env))
(cadr exp))))
((eq? (car exp) 'lambda)
(rec! (cddr exp)))
(else
(for-each! rec! (cdr exp))
(if (and (null? (cdr exp)) (symbol? (car exp)))
(let ((frame (binding-frame (car exp) env)))
(if frame ; is it a bound variable?
(let ((proc (bound-expr (car exp) frame)))
(if (and (pair? proc)
(eq? (car proc) 'lambda))
(begin
(set! changed? #t)
(set-car! where (caddr proc))))))))))))
(rec! where))
(define changed? #f)
(let ((x (list exp)))
(let loop ()
(set! changed? #f)
(simp! x '())
(remove-empty-calls! x '())
(if changed? (loop) (car x)))))
(define (ref-count exp var) ; compute how many references to variable 'var'
(let ((total 0) ; are contained in 'exp'
(oper 0)
(always-evaled #t))
(define (rc exp ae)
(cond ((const-expr? exp))
((symbol? exp)
(if (eq? exp var)
(begin
(set! total (+ total 1))
(set! always-evaled (and ae always-evaled)))))
((eq? (car exp) 'if)
(rc (cadr exp) ae)
(for-each (lambda (x) (rc x #f)) (cddr exp)))
((eq? (car exp) 'begin)
(for-each (lambda (x) (rc x ae)) (cdr exp)))
((or (eq? (car exp) 'let) (eq? (car exp) 'letrec))
(for-each (lambda (x) (rc (cadr x) ae)) (cadr exp))
(rc (caddr exp) ae))
((eq? (car exp) 'lambda)
(rc (caddr exp) #f))
(else
(for-each (lambda (x) (rc x ae)) exp)
(if (symbol? (car exp))
(if (eq? (car exp) var) (set! oper (+ oper 1)))))))
(rc exp #t)
(list total oper always-evaled)))
(define (binding-frame var env)
(cond ((null? env) #f)
((or (eq? (caar env) 'let) (eq? (caar env) 'letrec))
(if (assq var (cadar env)) (car env) (binding-frame var (cdr env))))
((eq? (caar env) 'lambda)
(if (memq var (cadar env)) (car env) (binding-frame var (cdr env))))
(else
(fatal-error "ill-formed environment"))))
(define (bound-expr var frame)
(cond ((or (eq? (car frame) 'let) (eq? (car frame) 'letrec))
(cadr (assq var (cadr frame))))
((eq? (car frame) 'lambda)
not-constant)
(else
(fatal-error "ill-formed frame"))))
(define (add-binding val frame name)
(define (find-val val bindings)
(cond ((null? bindings) #f)
((equal? val (cadar bindings)) ; *kludge* equal? is not exactly what
(caar bindings)) ; we want...
(else
(find-val val (cdr bindings)))))
(or (find-val val (cadr frame))
(let ((var (new-variable name)))
(set-cdr! (get-last-pair (cadr frame)) (list (list var val)))
var)))
(define (for-each! proc! l) ; call proc! on each CONS CELL in the list 'l'
(if (not (null? l))
(begin (proc! l) (for-each! proc! (cdr l)))))
(define (arg-pattern exps) ; return the argument pattern (i.e. the list of
(if (null? exps) ; constants in 'exps' but with the not-constant
'() ; value wherever the corresponding expression in
(cons (if (const-expr? (car exps)) ; 'exps' is not a constant)
(const-value (car exps))
not-constant)
(arg-pattern (cdr exps)))))
;------------------------------------------------------------------------------
;
; Knowledge about primitive procedures.
(define *primitives*
(list
(cons 'car (lambda (args)
(and (= (length args) 1)
(pair? (car args))
(quot (car (car args))))))
(cons 'cdr (lambda (args)
(and (= (length args) 1)
(pair? (car args))
(quot (cdr (car args))))))
(cons '+ (lambda (args)
(and (every? number? args)
(quot (peval-sum args 0)))))
(cons '* (lambda (args)
(and (every? number? args)
(quot (product args 1)))))
(cons '- (lambda (args)
(and (> (length args) 0)
(every? number? args)
(quot (if (null? (cdr args))
(- (car args))
(- (car args) (peval-sum (cdr args) 0)))))))
(cons '/ (lambda (args)
(and (> (length args) 1)
(every? number? args)
(quot (if (null? (cdr args))
(/ (car args))
(/ (car args) (product (cdr args) 1)))))))
(cons '< (lambda (args)
(and (= (length args) 2)
(every? number? args)
(quot (< (car args) (cadr args))))))
(cons '= (lambda (args)
(and (= (length args) 2)
(every? number? args)
(quot (= (car args) (cadr args))))))
(cons '> (lambda (args)
(and (= (length args) 2)
(every? number? args)
(quot (> (car args) (cadr args))))))
(cons 'eq? (lambda (args)
(and (= (length args) 2)
(quot (eq? (car args) (cadr args))))))
(cons 'not (lambda (args)
(and (= (length args) 1)
(quot (not (car args))))))
(cons 'null? (lambda (args)
(and (= (length args) 1)
(quot (null? (car args))))))
(cons 'pair? (lambda (args)
(and (= (length args) 1)
(quot (pair? (car args))))))
(cons 'symbol? (lambda (args)
(and (= (length args) 1)
(quot (symbol? (car args))))))
)
)
(define (peval-sum lst n)
(if (null? lst)
n
(peval-sum (cdr lst) (+ n (car lst)))))
(define (product lst n)
(if (null? lst)
n
(product (cdr lst) (* n (car lst)))))
(define (reduce-global name args)
(let ((x (assq name *primitives*)))
(and x ((cdr x) args))))
(define (constant-fold-global name exprs)
(define (flatten args op)
(cond ((null? args)
'())
((and (pair? (car args)) (eq? (caar args) op))
(append (flatten (cdar args) op) (flatten (cdr args) op)))
(else
(cons (car args) (flatten (cdr args) op)))))
(let ((args (if (or (eq? name '+) (eq? name '*)) ; associative ops
(flatten exprs name)
exprs)))
(or (and (every? const-expr? args)
(reduce-global name (map const-value args)))
(let ((pattern (arg-pattern args)))
(let ((non-const (remove-constant args pattern))
(const (map const-value (extract-constant args pattern))))
(cond ((eq? name '+) ; + is commutative
(let ((x (reduce-global '+ const)))
(if x
(let ((y (const-value x)))
(cons '+
(if (= y 0) non-const (cons x non-const))))
(cons name args))))
((eq? name '*) ; * is commutative
(let ((x (reduce-global '* const)))
(if x
(let ((y (const-value x)))
(cons '*
(if (= y 1) non-const (cons x non-const))))
(cons name args))))
((eq? name 'cons)
(cond ((and (const-expr? (cadr args))
(null? (const-value (cadr args))))
(list 'list (car args)))
((and (pair? (cadr args))
(eq? (car (cadr args)) 'list))
(cons 'list (cons (car args) (cdr (cadr args)))))
(else
(cons name args))))
(else
(cons name args))))))))
;------------------------------------------------------------------------------
;
; Examples:
(define (try-peval proc args)
(peval-partial-evaluate proc args))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example1
'(lambda (a b c)
(if (null? a) b (+ (car a) c))))
;(try-peval example1 (list '(10 11) not-constant '1))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example2
'(lambda (x y)
(let ((q (lambda (a b) (if (< a 0) b (- 10 b)))))
(if (< x 0) (q (- y) (- x)) (q y x)))))
;(try-peval example2 (list not-constant '1))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example3
'(lambda (l n)
(letrec ((add-list
(lambda (l n)
(if (null? l)
'()
(cons (+ (car l) n) (add-list (cdr l) n))))))
(add-list l n))))
;(try-peval example3 (list not-constant '1))
;(try-peval example3 (list '(1 2 3) not-constant))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example4
'(lambda (exp env)
(letrec ((eval
(lambda (exp env)
(letrec ((eval-list
(lambda (l env)
(if (null? l)
'()
(cons (eval (car l) env)
(eval-list (cdr l) env))))))
(if (symbol? exp) (lookup exp env)
(if (not (pair? exp)) exp
(if (eq? (car exp) 'quote) (car (cdr exp))
(apply (eval (car exp) env)
(eval-list (cdr exp) env)))))))))
(eval exp env))))
;(try-peval example4 (list 'x not-constant))
;(try-peval example4 (list '(f 1 2 3) not-constant))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example5
'(lambda (a b)
(letrec ((funct
(lambda (x)
(+ x b (if (< x 1) 0 (funct (- x 1)))))))
(funct a))))
;(try-peval example5 (list '5 not-constant))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example6
'(lambda ()
(letrec ((fib
(lambda (x)
(if (< x 2) x (+ (fib (- x 1)) (fib (- x 2)))))))
(fib 10))))
;(try-peval example6 '())
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example7
'(lambda (input)
(letrec ((copy (lambda (in)
(if (pair? in)
(cons (copy (car in))
(copy (cdr in)))
in))))
(copy input))))
;(try-peval example7 (list '(a b c d e f g h i j k l m n o p q r s t u v w x y z)))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define example8
'(lambda (input)
(letrec ((reverse (lambda (in result)
(if (pair? in)
(reverse (cdr in) (cons (car in) result))
result))))
(reverse input '()))))
;(try-peval example8 (list '(a b c d e f g h i j k l m n o p q r s t u v w x y z)))
; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(define (peval-test)
(set! *current-num* 0)
(list (try-peval example1 (list '(10 11) not-constant '1))
(try-peval example2 (list not-constant '1))
(try-peval example3 (list not-constant '1))
(try-peval example3 (list '(1 2 3) not-constant))
(try-peval example4 (list 'x not-constant))
(try-peval example4 (list '(f 1 2 3) not-constant))
(try-peval example5 (list '5 not-constant))
(try-peval example6 '())
(try-peval
example7
(list '(a b c d e f g h i j k l m n o p q r s t u v w x y z)))
(try-peval
example8
(list '(a b c d e f g h i j k l m n o p q r s t u v w x y z)))))
(define (main-peval . args)
(run-single-benchmark
"peval"
peval-iters
(lambda (result)
(and (list? result)
(= (length result) 10)
(equal? (list-ref result 9)
'(lambda ()
(list 'z 'y 'x 'w 'v 'u 't 's 'r 'q 'p 'o 'n
'm 'l 'k 'j 'i 'h 'g 'f 'e 'd 'c 'b 'a)))))
(lambda () (lambda () (peval-test)))))
;;; PNPOLY - Test if a point is contained in a 2D polygon.
(define (pt-in-poly2 xp yp x y)
(let loop ((c #f) (i (- (FLOATvector-length xp) 1)) (j 0))
(if (< i 0)
c
(if (or (and (or (FLOAT> (FLOATvector-ref yp i) y)
(FLOAT>= y (FLOATvector-ref yp j)))
(or (FLOAT> (FLOATvector-ref yp j) y)
(FLOAT>= y (FLOATvector-ref yp i))))
(FLOAT>= x
(FLOAT+ (FLOATvector-ref xp i)
(FLOAT/ (FLOAT*
(FLOAT- (FLOATvector-ref xp j)
(FLOATvector-ref xp i))
(FLOAT- y (FLOATvector-ref yp i)))
(FLOAT- (FLOATvector-ref yp j)
(FLOATvector-ref yp i))))))
(loop c (- i 1) i)
(loop (not c) (- i 1) i)))))
(define (pnpoly-run)
(let ((count 0)
(xp (FLOATvector-const 0. 1. 1. 0. 0. 1. -.5 -1. -1. -2. -2.5
-2. -1.5 -.5 1. 1. 0. -.5 -1. -.5))
(yp (FLOATvector-const 0. 0. 1. 1. 2. 3. 2. 3. 0. -.5 -1.
-1.5 -2. -2. -1.5 -1. -.5 -1. -1. -.5)))
(if (pt-in-poly2 xp yp .5 .5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp .5 1.5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -.5 1.5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp .75 2.25) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp 0. 2.01) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -.5 2.5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -1. -.5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -1.5 .5) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -2.25 -1.) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp .5 -.25) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp .5 -1.25) (set! count (+ count 1)))
(if (pt-in-poly2 xp yp -.5 -2.5) (set! count (+ count 1)))
count))
(define (main-pnpoly . args)
(run-single-benchmark
"pnpoly"
pnpoly-iters
(lambda (result)
(and (number? result) (= result 6)))
(lambda () (lambda () (pnpoly-run)))))
;;; PRIMES -- Compute primes less than 100, written by Eric Mohr.
(define (interval-list m n)
(if (> m n)
'()
(cons m (interval-list (+ 1 m) n))))
(define (sieve l)
(letrec ((remove-multiples
(lambda (n l)
(if (null? l)
'()
(if (= (modulo (car l) n) 0)
(remove-multiples n (cdr l))
(cons (car l)
(remove-multiples n (cdr l))))))))
(if (null? l)
'()
(cons (car l)
(sieve (remove-multiples (car l) (cdr l)))))))
(define (primes<= n)
(sieve (interval-list 2 n)))
(define (main-primes)
(run-single-benchmark
"primes"
primes-iters
(lambda (result)
(equal? result
'(2 3 5 7 11 13 17 19 23 29 31 37 41
43 47 53 59 61 67 71 73 79 83 89 97)))
(lambda (n) (lambda () (primes<= n)))
100))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; File: sboyer.sch
; Description: The Boyer benchmark
; Author: Bob Boyer
; Created: 5-Apr-85
; Modified: 10-Apr-85 14:52:20 (Bob Shaw)
; 22-Jul-87 (Will Clinger)
; 2-Jul-88 (Will Clinger -- distinguished #f and the empty list)
; 13-Feb-97 (Will Clinger -- fixed bugs in unifier and rules,
; rewrote to eliminate property lists, and added
; a scaling parameter suggested by Bob Boyer)
; 19-Mar-99 (Will Clinger -- cleaned up comments)
; Language: Scheme
; Status: Public Domain
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SBOYER -- Logic programming benchmark, originally written by Bob Boyer.
;;; Much less CONS-intensive than NBOYER because it uses Henry Baker's
;;; "sharing cons".
; Note: The version of this benchmark that appears in Dick Gabriel's book
; contained several bugs that are corrected here. These bugs are discussed
; by Henry Baker, "The Boyer Benchmark Meets Linear Logic", ACM SIGPLAN Lisp
; Pointers 6(4), October-December 1993, pages 3-10. The fixed bugs are:
;
; The benchmark now returns a boolean result.
; FALSEP and TRUEP use TERM-MEMBER? rather than MEMV (which is called MEMBER
; in Common Lisp)
; ONE-WAY-UNIFY1 now treats numbers correctly
; ONE-WAY-UNIFY1-LST now treats empty lists correctly
; Rule 19 has been corrected (this rule was not touched by the original
; benchmark, but is used by this version)
; Rules 84 and 101 have been corrected (but these rules are never touched
; by the benchmark)
;
; According to Baker, these bug fixes make the benchmark 10-25% slower.
; Please do not compare the timings from this benchmark against those of
; the original benchmark.
;
; This version of the benchmark also prints the number of rewrites as a sanity
; check, because it is too easy for a buggy version to return the correct
; boolean result. The correct number of rewrites is
;
; n rewrites peak live storage (approximate, in bytes)
; 0 95024
; 1 591777
; 2 1813975
; 3 5375678
; 4 16445406
; 5 51507739
; Sboyer is a 2-phase benchmark.
; The first phase attaches lemmas to symbols. This phase is not timed,
; but it accounts for very little of the runtime anyway.
; The second phase creates the test problem, and tests to see
; whether it is implied by the lemmas.
(define (main-sboyer . args)
(let ((n (if (null? args) 0 (car args))))
(setup-boyer)
(run-single-benchmark
(string-append "sboyer"
(number->string n))
sboyer-iters
(lambda (rewrites)
(and (number? rewrites)
(case n
((0) (= rewrites 95024))
((1) (= rewrites 591777))
((2) (= rewrites 1813975))
((3) (= rewrites 5375678))
((4) (= rewrites 16445406))
((5) (= rewrites 51507739))
; If it works for n <= 5, assume it works.
(else #t))))
(lambda (alist term n) (lambda () (test-boyer alist term n)))
(quote ((x f (plus (plus a b)
(plus c (zero))))
(y f (times (times a b)
(plus c d)))
(z f (reverse (append (append a b)
(nil))))
(u equal (plus a b)
(difference x y))
(w lessp (remainder a b)
(member a (length b)))))
(quote (implies (and (implies x y)
(and (implies y z)
(and (implies z u)
(implies u w))))
(implies x w)))
n)))
(define (setup-boyer) #t) ; assigned below
(define (test-boyer) #t) ; assigned below
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; The first phase.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; In the original benchmark, it stored a list of lemmas on the
; property lists of symbols.
; In the new benchmark, it maintains an association list of
; symbols and symbol-records, and stores the list of lemmas
; within the symbol-records.
(let ()
(define (setup)
(add-lemma-lst
(quote ((equal (compile form)
(reverse (codegen (optimize form)
(nil))))
(equal (eqp x y)
(equal (fix x)
(fix y)))
(equal (greaterp x y)
(lessp y x))
(equal (lesseqp x y)
(not (lessp y x)))
(equal (greatereqp x y)
(not (lessp x y)))
(equal (boolean x)
(or (equal x (t))
(equal x (f))))
(equal (iff x y)
(and (implies x y)
(implies y x)))
(equal (even1 x)
(if (zerop x)
(t)
(odd (_1- x))))
(equal (countps- l pred)
(countps-loop l pred (zero)))
(equal (fact- i)
(fact-loop i 1))
(equal (reverse- x)
(reverse-loop x (nil)))
(equal (divides x y)
(zerop (remainder y x)))
(equal (assume-true var alist)
(cons (cons var (t))
alist))
(equal (assume-false var alist)
(cons (cons var (f))
alist))
(equal (tautology-checker x)
(tautologyp (normalize x)
(nil)))
(equal (falsify x)
(falsify1 (normalize x)
(nil)))
(equal (prime x)
(and (not (zerop x))
(not (equal x (add1 (zero))))
(prime1 x (_1- x))))
(equal (and p q)
(if p (if q (t)
(f))
(f)))
(equal (or p q)
(if p (t)
(if q (t)
(f))))
(equal (not p)
(if p (f)
(t)))
(equal (implies p q)
(if p (if q (t)
(f))
(t)))
(equal (fix x)
(if (numberp x)
x
(zero)))
(equal (if (if a b c)
d e)
(if a (if b d e)
(if c d e)))
(equal (zerop x)
(or (equal x (zero))
(not (numberp x))))
(equal (plus (plus x y)
z)
(plus x (plus y z)))
(equal (equal (plus a b)
(zero))
(and (zerop a)
(zerop b)))
(equal (difference x x)
(zero))
(equal (equal (plus a b)
(plus a c))
(equal (fix b)
(fix c)))
(equal (equal (zero)
(difference x y))
(not (lessp y x)))
(equal (equal x (difference x y))
(and (numberp x)
(or (equal x (zero))
(zerop y))))
(equal (meaning (plus-tree (append x y))
a)
(plus (meaning (plus-tree x)
a)
(meaning (plus-tree y)
a)))
(equal (meaning (plus-tree (plus-fringe x))
a)
(fix (meaning x a)))
(equal (append (append x y)
z)
(append x (append y z)))
(equal (reverse (append a b))
(append (reverse b)
(reverse a)))
(equal (times x (plus y z))
(plus (times x y)
(times x z)))
(equal (times (times x y)
z)
(times x (times y z)))
(equal (equal (times x y)
(zero))
(or (zerop x)
(zerop y)))
(equal (exec (append x y)
pds envrn)
(exec y (exec x pds envrn)
envrn))
(equal (mc-flatten x y)
(append (flatten x)
y))
(equal (member x (append a b))
(or (member x a)
(member x b)))
(equal (member x (reverse y))
(member x y))
(equal (length (reverse x))
(length x))
(equal (member a (intersect b c))
(and (member a b)
(member a c)))
(equal (nth (zero)
i)
(zero))
(equal (exp i (plus j k))
(times (exp i j)
(exp i k)))
(equal (exp i (times j k))
(exp (exp i j)
k))
(equal (reverse-loop x y)
(append (reverse x)
y))
(equal (reverse-loop x (nil))
(reverse x))
(equal (count-list z (sort-lp x y))
(plus (count-list z x)
(count-list z y)))
(equal (equal (append a b)
(append a c))
(equal b c))
(equal (plus (remainder x y)
(times y (quotient x y)))
(fix x))
(equal (power-eval (big-plus1 l i base)
base)
(plus (power-eval l base)
i))
(equal (power-eval (big-plus x y i base)
base)
(plus i (plus (power-eval x base)
(power-eval y base))))
(equal (remainder y 1)
(zero))
(equal (lessp (remainder x y)
y)
(not (zerop y)))
(equal (remainder x x)
(zero))
(equal (lessp (quotient i j)
i)
(and (not (zerop i))
(or (zerop j)
(not (equal j 1)))))
(equal (lessp (remainder x y)
x)
(and (not (zerop y))
(not (zerop x))
(not (lessp x y))))
(equal (power-eval (power-rep i base)
base)
(fix i))
(equal (power-eval (big-plus (power-rep i base)
(power-rep j base)
(zero)
base)
base)
(plus i j))
(equal (gcd x y)
(gcd y x))
(equal (nth (append a b)
i)
(append (nth a i)
(nth b (difference i (length a)))))
(equal (difference (plus x y)
x)
(fix y))
(equal (difference (plus y x)
x)
(fix y))
(equal (difference (plus x y)
(plus x z))
(difference y z))
(equal (times x (difference c w))
(difference (times c x)
(times w x)))
(equal (remainder (times x z)
z)
(zero))
(equal (difference (plus b (plus a c))
a)
(plus b c))
(equal (difference (add1 (plus y z))
z)
(add1 y))
(equal (lessp (plus x y)
(plus x z))
(lessp y z))
(equal (lessp (times x z)
(times y z))
(and (not (zerop z))
(lessp x y)))
(equal (lessp y (plus x y))
(not (zerop x)))
(equal (gcd (times x z)
(times y z))
(times z (gcd x y)))
(equal (value (normalize x)
a)
(value x a))
(equal (equal (flatten x)
(cons y (nil)))
(and (nlistp x)
(equal x y)))
(equal (listp (gopher x))
(listp x))
(equal (samefringe x y)
(equal (flatten x)
(flatten y)))
(equal (equal (greatest-factor x y)
(zero))
(and (or (zerop y)
(equal y 1))
(equal x (zero))))
(equal (equal (greatest-factor x y)
1)
(equal x 1))
(equal (numberp (greatest-factor x y))
(not (and (or (zerop y)
(equal y 1))
(not (numberp x)))))
(equal (times-list (append x y))
(times (times-list x)
(times-list y)))
(equal (prime-list (append x y))
(and (prime-list x)
(prime-list y)))
(equal (equal z (times w z))
(and (numberp z)
(or (equal z (zero))
(equal w 1))))
(equal (greatereqp x y)
(not (lessp x y)))
(equal (equal x (times x y))
(or (equal x (zero))
(and (numberp x)
(equal y 1))))
(equal (remainder (times y x)
y)
(zero))
(equal (equal (times a b)
1)
(and (not (equal a (zero)))
(not (equal b (zero)))
(numberp a)
(numberp b)
(equal (_1- a)
(zero))
(equal (_1- b)
(zero))))
(equal (lessp (length (delete x l))
(length l))
(member x l))
(equal (sort2 (delete x l))
(delete x (sort2 l)))
(equal (dsort x)
(sort2 x))
(equal (length (cons x1
(cons x2
(cons x3 (cons x4
(cons x5
(cons x6 x7)))))))
(plus 6 (length x7)))
(equal (difference (add1 (add1 x))
2)
(fix x))
(equal (quotient (plus x (plus x y))
2)
(plus x (quotient y 2)))
(equal (sigma (zero)
i)
(quotient (times i (add1 i))
2))
(equal (plus x (add1 y))
(if (numberp y)
(add1 (plus x y))
(add1 x)))
(equal (equal (difference x y)
(difference z y))
(if (lessp x y)
(not (lessp y z))
(if (lessp z y)
(not (lessp y x))
(equal (fix x)
(fix z)))))
(equal (meaning (plus-tree (delete x y))
a)
(if (member x y)
(difference (meaning (plus-tree y)
a)
(meaning x a))
(meaning (plus-tree y)
a)))
(equal (times x (add1 y))
(if (numberp y)
(plus x (times x y))
(fix x)))
(equal (nth (nil)
i)
(if (zerop i)
(nil)
(zero)))
(equal (last (append a b))
(if (listp b)
(last b)
(if (listp a)
(cons (car (last a))
b)
b)))
(equal (equal (lessp x y)
z)
(if (lessp x y)
(equal (t) z)
(equal (f) z)))
(equal (assignment x (append a b))
(if (assignedp x a)
(assignment x a)
(assignment x b)))
(equal (car (gopher x))
(if (listp x)
(car (flatten x))
(zero)))
(equal (flatten (cdr (gopher x)))
(if (listp x)
(cdr (flatten x))
(cons (zero)
(nil))))
(equal (quotient (times y x)
y)
(if (zerop y)
(zero)
(fix x)))
(equal (get j (set i val mem))
(if (eqp j i)
val
(get j mem)))))))
(define (add-lemma-lst lst)
(cond ((null? lst)
#t)
(else (add-lemma (car lst))
(add-lemma-lst (cdr lst)))))
(define (add-lemma term)
(cond ((and (pair? term)
(eq? (car term)
(quote equal))
(pair? (cadr term)))
(put (car (cadr term))
(quote lemmas)
(cons
(translate-term term)
(get (car (cadr term)) (quote lemmas)))))
(else (fatal-error "ADD-LEMMA did not like term: " term))))
; Translates a term by replacing its constructor symbols by symbol-records.
(define (translate-term term)
(cond ((not (pair? term))
term)
(else (cons (symbol->symbol-record (car term))
(translate-args (cdr term))))))
(define (translate-args lst)
(cond ((null? lst)
'())
(else (cons (translate-term (car lst))
(translate-args (cdr lst))))))
; For debugging only, so the use of MAP does not change
; the first-order character of the benchmark.
(define (untranslate-term term)
(cond ((not (pair? term))
term)
(else (cons (get-name (car term))
(map untranslate-term (cdr term))))))
; A symbol-record is represented as a vector with two fields:
; the symbol (for debugging) and
; the list of lemmas associated with the symbol.
(define (put sym property value)
(put-lemmas! (symbol->symbol-record sym) value))
(define (get sym property)
(get-lemmas (symbol->symbol-record sym)))
(define (symbol->symbol-record sym)
(let ((x (assq sym *symbol-records-alist*)))
(if x
(cdr x)
(let ((r (make-symbol-record sym)))
(set! *symbol-records-alist*
(cons (cons sym r)
*symbol-records-alist*))
r))))
; Association list of symbols and symbol-records.
(define *symbol-records-alist* '())
; A symbol-record is represented as a vector with two fields:
; the symbol (for debugging) and
; the list of lemmas associated with the symbol.
(define (make-symbol-record sym)
(vector sym '()))
(define (put-lemmas! symbol-record lemmas)
(vector-set! symbol-record 1 lemmas))
(define (get-lemmas symbol-record)
(vector-ref symbol-record 1))
(define (get-name symbol-record)
(vector-ref symbol-record 0))
(define (symbol-record-equal? r1 r2)
(eq? r1 r2))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; The second phase.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (test alist term n)
(let ((term
(apply-subst
(translate-alist alist)
(translate-term
(do ((term term (list 'or term '(f)))
(n n (- n 1)))
((zero? n) term))))))
(tautp term)))
(define (translate-alist alist)
(cond ((null? alist)
'())
(else (cons (cons (caar alist)
(translate-term (cdar alist)))
(translate-alist (cdr alist))))))
(define (apply-subst alist term)
(cond ((not (pair? term))
(let ((temp-temp (assq term alist)))
(if temp-temp
(cdr temp-temp)
term)))
(else (cons (car term)
(apply-subst-lst alist (cdr term))))))
(define (apply-subst-lst alist lst)
(cond ((null? lst)
'())
(else (cons (apply-subst alist (car lst))
(apply-subst-lst alist (cdr lst))))))
(define (tautp x)
(tautologyp (rewrite x)
'() '()))
(define (tautologyp x true-lst false-lst)
(cond ((truep x true-lst)
#t)
((falsep x false-lst)
#f)
((not (pair? x))
#f)
((eq? (car x) if-constructor)
(cond ((truep (cadr x)
true-lst)
(tautologyp (caddr x)
true-lst false-lst))
((falsep (cadr x)
false-lst)
(tautologyp (cadddr x)
true-lst false-lst))
(else (and (tautologyp (caddr x)
(cons (cadr x)
true-lst)
false-lst)
(tautologyp (cadddr x)
true-lst
(cons (cadr x)
false-lst))))))
(else #f)))
(define if-constructor '*) ; becomes (symbol->symbol-record 'if)
(define rewrite-count 0) ; sanity check
; The next procedure is Henry Baker's sharing CONS, which avoids
; allocation if the result is already in hand.
; The REWRITE and REWRITE-ARGS procedures have been modified to
; use SCONS instead of CONS.
(define (scons x y original)
(if (and (eq? x (car original))
(eq? y (cdr original)))
original
(cons x y)))
(define (rewrite term)
(set! rewrite-count (+ rewrite-count 1))
(cond ((not (pair? term))
term)
(else (rewrite-with-lemmas (scons (car term)
(rewrite-args (cdr term))
term)
(get-lemmas (car term))))))
(define (rewrite-args lst)
(cond ((null? lst)
'())
(else (scons (rewrite (car lst))
(rewrite-args (cdr lst))
lst))))
(define (rewrite-with-lemmas term lst)
(cond ((null? lst)
term)
((one-way-unify term (cadr (car lst)))
(rewrite (apply-subst unify-subst (caddr (car lst)))))
(else (rewrite-with-lemmas term (cdr lst)))))
(define unify-subst '*)
(define (one-way-unify term1 term2)
(begin (set! unify-subst '())
(one-way-unify1 term1 term2)))
(define (one-way-unify1 term1 term2)
(cond ((not (pair? term2))
(let ((temp-temp (assq term2 unify-subst)))
(cond (temp-temp
(term-equal? term1 (cdr temp-temp)))
((number? term2) ; This bug fix makes
(equal? term1 term2)) ; nboyer 10-25% slower!
(else
(set! unify-subst (cons (cons term2 term1)
unify-subst))
#t))))
((not (pair? term1))
#f)
((eq? (car term1)
(car term2))
(one-way-unify1-lst (cdr term1)
(cdr term2)))
(else #f)))
(define (one-way-unify1-lst lst1 lst2)
(cond ((null? lst1)
(null? lst2))
((null? lst2)
#f)
((one-way-unify1 (car lst1)
(car lst2))
(one-way-unify1-lst (cdr lst1)
(cdr lst2)))
(else #f)))
(define (falsep x lst)
(or (term-equal? x false-term)
(term-member? x lst)))
(define (truep x lst)
(or (term-equal? x true-term)
(term-member? x lst)))
(define false-term '*) ; becomes (translate-term '(f))
(define true-term '*) ; becomes (translate-term '(t))
; The next two procedures were in the original benchmark
; but were never used.
(define (trans-of-implies n)
(translate-term
(list (quote implies)
(trans-of-implies1 n)
(list (quote implies)
0 n))))
(define (trans-of-implies1 n)
(cond ((equal? n 1)
(list (quote implies)
0 1))
(else (list (quote and)
(list (quote implies)
(- n 1)
n)
(trans-of-implies1 (- n 1))))))
; Translated terms can be circular structures, which can't be
; compared using Scheme's equal? and member procedures, so we
; use these instead.
(define (term-equal? x y)
(cond ((pair? x)
(and (pair? y)
(symbol-record-equal? (car x) (car y))
(term-args-equal? (cdr x) (cdr y))))
(else (equal? x y))))
(define (term-args-equal? lst1 lst2)
(cond ((null? lst1)
(null? lst2))
((null? lst2)
#f)
((term-equal? (car lst1) (car lst2))
(term-args-equal? (cdr lst1) (cdr lst2)))
(else #f)))
(define (term-member? x lst)
(cond ((null? lst)
#f)
((term-equal? x (car lst))
#t)
(else (term-member? x (cdr lst)))))
(set! setup-boyer
(lambda ()
(set! *symbol-records-alist* '())
(set! if-constructor (symbol->symbol-record 'if))
(set! false-term (translate-term '(f)))
(set! true-term (translate-term '(t)))
(setup)))
(set! test-boyer
(lambda (alist term n)
(set! rewrite-count 0)
(let ((answer (test alist term n)))
; (write rewrite-count)
; (display " rewrites")
; (newline)
(if answer
rewrite-count
#f)))))
;;; SIMPLEX -- Simplex algorithm.
(define (matrix-rows a) (vector-length a))
(define (matrix-columns a) (FLOATvector-length (vector-ref a 0)))
(define (matrix-ref a i j) (FLOATvector-ref (vector-ref a i) j))
(define (matrix-set! a i j x) (FLOATvector-set! (vector-ref a i) j x))
(define (fuck-up)
(fatal-error "This shouldn't happen"))
(define (simplex a m1 m2 m3)
(define *epsilon* 1e-6)
(if (not (and (>= m1 0)
(>= m2 0)
(>= m3 0)
(= (matrix-rows a) (+ m1 m2 m3 2))))
(fuck-up))
(let* ((m12 (+ m1 m2 1))
(m (- (matrix-rows a) 2))
(n (- (matrix-columns a) 1))
(l1 (make-vector n))
(l2 (make-vector m))
(l3 (make-vector m2))
(nl1 n)
(iposv (make-vector m))
(izrov (make-vector n))
(ip 0)
(kp 0)
(bmax 0.0)
(one? #f)
(pass2? #t))
(define (simp1 mm abs?)
(set! kp (vector-ref l1 0))
(set! bmax (matrix-ref a mm kp))
(do ((k 1 (+ k 1))) ((>= k nl1))
(if (FLOATpositive?
(if abs?
(FLOAT- (FLOATabs (matrix-ref a mm (vector-ref l1 k)))
(FLOATabs bmax))
(FLOAT- (matrix-ref a mm (vector-ref l1 k)) bmax)))
(begin
(set! kp (vector-ref l1 k))
(set! bmax (matrix-ref a mm (vector-ref l1 k)))))))
(define (simp2)
(set! ip 0)
(let ((q1 0.0)
(flag? #f))
(do ((i 0 (+ i 1))) ((= i m))
(if flag?
(if (FLOAT< (matrix-ref a (vector-ref l2 i) kp) (FLOAT- *epsilon*))
(begin
(let ((q (FLOAT/ (FLOAT- (matrix-ref a (vector-ref l2 i) 0))
(matrix-ref a (vector-ref l2 i) kp))))
(cond
((FLOAT< q q1)
(set! ip (vector-ref l2 i))
(set! q1 q))
((FLOAT= q q1)
(let ((qp 0.0)
(q0 0.0))
(let loop ((k 1))
(if (<= k n)
(begin
(set! qp (FLOAT/ (FLOAT- (matrix-ref a ip k))
(matrix-ref a ip kp)))
(set! q0 (FLOAT/ (FLOAT-
(matrix-ref a (vector-ref l2 i) k))
(matrix-ref a (vector-ref l2 i) kp)))
(if (FLOAT= q0 qp)
(loop (+ k 1))))))
(if (FLOAT< q0 qp)
(set! ip (vector-ref l2 i)))))))))
(if (FLOAT< (matrix-ref a (vector-ref l2 i) kp) (FLOAT- *epsilon*))
(begin
(set! q1 (FLOAT/ (FLOAT- (matrix-ref a (vector-ref l2 i) 0))
(matrix-ref a (vector-ref l2 i) kp)))
(set! ip (vector-ref l2 i))
(set! flag? #t)))))))
(define (simp3 one?)
(let ((piv (FLOAT/ (matrix-ref a ip kp))))
(do ((ii 0 (+ ii 1))) ((= ii (+ m (if one? 2 1))))
(if (not (= ii ip))
(begin
(matrix-set! a ii kp (FLOAT* piv (matrix-ref a ii kp)))
(do ((kk 0 (+ kk 1))) ((= kk (+ n 1)))
(if (not (= kk kp))
(matrix-set! a ii kk (FLOAT- (matrix-ref a ii kk)
(FLOAT* (matrix-ref a ip kk)
(matrix-ref a ii kp)))))))))
(do ((kk 0 (+ kk 1))) ((= kk (+ n 1)))
(if (not (= kk kp))
(matrix-set! a ip kk (FLOAT* (FLOAT- piv) (matrix-ref a ip kk)))))
(matrix-set! a ip kp piv)))
(do ((k 0 (+ k 1))) ((= k n))
(vector-set! l1 k (+ k 1))
(vector-set! izrov k k))
(do ((i 0 (+ i 1))) ((= i m))
(if (FLOATnegative? (matrix-ref a (+ i 1) 0))
(fuck-up))
(vector-set! l2 i (+ i 1))
(vector-set! iposv i (+ n i)))
(do ((i 0 (+ i 1))) ((= i m2)) (vector-set! l3 i #t))
(if (positive? (+ m2 m3))
(begin
(do ((k 0 (+ k 1))) ((= k (+ n 1)))
(do ((i (+ m1 1) (+ i 1)) (sum 0.0 (FLOAT+ sum (matrix-ref a i k))))
((> i m) (matrix-set! a (+ m 1) k (FLOAT- sum)))))
(let loop ()
(simp1 (+ m 1) #f)
(cond
((FLOAT<= bmax *epsilon*)
(cond ((FLOAT< (matrix-ref a (+ m 1) 0) (FLOAT- *epsilon*))
(set! pass2? #f))
((FLOAT<= (matrix-ref a (+ m 1) 0) *epsilon*)
(let loop ((ip1 m12))
(if (<= ip1 m)
(cond ((= (vector-ref iposv (- ip1 1)) (+ ip n -1))
(simp1 ip1 #t)
(cond ((FLOATpositive? bmax)
(set! ip ip1)
(set! one? #t))
(else
(loop (+ ip1 1)))))
(else
(loop (+ ip1 1))))
(do ((i (+ m1 1) (+ i 1))) ((>= i m12))
(if (vector-ref l3 (- i (+ m1 1)))
(do ((k 0 (+ k 1))) ((= k (+ n 1)))
(matrix-set! a i k (FLOAT- (matrix-ref a i k)))))))))
(else (simp2) (if (zero? ip) (set! pass2? #f) (set! one? #t)))))
(else (simp2) (if (zero? ip) (set! pass2? #f) (set! one? #t))))
(if one?
(begin
(set! one? #f)
(simp3 #t)
(cond
((>= (vector-ref iposv (- ip 1)) (+ n m12 -1))
(let loop ((k 0))
(cond
((and (< k nl1) (not (= kp (vector-ref l1 k))))
(loop (+ k 1)))
(else
(set! nl1 (- nl1 1))
(do ((is k (+ is 1))) ((>= is nl1))
(vector-set! l1 is (vector-ref l1 (+ is 1))))
(matrix-set! a (+ m 1) kp (FLOAT+ (matrix-ref a (+ m 1) kp) 1.0))
(do ((i 0 (+ i 1))) ((= i (+ m 2)))
(matrix-set! a i kp (FLOAT- (matrix-ref a i kp))))))))
((and (>= (vector-ref iposv (- ip 1)) (+ n m1))
(vector-ref l3 (- (vector-ref iposv (- ip 1)) (+ m1 n))))
(vector-set! l3 (- (vector-ref iposv (- ip 1)) (+ m1 n)) #f)
(matrix-set! a (+ m 1) kp (FLOAT+ (matrix-ref a (+ m 1) kp) 1.0))
(do ((i 0 (+ i 1))) ((= i (+ m 2)))
(matrix-set! a i kp (FLOAT- (matrix-ref a i kp))))))
(let ((t (vector-ref izrov (- kp 1))))
(vector-set! izrov (- kp 1) (vector-ref iposv (- ip 1)))
(vector-set! iposv (- ip 1) t))
(loop))))))
(and pass2?
(let loop ()
(simp1 0 #f)
(cond
((FLOATpositive? bmax)
(simp2)
(cond ((zero? ip) #t)
(else (simp3 #f)
(let ((t (vector-ref izrov (- kp 1))))
(vector-set! izrov (- kp 1) (vector-ref iposv (- ip 1)))
(vector-set! iposv (- ip 1) t))
(loop))))
(else (list iposv izrov)))))))
(define (simplex-test)
(simplex (vector (FLOATvector 0.0 1.0 1.0 3.0 -0.5)
(FLOATvector 740.0 -1.0 0.0 -2.0 0.0)
(FLOATvector 0.0 0.0 -2.0 0.0 7.0)
(FLOATvector 0.5 0.0 -1.0 1.0 -2.0)
(FLOATvector 9.0 -1.0 -1.0 -1.0 -1.0)
(FLOATvector 0.0 0.0 0.0 0.0 0.0))
2 1 1))
(define (main-simplex . args)
(run-single-benchmark
"simplex"
simplex-iters
(lambda (result) (equal? result '(#(4 1 3 2) #(0 5 7 6))))
(lambda () (lambda () (simplex-test)))))
;;; SUMFP -- Compute sum of integers from 0 to 10000 using floating point
(define (sumfp-run n)
(let loop ((i n) (sum 0.))
(if (FLOAT< i 0.)
sum
(loop (FLOAT- i 1.) (FLOAT+ i sum)))))
(define (main-sumfp . args)
(run-single-benchmark
"sumfp"
sumfp-iters
(lambda (result) (equal? result 50005000.))
(lambda (n) (lambda () (sumfp-run n)))
10000.))
;;; SUMLOOP -- One of the Kernighan and Van Wyk benchmarks.
(define lsum 0)
(define (tail-rec-aux i n)
(if (< i n)
(begin (set! lsum (+ lsum 1)) (tail-rec-aux (+ i 1) n))
lsum))
(define (tail-rec-loop n)
(set! lsum 0)
(tail-rec-aux 0 n)
lsum)
(define (do-loop n)
(set! lsum 0)
(do ((i 0 (+ i 1)))
((>= i n) lsum)
(set! lsum (+ lsum 1))))
(define (main-sumloop . args)
(run-single-benchmark
"sumloop"
sumloop-iters
(lambda (result) (equal? result 100000000))
(lambda (n) (lambda () (do-loop n)))
100000000))
;;; SUM -- Compute sum of integers from 0 to 10000
(define (sum-run n)
(let loop ((i n) (sum 0))
(if (< i 0)
sum
(loop (- i 1) (+ i sum)))))
(define (main-sum . args)
(run-single-benchmark
"sum"
sum-iters
(lambda (result) (equal? result 50005000))
(lambda (n) (lambda () (sum-run n)))
10000))
;;; TAKL -- The TAKeuchi function using lists as counters.
(define (listn n)
(if (= n 0)
'()
(cons n (listn (- n 1)))))
(define l18 (listn 18))
(define l12 (listn 12))
(define l6 (listn 6))
(define (mas x y z)
(if (not (shorterp y x))
z
(mas (mas (cdr x) y z)
(mas (cdr y) z x)
(mas (cdr z) x y))))
(define (shorterp x y)
(and (not (null? y))
(or (null? x)
(shorterp (cdr x)
(cdr y)))))
(define (main-takl . args)
(run-single-benchmark
"takl"
takl-iters
(lambda (result) (equal? result '(7 6 5 4 3 2 1)))
(lambda (x y z) (lambda () (mas x y z)))
l18
l12
l6))
;;; TAK -- A vanilla version of the TAKeuchi function.
(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 (main-tak . args)
(run-single-benchmark
"tak"
tak-iters
(lambda (result) (equal? result 7))
(lambda (x y z) (lambda () (tak x y z)))
18
12
6))
;;; TRIANGL -- Board game benchmark.
(define *board*
(list->vector '(1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1)))
(define *sequence*
(list->vector '(0 0 0 0 0 0 0 0 0 0 0 0 0 0)))
(define *a*
(list->vector '(1 2 4 3 5 6 1 3 6 2 5 4 11 12
13 7 8 4 4 7 11 8 12 13 6 10
15 9 14 13 13 14 15 9 10
6 6)))
(define *b*
(list->vector '(2 4 7 5 8 9 3 6 10 5 9 8
12 13 14 8 9 5 2 4 7 5 8
9 3 6 10 5 9 8 12 13 14
8 9 5 5)))
(define *c*
(list->vector '(4 7 11 8 12 13 6 10 15 9 14 13
13 14 15 9 10 6 1 2 4 3 5 6 1
3 6 2 5 4 11 12 13 7 8 4 4)))
(define *answer* '())
(define (attempt i depth)
(cond ((= depth 14)
(set! *answer*
(cons (cdr (vector->list *sequence*)) *answer*))
#t)
((and (= 1 (vector-ref *board* (vector-ref *a* i)))
(= 1 (vector-ref *board* (vector-ref *b* i)))
(= 0 (vector-ref *board* (vector-ref *c* i))))
(vector-set! *board* (vector-ref *a* i) 0)
(vector-set! *board* (vector-ref *b* i) 0)
(vector-set! *board* (vector-ref *c* i) 1)
(vector-set! *sequence* depth i)
(do ((j 0 (+ j 1))
(depth (+ depth 1)))
((or (= j 36) (attempt j depth)) #f))
(vector-set! *board* (vector-ref *a* i) 1)
(vector-set! *board* (vector-ref *b* i) 1)
(vector-set! *board* (vector-ref *c* i) 0) #f)
(else #f)))
(define (triangl-test i depth)
(set! *answer* '())
(attempt i depth)
(car *answer*))
(define (main-triangl . args)
(run-single-benchmark
"triangl"
triangl-iters
(lambda (result) (equal? result '(22 34 31 15 7 1 20 17 25 6 5 13 32)))
(lambda (i depth) (lambda () (triangl-test i depth)))
22
1))
(define (run-all)
(main-ack)
(main-array1)
(main-boyer)
(main-browse)
(main-compiler)
(main-conform)
(main-cpstak)
(main-dderiv)
(main-deriv)
(main-destruc)
(main-diviter)
(main-divrec)
(main-earley)
(main-fftrad4)
(main-fft)
(main-fibfp)
(main-fib)
(main-graphs)
(main-lattice)
(main-mazefun)
(main-mbrot)
(main-nbody)
(main-nboyer)
(main-nqueens)
(main-nucleic)
(main-paraffins)
(main-perm9)
(main-peval)
(main-pnpoly)
(main-primes)
(main-sboyer)
(main-simplex)
(main-sumfp)
(main-sumloop)
(main-sum)
(main-takl)
(main-tak)
(main-triangl)
#t)
(define (main)
(run-benchmark
"all"
1
(lambda (result) (equal? result #t))
(lambda () (lambda () (run-all)))))
| false |
7cafdfdc970f03f1605877f181152fc9fa5029f1
|
e08b41ec60fa76d239295cfb9f344bfad0c4ce98
|
/scheme/imp2.scm
|
e4f7993ec364a4c88314dcf576151f8a708de4d9
|
[] |
no_license
|
scotfu/parser
|
4783ef375d57a4bdf22dc0ae5689f9f766b54ac6
|
4811ecf7789016a45b6108a458faa436d4386444
|
refs/heads/master
| 2018-12-27T23:15:35.000932 | 2014-05-23T16:30:12 | 2014-05-23T16:30:12 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 26,087 |
scm
|
imp2.scm
|
#! /usr/local/bin/guile -s
!#
(use-modules (oop goops))
(use-modules (oop goops describe))
(use-modules (ice-9 regex))
;token type constants
(define N_CONF 101 )
(define N_GLOBAL 102)
(define GLOBAL_KEYWORD 1021)
(define N_HOSTS 103)
(define N_HOST 1031)
(define HOST_KEYWORD 1032)
(define HOST_NAME 1033)
(define LEFT 104)
(define KV_PAIRS 105)
(define KV_PAIR 1051)
(define KEY 1052)
(define EQUAL 1053)
(define VALUE 1054)
(define QUOTED_STRING 10541)
(define STRING 10542)
(define INT 10543)
(define FLOAT 10544)
(define RIGHT 106)
(define SEMI 107)
(define COMMENT 108)
(define NEW_LINE 109)
(define ERROR 110)
(define file_name "test.cfg")
(define contents "")
(define tokens (make-list 0))
(define global_keys (make-list 0))
(define global_node_list (make-list 0))
(define global_lineno 1)
(define last_lineno 100)
(define-class <node> ()
(type #:init-value 0 #:getter get-type #:setter set-type! #:init-keyword #:type)
(value #:init-value 0 #:getter get-value #:setter set-value! #:init-keyword #:value)
(lineno #:init-value 0 #:getter get-lineno #:setter set-lineno! #:init-keyword #:lineno)
(c1 #:init-value 0 #:getter get-c1 #:setter set-c1! #:init-keyword #:c1)
(c2 #:init-value 0 #:getter get-c2 #:setter set-c2! #:init-keyword #:c2)
(c3 #:init-value 0 #:getter get-c3 #:setter set-c3! #:init-keyword #:c3)
(c4 #:init-value 0 #:getter get-c4 #:setter set-c4! #:init-keyword #:c4)
(c5 #:init-value 0 #:getter get-c5 #:setter set-c5! #:init-keyword #:c5)
(c6 #:init-value 0 #:getter get-c6 #:setter set-c6! #:init-keyword #:c6)
)
(define origin_car car)
(define car
(lambda (list)
(let (
(last_one 10000)
(last_node 0)
(out `())
)
(if (not (null? list))
(begin
; (display "using original")
(set! out (origin_car list))
)
(begin
(get_nodes root)
(begin
(set! last_one (length global_node_list))
(if (not (null? global_node_list))
(begin
(set! last_one (- last_one 1))
(set! last_node (list-ref global_node_list last_one))
(while (and
(not (null? global_node_list))
(not (equal? RIGHT (get-type last_node))))
(begin
(set! global_node_list (reverse (cdr (reverse global_node_list))))
(if (not (null? global_node_list))
(begin
(set! last_one (- last_one 1))
(set! last_node (list-ref global_node_list last_one))
)
)
)
)
)))
; (set! global_node_list (append global_node_list (make-list 1 (make <node> #:type ERROR))))
(show_result)
(display "ERR:P:")
(display last_lineno)
(newline)
(exit)
)
)
out
)
)
)
(define root (make <node> #:type N_CONF))
;get file name
(define (get_file_name)
(if (eqv? 2 (length (command-line)))
(set! file_name (cadr(command-line)))
)
)
;
;test file if exists
(define (test_file file)
(if (file-exists? file_name)
(begin
(values))
;do something here
(begin
(display "ERR:F\n");todo exit here?
(exit)
)
)
)
(define format_quoted_string
(lambda (str)
(let ((out (make-list 0))
(n (string-length str))
(i 0)
)
(set! str (string->list str))
(while (< i n )
(if (equal? #\\ (list-ref str i))
(begin
(set! i (+ i 1))
(cond ((equal? #\n (list-ref str i))
(set! out (append out (make-list 1 #\newline)))
)
((equal? #\r (list-ref str i))
(set! out (append out (make-list 1 #\return)))
)
(else
(set! out (append out (make-list 1 (list-ref str i))))
)
)
)
(set! out (append out (make-list 1 (list-ref str i))))
)
(set! i (+ i 1))
)
(set! out (list->string out))
(set! out (string-append "\"\"" out "\"\""))
out
)
))
;read the file then return a string
(define get_contents
(lambda (file_name)
(letrec ((port (open-input-file file_name))
)
(while (> 1 0);#t
(let ((new_char (read-char port))
)
(if (eof-object? new_char)
(break)
(begin
; (display (string new_char))
(set! contents (string-append contents (string new_char)))
)
)
)
);while
(begin
;(display contents)
;(display (string? contents))
(close-input-port port)
)
);letrec
contents
);lambda
);define
(define quoted_string
(lambda (str)
(let ((n 1)
(var "")
(output `())
)
(while (> 1 0)
(cond
((char=? #\newline (list-ref str (- n 1)))
(begin
(display "ERR:L:")
(display global_lineno)
(newline)
(exit)
))
((char>? (list-ref str (- n 1)) #\delete)
(begin
(display "ERR:L:")
(display global_lineno)
(newline)
(exit)
))
((not(char=? #\" (list-ref str n)))
(begin
(set! n (+ n 1))
))
(else
(begin
(if (char=? #\\ (list-ref str (- n 1)))
(set! n (+ n 1))
(begin
(set! n (+ n 1))
(set! var (list->string (list-head str n)))
(set! str (list-tail str n))
(break)
)
);if
));begin
);if
)
(set! output (list str var))
output
);while
)
);
(define-syntax for
(syntax-rules (in as)
((for element in list body ...)
(map (lambda (element)
body ...)
list))
((for list as element body ...)
(for element in list body ...))))
(define char_in
(lambda (char char_list)
(let ((output #f)
)
(for i in char_list
(if (equal? char i)
(set! output #t)
)
);for
output
);lambda
);let
);function
(define n_string
(lambda (str)
(let ((var "")
(terminal `(#\space #\{ #\} #\; #\= #\newline #\#))
)
(if (char<=? (list-ref str 0) #\delete)
(begin
(set! var (string (list-ref str 0)))
(set! str (list-tail str 1))
(while (> (length str) 0)
(if (not(char_in (list-ref str 0) terminal))
(begin
(set! var (string-append var (string (list-ref str 0))))
(set! str (list-tail str 1))
)
(begin;else
(break)
)
)
);if
)
);lambda
(list str var)
);n_string
)
)
;(define commment ;remove comment and leave the newline
;(lambda (str)
;);lambda
;);function
(define (tokenize str)
(let (
(str_list (string->list str))
; (lineno 1)
)
(if (char_in #\null str_list)
(begin
(display "ERR:L:");bug here no lineno
(display global_lineno)
(newline)
(exit))
)
(while (> (length str_list) 0)
(letrec (
(var "")
(tmp `())
(mchar (car str_list))
)
(cond
((char=? mchar #\") (begin ;(display #\")
(set! tmp (quoted_string str_list))
(set! str_list (car tmp))
(set! var (car (cdr tmp)))
(set! tokens (append tokens (make-list 1
(make <node> #:value var
#:lineno global_lineno
#:type QUOTED_STRING))))
;(display var)
)
; (display "ERR:L\n")
)
((char=? mchar #\#) (begin
;(display "# ")
;remove valid comment
(while (not(char=? #\newline (list-ref str_list 0)))
(set! str_list (list-tail str_list 1 ))
);while
;(set! str_list (cdr str_list))
;(set! tokens (append tokens (list mchar)))
))
((char=? mchar #\{) (begin
;(display "{")
(set! str_list (cdr str_list))
(set! tokens (append tokens (make-list 1 (make <node>
#:value #\{
#:lineno global_lineno
#:type LEFT))))
))
((char=? mchar #\}) (begin
;(display "}" )
(set! str_list (cdr str_list))
(set! tokens (append tokens (make-list 1 (make <node>
#:value #\}
#:lineno global_lineno
#:type RIGHT))))
; (set! tokens (append tokens (list mchar)))
))
((char=? mchar #\;) (begin
;(display ";")
(set! str_list (cdr str_list))
(set! tokens (append tokens (make-list 1 (make <node>
#:value #\;
#:lineno global_lineno
#:type SEMI))))
; (set! tokens (append tokens (list mchar)))
))
((char=? mchar #\space) (begin
;(display " ")
(set! str_list (cdr str_list))
;(set! tokens (append tokens (list mchar)))
))
((char=? mchar #\newline) (begin
;(display "\n ")
(set! str_list (cdr str_list))
(set! tokens (append tokens (make-list 1 (make <node>
#:value "newline"
#:type NEW_LINE
#:lineno global_lineno))))
(set! global_lineno (+ 1 global_lineno))
))
((char=? mchar #\=) (begin
;(display "=")
(set! str_list (cdr str_list))
(set! tokens (append tokens (make-list 1 (make <node>
#:value #\=
#:type EQUAL
#:lineno global_lineno))))
))
((char<=? mchar #\delete) (begin
(set! tmp (n_string str_list))
(set! var (car (cdr tmp)))
(set! str_list (car tmp))
(set! tokens (append tokens (make-list 1 (make <node>
#:value var
#:type STRING
#:lineno global_lineno))))
;(display var)
; (display (list? var))
))
(else
(begin
(display "ERR:L:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
)
)
);let
);while
tokens
);let*
);function
;parser parts start here
(define clean_newline
(lambda ()
(while (and (not(null? tokens)) (eqv? (get-type (car tokens)) NEW_LINE))
(set! tokens (cdr tokens))
)
tokens
)
)
(define key_value_pair
(lambda (currnode flag)
(set! tokens (clean_newline))
(cond (
(and (not (null? tokens))
(eqv? STRING (get-type (car tokens)))
(regexp-match? (string-match "^[a-zA-Z_][a-zA-Z_0-9]*$" (get-value (car tokens)))))
(begin
(slot-set! currnode `c1 (make <node> #:type KEY #:value (get-value (car tokens))))
(set! tokens (cdr tokens))
(letrec (
(node_type 0)
(prefix "")
)
(if flag
(set! global_keys (append global_keys (make-list 1 (get-value (get-c1 currnode)))))
);add to global keys
(if (and (not (null? tokens))
(eqv? EQUAL (get-type (car tokens))))
(begin
(slot-set! currnode `c2 (car tokens))
(set! tokens (cdr tokens))
(cond
((and (not (null? tokens))
(eqv? STRING (get-type (car tokens))))
(begin
(cond
(
(regexp-match? (string-match "^[+-]?[0-9]+$" (get-value (car tokens))))
(begin
(set! node_type INT)
(set! prefix "I::")
)
);int
((and (not (null? tokens))
(eqv? STRING (get-type (car tokens)))
(regexp-match? (string-match "^[+-]?[0-9]+\\.[0-9]*$" (get-value (car tokens))))
)
(begin
(set! node_type FLOAT)
(set! prefix "F::")
));float
((and (not (null? tokens))
(eqv? STRING (get-type (car tokens)))
(regexp-match? (string-match "^[/a-zA-Z][/\\._a-zA-Z0-9\\-]*$" (get-value (car tokens))))
)
(begin
(set! node_type STRING)
(set! prefix "S::")
)
);string
(else
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
)
)
(set-c3! currnode (make <node> #:type node_type #:value (get-value (car tokens))))
(set! tokens (cdr tokens))
))
((and (not (null? tokens)) (eqv? QUOTED_STRING (get-type (car tokens))))
(set-c3! currnode (make <node> #:type QUOTED_STRING #:value (format_quoted_string (get-value (car tokens)))))
(set! tokens (cdr tokens))
(set! prefix "Q::")
)
(else
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
)
)
(if (and (char_in (get-value (get-c1 currnode)) global_keys)
(not flag))
(begin
(set! prefix (string-append (string-take prefix 2) "O" (string-take-right prefix 1)))
))
(set-value! (get-c1 currnode) (string-append " " prefix (get-value (get-c1 currnode))))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
);END OF IF
(if (not (null? tokens))
(cond
((eqv? NEW_LINE (get-type (car tokens)))
(set! tokens (cdr tokens))
)
((eqv? RIGHT (get-type (car tokens)))
(values)
)
(else (begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
))
))
)))
((eqv? RIGHT (get-type (car tokens)))(values))
(else
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
)
)
tokens
)
)
(define key_value_pairs
(lambda (currnode flag)
(set! tokens (clean_newline))
(if (null? tokens)
(values)
)
(if (eqv? RIGHT (get-type (car tokens) ));diff
(begin
(values))
(begin
(set-c1! currnode (make <node> #:type KV_PAIR))
(set! tokens (key_value_pair (get-c1 currnode) flag))
;reset tokens
(set-c2! currnode (make <node> #:type KV_PAIRS))
(set! tokens (key_value_pairs (get-c2 currnode) flag))
)
)
tokens
)
)
(define host_conf
(lambda (currnode)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (equal? "host"
(get-value (car tokens))))
(begin
(set! tokens (cdr tokens))
(slot-set! currnode `c1 (make <node> #:value "HOST" #:type HOST_KEYWORD))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(if (and (not(null? tokens))
(regexp-match? (string-match "^[a-zA-Z_0-9\\._\\-]*$" (get-value (car tokens)))))
(begin
(slot-set! currnode `c2 (make <node> #:value (get-value (car tokens)) #:type HOST_NAME))
(set! tokens (cdr tokens))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (eqv? LEFT (get-type (car tokens))) )
(begin
(slot-set! currnode `c3 (car tokens))
(set! tokens (cdr tokens))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(slot-set! currnode `c4 (make <node> #:type KV_PAIRS));todo c3
(set! tokens (key_value_pairs (get-c4 currnode) #f));return tokens needed
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (equal? RIGHT (get-type (car tokens))) )
(begin
(slot-set! currnode `c5 (car tokens));todo c3
(set! tokens (cdr tokens))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (eqv? SEMI (get-type (car tokens))))
(begin
(slot-set! currnode `c6 (car tokens))
(set! tokens (cdr tokens))
)
;optional, no exception here
)
tokens
)
)
(define host_confs
(lambda (currnode)
(set! tokens (clean_newline))
(if (null? tokens)
(values)
(begin
(set-c1! currnode (make <node> #:type N_HOST))
(set! tokens (host_conf (get-c1 currnode)))
(set-c2! currnode (make <node> #:type N_HOSTS))
(set! tokens (host_confs (get-c2 currnode)))
)
)
tokens
)
)
(define conf
(lambda (currnode)
(begin
(slot-set! currnode `c1 (make <node> #:type N_GLOBAL ))
(set! tokens (global_conf (get-c1 currnode)))
(slot-set! currnode `c2 (make <node> #:type N_HOSTS ))
(host_confs (get-c2 currnode))
)
)
)
(define global_conf
(lambda (currnode)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (equal? "global" (get-value (car tokens))))
(begin
(set! tokens (cdr tokens))
(slot-set! currnode `c1 (make <node> #:value "GLOBAL" #:type GLOBAL_KEYWORD))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (eqv? LEFT (get-type (car tokens))) )
(begin
(slot-set! currnode `c2 (car tokens))
(set! tokens (cdr tokens))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(slot-set! currnode `c3 (make <node> #:type KV_PAIRS));todo c3
(set! tokens (key_value_pairs (get-c3 currnode) #t));return tokens needed
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (equal? RIGHT (get-type (car tokens))) )
(begin
(slot-set! currnode `c4 (car tokens));todo c3
(set! tokens (cdr tokens))
)
(begin
(set-type! currnode ERROR)
(get_nodes root)
(show_result)
(display "ERR:P:")
(display (get-lineno (car tokens)))
(newline)
(exit)
)
;todo exception handler
)
(set! tokens (clean_newline))
(if (and (not(null? tokens)) (eqv? SEMI (get-type (car tokens))))
(begin
(slot-set! currnode `c5 (car tokens))
(set! tokens (cdr tokens))
)
;optional, no exception here
)
tokens
)
)
(define get_nodes
(lambda (node)
(let ((last_one 10000)
(last_node 0)
)
(if (char_in (get-type node)
(list GLOBAL_KEYWORD HOST_KEYWORD HOST_NAME KEY STRING INT FLOAT EQUAL QUOTED_STRING RIGHT SEMI LEFT))
(set! global_node_list (append global_node_list (make-list 1 node)))
)
(if
(equal? ERROR (get-type node))
(begin
(set! last_one (length global_node_list))
(if (not (null? global_node_list))
(begin
(set! last_one (- last_one 1))
(set! last_node (list-ref global_node_list last_one))
(while (and
(not (null? global_node_list))
(not (equal? RIGHT (get-type last_node))))
(begin
(set! global_node_list (reverse (cdr (reverse global_node_list))))
(if (not (null? global_node_list))
(begin
(set! last_one (- last_one 1))
(set! last_node (list-ref global_node_list last_one))
)
)
)
)
)))
(begin
(if (not (eqv? 0 (get-c1 node)))
(get_nodes (get-c1 node)))
(if (not (eqv? 0 (get-c2 node)))
(get_nodes (get-c2 node) ))
(if (not (eqv? 0 (get-c3 node)))
(get_nodes (get-c3 node)))
(if (not (eqv? 0 (get-c4 node)))
(get_nodes (get-c4 node)))
(if (not (eqv? 0 (get-c5 node)))
(get_nodes (get-c5 node)))
(if (not (eqv? 0 (get-c6 node)))
(get_nodes (get-c6 node)))
)
)
)
))
(define parser
(lambda ()
(conf root)
)
)
(define show_result
(lambda ()
(let (
(output "")
)
(for node in global_node_list
(if (equal? GLOBAL_KEYWORD (get-type node))
(set! output (string-append output "GLOBAL:\n"))
)
(if (equal? HOST_KEYWORD (get-type node))
(set! output (string-append output "HOST "))
)
(if (equal? HOST_NAME (get-type node))
(set! output (string-append output (get-value node) ":\n"))
)
(if (equal? KEY (get-type node))
(set! output (string-append output (get-value node)))
)
(if (equal? STRING (get-type node))
(set! output (string-append output (get-value node) "\n"))
)
(if (equal? INT (get-type node))
(set! output (string-append output (get-value node) "\n"))
)
(if (equal? FLOAT (get-type node))
(set! output (string-append output (get-value node) "\n"))
)
(if (equal? EQUAL (get-type node))
(set! output (string-append output ":"))
)
(if (equal? QUOTED_STRING (get-type node))
(set! output (string-append output (get-value node) "\n"))
)
)
(display output)
)
)
)
(get_file_name)
(test_file file_name)
;(display (get_contents file_name))
(tokenize (get_contents file_name))
(set! last_lineno (get-lineno (list-ref tokens (- (length tokens) 1))))
(parser)
(get_nodes root)
(show_result)
| true |
fbbeee9bf844f2a900eb6bc0cc9c0ce501064931
|
0ffe5235b0cdac3846e15237c2232d8b44995421
|
/src/scheme/Section_1.2/1.12.scm
|
b9e8dd87a72014011bd5e30477caf60ab343b55e
|
[] |
no_license
|
dawiedotcom/SICP
|
4d05014ac2b075b7de5906ff9a846e42298fa425
|
fa6ccac0dad8bdad0645aa01197098c296c470e0
|
refs/heads/master
| 2020-06-05T12:36:41.098263 | 2013-05-16T19:41:38 | 2013-05-16T19:41:38 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,035 |
scm
|
1.12.scm
|
; SICP Exercise 1.12
; Dawie de Klerk
; 2012-08-05
(load "../utils.scm")
(define (snd ll)
;; Gets the second element in a list
(car (cdr ll)))
(define (add-pairs lst)
;; Adds every two adjacent element in a list together
(let ((len (length lst)))
(cond
((= len 0) '())
((= len 2) (list (apply + lst)))
(else (cons (+ (car lst) (snd lst)) (add-pairs (cdr lst)))))))
(define (wrap-ones lst)
;; Adds a 1 at the begining and end of lst
(append (list 1) lst (list 1)))
(define (pascal-triangle-row n)
;; Calculates the n-th row of Pascal's triangle.
(cond
((= n 1) (list 1))
((= n 2) (list 1 1))
;(else (wrap-ones (add-pairs (pascal-triangle (- n 1)))))))
(else (-> (- n 1) pascal-triangle-row add-pairs wrap-ones))))
(define (pascal-triangle n)
;; Prints the first n rows of Pascal's triangle.
(define (pascal-triangle-helper n row)
(if (> n row)
(begin (println (pascal-triangle-row row))
(pascal-triangle-helper n (+ 1 row)))))
(pascal-triangle-helper n 1))
| false |
2b630a13d8c58bcf3ea97a98535a1a911765cb6e
|
8eb21733f83949941fadcb268dd4f0efab594b7f
|
/150/srfi-153/srfi-153-impl.scm
|
a6ed26752992d1279aafa4b73cabf8d7919cf602
|
[] |
no_license
|
srfi-explorations/final-srfis
|
d0994d215490333062a43241c57d0c2391224527
|
bc8e7251d5b52bf7b11d9e8ed8b6544a5d973690
|
refs/heads/master
| 2020-05-02T07:29:24.865266 | 2019-03-26T19:02:18 | 2019-03-26T19:02:18 | 177,819,656 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 7,945 |
scm
|
srfi-153-impl.scm
|
;; Copyright (C) Marc Nieper-Wißkirchen (2017). 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.
(define-record-type <oset>
(make-oset mapping)
oset?
(mapping oset-mapping))
(define (make-empty-oset comparator)
(make-oset (mapping comparator)))
;; Constructors
(define (oset comparator . elements)
(assume (comparator? comparator))
(oset-unfold null? car cdr elements comparator))
(define oset/ordered oset)
(define (oset-unfold stop? mapper successor seed comparator)
(assume (procedure? stop?))
(assume (procedure? mapper))
(assume (procedure? successor))
(assume (comparator? comparator))
(make-oset (mapping-unfold stop?
(lambda (seed)
(values (mapper seed) 1))
successor
seed
comparator)))
;; Predicates
(define (oset-contains? oset element)
(assume (oset? oset))
(mapping-contains? (oset-mapping oset) element))
(define (oset-empty? oset)
(assume (oset? oset))
(mapping-empty? (oset-mapping oset)))
(define (oset-disjoint? oset1 oset2)
(assume (oset? oset1))
(assume (oset? oset2))
(mapping-disjoint? (oset-mapping oset1) (oset-mapping oset2)))
;; Accessors
(define (oset-member oset element default)
(assume (oset? oset))
(call/cc
(lambda (return)
(mapping-search (oset-mapping oset)
element
(lambda (insert ignore)
(return default))
(lambda (old-element old-count update remove)
(return old-element))))))
(define (oset-element-comparator oset)
(assume (oset? oset))
(mapping-key-comparator (oset-mapping oset)))
;; Updaters
(define (oset-adjoin oset . elements)
(assume (oset? oset))
(make-oset (fold (lambda (element mapping)
(receive (mapping value)
(mapping-intern mapping element (lambda () 1))
mapping))
(oset-mapping oset) elements)))
(define oset-adjoin! oset-adjoin)
(define oset-replace! oset-replace)
(define oset-delete! oset-delete)
(define (oset-delete-all oset elements)
(assume (oset? oset))
(make-oset (mapping-delete-all (oset-mapping oset) elements)))
(define oset-delete-all! oset-delete-all)
;; The whole oset
(define (oset-size oset)
(assume (oset? oset))
(mapping-size (oset-mapping oset)))
(define (oset-find predicate oset failure)
(assume (procedure? predicate))
(assume (oset? oset))
(assume (procedure? failure))
((call/cc
(lambda (return-thunk)
(receive (element count)
(mapping-find (lambda (element count)
(predicate element))
(oset-mapping oset)
(lambda () (return-thunk failure)))
(lambda () element))))))
(define (oset-count predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(mapping-count (lambda (element count)
(predicate element))
(oset-mapping oset)))
(define (oset-any? predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(mapping-any? (lambda (element count)
(predicate element))
(oset-mapping oset)))
(define (oset-every? predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(mapping-every? (lambda (element count)
(predicate element))
(oset-mapping oset)))
;; Mapping and folding
(define (oset-map proc comparator oset)
(assume (procedure? proc))
(assume (comparator? comparator))
(assume (oset? oset))
(make-oset (mapping-map (lambda (element count)
(values (proc element)
count))
(oset-element-comparator oset)
(oset-mapping oset))))
(define oset-map/monotone oset-map)
(define (oset-for-each proc oset)
(assume (procedure? proc))
(assume (oset? oset))
(mapping-for-each (lambda (element count)
(proc element))
(oset-mapping oset)))
(define (oset-fold proc nil oset)
(assume (procedure? proc))
(assume (oset? oset))
(mapping-fold (lambda (element count nil)
(proc element nil))
nil (oset-mapping oset)))
(define (oset-filter predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(make-oset (mapping-filter (lambda (element count)
(predicate element))
(oset-mapping oset))))
(define oset-filter! oset-filter)
(define (oset-remove predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(make-oset (mapping-remove (lambda (element count)
(predicate element))
(oset-mapping oset))))
(define oset-remove! oset-remove)
(define (oset-partition predicate oset)
(assume (procedure? predicate))
(assume (oset? oset))
(receive (mapping1 mapping2)
(mapping-partition (lambda (element count)
(predicate element))
(oset-mapping oset))
(values (make-oset mapping1) (make-oset mapping2))))
(define oset-partition! oset-partition)
;; Copying and conversion
(define (oset-copy oset)
(assume (oset? oset))
oset)
(define (oset->list oset)
(assume (oset? oset))
(mapping-fold/reverse (lambda (element count lst)
(cons element lst))
'() (oset-mapping oset)))
(define (list->oset comparator lst)
(assume (comparator? comparator))
(assume (list? lst))
(apply oset comparator lst))
;; Subsets
(define (oset=? oset . osets)
(assume (oset? oset))
(apply mapping=? (make-eqv-comparator) (oset-mapping oset) (map oset-mapping osets)))
(define (oset<? oset . osets)
(assume (oset? oset))
(apply mapping<? (make-eqv-comparator) (oset-mapping oset) (map oset-mapping osets)))
(define (oset>? oset . osets)
(assume (oset? oset))
(apply mapping>? (make-eqv-comparator) (oset-mapping oset) (map oset-mapping osets)))
(define (oset<=? oset . osets)
(assume (oset? oset))
(apply mapping<=? (make-eqv-comparator) (oset-mapping oset) (map oset-mapping osets)))
(define (oset>=? oset . osets)
(assume (oset? oset))
(apply mapping>=? (make-eqv-comparator) (oset-mapping oset) (map oset-mapping osets)))
;; Set theory operations
(define (oset-union oset . osets)
(assume (oset? oset))
(make-oset (apply mapping-union (oset-mapping oset) (map oset-mapping osets))))
(define (oset-intersection oset . osets)
(assume (oset? oset))
(make-oset (apply mapping-intersection (oset-mapping oset) (map oset-mapping osets))))
(define (oset-difference oset . osets)
(assume (oset? oset))
(make-oset (apply mapping-difference (oset-mapping oset) (map oset-mapping osets))))
(define (oset-xor oset1 oset2)
(assume (oset? oset1))
(assume (oset? oset2))
(make-oset (mapping-xor (oset-mapping oset1) (oset-mapping oset2))))
(define oset-union! oset-union)
(define oset-intersection! oset-intersection)
(define oset-difference! oset-difference)
(define oset-xor! oset-xor)
;; Comparators
(define mapping-ordering
(comparator-ordering-predicate (make-mapping-comparator (make-default-comparator))))
(define (oset-ordering oset1 oset2)
(mapping-ordering (oset-mapping oset1) (oset-mapping oset2)))
(define oset-comparator
(make-comparator oset? oset=? oset-ordering #f))
(comparator-register-default! oset-comparator)
| false |
5c76b863cfdeeb2460d2b2e1c22c01a1b50ce5a9
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/mscorlib/system/runtime/serialization/formatters/binary/object-reader.sls
|
ed8537969ddeffcd47cb7c91e29430765145f2f0
|
[] |
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,976 |
sls
|
object-reader.sls
|
(library (system runtime serialization formatters binary object-reader)
(export new
is?
object-reader?
read-next-object?
read-type
read-primitive-type-value
read-object-graph
current-object)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Runtime.Serialization.Formatters.Binary.ObjectReader
a
...)))))
(define (is? a)
(clr-is
System.Runtime.Serialization.Formatters.Binary.ObjectReader
a))
(define (object-reader? a)
(clr-is
System.Runtime.Serialization.Formatters.Binary.ObjectReader
a))
(define-method-port
read-next-object?
System.Runtime.Serialization.Formatters.Binary.ObjectReader
ReadNextObject
(System.Boolean System.IO.BinaryReader))
(define-method-port
read-type
System.Runtime.Serialization.Formatters.Binary.ObjectReader
ReadType
(System.Type
System.IO.BinaryReader
System.Runtime.Serialization.Formatters.Binary.TypeTag))
(define-method-port
read-primitive-type-value
System.Runtime.Serialization.Formatters.Binary.ObjectReader
ReadPrimitiveTypeValue
(static: System.Object System.IO.BinaryReader System.Type))
(define-method-port
read-object-graph
System.Runtime.Serialization.Formatters.Binary.ObjectReader
ReadObjectGraph
(System.Void
System.Runtime.Serialization.Formatters.Binary.BinaryElement
System.IO.BinaryReader
System.Boolean
System.Object&
System.Runtime.Remoting.Messaging.Header[]&)
(System.Void
System.IO.BinaryReader
System.Boolean
System.Object&
System.Runtime.Remoting.Messaging.Header[]&))
(define-field-port
current-object
#f
#f
(property:)
System.Runtime.Serialization.Formatters.Binary.ObjectReader
CurrentObject
System.Object))
| true |
8deceb011d34cc5dd4dff4a15235cef688b1ec0a
|
3629e5c33ebbc3acbaa660fb324c26357098147c
|
/examples/glbook/example2-18.scm
|
6f7e8160e6d457f465332d70c992a9bb23eac7d6
|
[
"LicenseRef-scancode-x11-sg",
"MIT"
] |
permissive
|
shirok/Gauche-gl
|
f31a62ce4c2d91795f972b668861a77626b02cb5
|
a569e3009314f81bc513827064e05869220c6a9d
|
refs/heads/master
| 2023-06-07T15:56:17.514969 | 2023-06-01T06:56:48 | 2023-06-01T06:56:48 | 9,487,174 | 4 | 5 |
MIT
| 2018-09-24T21:39:18 | 2013-04-17T02:13:32 |
C
|
UTF-8
|
Scheme
| false | false | 5,353 |
scm
|
example2-18.scm
|
;; Example 2-18 Using vertex array object
(use gl)
(use gl.glut)
(use gauche.record)
(use gauche.uvector)
(use math.const)
(define-record-type xform #t #t
xlate ;Translation
angle
axis)
(define-constant Cube 0)
(define-constant Cone 1)
(define-constant NumVAOs 2)
(define *vao* #f) ; set by init
(define *prim-types* (make-vector NumVAOs))
(define *num-elements* (make-vector NumVAOs))
(define *xform*
`#(,(make-xform #f32(-2.0 0.0 0.0) 0.0 #f32( 0.0 1.0 0.0))
,(make-xform #f32( 0.0 0.0 2.0) 0.0 #f32( 1.0 0.0 0.0))))
(define *angle* 0.0)
(define (init)
(define Vertices 0)
(define Colors 1)
(define Elements 2)
(define NumVBOs 3)
(define (initCube)
(define cube-verts
'#f32(-1.0 -1.0 -1.0
-1.0 -1.0 1.0
-1.0 1.0 -1.0
-1.0 1.0 1.0
1.0 -1.0 -1.0
1.0 -1.0 1.0
1.0 1.0 -1.0
1.0 1.0 1.0))
(define cube-colors
'#f32( 0.0 0.0 0.0
0.0 0.0 1.0
0.0 1.0 0.0
0.0 1.0 1.0
1.0 0.0 0.0
1.0 0.0 1.0
1.0 1.0 0.0
1.0 1.0 1.0))
(define cube-indices
'#u8(0 1 3
0 3 2
4 6 7
4 7 5
2 3 7
2 7 6
0 4 5
0 5 1
0 2 6
0 6 4
1 5 7
1 7 3))
(define buffers)
(gl-bind-vertex-array (~ *vao* Cube))
(set! buffers (gl-gen-buffers NumVBOs))
(gl-bind-buffer GL_ARRAY_BUFFER (~ buffers Vertices))
(gl-buffer-data GL_ARRAY_BUFFER 0 cube-verts GL_STATIC_DRAW)
(gl-vertex-pointer 3 #f 0 0 GL_FLOAT)
(gl-enable-client-state GL_VERTEX_ARRAY)
(gl-bind-buffer GL_ARRAY_BUFFER (~ buffers Colors))
(gl-buffer-data GL_ARRAY_BUFFER 0 cube-colors GL_STATIC_DRAW)
(gl-color-pointer 3 #f 0 0 GL_FLOAT)
(gl-enable-client-state GL_COLOR_ARRAY)
(gl-bind-buffer GL_ELEMENT_ARRAY_BUFFER (~ buffers Elements))
(gl-buffer-data GL_ELEMENT_ARRAY_BUFFER 0 cube-indices GL_STATIC_DRAW)
(set! (~ *prim-types* Cube) GL_TRIANGLES)
(set! (~ *num-elements* Cube) (uvector-length cube-indices))
)
(define (f32set3! v k x y z)
(f32vector-set! v (* k 3) x)
(f32vector-set! v (+ (* k 3) 1) y)
(f32vector-set! v (+ (* k 3) 2) z))
(define (initCone)
(define numConePoints 36)
(define cone-verts (make-f32vector (* (+ numConePoints 1) 3)))
(define cone-colors (make-f32vector (* (+ numConePoints 1) 3)))
(define cone-indices (make-u8vector 37))
(define dTheta (/ (* 2 pi) (- numConePoints 1)))
(define buffers)
(f32set3! cone-verts 0 0.0 0.0 1.0)
(f32set3! cone-colors 0 1.0 1.0 1.0)
(do ([i 0 (+ i 1)]
[j 1 (+ j 1)])
[(= i numConePoints)]
(let1 theta (* i dTheta)
(f32set3! cone-verts j (cos theta) (sin theta) 0.0)
(f32set3! cone-colors j (cos theta) (sin theta) 0.0)
(u8vector-set! cone-indices j j)))
(gl-bind-vertex-array (~ *vao* Cone))
(set! buffers (gl-gen-buffers NumVBOs))
(gl-bind-buffer GL_ARRAY_BUFFER (~ buffers Vertices))
(gl-buffer-data GL_ARRAY_BUFFER 0 cone-verts GL_STATIC_DRAW)
(gl-vertex-pointer 3 #f 0 0 GL_FLOAT)
(gl-enable-client-state GL_VERTEX_ARRAY)
(gl-bind-buffer GL_ARRAY_BUFFER (~ buffers Colors))
(gl-buffer-data GL_ARRAY_BUFFER 0 cone-colors GL_STATIC_DRAW)
(gl-color-pointer 3 #f 0 0 GL_FLOAT)
(gl-enable-client-state GL_COLOR_ARRAY)
(gl-bind-buffer GL_ELEMENT_ARRAY_BUFFER (~ buffers Elements))
(gl-buffer-data GL_ELEMENT_ARRAY_BUFFER 0 cone-indices GL_STATIC_DRAW)
(set! (~ *prim-types* Cone) GL_TRIANGLE_FAN)
(set! (~ *num-elements* Cone) (uvector-length cone-indices))
)
(set! *vao* (gl-gen-vertex-arrays NumVAOs))
(initCube)
(initCone)
(gl-enable GL_DEPTH_TEST)
)
(define (disp)
(gl-clear (logior GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT))
(gl-push-matrix)
(gl-rotate *angle* 0.0 1.0 0.0)
(dotimes [i NumVAOs]
(gl-push-matrix)
(gl-translate (~ *xform* i 'xlate 0)
(~ *xform* i 'xlate 1)
(~ *xform* i 'xlate 2))
(gl-rotate (~ *xform* i 'angle)
(~ *xform* i 'axis 0)
(~ *xform* i 'axis 1)
(~ *xform* i 'axis 2))
(gl-bind-vertex-array (~ *vao* i))
(gl-draw-elements (~ *prim-types* i) (~ *num-elements* i) GL_UNSIGNED_BYTE)
(let1 e (gl-get-error)
(unless (zero? e) (print e)))
(gl-pop-matrix))
(gl-pop-matrix)
(glut-swap-buffers))
(define (reshape w h)
(gl-viewport 0 0 w h)
(gl-matrix-mode GL_PROJECTION)
(gl-load-identity)
(gl-frustum -1.0 1.0 -1.0 1.0 1.5 20.0)
(gl-matrix-mode GL_MODELVIEW))
(define (keyboard key x y)
(when (= key 27) (exit 0)))
(define (timer _)
(inc! *angle*)
(glut-post-redisplay)
(glut-timer-func 20 timer 0))
(define (main args)
(glut-init args)
(glut-init-display-mode (logior GLUT_DOUBLE GLUT_RGB GLUT_DEPTH))
(glut-init-window-size 350 350)
(glut-init-window-position 100 100)
(glut-create-window *program-name*)
(gl-clear-color 0.0 0.0 0.0 0.0)
(gl-shade-model GL_FLAT)
(init)
(glut-display-func disp)
(glut-timer-func 20 timer 0)
(glut-reshape-func reshape)
(glut-keyboard-func keyboard)
(glut-main-loop)
0)
| false |
e1b24b961a40d5db58d60d89f8616ced1a40ab89
|
e274a2d8e7c094faa086f1f0a2a0530fc1113b90
|
/ch01/exercise/1-33.scm
|
b11748d4f8f8d83e16a8d7d4dd1b4ee9bc2b4fc4
|
[
"MIT"
] |
permissive
|
happyo/sicp
|
9b4def6f235ff287fd29dc9b42b0f0fea142bdc1
|
baeca9f87560daac58dacd1d548adfec7eaab260
|
refs/heads/master
| 2021-06-24T15:20:53.986908 | 2020-09-25T07:10:46 | 2020-09-25T07:10:46 | 131,562,767 | 0 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 834 |
scm
|
1-33.scm
|
(load "../example/1-2-6-primality.scm")
(define (filtered-accumulate combiner null-value term a next b filter)
(cond ((> a b) null-value)
((filter a)
(combiner (term a)
(filtered-accumulate combiner null-value term (next a) next b filter)))
(else
(filtered-accumulate combiner null-value term (next a) next b filter))))
(define (add a b)
(+ a b))
(define (identity x) x)
(define (inc x)
(+ x 1))
(filtered-accumulate add 0 identity 1 inc 5 odd?)
;; a)
(define (sum-prime a b)
(filtered-accumulate add 0 identity a inc b prime?))
(sum-prime 1 10)
;; b)
(define (mult a b)
(* a b))
(define (mult-prime n)
(filtered-accumulate mult 1 identity 1 inc n (lambda (x) (coprime? x n))))
(define (coprime? i n)
(and (< i n)
(= 1 (gcd i n))))
(mult-prime 10)
| false |
48cb9365240c2ea0a484e125ce978c5738236f78
|
e76da0bc738f15fbdc7ba8a92265a866592e8d96
|
/backtracking.scm
|
4082825c68b743b033e7fb59565768fc10db4d67
|
[] |
no_license
|
pujun-ai/aima
|
42bba66982dc9043640d821cfb3d1117fbe28986
|
df78e161f22ddb677dbf2fa819e5a4869be22f50
|
refs/heads/master
| 2022-07-21T08:14:01.824495 | 2014-12-26T04:58:58 | 2014-12-26T04:58:58 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 16,318 |
scm
|
backtracking.scm
|
#!/usr/bin/env chicken-scheme
;; [[file:~/prg/scm/aima/aima.org::*6.1][6\.1:1]]
(use debug
define-record-and-printer
matchable
srfi-1
srfi-69
test)
(define-record-and-printer unassigned)
(define unassigned (make-unassigned))
(define assigned? (complement unassigned?))
(define-record-and-printer failure)
(define failure (make-failure))
(define-record-and-printer csp
domains
constraints
neighbors)
(define (csp-copy csp)
(make-csp (hash-table-copy (csp-domains csp))
(hash-table-copy (csp-constraints csp))
(hash-table-copy (csp-neighbors csp))))
;;; Dispense with this and do equality on the number of keys!
(define (make-assignment csp)
(alist->hash-table
(map (lambda (variable) (cons variable unassigned))
(hash-table-keys (csp-domains csp)))))
(define (backtracking-search csp)
(let ((enumeration (backtracking-enumeration 1 csp)))
;; Return #f here? No, need to distinguish between failure and the
;; legitimate value #f.
(if (null? enumeration) failure (car enumeration))))
(define (complete? assignment)
(hash-table-fold
assignment
(lambda (variable value complete?)
(and (assigned? value) complete?))
#t))
;;; Too bad this is linear across variables, right? Optimize later.
;;;
;;; Need the CSP, at some point, to do the degree heuristic.
(define (select-unassigned-variable assignment)
;; We can assume there is at least one unassigned variable.
(car (find (compose unassigned? cdr) (hash-table->alist assignment))))
;;; Need assignment, at some point, to do least-constraining-value.
(define (order-domain-values variable csp)
(hash-table-ref (csp-domains csp) variable))
;;; Find the assigned neighbors of the variable; does the value
;;; satisfy each constraint?
;;;
;;; What if the variable is already assigned something else? Seems
;;; like a pathological case.
;;;
;;; Should we check here if we've already assigned something?
(define (consistent? variable value assignment csp)
;; (debug variable
;; value
;; (hash-table-ref assignment variable)
;; (or (unassigned? (hash-table-ref assignment variable))
;; (eq? value (hash-table-ref assignment variable))))
(let* ((neighbors (hash-table-ref (csp-neighbors csp) variable))
(assigned-neighbors (filter (lambda (neighbor) (assigned? (hash-table-ref assignment neighbor)))
neighbors)))
(every values (map (lambda (neighbor) ((hash-table-ref (csp-constraints csp) (cons variable neighbor))
value
(hash-table-ref assignment neighbor)))
assigned-neighbors))))
(define (inference csp variable value)
(make-hash-table))
(define backtracking-enumeration
(case-lambda
((csp) (backtracking-enumeration #f csp))
((n csp) (let ((enumeration (make-parameter '())))
(backtrack-enumerate n enumeration (make-assignment csp) csp)
(enumeration)))))
(define (backtrack-enumerate n enumeration assignment csp)
(if (complete? assignment)
(enumeration (cons assignment (enumeration)))
(let ((variable (select-unassigned-variable assignment)))
(let iter ((values (order-domain-values variable csp)))
(if (null? values)
failure
(let ((value (car values))
(csp (csp-copy csp))
(assignment (hash-table-copy assignment)))
;; Do we have to address constraints at this point? Yes.
(if (consistent? variable value assignment csp)
(begin
;; Copy at this point?
(hash-table-set! assignment variable value)
;; This might actually modify the domains in the CSP;
;; better copy before we get here?
(let ((inferences (inference csp variable value)))
(if (failure? inferences)
(iter (cdr values))
(begin
;; When duplicate, take inferences; the only
;; values we should be overriding, however, are
;; unassigned.
(hash-table-merge! inferences assignment)
;; By the time this finishes recursing,
;; we have a complete assignment; don't
;; we? Or should we handle the
;; enumeration at the leaf?
(let ((result (backtrack-enumerate n enumeration assignment csp)))
;; (debug (if (failure? result) result (hash-table->alist result)))
(if (failure? result)
(iter (cdr values))
(unless (and n (= (length (enumeration)) n))
(iter (cdr values)))))))))
(iter (cdr values)))))))))
;;; Do we need to copy the thing? We're constantly destroying the CSP.
(define (ac-3 csp)
(let ((queue (list->queue (hash-table-keys (csp-constraints csp)))))
(let iter ()
(if (queue-empty? queue)
#t
(match (queue-remove! queue)
((x . y)
(if (revise csp x y)
;; How does this work for e.g. infinite domains?
(if (zero? (length (hash-table-ref (csp-domains csp) x)))
#f
(begin
(for-each (lambda (neighbor)
(queue-add! queue (cons neighbor x)))
(delete y (hash-table-ref (csp-neighbors csp) x)))
(iter)))
(iter))))))))
(define (revise csp x y)
(let ((y-domain (hash-table-ref (csp-domains csp) y))
(constraint (hash-table-ref (csp-constraints csp) (cons x y))))
(let iter ((revised #f)
(x-domain (hash-table-ref (csp-domains csp) x)))
;; (debug revised x-domain)
;; How does this work for infinite domains?
(if (null? x-domain)
revised
(let ((x-value (car x-domain)))
(if (any values (map (lambda (y-value) (constraint x-value y-value)) y-domain))
(iter revised (cdr x-domain))
(begin
(hash-table-update!
(csp-domains csp)
x
(lambda (x-domain)
(delete x-value x-domain)))
(iter #t (cdr x-domain)))))))))
(define neq? (complement eq?))
(define arc-consistent-coloring
(make-csp
;; Domain can also be lambdas?
(alist->hash-table '((a . (white black))
(b . (white black))))
(alist->hash-table `(((a . b) . ,neq?)
((b . a) . ,neq?)))
(alist->hash-table '((a b)
(b a)))))
(define arc-inconsistent-coloring
(make-csp
;; Domain can also be lambdas?
(alist->hash-table '((a . (white))
(b . (white))))
(alist->hash-table `(((a . b) . ,neq?)
((b . a) . ,neq?)))
(alist->hash-table '((a b)
(b a)))))
(define 3-colors '(red green blue))
;;; Could find a mechanism for automatically creating these things;
;;; indeed, will have to randomly.
(define 3-color-australia
(make-csp
(alist->hash-table `((wa . ,3-colors)
(nt . ,3-colors)
(sa . ,3-colors)
(q . ,3-colors)
(nsw . ,3-colors)
(v . ,3-colors)
(t . ,3-colors)))
(alist->hash-table `(((wa . nt) . ,neq?)
((nt . wa) . ,neq?)
((wa . sa) . ,neq?)
((sa . wa) . ,neq?)
((nt . sa) . ,neq?)
((sa . nt) . ,neq?)
((nt . q) . ,neq?)
((q . nt) . ,neq?)
((sa . q) . ,neq?)
((q . sa) . ,neq?)
((nsw . q) . ,neq?)
((q . nsw) . ,neq?)
((nsw . v) . ,neq?)
((v . nsw) . ,neq?)
((sa . nsw) . ,neq?)
((nsw . sa) . ,neq?)
((sa . v) . ,neq?)
((v . sa) . ,neq?)))
(alist->hash-table '((wa nt sa)
(nt wa sa)
(sa wa nt q nsw v)
(q nt sa nsw)
(nsw q sa v)
(v nsw sa)
(t)))))
(define 2-colors '(red green))
;;; Could find a mechanism for automatically creating these things;
;;; indeed, will have to randomly.
(define 2-color-australia
(make-csp
(alist->hash-table `((wa . ,2-colors)
(nt . ,2-colors)
(sa . ,2-colors)
(q . ,2-colors)
(nsw . ,2-colors)
(v . ,2-colors)
(t . ,2-colors)))
(alist->hash-table `(((wa . nt) . ,neq?)
((nt . wa) . ,neq?)
((wa . sa) . ,neq?)
((sa . wa) . ,neq?)
((nt . sa) . ,neq?)
((sa . nt) . ,neq?)
((nt . q) . ,neq?)
((q . nt) . ,neq?)
((sa . q) . ,neq?)
((q . sa) . ,neq?)
((nsw . q) . ,neq?)
((q . nsw) . ,neq?)
((nsw . v) . ,neq?)
((v . nsw) . ,neq?)
((sa . nsw) . ,neq?)
((nsw . sa) . ,neq?)
((sa . v) . ,neq?)
((v . sa) . ,neq?)))
(alist->hash-table '((wa nt sa)
(nt wa sa)
(sa wa nt q nsw v)
(q nt sa nsw)
(nsw q sa v)
(v nsw sa)
(t)))))
(test-assert (ac-3 arc-consistent-coloring))
(test-assert (not (ac-3 arc-inconsistent-coloring)))
(test '((b . white) (a . black))
(hash-table->alist (backtracking-search arc-consistent-coloring)))
(test-assert (failure? (backtracking-search arc-inconsistent-coloring)))
(test '((wa . red)
(v . red)
(t . red)
(q . red)
(sa . green)
(nt . blue)
(nsw . blue))
(hash-table->alist (backtracking-search 3-color-australia)))
(test '(((wa . blue)
(v . blue)
(t . blue)
(q . blue)
(sa . green)
(nt . red)
(nsw . red))
((wa . blue)
(v . blue)
(t . blue)
(q . blue)
(sa . red)
(nt . green)
(nsw . green))
((wa . blue)
(v . blue)
(t . green)
(q . blue)
(sa . green)
(nt . red)
(nsw . red))
((wa . blue)
(v . blue)
(t . green)
(q . blue)
(sa . red)
(nt . green)
(nsw . green))
((wa . blue)
(v . blue)
(t . red)
(q . blue)
(sa . green)
(nt . red)
(nsw . red))
((wa . blue)
(v . blue)
(t . red)
(q . blue)
(sa . red)
(nt . green)
(nsw . green))
((wa . blue)
(v . green)
(t . blue)
(q . green)
(sa . red)
(nt . green)
(nsw . blue))
((wa . blue)
(v . green)
(t . green)
(q . green)
(sa . red)
(nt . green)
(nsw . blue))
((wa . blue)
(v . green)
(t . red)
(q . green)
(sa . red)
(nt . green)
(nsw . blue))
((wa . blue)
(v . red)
(t . blue)
(q . red)
(sa . green)
(nt . red)
(nsw . blue))
((wa . blue)
(v . red)
(t . green)
(q . red)
(sa . green)
(nt . red)
(nsw . blue))
((wa . blue)
(v . red)
(t . red)
(q . red)
(sa . green)
(nt . red)
(nsw . blue))
((wa . green)
(v . blue)
(t . blue)
(q . blue)
(sa . red)
(nt . blue)
(nsw . green))
((wa . green)
(v . blue)
(t . green)
(q . blue)
(sa . red)
(nt . blue)
(nsw . green))
((wa . green)
(v . blue)
(t . red)
(q . blue)
(sa . red)
(nt . blue)
(nsw . green))
((wa . green)
(v . green)
(t . blue)
(q . green)
(sa . blue)
(nt . red)
(nsw . red))
((wa . green)
(v . green)
(t . blue)
(q . green)
(sa . red)
(nt . blue)
(nsw . blue))
((wa . green)
(v . green)
(t . green)
(q . green)
(sa . blue)
(nt . red)
(nsw . red))
((wa . green)
(v . green)
(t . green)
(q . green)
(sa . red)
(nt . blue)
(nsw . blue))
((wa . green)
(v . green)
(t . red)
(q . green)
(sa . blue)
(nt . red)
(nsw . red))
((wa . green)
(v . green)
(t . red)
(q . green)
(sa . red)
(nt . blue)
(nsw . blue))
((wa . green)
(v . red)
(t . blue)
(q . red)
(sa . blue)
(nt . red)
(nsw . green))
((wa . green)
(v . red)
(t . green)
(q . red)
(sa . blue)
(nt . red)
(nsw . green))
((wa . green)
(v . red)
(t . red)
(q . red)
(sa . blue)
(nt . red)
(nsw . green))
((wa . red)
(v . blue)
(t . blue)
(q . blue)
(sa . green)
(nt . blue)
(nsw . red))
((wa . red)
(v . blue)
(t . green)
(q . blue)
(sa . green)
(nt . blue)
(nsw . red))
((wa . red)
(v . blue)
(t . red)
(q . blue)
(sa . green)
(nt . blue)
(nsw . red))
((wa . red)
(v . green)
(t . blue)
(q . green)
(sa . blue)
(nt . green)
(nsw . red))
((wa . red)
(v . green)
(t . green)
(q . green)
(sa . blue)
(nt . green)
(nsw . red))
((wa . red)
(v . green)
(t . red)
(q . green)
(sa . blue)
(nt . green)
(nsw . red))
((wa . red)
(v . red)
(t . blue)
(q . red)
(sa . blue)
(nt . green)
(nsw . green))
((wa . red)
(v . red)
(t . blue)
(q . red)
(sa . green)
(nt . blue)
(nsw . blue))
((wa . red)
(v . red)
(t . green)
(q . red)
(sa . blue)
(nt . green)
(nsw . green))
((wa . red)
(v . red)
(t . green)
(q . red)
(sa . green)
(nt . blue)
(nsw . blue))
((wa . red)
(v . red)
(t . red)
(q . red)
(sa . blue)
(nt . green)
(nsw . green))
((wa . red)
(v . red)
(t . red)
(q . red)
(sa . green)
(nt . blue)
(nsw . blue)))
(map hash-table->alist (backtracking-enumeration 3-color-australia)))
(test '() (backtracking-enumeration 2-color-australia))
;; 6\.1:1 ends here
| false |
e340befb0d8fc302cf0136125a5c1b02df986005
|
c3943da4e4880c2893c1b49bb55795dff9d9debf
|
/s/pb.ss
|
ce6dcb4ecde6c0c213cbaeebaac74a4bd745b6dc
|
[
"Apache-2.0"
] |
permissive
|
pmatos/ChezScheme
|
aa4171181c7bcc47835ab80432ff8ee3d03c42e0
|
6b136b1bd972091273b6b2f58334912a3726897d
|
refs/heads/master
| 2021-07-17T00:24:36.342654 | 2020-07-28T12:48:18 | 2020-07-28T12:48:18 | 188,067,598 | 8 | 0 |
Apache-2.0
| 2020-06-12T08:26:30 | 2019-05-22T15:37:34 |
Scheme
|
UTF-8
|
Scheme
| false | false | 61,410 |
ss
|
pb.ss
|
;;; pb.ss
;; The pb (portable bytecode) interpreter is implemented by "pb.c".
;; The intent is that the machine uses 64-bit Scheme object
;; representations and a runtime-determined endianness, so code
;; compiled as portable bytecode can run on any machine (as long as
;; the C compiler supports 64-bit integers for the kernel's
;; implementation, where care is taken for the conversion between C
;; pointers and Scheme object addresses). That way, a single set of pb
;; boot files can be used to bootstrap the compiler for any supporrted
;; platform.
;; The pb machine can be configured (through ".def") for 32-bit Scheme
;; object representations and a specific endianness, but that's not
;; the main intended use.
;; In all configurations, the pb machine uses 32-bit instructions. The
;; fasl format of instructuctions is always little-endian, and the
;; machine-code content is swapped on load for a big-endian
;; environment.
;; The pb binstruction set is load--store and vaguely similar to Arm.
;; One difference is that there's a single flag for branching:
;; signalling arithemtic, bitwise, and comparison operations set the
;; flag for a specific condition, such as "overflow" or "equal", and
;; the branch variants are "branch if true" or "branch if false".
;; Each 32-bit instruction has one of these formats, shown in byte
;; order for a little-endian machine:
;;
;; low byte high byte
;; 8 8 8 8
;; -----------------------------------------------
;; | op | reg | immed/reg |
;; -----------------------------------------------
;; -----------------------------------------------
;; | op | reg reg | immed/reg |
;; -----------------------------------------------
;; -----------------------------------------------
;; | op | immed |
;; -----------------------------------------------
;;
;; Integer and floating-point registers (up to 16 of each) are
;; different, and an `op` determines which bank is meant for a `reg`
;; reference. The low-bits `reg` in the byte after the `op` tends to
;; be the destination register. The long `immed` form is mainly for
;; branches. See "cmacros.ss" for the `op` constructions.
;; Foreign-procedure calls are supported only for specific prototypes,
;; which are generally the ones for functions implemented the Chez
;; Scheme kernel. Supported prototypes are specified in "cmacros.ss".
;; Foreign callables are not supported. All foreign-call arguments and
;; results are passed in registers.
;;; SECTION 1: registers
(define-registers
(reserved
[%tc #t 0 uptr]
[%sfp #t 1 uptr]
[%ap #t 2 uptr]
[%trap #t 3 uptr])
(allocable
[%ac0 #f 4 uptr]
[%xp #f 5 uptr]
[%ts #f 6 uptr]
[%td #f 7 uptr]
[%cp #f 8 uptr]
[%r9 %Carg1 %Cretval #f 9 uptr]
[%r10 %Carg2 #f 10 uptr]
[%r11 %Carg3 #f 11 uptr]
[%r12 %Carg4 #f 12 uptr]
[%r13 %Carg5 #f 13 uptr]
[%r14 %Carg6 #f 14 uptr]
[%r15 %Carg7 #f 15 uptr]
[%fp1 #f 0 fp]
[%fp2 %Cfparg1 %Cfpretval #f 1 fp]
[%fp3 %Cfparg2 #f 2 fp]
[%fp4 %Cfparg3 #f 3 fp]
[%fp5 %Cfparg4 #f 4 fp]
[%fp6 %Cfparg5 #f 5 fp]
[%fp7 %Cfparg6 #f 6 fp]
[%fp8 #f 7 fp])
(machine-dependent))
;;; SECTION 2: instructions
(module (md-handle-jump ; also sets primitive handlers
mem->mem
fpmem->fpmem
coercible?
coerce-opnd)
(import asm-module)
(define imm-signed16?
(lambda (x)
(nanopass-case (L15c Triv) x
[(immediate ,imm) (signed16? imm)]
[else #f])))
(define mref->mref
(lambda (a k)
(define return
(lambda (x0 x1 imm type)
;; load & store instructions support index or offset, but not both
(safe-assert (or (eq? x1 %zero) (eqv? imm 0)))
(k (with-output-language (L15d Triv) `(mref ,x0 ,x1 ,imm ,type)))))
(nanopass-case (L15c Triv) a
[(mref ,lvalue0 ,lvalue1 ,imm ,type)
(lvalue->ur lvalue0
(lambda (x0)
(lvalue->ur lvalue1
(lambda (x1)
(cond
[(and (eq? x1 %zero) (signed16? imm))
(return x0 %zero imm type)]
[(and (not (eq? x1 %zero)) (signed16? imm))
(if (eqv? imm 0)
(return x0 x1 0 type)
(let ([u (make-tmp 'u)])
(seq
(build-set! ,u (asm ,null-info ,(asm-add #f) ,x1 (immediate ,imm)))
(return x0 u 0 type))))]
[else
(let ([u (make-tmp 'u)])
(seq
(build-set! ,u (immediate ,imm))
(if (eq? x1 %zero)
(return x0 u 0 type)
(seq
(build-set! ,u (asm ,null-info ,(asm-add #f) ,u ,x1))
(return x0 u 0 type)))))])))))])))
(define mem->mem
(lambda (a k)
(cond
[(literal@? a)
(let ([u (make-tmp 'u)])
(seq
(build-set! ,u ,(literal@->literal a))
(k (with-output-language (L15d Lvalue) `(mref ,u ,%zero 0 uptr)))))]
[else (mref->mref a k)])))
(define fpmem->fpmem mem->mem)
;; `define-instruction` code takes care of `ur` and `fpur`, to which
;; all type-compatible values must convert
(define-syntax coercible?
(syntax-rules ()
[(_ ?a ?aty*)
(let ([a ?a] [aty* ?aty*])
(or (and (memq 'signed16 aty*) (imm-signed16? a))
(and (memq 'mem aty*) (mem? a))
(and (memq 'fpmem aty*) (fpmem? a))))]))
;; `define-instruction` doesn't try to cover `ur` and `fpur`
(define-syntax coerce-opnd ; passes k something compatible with aty*
(syntax-rules ()
[(_ ?a ?aty* ?k)
(let ([a ?a] [aty* ?aty*] [k ?k])
(cond
[(and (memq 'mem aty*) (mem? a)) (mem->mem a k)]
[(and (memq 'fpmem aty*) (fpmem? a)) (fpmem->fpmem a k)]
[(and (memq 'signed16 aty*) (imm-signed16? a)) (k (imm->imm a))]
[(or (memq 'ur aty*)
(memq 'fpur aty*))
(cond
[(ur? a) (k a)]
[(imm? a)
(let ([u (make-tmp 'u)])
(seq
(build-set! ,u ,(imm->imm a))
(k u)))]
[(or (mem? a) (fpmem? a))
(let ([type (if (fpmem? a) 'fp 'uptr)])
(mem->mem a
(lambda (a)
(let ([u (make-tmp 'u type)])
(seq
(build-set! ,u ,a)
(k u))))))]
[else (sorry! 'coerce-opnd "unexpected operand ~s" a)])]
[else (sorry! 'coerce-opnd "cannot coerce ~s to ~s" a aty*)]))]))
(define md-handle-jump
(lambda (t)
(with-output-language (L15d Tail)
(define long-form
(lambda (e)
(let ([tmp (make-tmp 'utmp)])
(values
(in-context Effect `(set! ,(make-live-info) ,tmp ,e))
`(jump ,tmp)))))
(nanopass-case (L15c Triv) t
[,lvalue
(if (mem? lvalue)
(mem->mem lvalue (lambda (e) (values '() `(jump ,e))))
(values '() `(jump ,lvalue)))]
[(literal ,info)
(guard (and (not (info-literal-indirect? info))
(memq (info-literal-type info) '(entry library-code))))
(values '() `(jump (literal ,info)))]
[(label-ref ,l ,offset)
(values '() `(jump (label-ref ,l ,offset)))]
[else (long-form t)]))))
(define info-cc-eq (make-info-condition-code 'eq? #f #t))
(define asm-eq (asm-relop info-cc-eq))
; x is not the same as z in any clause that follows a clause where (x z)
; and y is coercible to one of its types, however:
; WARNING: do not assume that if x isn't the same as z then x is independent
; of z, since x might be an mref with z as it's base or index
(define-instruction value (- -/ovfl -/eq)
[(op (z ur) (x ur) (y signed16))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-sub op) ,x ,y))]
[(op (z ur) (x ur) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-sub op) ,x ,y))])
(define-instruction value (+ +/ovfl +/carry)
[(op (z ur) (x ur) (y signed16))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add (memq op '(+/ovfl +/carry))) ,x ,y))]
[(op (z ur) (x signed16) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add (memq op '(+/ovfl +/carry))) ,y ,x))]
[(op (z ur) (x ur) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add (memq op '(+/ovfl +/carry))) ,x ,y))])
(define-instruction value (* */ovfl)
[(op (z ur) (x ur) (y signed16))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-mul (memq op '(*/ovfl))) ,x ,y))]
[(op (z ur) (x signed16) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-mul (memq op '(*/ovfl))) ,y ,x))]
[(op (z ur) (x ur) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-mul (memq op '(*/ovfl))) ,x ,y))])
(define-instruction value (/)
[(op (z ur) (x ur) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,asm-div ,x ,y))])
(define-instruction value (logand logor logxor)
[(op (z ur) (x ur) (y signed16))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-logical op) ,x ,y))]
[(op (z ur) (x signed16) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-logical op) ,y ,x))]
[(op (z ur) (x ur) (y ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-logical op) ,x ,y))])
(define-instruction value (lognot)
[(op (z ur) (x ur))
`(set! ,(make-live-info) ,z (asm ,info ,asm-lognot ,x))])
(define-instruction value (sll srl sra slol)
[(op (z ur) (x ur) (y signed16 ur))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-logical op) ,x ,y))])
(define-instruction value (move)
[(op (z mem) (x ur))
`(set! ,(make-live-info) ,z ,x)]
[(op (z ur) (x ur mem signed16))
`(set! ,(make-live-info) ,z ,x)])
(let ()
(define build-lea1
(lambda (info z x)
(let ([offset (info-lea-offset info)])
(with-output-language (L15d Effect)
(cond
[(signed16? offset)
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add #f) ,x (immediate ,offset)))]
[else
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (immediate ,offset))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add #f) ,x ,u))))])))))
(define-instruction value lea1
[(op (z ur) (x ur)) (build-lea1 info z x)])
(define-instruction value lea2
[(op (z ur) (x ur) (y ur))
(let ([u (make-tmp 'u)])
(seq
(build-lea1 info u x)
`(set! ,(make-live-info) ,z (asm ,info ,(asm-add #f) ,y ,u))))]))
(let ()
(define imm-zero (with-output-language (L15d Triv) `(immediate 0)))
(define load/store
(lambda (x y w k) ; x ur, y ur, w ur or imm
(with-output-language (L15d Effect)
(if (ur? w)
(if (eq? y %zero)
(k x w)
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,y ,w))
(k x u))))
(let ([n (nanopass-case (L15d Triv) w [(immediate ,imm) imm])])
(cond
[(and (eq? y %zero) (signed16? n))
(let ([w (in-context Triv `(immediate ,n))])
(k x w))]
[(eqv? n 0)
(k x y)]
[(signed16? n)
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x (immediate ,n)))
(k u y)))]
[else
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (immediate ,n))
(if (eq? y %zero)
(k x u)
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x ,u))
(k u y)))))]))))))
(define-instruction value (load)
[(op (z ur) (x ur) (y ur) (w ur signed16))
(let ([type (info-load-type info)])
(load/store x y w
(lambda (x y)
(let ([instr `(set! ,(make-live-info) ,z (asm ,null-info ,(asm-load type) ,x ,y))])
(if (info-load-swapped? info)
(seq
instr
`(set! ,(make-live-info) ,z (asm ,null-info ,(asm-swap type) ,z)))
instr)))))])
(define-instruction effect (store)
[(op (x ur) (y ur) (w ur signed16) (z ur))
(let ([type (info-load-type info)])
(load/store x y w
(lambda (x y)
(if (info-load-swapped? info)
(let ([u (make-tmp 'unique-bob)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-swap type) ,z))
`(asm ,null-info ,(asm-store type) ,x ,y ,u)))
`(asm ,null-info ,(asm-store type) ,x ,y ,z)))))]))
(define-instruction value (load-single->double)
[(op (x fpur) (y fpmem)) `(set! ,(make-live-info) ,x (asm ,null-info ,asm-fpmove-single ,y))])
(define-instruction effect (store-double->single)
[(op (x fpmem) (y fpur)) `(asm ,info ,asm-fpmove-single ,x ,y)])
(define-instruction value (single->double double->single)
[(op (x fpur) (y fpur))
`(set! ,(make-live-info) ,x (asm ,info ,(asm-fl-cvt op) ,y))])
(define-instruction value (fpt)
[(op (x fpur) (y ur))
`(set! ,(make-live-info) ,x (asm ,info ,asm-fpt ,y))])
(define-instruction value (fptrunc)
[(op (x ur) (y fpur))
`(set! ,(make-live-info) ,x (asm ,info ,asm-fptrunc ,y))])
(define-instruction value (fpmove)
[(op (x fpmem) (y fpur)) `(set! ,(make-live-info) ,x ,y)]
[(op (x fpur) (y fpmem fpur)) `(set! ,(make-live-info) ,x ,y)])
(constant-case ptr-bits
[(64)
(let ()
(define (mem->mem mem new-type)
(nanopass-case (L15d Triv) mem
[(mref ,x0 ,x1 ,imm ,type)
(with-output-language (L15d Lvalue) `(mref ,x0 ,x1 ,imm ,new-type))]))
(define-instruction value (fpcastto)
[(op (x mem) (y fpur)) `(set! ,(make-live-info) ,(mem->mem x 'fp) ,y)]
[(op (x ur) (y fpur)) `(set! ,(make-live-info) ,x (asm ,info ,asm-fpcastto ,y))])
(define-instruction value (fpcastfrom)
[(op (x fpmem) (y ur)) `(set! ,(make-live-info) ,(mem->mem x 'uptr) ,y)]
[(op (x fpur) (y ur)) `(set! ,(make-live-info) ,x (asm ,info ,asm-fpcastfrom ,y))]))]
[(32)
(let ()
(define (mem->mem mem delta)
(nanopass-case (L15d Triv) mem
[(mref ,x0 ,x1 ,imm ,type)
(let ([delta (constant-case native-endianness
[(little) (if (eq? delta 'lo) 0 4)]
[(big) (if (eq? delta 'hi) 0 4)])])
(with-output-language (L15d Lvalue) `(mref ,x0 ,x1 ,(fx+ imm delta) uptr)))]))
(define-instruction value (fpcastto/hi)
[(op (x ur) (y fpmem)) `(set! ,(make-live-info) ,x ,(mem->mem y 'hi))]
[(op (x ur) (y fpur)) `(set! ,(make-live-info) ,x (asm ,info ,(asm-fpcastto 'hi) ,y))])
(define-instruction value (fpcastto/lo)
[(op (x ur) (y fpmem)) `(set! ,(make-live-info) ,x ,(mem->mem y 'lo))]
[(op (x ur) (y fpur)) `(set! ,(make-live-info) ,x (asm ,info ,(asm-fpcastto 'lo) ,y))])
(define-instruction value (fpcastfrom)
[(op (x fpmem) (hi ur) (lo ur)) (seq
`(set! ,(make-live-info) ,(mem->mem x 'lo) ,lo)
`(set! ,(make-live-info) ,(mem->mem x 'hi) ,hi))]
[(op (x fpur) (hi ur) (lo ur)) `(set! ,(make-live-info) ,x (asm ,info ,asm-fpcastfrom ,lo ,hi))]))])
(define-instruction value (fp+ fp- fp/ fp*)
[(op (x fpur) (y fpur) (z fpur))
`(set! ,(make-live-info) ,x (asm ,info ,(asm-fpop-2 op) ,y ,z))])
(define-instruction value (fpsqrt)
[(op (x fpur) (y fpur))
`(set! ,(make-live-info) ,x (asm ,info ,asm-fpsqrt ,y))])
(define-instruction pred (fp= fp< fp<=)
[(op (x fpur) (y fpur))
(let ([info (make-info-condition-code op #f #f)])
(values '() `(asm ,info ,(asm-fp-relop info) ,x ,y)))])
(define-instruction effect (inc-cc-counter)
[(op (x ur) (w signed16) (z ur signed16))
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x ,w))
`(asm ,info ,asm-inc! ,u ,z)))])
(define-instruction effect (inc-profile-counter)
[(op (x mem) (y signed16))
(nanopass-case (L15d Triv) x
[(mref ,x0 ,x1 ,imm ,type)
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x0 ,(if (eq? x1 %zero)
`(immediate ,imm)
x1)))
`(asm ,info ,asm-inc! ,u ,y)))])])
(define-instruction value (read-time-stamp-counter)
[(op (z ur)) `(set! ,(make-live-info) ,z (immediate 0))])
(define-instruction value (read-performance-monitoring-counter)
[(op (z ur) (x ur)) `(set! ,(make-live-info) ,z (immediate 0))])
(define-instruction value (asmlibcall)
[(op (z ur))
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,asm-kill))
`(set! ,(make-live-info) ,z (asm ,info ,(asm-library-call (info-asmlib-libspec info)) ,u ,(info-kill*-live*-live* info) ...))))])
(define-instruction effect (asmlibcall!)
[(op)
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,asm-kill))
`(asm ,info ,(asm-library-call! (info-asmlib-libspec info)) ,u ,(info-kill*-live*-live* info) ...)))])
(define-instruction effect (c-simple-call)
[(op)
(let ([u (make-tmp 'u)])
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,asm-kill))
`(asm ,info ,(asm-c-simple-call (info-c-simple-call-entry info)) ,u)))])
(define-instruction pred (eq? u< < > <= >= logtest log!test)
[(op (y signed16) (x ur))
(let ([info (if (eq? op 'eq?) info-cc-eq (make-info-condition-code op #t #t))])
(values '() `(asm ,info ,(asm-relop info) ,x ,y)))]
[(op (x ur) (y ur signed16))
(let ([info (if (eq? op 'eq?) info-cc-eq (make-info-condition-code op #f #t))])
(values '() `(asm ,info ,(asm-relop info) ,x ,y)))])
(define-instruction pred (condition-code)
[(op) (values '() `(asm ,info ,(asm-condition-code info)))])
(define-instruction pred (type-check?)
[(op (x ur) (mask signed16 ur) (type signed16 ur))
(let ([tmp (make-tmp 'u)])
(values
(with-output-language (L15d Effect)
`(set! ,(make-live-info) ,tmp (asm ,null-info ,(asm-logical 'logand) ,x ,mask)))
`(asm ,info-cc-eq ,asm-eq ,tmp ,type)))])
(let ()
(define (addr-reg x y w k)
(with-output-language (L15d Effect)
(let ([n (nanopass-case (L15d Triv) w [(immediate ,imm) imm])])
(cond
[(and (eq? y %zero) (fx= n 0))
(k x)]
[else
(let ([u (make-tmp 'u)])
(cond
[(eq? y %zero)
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x ,w))
(k u))]
[(fx= n 0)
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x ,y))
(k u))]
[else
(seq
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,x ,y))
`(set! ,(make-live-info) ,u (asm ,null-info ,(asm-add #f) ,u ,w))
(k u))]))]))))
(define-instruction pred (lock!)
[(op (x ur) (y ur) (w signed16))
(addr-reg x y w (lambda (u)
(values '() `(asm ,info-cc-eq ,(asm-lock! info-cc-eq) ,u))))])
(define-instruction effect (locked-incr!)
[(op (x ur) (y ur) (w signed16))
(addr-reg x y w (lambda (u)
;; signals on zero after increment
`(asm ,info ,asm-inc! ,u (immediate 1))))])
(define-instruction effect (locked-decr!)
[(op (x ur) (y ur) (w signed16))
(addr-reg x y w (lambda (u)
;; signals on zero after decrement
`(asm ,info ,asm-inc! ,u (immediate -1))))])
(define-instruction effect (cas)
[(op (x ur) (y ur) (w signed16) (old ur) (new ur))
(addr-reg x y w (lambda (u)
;; signals on successful swap
`(asm ,info ,asm-cas! ,u ,old ,new)))]))
(define-instruction effect (pause)
;; NB: use sqrt or something like that?
[(op) '()])
(define-instruction effect (c-call)
[(op (x ur) (y signed16)) `(asm ,info ,asm-indirect-call ,x ,y ,(info-kill*-live*-live* info) ...)])
(define-instruction effect save-flrv
[(op) '()])
(define-instruction effect restore-flrv
[(op) '()])
(define-instruction effect (invoke-prelude)
[(op) '()])
)
;;; SECTION 3: assembler
(module asm-module (; required exports
asm-move asm-load asm-store asm-swap asm-library-call asm-library-call! asm-library-jump
asm-mul asm-div asm-add asm-sub asm-logical asm-lognot
asm-fp-relop asm-relop
asm-indirect-jump asm-literal-jump
asm-direct-jump asm-return-address asm-jump asm-conditional-jump
asm-indirect-call asm-condition-code
asm-fpmove-single asm-fl-cvt asm-fpt asm-fpmove asm-fpcastto asm-fpcastfrom asm-fptrunc
asm-inc! asm-lock! asm-cas!
asm-fpop-2 asm-fpsqrt asm-c-simple-call
asm-return asm-c-return asm-size
asm-enter asm-foreign-call asm-foreign-callable
asm-kill
signed16?)
(define ax-register?
(case-lambda
[(x) (record-case x [(reg) r #t] [else #f])]
[(x reg) (record-case x [(reg) r (eq? r reg)] [else #f])]))
(define-who ax-ea-reg-code
(lambda (ea)
(record-case ea
[(reg) r (reg-mdinfo r)]
[else (sorry! who "ea=~s" ea)])))
(define ax-reg?
(lambda (ea)
(record-case ea
[(reg) ignore #t]
[else #f])))
(define ax-imm?
(lambda (ea)
(record-case ea
[(imm) ignore #t]
[else #f])))
(define-who ax-imm-data
(lambda (ea)
(record-case ea
[(imm) (n) n]
[else (sorry! who "ax-imm-data ea=~s" ea)])))
; define-op sets up assembly op macros--
; the opcode and all other expressions are passed to the specified handler--
(define-syntax define-op
(lambda (x)
(syntax-case x ()
[(k op handler e ...)
(with-syntax ([op (construct-name #'k "asmop-" #'op)])
#'(define-syntax op
(syntax-rules ()
[(_ mneu arg (... ...))
(handler 'mneu e ... arg (... ...))])))])))
(define-syntax emit
(lambda (x)
(syntax-case x ()
[(k op x ...)
(with-syntax ([emit-op (construct-name #'k "asmop-" #'op)])
#'(emit-op op x ...))])))
(define-op mov mov-op (constant pb-i->i))
(define-op fpmov mov-op (constant pb-d->d))
(define-op movzi movi-op #f) ; 16-bit immediate, shifted
(define-op movki movi-op #t) ; 16-bit immediate, shifted
(define-op add signal-bin-op (constant pb-add))
(define-op sub signal-bin-op (constant pb-sub))
(define-op mul signal-bin-op (constant pb-mul))
(define-op div bin-op (constant pb-div))
(define-op subz signal-bin-op (constant pb-subz)) ; signals on 0 instead of overflow
(define-op land bin-op (constant pb-and))
(define-op lior bin-op (constant pb-ior))
(define-op lxor bin-op (constant pb-xor))
(define-op lnot un-op (constant pb-not))
(define-op lsl bin-op (constant pb-lsl))
(define-op lsr bin-op (constant pb-lsr))
(define-op asr bin-op (constant pb-asr))
(define-op lslo bin-op (constant pb-lslo))
(define-op rev rev-op)
(define-op eq cmp-op (constant pb-eq))
(define-op lt cmp-op (constant pb-lt))
(define-op gt cmp-op (constant pb-gt))
(define-op le cmp-op (constant pb-le))
(define-op ge cmp-op (constant pb-ge))
(define-op ab cmp-op (constant pb-ab)) ; above: unsigned compare
(define-op bl cmp-op (constant pb-bl)) ; below: unsigned compare
(define-op cs cmp-op (constant pb-cs)) ; bits in common
(define-op cc cmp-op (constant pb-cc)) ; no bits in common
(define-op ld load-op)
(define-op st store-op)
(define-op fadd fp-bin-op (constant pb-add))
(define-op fsub fp-bin-op (constant pb-sub))
(define-op fmul fp-bin-op (constant pb-mul))
(define-op fdiv fp-bin-op (constant pb-div))
(define-op fpeq fp-cmp-op (constant pb-eq))
(define-op fplt fp-cmp-op (constant pb-lt))
(define-op fple fp-cmp-op (constant pb-le))
(define-op fsqrt fp-un-op (constant pb-sqrt))
(define-op mov.s->d mov-op (constant pb-s->d))
(define-op mov.d->s mov-op (constant pb-d->s))
(define-op mov.i->d mov-op (constant pb-i->d))
(define-op mov.d->i mov-op (constant pb-d->i))
;; 64-bit versions
(define-op mov.i*>d mov-op (constant pb-i-bits->d-bits))
(define-op mov.d*>i mov-op (constant pb-d-bits->i-bits))
;; 32-bit versions
(define-op mov.ii*>d mov2-op (constant pb-i-i-bits->d-bits))
(define-op mov.d*l>i mov-op (constant pb-d-lo-bits->i-bits))
(define-op mov.d*h>i mov-op (constant pb-d-hi-bits->i-bits))
(define-op btrue branch-op (constant pb-true))
(define-op bfals branch-op (constant pb-fals))
(define-op b branch-op (constant pb-always))
(define-op b* branch-indirect-op)
(define-op lock lock-op)
(define-op cas cas-op)
(define-op inc inc-op)
(define-op call call-op)
(define-op interp interp-op)
(define-op ret ret-op)
(define-op adr adr-op) ; use only for an address after an rpheader (or compact)
(define movi-op
(lambda (op keep? dest imm shift code*)
(emit-code (op dest imm shift code*)
(fx+ (constant pb-mov16)
(if keep?
(constant pb-keep-bits)
(constant pb-zero-bits))
shift)
(ax-ea-reg-code dest)
imm)))
(define mov-op
(lambda (op mode dest src code*)
(emit-code (op dest src code*)
(fx+ (constant pb-mov)
mode)
(ax-ea-reg-code dest)
(ax-ea-reg-code src))))
(define mov2-op
(lambda (op mode dest src0 src1 code*)
(emit-code (op dest src0 src1 code*)
(fx+ (constant pb-mov)
mode)
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))))
(define signal-bin-op
(lambda (op opcode set-cc? dest src0 src1 code*)
(cond
[(ax-reg? src1)
(emit-code (op set-cc? dest src0 src1 code*)
(fx+ (constant pb-bin-op)
(if set-cc?
(constant pb-signal)
(constant pb-no-signal))
opcode
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))]
[else
(emit-code (op set-cc? dest src0 src1 code*)
(fx+ (constant pb-bin-op)
(if set-cc?
(constant pb-signal)
(constant pb-no-signal))
opcode
(constant pb-immediate))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-imm-data src1))])))
(define bin-op
(lambda (op opcode dest src0 src1 code*)
(cond
[(ax-reg? src1)
(emit-code (op dest src0 src1 code*)
(fx+ (constant pb-bin-op)
(constant pb-no-signal)
opcode
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))]
[else
(emit-code (op dest src0 src1 code*)
(fx+ (constant pb-bin-op)
(constant pb-no-signal)
opcode
(constant pb-immediate))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-imm-data src1))])))
(define un-op
(lambda (op opcode dest src code*)
(cond
[(ax-reg? src)
(emit-code (op dest src code*)
(fx+ (constant pb-un-op)
opcode
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src))]
[else
(emit-code (op dest src code*)
(fx+ (constant pb-un-op)
opcode
(constant pb-immediate))
(ax-ea-reg-code dest)
(ax-imm-data src))])))
(define rev-op
(lambda (op size dest src code*)
(emit-code (op dest src code*)
(fx+ (constant pb-rev-op)
size
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src))))
(define cmp-op
(lambda (op opcode src0 src1 code*)
(cond
[(ax-reg? src1)
(emit-code (op src0 src1 code*)
(fx+ (constant pb-cmp-op)
opcode
(constant pb-register))
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))]
[else
(emit-code (op src0 src1 code*)
(fx+ (constant pb-cmp-op)
opcode
(constant pb-immediate))
(ax-ea-reg-code src0)
(ax-imm-data src1))])))
(define load-op
(lambda (op size dest src0 src1 code*)
(cond
[(ax-reg? src1)
(emit-code (op size dest src0 src1 code*)
(fx+ (constant pb-ld-op)
size
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))]
[else
(emit-code (op size dest src0 src1 code*)
(fx+ (constant pb-ld-op)
size
(constant pb-immediate))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-imm-data src1))])))
(define store-op
(lambda (op size dest0 dest1 src code*)
(cond
[(ax-reg? dest1)
(emit-code (op size dest0 dest1 src code*)
(fx+ (constant pb-st-op)
size
(constant pb-register))
(ax-ea-reg-code src)
(ax-ea-reg-code dest0)
(ax-ea-reg-code dest1))]
[else
(emit-code (op size dest0 dest1 src code*)
(fx+ (constant pb-st-op)
size
(constant pb-immediate))
(ax-ea-reg-code src)
(ax-ea-reg-code dest0)
(ax-imm-data dest1))])))
(define fp-bin-op
(lambda (op opcode dest src0 src1 code*)
(emit-code (op dest src0 src1 code*)
(fx+ (constant pb-fp-bin-op)
opcode
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))))
(define fp-un-op
(lambda (op opcode dest src code*)
(emit-code (op dest src code*)
(fx+ (constant pb-fp-un-op)
opcode
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src))))
(define fp-cmp-op
(lambda (op opcode src0 src1 code*)
(emit-code (op src0 src1 code*)
(fx+ (constant pb-fp-cmp-op)
opcode
(constant pb-register))
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))))
(define-who branch-op
(lambda (op sel addr code*)
(record-case addr
[(reg) r
(emit-code (op sel addr code*)
(fx+ (constant pb-b-op)
sel
(constant pb-register))
0
(reg-mdinfo r))]
[(imm) (n)
(emit-code (op sel addr code*)
(fx+ (constant pb-b-op)
sel
(constant pb-immediate))
n)]
[(label) (offset l)
(emit-code (op sel addr code*)
(fx+ (constant pb-b-op)
sel
(constant pb-immediate))
offset)]
[else
(sorry! who "unrecognized destination ~s" addr)])))
(define branch-indirect-op
(lambda (op src0 src1 code*)
(cond
[(ax-reg? src1)
(emit-code (op src0 src1 code*)
(fx+ (constant pb-b*-op)
(constant pb-register))
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))]
[else
(emit-code (op src0 src1 code*)
(fx+ (constant pb-b*-op)
(constant pb-immediate))
(ax-ea-reg-code src0)
(ax-imm-data src1))])))
(define ret-op
(lambda (op code*)
(emit-code (op code*)
(constant pb-return)
0
0)))
(define call-op
(lambda (op dest proto code*)
(emit-code (op dest code*)
(constant pb-call)
(ax-ea-reg-code dest)
(ax-imm-data proto))))
(define interp-op
(lambda (op dest code*)
(emit-code (op dest code*)
(constant pb-interp)
(ax-ea-reg-code dest)
0)))
(define adr-op
(lambda (op dest offset code*)
(emit-code (op dest offset code*)
(constant pb-adr)
(ax-ea-reg-code dest)
offset)))
(define inc-op
(lambda (op dest src code*)
(cond
[(ax-reg? src)
(emit-code (op dest src code*)
(fx+ (constant pb-inc)
(constant pb-register))
(ax-ea-reg-code dest)
(ax-ea-reg-code src))]
[else
(emit-code (op dest src code*)
(fx+ (constant pb-inc)
(constant pb-immediate))
(ax-ea-reg-code dest)
(ax-imm-data src))])))
(define lock-op
(lambda (op dest code*)
(emit-code (op dest code*)
(constant pb-lock)
(ax-ea-reg-code dest)
0)))
(define cas-op
(lambda (op dest src0 src1 code*)
(emit-code (op dest src0 src1 code*)
(constant pb-cas)
(ax-ea-reg-code dest)
(ax-ea-reg-code src0)
(ax-ea-reg-code src1))))
(define-syntax emit-code
(lambda (x)
(syntax-case x ()
[(_ (op opnd ... ?code*) chunk ...)
(let ([safe-check (lambda (e)
(if (fx= (debug-level) 0)
e
#`(let ([code #,e])
(unless (<= 0 code (sub1 (expt 2 32)))
(sorry! 'emit-code "bad result ~s for ~s"
code
(list op opnd ...)))
code)))])
#`(cons (build long #,(safe-check #`(byte-fields chunk ...)))
(aop-cons* `(asm ,op ,opnd ...) ?code*)))])))
(define-syntax build
(syntax-rules ()
[(_ x e)
(and (memq (datum x) '(byte word long)) (integer? (datum e)))
(begin
(safe-assert (fixnum? (datum e)))
(quote (x . e)))]
[(_ x e)
(memq (datum x) '(byte word long))
(cons 'x e)]))
(define-syntax byte-fields
(syntax-rules ()
[(byte-fields op d r/i)
(+ op
(bitwise-arithmetic-shift-left d 8)
(bitwise-arithmetic-shift-left (fxand r/i #xFFFF) 16))]
[(byte-fields op d r r/i)
(+ op
(bitwise-arithmetic-shift-left d 8)
(bitwise-arithmetic-shift-left r 12)
(bitwise-arithmetic-shift-left (fxand r/i #xFFFF) 16))]
[(byte-fields op i)
(+ op
(bitwise-arithmetic-shift-left (fxand i #xFFFFFF) 8))]))
(define signed16?
(lambda (imm)
(and (fixnum? imm) (fx<= (fx- (expt 2 15)) imm (fx- (expt 2 15) 1)))))
(define signed24?
(lambda (imm)
(and (fixnum? imm) (fx<= (fx- (expt 2 23)) imm (fx- (expt 2 23) 1)))))
(define asm-size
(lambda (x)
(case (car x)
[(asm pb-abs pb-proc) 0]
[(long) 4]
[else (constant-case ptr-bits
[(64) 8]
[(32) 4])])))
(define ax-mov64
(lambda (dest n code*)
(emit movzi dest (logand n #xffff) 0
(emit movki dest (logand (bitwise-arithmetic-shift-right n 16) #xffff) 1
(emit movki dest (logand (bitwise-arithmetic-shift-right n 32) #xffff) 2
(emit movki dest (logand (bitwise-arithmetic-shift-right n 48) #xffff) 3
code*))))))
(define ax-movi
(lambda (dest n code*)
(let loop ([n n] [shift 0] [init? #t])
(cond
[(or (eqv? n 0) (fx= shift 4))
(if init?
;; make sure 0 is installed
(emit movzi dest 0 0 code*)
code*)]
[else
(let ([m (logand n #xFFFF)])
(cond
[(eqv? m 0)
(loop (bitwise-arithmetic-shift-right n 16) (fx+ shift 1) init?)]
[else
(let ([code* (loop (bitwise-arithmetic-shift-right n 16) (fx+ shift 1) #f)])
(if init?
(emit movzi dest m shift code*)
(emit movki dest m shift code*)))]))]))))
(define-who asm-move
(lambda (code* dest src)
;; move pseudo instruction used by set! case in select-instruction
;; guarantees dest is a reg and src is reg, mem, or imm OR dest is
;; mem and src is reg.
(Trivit (dest src)
(define (bad!) (sorry! who "unexpected combination of src ~s and dest ~s" src dest))
(cond
[(ax-reg? dest)
(record-case src
[(reg) ignore (emit mov dest src code*)]
[(imm) (n)
(ax-movi dest n code*)]
[(literal) stuff
(ax-mov64 dest 0
(asm-helper-relocation code* (cons 'pb-abs stuff)))]
[(disp) (n breg)
(safe-assert (signed16? n))
(emit ld (constant pb-int64) dest `(reg . ,breg) `(imm ,n) code*)]
[(index) (n ireg breg)
(safe-assert (eqv? n 0))
(emit ld (constant pb-int64) dest `(reg . ,breg) `(reg . ,ireg) code*)]
[else (bad!)])]
[(ax-reg? src)
(record-case dest
[(disp) (n breg)
(safe-assert (signed16? n))
(emit st (constant pb-int64) `(reg . ,breg) `(imm ,n) src code*)]
[(index) (n ireg breg)
(safe-assert (eqv? n 0))
(emit st (constant pb-int64) `(reg . ,breg) `(reg . ,ireg) src code*)]
[else (bad!)])]
[else (bad!)]))))
(define asm-add
(lambda (set-cc?)
(lambda (code* dest src0 src1)
(Trivit (dest src0 src1)
(emit add set-cc? dest src0 src1 code*)))))
(define asm-sub
(lambda (op)
(lambda (code* dest src0 src1)
(Trivit (dest src0 src1)
(if (eq? op '-/eq)
(emit subz #t dest src0 src1 code*)
(emit sub (eq? op '-/ovfl) dest src0 src1 code*))))))
(define asm-mul
(lambda (set-cc?)
(lambda (code* dest src0 src1)
(Trivit (dest src0 src1)
(emit mul set-cc? dest src0 src1 code*)))))
(define asm-div
(lambda (code* dest src0 src1)
(Trivit (dest src0 src1)
(emit div dest src0 src1 code*))))
(define asm-logical
(lambda (op)
(lambda (code* dest src0 src1)
(Trivit (dest src0 src1)
(case op
[(logand) (emit land dest src0 src1 code*)]
[(logor) (emit lior dest src0 src1 code*)]
[(logxor) (emit lxor dest src0 src1 code*)]
[(sll) (emit lsl dest src0 src1 code*)]
[(srl) (emit lsr dest src0 src1 code*)]
[(sra) (emit asr dest src0 src1 code*)]
[(slol) (emit lslo dest src0 src1 code*)]
[else ($oops 'asm-logical "unexpected ~s" op)])))))
(define asm-lognot
(lambda (code* dest src)
(Trivit (dest src)
(emit lnot dest src code*))))
(define-who asm-fl-cvt
(lambda (op)
(lambda (code* dest src)
(Trivit (dest src)
(case op
[(single->double)
(emit mov.s->d dest src code*)]
[(double->single)
(emit mov.d->s dest src code*)]
[else (sorry! who "unrecognized op ~s" op)])))))
(define-who asm-load
(lambda (type)
(lambda (code* dest base index/offset)
(Trivit (dest base index/offset)
(case type
[(integer-64 unsigned-64) (emit ld (constant pb-int64) dest base index/offset code*)]
[(integer-32) (emit ld (constant pb-int32) dest base index/offset code*)]
[(unsigned-32) (emit ld (constant pb-uint32) dest base index/offset code*)]
[(integer-16) (emit ld (constant pb-int16) dest base index/offset code*)]
[(unsigned-16) (emit ld (constant pb-uint16) dest base index/offset code*)]
[(integer-8) (emit ld (constant pb-int8) dest base index/offset code*)]
[(unsigned-8) (emit ld (constant pb-uint8) dest base index/offset code*)]
[(double) (emit ld (constant pb-double) dest base index/offset code*)]
[(float) (emit ld (constant pb-single) dest base index/offset code*)]
[else (sorry! who "unexpected mref type ~s" type)])))))
(define-who asm-store
(lambda (type)
(lambda (code* base index/offset src)
(Trivit (base index/offset src)
(case type
[(integer-64 unsigned-64) (emit st (constant pb-int64) base index/offset src code*)]
[(integer-32 unsigned-32) (emit st (constant pb-int32) base index/offset src code*)]
[(integer-16 unsigned-16) (emit st (constant pb-int16) base index/offset src code*)]
[(integer-8 unsigned-8) (emit st (constant pb-int8) base index/offset src code*)]
[(double) (emit st (constant pb-double) base index/offset src code*)]
[(float) (emit st (constant pb-single) base index/offset src code*)]
[else (sorry! who "unexpected mref type ~s" type)])))))
(define-who asm-fpop-2
(lambda (op)
(lambda (code* dest src1 src2)
(Trivit (dest src1 src2)
(case op
[(fp+) (emit fadd dest src1 src2 code*)]
[(fp-) (emit fsub dest src1 src2 code*)]
[(fp*) (emit fmul dest src1 src2 code*)]
[(fp/) (emit fdiv dest src1 src2 code*)]
[else (sorry! who "unrecognized op ~s" op)])))))
(define asm-fpsqrt
(lambda (code* dest src)
(Trivit (dest src)
(emit fsqrt dest src code*))))
(define asm-fptrunc
(lambda (code* dest src)
(Trivit (dest src)
(emit mov.d->i dest src code*))))
(define asm-fpt
(lambda (code* dest src)
(Trivit (dest src)
(emit mov.i->d dest src code*))))
(define-who asm-fpmove
;; fpmove pseudo instruction is used by set! case in
;; select-instructions! and generate-code; at most one of src or
;; dest can be an mref
(lambda (code* dest src)
(gen-fpmove who code* dest src #t)))
(define-who asm-fpmove-single
(lambda (code* dest src)
(gen-fpmove who code* dest src #f)))
(define gen-fpmove
(lambda (who code* dest src double?)
(Trivit (dest src)
(record-case dest
[(disp) (imm reg)
(emit st (if double? (constant pb-double) (constant pb-single)) `(reg . ,reg) `(imm ,imm) src code*)]
[(index) (n ireg breg)
(emit st (if double? (constant pb-double) (constant pb-single)) `(reg . ,breg) `(reg . ,ireg) src code*)]
[else
(record-case src
[(disp) (imm reg)
(emit ld (if double? (constant pb-double) (constant pb-single)) dest `(reg . ,reg) `(imm ,imm) code*)]
[(index) (n ireg breg)
(emit ld (if double? (constant pb-double) (constant pb-single)) dest `(reg . ,breg) `(reg . ,ireg) code*)]
[else (emit fpmov dest src code*)])]))))
(constant-case ptr-bits
[(64)
(define asm-fpcastto
(lambda (code* dest src)
(Trivit (dest src)
(emit mov.d*>i dest src code*))))
(define asm-fpcastfrom
(lambda (code* dest src)
(Trivit (dest src)
(emit mov.i*>d dest src code*))))]
[(32)
(define asm-fpcastto
(lambda (part)
(lambda (code* dest src)
(Trivit (dest src)
(if (eq? part 'hi)
(emit mov.d*h>i dest src code*)
(emit mov.d*l>i dest src code*))))))
(define asm-fpcastfrom
(lambda (code* dest src-lo src-hi)
(Trivit (dest src-lo src-hi)
(emit mov.ii*>d dest src-lo src-hi code*))))])
(define-who asm-swap
(lambda (type)
(lambda (code* dest src)
(Trivit (dest src)
(case type
[(integer-64 unsigned-64) (emit rev (constant pb-int64) dest src code*)]
[(integer-32) (emit rev (constant pb-int32) dest src code*)]
[(unsigned-32) (emit rev (constant pb-uint32) dest src code*)]
[(integer-16) (emit rev (constant pb-int16) dest src code*)]
[(unsigned-16) (emit rev (constant pb-uint16) dest src code*)]
[else (sorry! who "unexpected asm-swap type argument ~s" type)])))))
(define asm-inc!
(lambda (code* dest src)
(Trivit (dest src)
(emit inc dest src code*))))
(define asm-lock!
(lambda (info)
(lambda (l1 l2 offset dest)
(values
(Trivit (dest)
(emit lock dest '()))
(asm-conditional-jump info l1 l2 offset)))))
(define asm-cas!
(lambda (code* dest old new)
(Trivit (dest old new)
(emit cas dest old new code*))))
(define-who asm-relop
(lambda (info)
(lambda (l1 l2 offset x y)
(values
(Trivit (x y)
(define-syntax sel
(lambda (stx)
(syntax-case stx ()
[(_ pos neg)
#`(if (info-condition-code-reversed? info)
(emit neg x y '())
(emit pos x y '()))])))
(case (info-condition-code-type info)
[(eq?) (emit eq x y '())]
[(u<) (sel bl ab)]
[(<) (sel lt gt)]
[(>) (sel gt lt)]
[(<=) (sel le ge)]
[(>=) (sel ge le)]
[(logtest) (emit cs x y '())]
[(log!test) (emit cc x y '())]
[else (sorry! who "unexpected ~s" (info-condition-code-type info))]))
(asm-conditional-jump info l1 l2 offset)))))
(define-who asm-fp-relop
(lambda (info)
(lambda (l1 l2 offset x y)
(Trivit (x y)
(values
(case (info-condition-code-type info)
[(fp=) (emit fpeq x y '())]
[(fp<) (emit fplt x y '())]
[(fp<=) (emit fple x y '())]
[else (sorry! who "unrecognized ~s" (info-condition-code-type info))])
(asm-conditional-jump info l1 l2 offset))))))
(define asm-condition-code
(lambda (info)
(rec asm-check-flag-internal
(lambda (l1 l2 offset)
(values '() (asm-conditional-jump info l1 l2 offset))))))
(define asm-library-jump
(lambda (l)
(asm-helper-jump '()
`(pb-proc ,(constant code-data-disp) (library-code ,(libspec-label-libspec l))))))
(define asm-library-call
(lambda (libspec)
(let ([target `(pb-proc ,(constant code-data-disp) (library-code ,libspec))])
(lambda (code* dest jmptmp . ignore)
(asm-helper-call code* jmptmp #t target)))))
(define asm-library-call!
(lambda (libspec)
(let ([target `(pb-proc ,(constant code-data-disp) (library-code ,libspec))])
(lambda (code* jmptmp . ignore)
(asm-helper-call code* jmptmp #t target)))))
(define asm-c-simple-call
(lambda (entry)
(let ([target `(pb-proc 0 (entry ,entry))])
(lambda (code* jmptmp . ignore)
(asm-helper-call code* jmptmp #f target)))))
(define-who asm-indirect-call
(lambda (code* dest proto . ignore)
(Trivit (dest proto)
(unless (ax-reg? dest) (sorry! who "unexpected dest ~s" dest))
(emit call dest proto code*))))
(define asm-direct-jump
(lambda (l offset)
(let ([offset (adjust-return-point-offset offset l)])
(asm-helper-jump '() (make-funcrel 'pb-proc l offset)))))
(define asm-literal-jump
(lambda (info)
(asm-helper-jump '()
`(pb-proc ,(info-literal-offset info) (,(info-literal-type info) ,(info-literal-addr info))))))
(define-who asm-indirect-jump
(lambda (src)
(Trivit (src)
(record-case src
[(reg) ignore (emit b src '())]
[(disp) (n breg)
(assert (signed16? n))
(emit b* `(reg . ,breg) `(imm ,n) '())]
[(index) (n ireg breg)
(safe-assert (eqv? n 0))
(emit b* `(reg . ,breg) `(reg . ,ireg) '())]
[else (sorry! who "unexpected src ~s" src)]))))
(define-who asm-return-address
(lambda (dest l incr-offset next-addr)
(make-rachunk dest l incr-offset next-addr
(cond
[(local-label-offset l) =>
(lambda (offset)
(let ([incr-offset (adjust-return-point-offset incr-offset l)])
(let ([disp (fx- next-addr (fx- offset incr-offset))])
(emit adr `(reg . ,dest) disp '()))))]
[else
(asm-move '() dest (with-output-language (L16 Triv) `(label-ref ,l ,incr-offset)))]))))
(define-who asm-jump
(lambda (l next-addr)
(make-gchunk l next-addr
(cond
[(local-label-offset l) =>
(lambda (offset)
(let ([disp (fx- next-addr offset)])
(cond
[(eqv? disp 0) '()]
[else
(safe-assert (signed24? disp))
(emit b `(label ,disp ,l) '())])))]
[else
;; label must be somewhere above. generate something so that a hard loop
;; doesn't get dropped. this also has some chance of being the right size
;; for the final branch instruction.
(emit b `(label 0 ,l) '())]))))
(define-who asm-conditional-jump
(lambda (info l1 l2 next-addr)
(make-cgchunk info l1 l2 next-addr
(let ()
(define get-disp-opnd
(lambda (next-addr l)
(if (local-label? l)
(cond
[(local-label-offset l) =>
(lambda (offset)
(let ([disp (fx- next-addr offset)])
(safe-assert (signed24? disp))
(values disp `(label ,disp ,l))))]
[else (values 0 `(label 0 ,l))])
(sorry! who "unexpected label ~s" l))))
(let-values ([(disp1 opnd1) (get-disp-opnd next-addr l1)]
[(disp2 opnd2) (get-disp-opnd next-addr l2)])
(cond
[(fx= disp1 0)
(emit bfals opnd2 '())]
[(fx= disp2 0)
(emit btrue opnd1 '())]
[else
(let-values ([(disp1 opnd1) (get-disp-opnd (fx+ next-addr 4) l1)])
(emit btrue opnd1 (emit b opnd2 '())))]))))))
(define asm-helper-jump
(lambda (code* reloc)
(let ([jmptmp (cons 'reg %ts)])
(ax-mov64 jmptmp 0
(emit b jmptmp
(asm-helper-relocation code* reloc))))))
(define asm-helper-call
(lambda (code* jmptmp interp? reloc)
(ax-mov64 `(reg . ,jmptmp) 0
(let ([code* (asm-helper-relocation code* reloc)])
(if interp?
(emit interp `(reg . ,jmptmp) code*)
(emit call `(reg . ,jmptmp) `(imm ,(constant pb-call-void)) code*))))))
(define asm-helper-relocation
(lambda (code* reloc)
(cons* reloc (aop-cons* `(asm "relocation:" ,reloc) code*))))
(define asm-return (lambda () (emit ret '())))
(define asm-c-return (lambda (info) (emit ret '())))
(define asm-enter values)
(define asm-kill
(lambda (code* dest)
code*))
(module (asm-foreign-call asm-foreign-callable)
(define int-argument-regs (lambda () (list %Carg1 %Carg2 %Carg3 %Carg4 %Carg5 %Carg6 %Carg7)))
(define fp-argument-regs (lambda () (list %Cfparg1 %Cfparg2 %Cfparg3 %Cfparg4 %Cfparg5 %Cfparg6)))
(define prototypes (constant pb-prototype-table))
(define-who asm-foreign-call
(with-output-language (L13 Effect)
(letrec ([load-double-reg
(lambda (fpreg)
(lambda (x) ; unboxed
`(set! ,fpreg ,x)))]
[load-int-reg
(lambda (ireg)
(lambda (x)
`(set! ,ireg ,x)))]
[load-two-int-regs
(lambda (lo-ireg hi-ireg)
(lambda (lo hi)
`(seq
(set! ,lo-ireg ,lo)
(set! ,hi-ireg ,hi))))]
[64-bit-type-on-32-bit?
(lambda (type)
(nanopass-case (Ltype Type) type
[(fp-integer ,bits)
(constant-case ptr-bits
[(64) #f]
[(32) (fx= bits 64)])]
[(fp-integer ,bits)
(constant-case ptr-bits
[(64) #f]
[(32) (fx= bits 64)])]
[else #f]))]
[do-args
(lambda (in-types)
(let loop ([types in-types] [locs '()] [live* '()] [int* (int-argument-regs)] [fp* (fp-argument-regs)])
(if (null? types)
(values locs live*)
(let ([type (car types)]
[types (cdr types)])
(nanopass-case (Ltype Type) type
[(fp-double-float)
(when (null? fp*) (sorry! who "too many floating-point arguments"))
(loop types
(cons (load-double-reg (car fp*)) locs)
(cons (car fp*) live*)
int* (cdr fp*))]
[(fp-single-float)
(when (null? fp*) (sorry! who "too many floating-point arguments"))
(loop types
(cons (load-double-reg (car fp*)) locs)
(cons (car fp*) live*)
int* (cdr fp*))]
[(fp-ftd& ,ftd)
(sorry! who "indirect arguments no supported")]
[else
(when (null? int*) (sorry! who "too many integer/pointer arguments: ~s" (length in-types)))
(cond
[(64-bit-type-on-32-bit? type)
(when (null? (cdr int*)) (sorry! who "too many integer/pointer arguments: ~s" (length in-types)))
(loop types
(cons (load-two-int-regs (car int*) (cadr int*)) locs)
(cons* (cadr int*) (car int*) live*)
(cddr int*) fp*)]
[else
(loop types
(cons (load-int-reg (car int*)) locs)
(cons (car int*) live*)
(cdr int*) fp*)])])))))]
[do-result
(lambda (type)
(nanopass-case (Ltype Type) type
[(fp-double-float)
(values (lambda (lvalue) ; unboxed
`(set! ,lvalue ,%Cfpretval))
(list %Cfpretval))]
[(fp-single-float)
(values (lambda (lvalue) ; unboxed
`(set! ,lvalue ,(%inline single->double ,%Cfpretval)))
(list %Cfpretval))]
[(fp-ftd& ,ftd)
(sorry! who "unhandled result type ~s" type)]
[else
(when (64-bit-type-on-32-bit? type)
(sorry! who "unhandled result type ~s" type))
(values (lambda (lvalue) `(set! ,lvalue ,%Cretval))
(list %Cretval))]))]
[get-prototype
(lambda (type*)
(let* ([prototype
(map (lambda (type)
(nanopass-case (Ltype Type) type
[(fp-double-float) 'double]
[(fp-single-float) 'float]
[(fp-integer ,bits)
(constant-case ptr-bits
[(64) (case bits
[(8) 'int8]
[(16) 'int16]
[(32) 'int32]
[else 'uptr])]
[(32) (case bits
[(8) 'int8]
[(16) 'int16]
[(32) 'uptr]
[else 'int64])])]
[(fp-unsigned ,bits)
(constant-case ptr-bits
[(64) (case bits
[(8) 'uint8]
[(16) 'uint16]
[(32) 'uint32]
[else 'uptr])]
[(32) (case bits
[(8) 'uint8]
[(16) 'uint16]
[(32) 'uptr]
[else 'int64])])]
[(fp-scheme-object) 'uptr]
[(fp-fixnum) 'uptr]
[(fp-u8*) 'void*]
[(fp-void) 'void]
[else (sorry! who "unhandled type in prototype ~s" type)]))
type*)]
[a (assoc prototype prototypes)])
(unless a
(sorry! who "unsupported prototype ~a" prototype))
(cdr a)))])
(lambda (info)
(let* ([arg-type* (info-foreign-arg-type* info)]
[result-type (info-foreign-result-type info)])
(let-values ([(locs arg-live*) (do-args arg-type*)]
[(get-result result-live*) (do-result result-type)])
(values
(lambda () `(nop))
(reverse locs)
(lambda (t0 not-varargs?)
(let ([info (make-info-kill*-live* (add-caller-save-registers result-live*) arg-live*)])
`(inline ,info ,%c-call ,t0 (immediate ,(get-prototype (cons result-type arg-type*))))))
get-result
(lambda () `(nop)))))))))
(define-who asm-foreign-callable
(lambda (info)
(sorry! who "callables are not supported"))))
)
| true |
7d30626ea591382d29a74a02b070af0ff314edbe
|
b21f59bbd4faf31159321e8d26eb170f9aa410c0
|
/1.3.4-procedures-as-return-values/smooth.scm
|
70b8c6da64437d235140eb19d7e7f818371330d9
|
[] |
no_license
|
furkhat/sicp-practice
|
4774048022718c165e0ec35602bb192241d9f97a
|
301fea9ee4d6cea895cec4b618c664b48c2106f0
|
refs/heads/master
| 2021-06-08T06:01:01.760120 | 2016-12-11T08:11:34 | 2016-12-11T08:11:34 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 217 |
scm
|
smooth.scm
|
(load "repeated.scm")
(define dx 0.00001)
(define (smooth f)
(lambda (x)
(/ (+ (f (- x dx))
(f x)
(f (+ x dx)))
3.0)))
(define (n-fold-smoothed f times)
(repeated smooth times))
| false |
52ffe54990b63fd085fee4ef344bca4e178fa4b5
|
6b961ef37ff7018c8449d3fa05c04ffbda56582b
|
/bbn_cl/mach/zcomp/fgopt/folcon.scm
|
0a49996aa6cff09715242ff50327aac4a81c69c1
|
[] |
no_license
|
tinysun212/bbn_cl
|
7589c5ac901fbec1b8a13f2bd60510b4b8a20263
|
89d88095fc2a71254e04e57cf499ae86abf98898
|
refs/heads/master
| 2021-01-10T02:35:18.357279 | 2015-05-26T02:44:00 | 2015-05-26T02:44:00 | 36,267,589 | 4 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,528 |
scm
|
folcon.scm
|
#| -*-Scheme-*-
$Header: folcon.scm,v 1.2 88/08/31 10:40:53 jinx Exp $
$MIT-Header: folcon.scm,v 4.2 87/12/30 06:44:31 GMT cph Exp $
Copyright (c) 1987 Massachusetts Institute of Technology
This material was developed by the Scheme project at the Massachusetts
Institute of Technology, Department of Electrical Engineering and
Computer Science. Permission to copy this software, to redistribute
it, 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. Users of this software agree to make their best efforts (a) to
return to the MIT Scheme project any improvements or extensions that
they make, so that these may be included in future releases; and (b)
to inform MIT of noteworthy uses of this software.
3. All materials developed as a consequence of the use of this
software shall duly acknowledge such use, in accordance with the usual
standards of acknowledging credit in academic research.
4. MIT has made no warrantee or representation that the operation of
this software will be error-free, and MIT is under no obligation to
provide any services, by way of maintenance, update, or otherwise.
5. In conjunction with products arising from the use of this material,
there shall be no use of the name of the Massachusetts Institute of
Technology nor of any adaptation thereof in any advertising,
promotional, or sales literature without prior written consent from
MIT in each case. |#
;;;; Constant Folding
(declare (usual-integrations))
(package (fold-constants)
(define-export (fold-constants lvalues applications)
(let loop
((lvalues lvalues)
(combinations
(list-transform-positive applications application/combination?)))
(let ((unknown-lvalues (eliminate-known-nodes lvalues)))
(transmit-values (fold-combinations combinations)
(lambda (any-folded? not-folded)
(if any-folded?
(loop unknown-lvalues not-folded)
not-folded))))))
(define (eliminate-known-nodes lvalues)
(let ((knowable-nodes
(list-transform-positive lvalues
(lambda (lvalue)
(and (not (or (lvalue-passed-in? lvalue)
(and (variable? lvalue)
(variable-assigned? lvalue)
(not (memq 'CONSTANT
(variable-declarations lvalue))))))
(let ((values (lvalue-values lvalue)))
(and (not (null? values))
(null? (cdr values))
(or (rvalue/procedure? (car values))
(and (rvalue/constant? (car values))
(object-immutable?
(constant-value (car values))))))))))))
(for-each (lambda (lvalue) (lvalue-mark-set! lvalue 'KNOWABLE))
knowable-nodes)
(transitive-closure false delete-if-known! knowable-nodes)
(for-each (lambda (lvalue) (lvalue-mark-clear! lvalue 'KNOWABLE))
knowable-nodes))
(list-transform-negative lvalues lvalue-known-value))
(define (delete-if-known! lvalue)
(if (and (not (lvalue-known-value lvalue))
(for-all? (lvalue-backward-links lvalue) lvalue-known-value))
(let ((value (car (lvalue-values lvalue))))
(for-each (lambda (lvalue*)
(if (lvalue-mark-set? lvalue* 'KNOWABLE)
(enqueue-node! lvalue*)))
(lvalue-forward-links lvalue))
(set-lvalue-known-value! lvalue value))))
(define (fold-combinations combinations)
(if (null? combinations)
(return-2 false '())
(transmit-values (fold-combinations (cdr combinations))
(lambda (any-folded? not-folded)
(if (fold-combination (car combinations))
(return-2 true not-folded)
(return-2 any-folded? (cons (car combinations) not-folded)))))))
(define (fold-combination combination)
(let ((operator (combination/operator combination))
(continuation (combination/continuation combination))
(operands (combination/operands combination)))
(and (rvalue-known-constant? operator)
(let ((operator (rvalue-constant-value operator)))
(and (operator-constant-foldable? operator)
(primitive-arity-correct? operator (length operands))))
;; (rvalue-known? continuation)
;; (uni-continuation? (rvalue-known-value continuation))
(for-all? operands rvalue-known-constant?)
(begin
(let ((constant
(make-constant
(apply (rvalue-constant-value operator)
(map rvalue-constant-value operands)))))
(combination/constant! combination constant)
(map (lambda (value)
(if (uni-continuation? value)
(lvalue-connect!:rvalue
(uni-continuation/parameter value)
constant)))
(rvalue-values continuation)))
true))))
)
| false |
dafd228edf60f4c2b9dbbe559c314c3be6387526
|
a2bc20ee91471c8116985e0eb6da1d19ab61f6b0
|
/exercise_8_5/main.scm
|
6e7c291a8bac77e0d69a82c13a38ea1b058f24ff
|
[] |
no_license
|
cthulhu-irl/my-scheme-practices
|
6209d01aa1497971a5b970ab8aa976bb3481e9c9
|
98867870b0cb0306bdeb209d076bdc80e2e0e8cc
|
refs/heads/master
| 2022-09-22T15:19:48.798783 | 2020-06-06T14:16:07 | 2020-06-06T14:16:07 | 265,855,102 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 126 |
scm
|
main.scm
|
(define (func ls)
(sqrt (apply + (map (lambda (x) (expt x 2)) ls))))
(format #t "(func '(2 2 1)): ~a\n" (func '(2 2 1)))
| false |
48d37aa69259d2d9987a0b056927166303260ac3
|
6b288a71553cf3d8701fe7179701d100c656a53c
|
/s/layout.ss
|
a46b552c54f6fbf151e266e91d541bb8f3ba63b2
|
[
"Apache-2.0"
] |
permissive
|
cisco/ChezScheme
|
03e2edb655f8f686630f31ba2574f47f29853b6f
|
c048ad8423791de4bf650fca00519d5c2059d66e
|
refs/heads/main
| 2023-08-26T16:11:15.338552 | 2023-08-25T14:17:54 | 2023-08-25T14:17:54 | 56,263,501 | 7,763 | 1,410 |
Apache-2.0
| 2023-08-28T22:45:52 | 2016-04-14T19:10:25 |
Scheme
|
UTF-8
|
Scheme
| false | false | 4,706 |
ss
|
layout.ss
|
;;; layout.ss
;;; Copyright 1984-2017 Cisco Systems, Inc.
;;;
;;; 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.
(define compute-field-offsets
; type-disp is the offset from the ptr to the object's true address
; ls is a list of field descriptors
(lambda (who type-disp ls)
(define parse-field
(lambda (f)
(define supported-type
(lambda (x)
(let ([x (filter-foreign-type x)])
(and (memq x (record-datatype list)) x))))
(define (err) ($oops who "invalid field specifier ~s" f))
(define (s0 f)
(cond
[(symbol? f) (values f #t 'scheme-object 'scheme-object 1)]
[(list? f) (s1 f)]
[else (err)]))
(define (s1 f)
(cond
[(null? f) (err)]
[(null? (cdr f))
(if (symbol? (car f))
(values (car f) #t 'scheme-object 'scheme-object 1)
(err))]
[(eq? (car f) 'immutable) (s2 (cdr f) #f)]
[(eq? (car f) 'mutable) (s2 (cdr f) #t)]
[else (s2 f #t)]))
(define (s2 f mutable?)
(cond
[(null? f) (err)]
[(null? (cdr f))
(if (symbol? (car f))
(values (car f) mutable? 'scheme-object 'scheme-object 1)
(err))]
[(supported-type (car f)) =>
(lambda (real-type) (s3 (cdr f) mutable? (car f) real-type))]
[else (s3 f mutable? 'scheme-object 'scheme-object)]))
(define (s3 f mutable? type real-type)
(cond
[(null? f) (err)]
[(symbol? (car f)) (s4 (cdr f) mutable? type real-type (car f))]
[else (err)]))
(define (s4 f mutable? type real-type name)
(cond
[(null? f) (values name mutable? type real-type 1)]
[(and (integer? (car f)) (nonnegative? (car f)))
(values name mutable? type real-type (car f))]
[else (err)]))
(s0 f)))
(define type->bytes
(lambda (ty)
(define-syntax ->bytes
(syntax-rules () ((_ type bytes pred) bytes)))
(record-datatype cases ty ->bytes
($oops who "unrecognized type ~s" ty))))
(define get-max-alignment
(lambda (ty)
(case ty
[(single-float double-float) (constant max-float-alignment)]
[else (constant max-integer-alignment)])))
(define align
(lambda (n bytes type)
(let ([k (gcd (get-max-alignment type) bytes)])
(logand (+ n (fx- k 1)) (fx- k)))))
(with-values
(let f ((ls ls) (byte 0))
(if (null? ls)
(values 0 0 '() byte) ; pm, mpm, flds, size
(with-values (parse-field (car ls))
(lambda (name mutable? type real-type len)
(let* ((bytes (type->bytes real-type))
; align even if len is zero to give element its
; proper alignment, since zero at the end can mean
; variable-length
(byte (align byte bytes real-type)))
(with-values (f (cdr ls) (+ byte (* bytes len)))
(lambda (pm mpm flds size)
(let ((flds (cons (make-fld name mutable? type (+ type-disp byte)) flds)))
(if (eq? real-type 'scheme-object)
(let ((m (ash (- (ash 1 len) 1)
(fxsrl byte (constant log2-ptr-bytes)))))
(values
(+ pm m)
(if mutable? (+ mpm m) mpm)
flds
size))
(values pm mpm flds size))))))))))
(lambda (pm mpm flds size)
(define sanitize-mask
; if bits are set for each word, return mask of -1
; to give gc a quick test for pure vs. impure
(lambda (m size)
(if (= (- (ash 1 (quotient (+ size -1 (constant ptr-bytes)) (constant ptr-bytes))) 1) m)
-1
m)))
(values (sanitize-mask pm size) mpm flds size)))))
| true |
05f4832d5f47f9f2b727090db9ef2c436c76b7f4
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/vr/input-tracking.sls
|
6b1366be835837d89cecb7bf3861a88306815903
|
[] |
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 | 892 |
sls
|
input-tracking.sls
|
(library (unity-engine vr input-tracking)
(export new
is?
input-tracking?
get-local-position
get-local-rotation
recenter)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...) #'(clr-new UnityEngine.VR.InputTracking a ...)))))
(define (is? a) (clr-is UnityEngine.VR.InputTracking a))
(define (input-tracking? a) (clr-is UnityEngine.VR.InputTracking a))
(define-method-port
get-local-position
UnityEngine.VR.InputTracking
GetLocalPosition
(static: UnityEngine.Vector3 UnityEngine.VR.VRNode))
(define-method-port
get-local-rotation
UnityEngine.VR.InputTracking
GetLocalRotation
(static: UnityEngine.Quaternion UnityEngine.VR.VRNode))
(define-method-port
recenter
UnityEngine.VR.InputTracking
Recenter
(static: System.Void)))
| true |
4702e47f35fa3f2e8c2dfd7bd903e80623139d5a
|
8def8726df4eb28d7b22d123c7e3a208d5577999
|
/new/common/utils.ss
|
21593328ded07ce256a19a1e838a3bf0a64b3f8d
|
[] |
no_license
|
racket/old-web
|
9e0afa241fe443ddb5e9fa083d58c978ed38b459
|
d7b670c23e570d398257fbc7b658b3948a5f3d81
|
refs/heads/master
| 2022-11-11T09:46:58.220698 | 2020-06-25T13:12:02 | 2020-06-25T13:12:02 | 274,562,458 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 481 |
ss
|
utils.ss
|
#lang at-exp s-exp "../code/main.ss"
(require (for-syntax scheme/base))
(provide in-here)
(define-syntax (in-here stx)
(syntax-case stx ()
[(_ path paths ...)
(let ([src (let-values ([(dir name dir?)
(split-path (syntax-source stx))])
dir)])
#`(build-path '#,src path paths ...))]))
(define/provide (copyfile source target [referrer values])
(resource target (lambda (file) (copy-file source file)) referrer))
| true |
909f8ef5d2e93d25dc0ead7df1987d47b6ac1573
|
4b570eebce894b4373cba292f09883932834e543
|
/ch2/2.46.scm
|
ef338b5251bf5d17bfaf7650166ea268bcf94f8a
|
[] |
no_license
|
Pulkit12083/sicp
|
ffabc406c66019e5305ad701fbc022509319e4b1
|
8ea6c57d2b0be947026dd01513ded25991e5c94f
|
refs/heads/master
| 2021-06-17T13:44:06.381879 | 2021-05-14T16:52:30 | 2021-05-14T16:52:30 | 197,695,022 | 0 | 0 | null | 2021-04-14T17:04:01 | 2019-07-19T03:25:41 |
Scheme
|
UTF-8
|
Scheme
| false | false | 873 |
scm
|
2.46.scm
|
;; tedious
(define (frame-coord-map frame)
(lambda (v)
(add-vect
(origin-frame frame)
(add-vect (scale-vect (xcor-vect v)
(edge1-frame frame))
(scale-vect (ycor-vect v)
(edge2-frame frame))))))
((frame-coord-map a-frame) (make-vect 0 0))
(origin-frame a-frame)
;;Exercise 2.46.
;; add-vect
(define (add-vect vec1 vec2)
(make-vect (+ (xcor-vect vec1) (xcor-vect vec2))
(+ (ycor-vect vec1) (ycor-vect vec2))))
;; sub-vect
(define (sub-vect vec1 vec2)
(make-vect (- (xcor-vect vec1) (xcor-vect vec2))
(- (ycor-vect vec1) (ycor-vect vec2))))
;; scale-vect
(define (scale-vect sc vec2)
(make-vect (* sc (xcor-vect vec2))
(* sc (ycor-vect vec2))))
;;make=vect
(define (make-vect x y)
(cons x y))
(define (xcor-vect v)
(car v))
(define (ycor-vect v)
(cdr v))
| false |
0ae591a8088720869d65e79982185802553d0eb4
|
c085780da34766c02f47f181bd8a7bb515126caa
|
/lab19 memofunc.scm
|
3f2dc24f5dd2aca279c9ab7d769d45d74c046e37
|
[] |
no_license
|
juleari/r5rs
|
37ede50989e59b0936f7aac2b204cb9affa22d21
|
880b0df41e94c103386c158cc172b658f485a465
|
refs/heads/master
| 2016-09-16T17:23:42.192923 | 2016-05-04T11:58:18 | 2016-05-04T11:58:18 | 42,339,524 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,474 |
scm
|
lab19 memofunc.scm
|
;(use-syntax (ice-9 syncase))
(define-syntax define-memoized
(syntax-rules ()
((_ (func a ...) body ...) (define func
(let ((memo '()))
(lambda (a ...)
(let ((m (assoc (list a ...) memo)))
(if m
(cadr m)
(let ((res (begin body ...)))
(set! memo
(cons (list (list a ...) res)
memo))
res)))))))
((_ func (lambda (a ...) body ...)) (define-memoized (func a ...) body ...))))
;; tests
#|(define-memoized (trib n)
(cond
((= n 0) 0)
((= n 1) 1)
((= n 2) 1)
(else (+ (trib (- n 1))
(trib (- n 2))
(trib (- n 3))))))
(trib 10)
(define-memoized (A m n)
(cond ((zero? m) (+ n 1))
((zero? n) (A (- m 1) 1))
(else (A (- m 1) (A m (- n 1))))))
(A 3 7)
(begin
(define-memoized ackermann
(lambda (m n)
(cond
((= m 0) (+ n 1))
((and (> m 0) (= n 0)) (ackermann (- m 1) 1))
(else (ackermann (- m 1) (ackermann m (- n 1)))))))
(map ackermann '(2 3 3 3) '(3 4 5 6))
(map ackermann '(2 3 3 3) '(3 4 5 6)))|#
| true |
e991b563e57c9de1662c8822614ea00883ed7a3f
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/mscorlib/system/runtime/remoting/channels/server-dispatch-sink-provider.sls
|
e2053cdebbd31e7dc10708da0be6742e56dde238
|
[] |
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,425 |
sls
|
server-dispatch-sink-provider.sls
|
(library (system
runtime
remoting
channels
server-dispatch-sink-provider)
(export new
is?
server-dispatch-sink-provider?
create-sink
get-channel-data
next-get
next-set!
next-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
a
...)))))
(define (is? a)
(clr-is
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
a))
(define (server-dispatch-sink-provider? a)
(clr-is
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
a))
(define-method-port
create-sink
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
CreateSink
(System.Runtime.Remoting.Channels.IServerChannelSink
System.Runtime.Remoting.Channels.IChannelReceiver))
(define-method-port
get-channel-data
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
GetChannelData
(System.Void System.Runtime.Remoting.Channels.IChannelDataStore))
(define-field-port
next-get
next-set!
next-update!
(property:)
System.Runtime.Remoting.Channels.ServerDispatchSinkProvider
Next
System.Runtime.Remoting.Channels.IServerChannelSinkProvider))
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.