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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
bb374c7b4c1b9a54d5342512e52f2919dbea71b9 | 174072a16ff2cb2cd60a91153376eec6fe98e9d2 | /Chap-two/2-38.scm | 22e3996d85609f8d01ffdfb0e0e4e54296156140 | []
| no_license | Wang-Yann/sicp | 0026d506ec192ac240c94a871e28ace7570b5196 | 245e48fc3ac7bfc00e586f4e928dd0d0c6c982ed | refs/heads/master | 2021-01-01T03:50:36.708313 | 2016-10-11T10:46:37 | 2016-10-11T10:46:37 | 57,060,897 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 219 | scm | 2-38.scm | (define (foldleft op init seq)
(define (iter result rest)
(if (null? rest) result
(iter (op result (car rest)) (cdr rest))))
(iter init seq))
(load "filter.scm")
(define (foldright op init seq) (acc op init seq))
| false |
55b399f5ee6b563fcd7d783e9c18a4a72c77ff9c | ec0f122fdcf4ceaf5e9e183575a460006c19ebe0 | /clean.scm | 6931dd238a4501d9b2ddf273e646681b99f47794 | []
| no_license | ThomasHintz/keep-the-records | d96e6253ebc3d2e11ee37277a6293c7365b25f9b | c20e648e831bed2ced3f2f74bfc590dc06b5f076 | refs/heads/master | 2021-01-13T02:37:41.053488 | 2013-07-19T04:18:44 | 2013-07-19T04:18:44 | 1,272,038 | 2 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 118 | scm | clean.scm | #!/usr/local/bin/csi
(use system)
(load "keep-the-records.system")
(clean-system ktr)
(print "\nSystem clean")
(exit)
| false |
06641641a80fe5efe646e30ef689e599fdd5c0a9 | 66ee0dd65a25484c064b09edb360a9b2a0217883 | /remove!.ss | 1fc0c76bfb7dbba24d9af85f1f5886fe849b52a4 | []
| no_license | Liudx1985/Lisp-Scheme-Haskell | 337c1faceed9318905a7235379163bbe258d0bd0 | f874b92b86cabc09ead4f6c711e7550561a9d628 | refs/heads/master | 2016-09-06T03:37:02.977060 | 2015-02-02T02:17:53 | 2015-02-02T02:17:53 | 18,743,986 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 400 | ss | remove!.ss | (define remove_
(lambda (a lat)
(cond ((null? lat) '())
((eq? (car lat) a) (remove_ a (cdr lat)))
(else (cons (car lat) (remove_ a (cdr lat))))
)))
; (append lat a) generate a [lat.a] list not flatten
(define insert-back
(lambda (lat a)
(if (list? lat) (append lat (list a))
'failed))
)
(define remove_
(lambda (ls x)
(filter (lambda (y) (not (eq? y x))) ls)
)) | false |
34aed86ab26967bfd158f46a5b797802057abd1b | a6a1c8eb973242fd2345878e5a871a89468d4080 | /slib.scm | fd941049d223adec99411003de4d697425943d65 | []
| 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 | 202 | scm | slib.scm | (use slib)
(require 'trace)
(define (fibonacci n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fibonacci (- n 1))
(fibonacci (- n 2))))))
(trace fibonacci)
(fibonacci 3)
| false |
b4e74d4983f980c6cc5c90d2ec36600c9d851cf7 | 000dbfe5d1df2f18e29a76ea7e2a9556cff5e866 | /test/tests/srfi/%3a114.scm | 03dbb74fa67dc0722186beb415c47dc7171e521f | [
"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 | 4,650 | scm | %3a114.scm | (import (rnrs)
(srfi :114)
(srfi :64))
(test-begin "SRFI-114 comparators")
;; predicates
(test-assert "comparator? (default-comparator)"
(comparator? default-comparator))
(test-assert "comparator-comparison-procedure? (default-comparator)"
(comparator-comparison-procedure? default-comparator))
(test-assert "comparator-hash-function? (default-comparator)"
(comparator-hash-function? default-comparator))
;; standard comparators
(define-syntax test-existance
(syntax-rules ()
((_ comparator rest ...)
(begin
(test-assert (format "comparator? (~a)" 'comparator)
(comparator? comparator))
(test-assert (format "comparator-comparison-procedure? (~a)" 'comparator)
(comparator-comparison-procedure? comparator))
(test-assert (format "comparator-hash-function? (~a)" 'comparator)
(comparator-hash-function? comparator))
(test-existance rest ...)))
((_) (values))))
(test-existance boolean-comparator char-comparator char-ci-comparator
string-comparator string-ci-comparator symbol-comparator
exact-integer-comparator integer-comparator rational-comparator
real-comparator complex-comparator number-comparator
pair-comparator list-comparator vector-comparator
bytevector-comparator)
;; wrapped equality predicates
(define-syntax test-wrapped
(syntax-rules ()
((_ c rest ...)
(begin
(test-assert (format "comparator? (~a)" 'c) (comparator? c))
(test-assert (format "comparator-hash-function? (~a)" 'c)
(comparator-hash-function? c))
(test-wrapped rest ...)))
((_) (values))))
(test-wrapped eq-comparator eqv-comparator equal-comparator)
;; accessors
(test-assert "comparator-type-test-procedure"
(comparator-type-test-procedure boolean-comparator))
(test-assert "comparator-equality-predicate"
(comparator-equality-predicate boolean-comparator))
(test-assert "comparator-comparison-procedure"
(comparator-comparison-procedure boolean-comparator))
(test-assert "comparator-hash-function"
(comparator-hash-function boolean-comparator))
(define-syntax test-applicators
(syntax-rules ()
((_ (c type error-type eq lt gt hash) rest ...)
(begin
(let ((cp c))
(when (comparator-type-test-procedure cp)
(test-assert (format "test ~a" 'c) (comparator-test-type cp type))
(test-assert (format "test not ~a" 'c)
(not (comparator-test-type cp error-type)))
(test-assert (format "check ~a" 'c) (comparator-check-type cp type))
(test-error (format "check not ~a" 'c) condition?
(comparator-check-type cp error-type)))
(when (comparator-equality-predicate cp)
(test-assert (format "equal ~a" 'c)
(comparator-equal? cp type eq)))
(when (comparator-comparison-procedure? cp)
(test-equal (format "compare eq ~a" 'c) 0
(comparator-compare cp type eq))
(test-equal (format "compare lt ~a" 'c) -1
(comparator-compare cp lt gt))
(test-equal (format "compare gt ~a" 'c) 1
(comparator-compare cp gt lt)))
(when (comparator-hash-function cp)
(let ((h hash))
(if h
(test-equal (format "hash ~a" 'c) h
(comparator-hash cp type))
;; it's hard to compute
(test-assert (format "hash ~a" 'c)
(integer? (comparator-hash cp type)))))))
(test-applicators rest ...)))
((_) (values))))
(test-applicators (boolean-comparator #t 'a #t #f #t 1)
(char-comparator #\b "a" #\b #\a #\c (char->integer #\b))
(char-ci-comparator #\A "a" #\A #\a #\c
(char->integer (char-foldcase #\a)))
(string-comparator "abc" 'abc "abc" "ABC" "def"
(string-hash "abc"))
(string-ci-comparator "bcd" 'abc "bcD" "abc" "DEF"
(string-ci-hash "bcd"))
(symbol-comparator 'bcd 123 'bcd 'abc 'def #f)
(number-comparator 123 'abc 123 100 200 #f)
(complex-comparator 1+1i "abc" 1+1i 0+1i 2+1i #f)
(real-comparator 123.0 1+1i 123 100.0 200 #f)
(rational-comparator 123/10 1+1i 123/10 100 200 #f)
(integer-comparator 123.0 1.1 123 100 200 #f)
(exact-integer-comparator 123 1.1 123 100 200 #f))
;; TODO more tests...
;; fixed car comparator and cdr comparator
(let ((carh (comparator-hash default-comparator 'car))
(cdrh (comparator-hash default-comparator 'cdr))
(objh (comparator-hash default-comparator '(car . cdr))))
(define car-comparator (make-car-comparator default-comparator))
(define cdr-comparator (make-cdr-comparator default-comparator))
(test-equal "car hash" carh (comparator-hash car-comparator '(car . cdr)))
(test-equal "cdr hash" cdrh (comparator-hash cdr-comparator '(car . cdr))))
(test-end)
| true |
dc730ccfbfc85bbcf5d02ab2b0a8634f00eb30ad | 8eb21733f83949941fadcb268dd4f0efab594b7f | /070/srfi-75/r6rs-reader.ss | c3c7e90f7eb1cf8012b20a0aaa09771485e0d718 | []
| 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 | 9,728 | ss | r6rs-reader.ss |
;; This readtable-based replacement for `read ' works in MzScheme
;; version 299.103 and later.
;;
;; To use this reader, either
;;
;; 1. Require the module and set the current readtable:
;; > (require "r6rs-reader.ss")
;; > (current-readtable r6rs-readtable)
;; > '|\u03BB|
;; 2. Use `read' exported by this module:
;; > (require "r6rs-reader.ss")
;; > (read)
;; '|\u03BB|
;; 3. Prefix an S-expression with #reader"r6rs-reader.ss":
;; > #reader"r6rs-reader.ss" '|\u03B|B
;;
;; See also "r6rs-reader-test.ss".
(module r6rs-reader mzscheme
(provide r6rs-readtable
(rename r6rs-read read)
(rename r6rs-read-syntax read-syntax))
;; for raise-read-[eof-]error:
(require (lib "readerr.ss" "syntax"))
(define hex-digits (string->list "0123456789abcdefABCDEF"))
(define standard-delimiters (string->list ";',`()[]{}"))
;; hex-value : char -> int
(define (hex-value ch)
(cond
[(char-numeric? ch)
(- (char->integer ch) 48)]
[(memv ch '(#\a #\b #\c #\d #\e #\f))
(- (char->integer ch) 87)]
[else
(- (char->integer ch) 55)]))
;; read-delimited-string : char input-port .... -> string
;; Reads a string or symbol, given the closing character
(define (read-delimited-string closer-ch port
what src line col pos)
;; raise-bad-eof
;; Reports an unexpected EOF in a string/symbol
(define (raise-bad-eof len)
(raise-read-eof-error
(format "unexpected end-of-file in ~a" what)
src line col pos len))
;; to-hex : char int -> int
;; Checks input and gets it's value as a hex digit
(define (to-hex ch len)
(unless (memv ch hex-digits)
(if (eof-object? ch)
(raise-bad-eof len)
(raise-read-error
(format "expected a hex digit for ~a, found: ~e" what ch)
src line col pos len)))
(hex-value ch))
;; loop to read string/symbol characters; track the length for error reporting
(let loop ([chars null][len 1])
(let ([ch (read-char port)])
(cond
;; eof
[(eof-object? ch) (raise-bad-eof len)]
;; closing quote or bar
[(char=? ch closer-ch) (list->string (reverse chars))]
;; escape
[(char=? ch #\\)
(let ([ch (read-char port)])
(cond
;; eof after escape
[(eof-object? ch) (raise-bad-eof (add1 len))]
;; newline escape
[(char=? #\newline ch)
;; Eat whitespace until we find a newline...
(let w-loop ([len (+ len 1)])
(let ([ch (peek-char port)])
(cond
[(eof-object? ch) (raise-bad-eof len)]
[(and (char-whitespace? ch)
(not (char=? #\newline ch)))
(read-char port)
(w-loop (+ len 1))]
[else
(loop chars len)])))]
;; space escape
[(char=? #\space ch)
(loop (cons #\space chars) (+ len 2))]
;; 2-digit hex escape
[(char=? #\x ch)
(let* ([ch1 (to-hex (read-char port) (+ len 2))]
[ch2 (to-hex (read-char port) (+ len 3))])
(loop (cons (integer->char (+ (* ch1 16) ch2))
chars)
(+ len 3)))]
;; 4-digit hex escape
[(char=? #\u ch)
(let* ([ch1 (to-hex (read-char port) (+ len 2))]
[ch2 (to-hex (read-char port) (+ len 3))]
[ch3 (to-hex (read-char port) (+ len 4))]
[ch4 (to-hex (read-char port) (+ len 5))])
(let ([v (+ (* ch1 4096) (* ch2 256) (* ch3 16) ch4)])
(when (<= #xD8FF v #xDFFF)
(raise-read-error
(format "out-of-range character for ~a: \\u~a~a~a~a"
what ch1 ch2 ch3 ch4)
src line col pos (+ len 5)))
(loop (cons (integer->char v) chars)
(+ len 5))))]
;; 8-digit hex escape
[(char=? #\U ch)
(let* ([ch1 (to-hex (read-char port) (+ len 2))]
[ch2 (to-hex (read-char port) (+ len 3))]
[ch3 (to-hex (read-char port) (+ len 4))]
[ch4 (to-hex (read-char port) (+ len 5))]
[ch5 (to-hex (read-char port) (+ len 6))]
[ch6 (to-hex (read-char port) (+ len 7))]
[ch7 (to-hex (read-char port) (+ len 8))]
[ch8 (to-hex (read-char port) (+ len 9))])
(let ([v (+ (* ch1 268435456) (* ch2 16777216) (* ch3 1048576) (* ch4 65536)
(* ch5 4096) (* ch6 256) (* ch7 16) ch8)])
(when (or (> v #x10FFFF)
(<= #xD8FF v #xDFFF))
(raise-read-error
(format "out-of-range character for ~a: \\U~a~a~a~a~a~a~a~a"
what ch1 ch2 ch3 ch4 ch5 ch6 ch7 ch8)
src line col pos (+ len 9)))
(loop (cons (integer->char v) chars)
(+ len 9))))]
;; other escapes
[else (let ([v (case ch
[(#\a) 7]
[(#\b) 8]
[(#\t) 9]
[(#\n) 10]
[(#\v) 11]
[(#\f) 12]
[(#\r) 13]
[(#\") 34]
[(#\\) 92]
[(#\|) 124]
;; not a valid escape!
[else
(raise-read-error
(format "illegal escape for ~a: \\~a" what ch)
src line col pos (+ len 2))])])
(loop (cons (integer->char v) chars) (+ len 2)))]))]
;; other character
[else (loop (cons ch chars) (+ len 1))]))))
;; read-quoted-symbol
;; Reader macro for |
(define (read-quoted-symbol ch port src line col pos)
(string->symbol (read-delimited-string #\| port
"symbol" src line col pos)))
;; read-quoted-string
;; Reader macro for "
(define (read-quoted-string ch port src line col pos)
(read-delimited-string #\" port
"string" src line col pos))
;; read-character
;; Reader macro for characters
(define (read-character ch port src line col pos)
;; make-char-const : list-of-char len -> char
;; Checks whether the character sequence names a char,
;; and either reports and error or returns the character
(define (make-char-const chars len)
(let ([chars (reverse chars)])
(if (null? (cdr chars))
;; simple case: single character
(car chars)
;; multi-character name:
(let ([name (list->string chars)])
;; raise-bad-char
;; When it's not a valid character
(define (raise-bad-char detail)
(raise-read-error
(format "bad character constant~a: #\\~a" detail name)
src line col pos len))
;; hex-char : int -> char
;; Checks whether chars has n hex digits, and
;; produces the character if so
(define (hex-char n)
(unless (= (+ n 1) (length chars))
(raise-bad-char (format " (expected ~a hex digits after #\\~a) "
n
(car chars))))
(for-each (lambda (c)
(unless (memv c hex-digits)
(raise-bad-char (format " (expected hex digit, found ~a) " c))))
(cdr chars))
(let loop ([n 0][chars (cdr chars)])
(if (null? chars)
(begin
(when (or (> n #x10FFFF)
(<= #xD8FF n #xDFFF))
(raise-read-error
(format "out-of-range character: #\\~a" name)
src line col pos (+ len 9)))
(integer->char n))
(loop (+ (* n 16) (hex-value (car chars)))
(cdr chars)))))
;; Check for standard names or hex, and report an error if not
(case (string->symbol name)
[(nul) (integer->char 0)]
[(alarm) (integer->char 7)]
[(backspace) (integer->char 8)]
[(tab) (integer->char 9)]
[(newline linefeed) (integer->char 10)]
[(vtab) (integer->char 11)]
[(page) (integer->char 12)]
[(return) (integer->char 13)]
[(esc) (integer->char 27)]
[(space) (integer->char 32)]
[(delete) (integer->char 127)]
[else
;; Hex?
(case (car chars)
[(#\x)
(hex-char 2)]
[(#\u)
(hex-char 4)]
[(#\U)
(hex-char 8)]
[else
(raise-bad-char "")])])))))
;; read the leading character:
(let ([ch (read-char port)])
(when (eof-object? ch)
(raise-read-eof-error "unexpected end-of-file after #\\"
src line col pos 2))
;; loop until delimiter:
(let loop ([len 3][chars (list ch)])
(let ([ch (peek-char port)])
(if (eof-object? ch)
;; eof is a delimiter
(make-char-const chars len)
;; otherwise, consult the current readtable to find delimiters
;; in case someone extends r6rs-readtable:
(let-values ([(kind proc dispatch-proc)
(readtable-mapping (current-readtable) ch)])
(cond
[(eq? kind 'terminating-macro)
;; a terminating macro is a delimiter by definition
(make-char-const chars len)]
[(or (char-whitespace? ch)
(member ch standard-delimiters))
;; something mapped to one of the standard delimiters is
;; a delimiter
(make-char-const chars len)]
[else
;; otherwise, it's not a delimiter
(read-char port)
(loop (add1 len) (cons ch chars))])))))))
(define (reject-backslash ch port src line col pos)
(raise-read-error
"illegal character in input: \\"
src line col pos 1))
;; r6rs-readtable
;; Extends MzScheme's default reader to handle quoted symbols,
;; strings, and characters:
(define r6rs-readtable
(make-readtable #f
;; New syntax:
#\| 'terminating-macro read-quoted-symbol
#\" 'terminating-macro read-quoted-string
#\\ 'dispatch-macro read-character
;; Disable \ symbol escape:
#\\ 'terminating-macro reject-backslash))
;; r6rs-read
;; Like the normal read, but uses r6rs-readtable
(define r6rs-read
(case-lambda
[() (r6rs-read (current-input-port))]
[(input) (parameterize ([current-readtable r6rs-readtable])
(read input))]))
;; r6rs-read
;; Like the normal read-syntax, but uses r6rs-readtable
(define r6rs-read-syntax
(case-lambda
[() (r6rs-read-syntax (object-name (current-input-port)) (current-input-port))]
[(src-v) (r6rs-read-syntax src-v (current-input-port))]
[(src-v input) (parameterize ([current-readtable r6rs-readtable])
(read-syntax src-v input))]))) | false |
6d643330da5553858b89f49ae489377a9e41cae2 | d3e9eecbf7fa7e015ab8b9c357882763bf6d6556 | /solutions/exercises/2.73-2.76.ss | 971adfc50d06c026b0e5cd2d3bf31bf411058b95 | []
| no_license | yangchenyun/learning-sicp | 37d43f18836055274f78755ff93eb20fba63d383 | 99a19a06eddc282e0eb364536e297f27c32a9145 | refs/heads/master | 2021-01-19T02:15:15.634140 | 2017-02-13T22:26:58 | 2017-02-13T22:26:58 | 5,344,488 | 17 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 5,959 | ss | 2.73-2.76.ss | #lang r5rs
(#%require racket/include)
(include "../lib/dispatch.ss")
(include "../lib/arithmetic.ss")
(include "../lib/utils.ss")
;; Exercise 2.73
(define (variable? x) (symbol? x))
(define (same-variable? v1 v2)
(and (variable? v1) (variable? v2) (eq? v1 v2)))
;; treat the operator as a type tag
(define operator car)
(define operands cdr)
(define (deriv exp var)
(cond ((number? exp) 0)
((variable? exp)
(if (same-variable? exp var) 1 0))
(else ((get 'deriv (operator exp))
(operands exp)
var))))
;; a.
;; `deriv' returns for number? and variable? exp, otherwise
;; it dispatches on the type of exp for proper `deriv' methods
;; on that type
;; Because the exp in that case doesn't have the type-tag and
;; cannot be dispatched.
;; But actually we could define another two types, 'var and 'num
;; and make this generic as well
;; b.
(define (install-sums-deriv)
(define (addend s) (car s))
(define (augend s) (cadr s))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2))
(+ a1 a2))
(else (list '+ a1 a2))))
;; choose a different name from deriv
;; to avoid the clojure scope inside
(define (exp-deriv exp var)
(make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
(put 'deriv '+ exp-deriv))
(define (install-products-deriv)
(define (multiplier s) (car s))
(define (multiplicand s) (cadr s))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2)) (else (list '* m1 m2))))
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2))
(+ a1 a2))
(else (list '+ a1 a2))))
(define (exp-deriv exp var)
(make-sum
(make-product (multiplier exp)
(deriv (multiplicand exp) var))
(make-product (deriv (multiplier exp) var)
(multiplicand exp))))
(put 'deriv '* exp-deriv))
(install-sums-deriv)
(install-products-deriv)
;; c.
(define (install-exponents-deriv)
(define (base s) (car s))
(define (exponent s) (cadr s))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (make-exponentiation base expo)
(cond
((=number? expo 1) base)
((=number? expo 0) 1)
(else (list '** base expo))))
(define (make-product m1 m2)
(cond ((or (=number? m1 0) (=number? m2 0)) 0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2)) (* m1 m2)) (else (list '* m1 m2))))
(define (make-sum a1 a2)
(cond ((=number? a1 0) a2)
((=number? a2 0) a1)
((and (number? a1) (number? a2))
(+ a1 a2))
(else (list '+ a1 a2))))
(define (exp-deriv exp var)
(make-product (exponent exp)
(make-product
(make-exponentiation
(base exp)
(make-sum (exponent exp) -1))
(deriv (base exp) var))))
(put 'deriv '** exp-deriv))
(install-exponents-deriv)
(deriv '(** (+ (** x 2) 2) 3) 'x)
;; d.
;; the install method in each package `put' will need to be changed
;; Exercise 2.74
;; personnel records, contains a set of records keyed on employees' name
;; employee record,
;; a.
(define (get-record personnel employee)
(apply-generic 'get-record personnel employee))
;; there is no restriction on the main data structure for the personnel file
;; as long as it contains the division name in the head. In particular, it
;; must provide information to identify the division
;; In addition, the implementation also requires the employee record through the `get-record' method
;; b.
(define (get-salary personnel employee)
(let ((record (get-record personnel employee)))
(apply-generic 'get-salary record)))
;; the employee record data also must provide the division information as well
;; c.
(define (find-employee-record employee personnels)
(if (null? personnels)
#f
(let* ((personel (car personnels))
(record (get-record personnel employee)))
(if record
record
(find-employee-record employee (cdr personnels))))))
;; d.
;; the new corporate just need to follow the above restriction on
;; personnel file and employee record
;; Exercise 2.75
(define (make-from-mag-ang r a)
(define (dispatch op)
(cond ((eq? op 'magnitude r))
((eq? op 'angle a))
((eq? op 'real-part)
(* r (cos a)))
((eq? op 'imag-part)
(* r (sin a)))
(else (error "Unknown op: MAKE-FROM-MAG-ANG" op))))
dispatch)
;; Exercise 2.76
;; generic operation with explicit dispatch
;; for every new type, all the operation must added one dispatch condition
;; for every new operation, it needed to create a new method for all types
;; data-directed style
;; for every new type
;; - a new package needed to be implemented to include all operations
;; - an install package procedure call
;; for every new operation
;; - all packages needed to implement and install the operation
;; - a global operation procedure
;; message-passing style
;; for every new type
;; - a new constructor embodies all the operations as a dispatch proc
;; for every new operation
;; - all data type needed to be updated to include the new operation
;; Data-directed style is more explicit about the accessible operations
;; in the sytem, so it is suitable for a system with heavy operation changes.
;; Message-passing style exposes the data type as interfaces to the system
;; and is more suitable for systems with heavy type changes.
| false |
6ed7fc1649e85b9df7774ec7e769cb9dd9a781a4 | 58381f6c0b3def1720ca7a14a7c6f0f350f89537 | /Chapter 3/3.5/Ex3.71.scm | 6d9b144c2a57e5a66502a00a59d12fd9485b8e16 | []
| 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 | 2,252 | scm | Ex3.71.scm | #lang racket
(define (print-n stream n)
(newline)
(if (= n 0)
(display "Done")
(begin (display (stream-first stream))
(print-n (stream-rest stream) (- n 1)))))
(define (integers-starting-from n)
(stream-cons n (integers-starting-from (+ n 1))))
(define integers (integers-starting-from 1))
(define (merge-weighted s1 s2 weight)
(cond ((stream-empty? s1) s2)
((stream-empty? s2) s1)
(else
(let* ((s1pair (stream-first s1))
(s2pair (stream-first s2))
(s1weight (weight s1pair))
(s2weight (weight s2pair)))
(cond ((< s1weight s2weight)
(stream-cons
s1pair
(merge-weighted (stream-rest s1) s2 weight)))
((> s1weight s2weight)
(stream-cons
s2pair
(merge-weighted s1 (stream-rest s2) weight)))
(else
(stream-cons
s1pair
(stream-cons s2pair
(merge-weighted (stream-rest s1) (stream-rest s2) weight)))))))))
(define (weighted-pairs s t weight)
(stream-cons
(list (stream-first s) (stream-first t))
(merge-weighted
(stream-map (lambda (x) (list (stream-first s) x))
(stream-rest t))
(weighted-pairs (stream-rest s) (stream-rest t) weight)
weight)))
(define (cube x) (* x x x))
(define (sum-cube-pair pair) (+ (cube (car pair))
(cube (cadr pair))))
;; 1st task
(define cube-pairs-stream
(weighted-pairs integers integers sum-cube-pair))
(define (ramanujan-numbers s)
(let* ((first-pair (stream-first s))
(second-pair (stream-first (stream-rest s)))
(w1 (sum-cube-pair first-pair))
(w2 (sum-cube-pair second-pair)))
(if (= w1 w2)
(stream-cons
(list w1 first-pair second-pair)
(ramanujan-numbers (stream-rest (stream-rest s))))
(ramanujan-numbers (stream-rest s)))))
(define r-numbers (ramanujan-numbers cube-pairs-stream))
(print-n r-numbers 5)
;(1729 (1 12) (9 10))
;(4104 (2 16) (9 15))
;(13832 (2 24) (18 20))
;(20683 (10 27) (19 24))
;(32832 (4 32) (18 30)) | false |
3fe3cbc468021e7d7a83a364bf9f2bed5a355858 | 41463d53f24660cae8b0212349ead9eae590e79e | /scheme/19/21.ss | dae46376f45d2b2549f2ea8e9039ff3e0d984d83 | []
| no_license | jitwit/aoc | a3bc02ca43af6ac23bf2e5ea0a422ecd236c466f | 473af1d25919514f423c2937e088d549421fe045 | refs/heads/a | 2023-02-05T08:15:21.340125 | 2023-01-30T01:41:50 | 2023-01-30T01:41:50 | 222,753,516 | 23 | 5 | null | 2020-12-08T19:36:52 | 2019-11-19T17:37:10 | Scheme | UTF-8 | Scheme | false | false | 1,272 | ss | 21.ss | (load "~/code/aoc/load.ss")
(define program
(parameterize ((advent-day 21) (advent-year 19))
(parse-advent comma-separated)))
(define m (intcode program))
(define (showme M)
(for-all (compose display integer->char) (read-output M)))
(define (spring-it plan)
(define M (intcode program))
(apply M 'in plan)
(run-until-halt M)
(showme M))
(define (spring-script program)
(call/cc
(lambda (woot)
(with-exception-handler
(lambda (e)
(when (eq? (condition-who e) 'integer->char)
(woot (car (condition-irritants e)))))
(lambda ()
(spring-it (map char->integer (string->list (stmts->string program)))))))))
(define (stmt->string stmt)
(let ((pieces (intersperse " " (map symbol->string stmt))))
(string-upcase (string-append (apply string-append pieces) "\n"))))
(define (stmts->string program)
(apply string-append (map stmt->string program)))
(define progA
'((not a j)
(not c t)
(and d t)
(or t j)
(walk)))
;; @ A B C D E F G H I
;; ? ? ? ? ? ? ? ? ? ?
(define progB
'((not c j) ;; no c, but (d and) h
(and h j)
(not b t) ;; no b(, but d)
(or t j)
(not a t) ;; not a, have to jump now
(or t j)
(and d j) ;; need d no matter what
(run)))
| false |
52e156837eaf2510fedb9dc91d4ced59a12e2357 | ebc5db754946092d65c73d0b55649c50d0536bd9 | /2017/testlseq.scm | daea096da40125481bcdbc2b5c44b253d63c7194 | []
| no_license | shawnw/adventofcode | 6456affda0d7423442d0365a2ddfb7b704c0aa91 | f0ecba80168289305d438c56f3632d8ca89c54a9 | refs/heads/master | 2022-12-07T22:54:04.957724 | 2022-12-02T07:26:06 | 2022-12-02T07:26:06 | 225,129,064 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 729 | scm | testlseq.scm | (define (make-coroutine-generator proc)
(define return #f)
(define resume #f)
(define yield (lambda (v) (call/cc (lambda (r) (set! resume r) (return v)))))
(lambda () (call/cc (lambda (cc) (set! return cc)
(if resume
(resume (if #f #f #f)) ; void? or yield again?
(begin (proc yield)
(set! resume (lambda (v) (return (eof-object))))
(return (eof-object))))))))
(define g (make-coroutine-generator
(lambda (yield)
(do ((i 0 (+ i 1)))
((= i 100) (eof-object))
(yield i)))))
(display (g))
(newline)
(display (g))
(newline)
| false |
44dfb1bac46823c16e89653a596a15f88671b2e5 | 92b8d8f6274941543cf41c19bc40d0a41be44fe6 | /testsuite/classes1.scm | 39969123468b8c9bccac16288dffa1947db5d0c6 | [
"MIT"
]
| permissive | spurious/kawa-mirror | 02a869242ae6a4379a3298f10a7a8e610cf78529 | 6abc1995da0a01f724b823a64c846088059cd82a | refs/heads/master | 2020-04-04T06:23:40.471010 | 2017-01-16T16:54:58 | 2017-01-16T16:54:58 | 51,633,398 | 6 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,860 | scm | classes1.scm | (module-static counter get-new-count <IdClass1> <IdClass2> my-id-class-2 call-lambda)
;; Based on a test-case from Jamison Hope <[email protected]>
(define-syntax (import-class form)
(syntax-case form ()
((import-class fqcn)
(let* ((cls :: java.lang.Class (eval (syntax fqcn)))
(name (string->symbol (java.lang.Class:getSimpleName cls))))
#`(define-alias #,(datum->syntax-object form name) fqcn)))))
(import-class java.util.Date)
(define-constant xx :: <int> 20)
(define-simple-class <SimpleA> ()
(two :: <int> init-form: 2 access: 'private)
(a :: <int> init: (- b two))
(b :: <int> init-form: 6 allocation: class:)
(n22 :: <int> init-value: 22 allocation: 'static access: 'protected)
(hyphenated-field? init-value: "yes")
(mHappy init: #t)
((isHappy) :: <boolean>
mHappy)
((setHappy val :: <boolean>) :: <void>
(set! mHappy val))
((lambda-method1)
(lambda (x) (make-vector 1 x))) ; This lambda doesn't "capture" anything.
((lambda-method2 n)
(lambda (x) (make-vector (+ a n) x))) ; This lambda does.
((lambda-method3)
(call-lambda (lambda () (slot-ref (this) 'two))))
((lambda-method4)
(call-lambda (lambda () two)))
((lambda-method5 x)
(lambda () (set! two x)))
((lambda-method6)
(lambda (x) (set! two x)))
((lambda-method7)
(lambda (x) (slot-set! (this) 'two x)))
((lambda-method-rest1 name)
(lambda (arg1 . rest) (list name arg1 rest)))
((x1900) :: <int> access: 'package allocation: 'static
1900)
((g) :: <int> access: 'protected
(+ xx a))
((f (y :: <int>)) :: <int>
(if (equal? hyphenated-field? "yes") (+ (g) b y) 999))
((withVarArg a #!rest b)
(format "a:~a b:~b" a b))
((asText (i ::int))::string (java.lang.Integer:toString i))
((asText (t ::java.lang.CharSequence))::string (t:toString))
((test-asText)
(with-compile-options warn-invoke-unknown-method: #t warn-as-error: #t
((this):asText "hello")))
;; Bug reported by Dean Ferreyra <[email protected]> 2005-06-09
((trouble)
(let ((fn (lambda (o)
(get-identity-property-name o))))
fn))
((get-identity-property-name property-name)
(string-append property-name "Identity")))
(define (call-lambda fn)
(fn))
(define-class <ClsB> ()
(b :: <int> 14)) ;; deprecated syntax
(define-class <ClsC> (<ClsB>)
(c :: <int>)
(init: (set! c (static-field <SimpleA> 'n22)))
((f (y :: <int>)) :: <int> (+ xx c y)))
(define-syntax define-class-using-syntax-rules
(syntax-rules ()
((define-class-using-syntax-rules name super parts ...)
(define-simple-class name (super) parts ...))))
(define *MY-YEAR-OFFSET* 1900)
(define (default-offset)
*MY-YEAR-OFFSET*)
(define-simple-class <DateTest> (Date)
(offset init-form: (default-offset))
((get-year) :: <int>
;; Saying plain Date below doesn't work - we get (this):getDate
(+ (invoke-special java.util.Date (this) 'get-year) offset)))
(define-simple-class <SimpleDateTest> (<java.util.Date>)
((get-year) :: <int>
(+ (invoke-special <java.util.Date> (this) 'get-year)
(invoke-static <SimpleA> 'x1900))))
;; Test separate compilation of type-alias for simple class.
;; Make it a forward declaration for a better test.
(define-alias my-id-class-2 <IdClass2>)
(define-simple-class <IdClass1> ()
(var0 allocation: 'class init: (get-new-count))
(var1 init-form: (get-new-count)))
(define-private counter :: <int> 0)
(define (get-new-count)
(set! counter (+ counter 1))
counter)
(define-simple-class <IdClass2> (<IdClass1>)
(allocation: 'class init: (get-new-count))
(var2 init-form: (get-new-count)))
(module-static incr-field-function)
(define incr-field-function #f)
(define-simple-class <TestCapturedFieldRef> ()
(var 100)
((*init* var0)
(set! var (+ var var0))
(set! incr-field-function
(lambda (delta)
(set! var (+ var delta))))))
| true |
4e30c06791ff2704eeab7d7457ae991407db3e6f | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System.Data/system/data/odbc/odbc-transaction.sls | 842b97eba69d32f3356ca483c587558c3658416c | []
| 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 | 867 | sls | odbc-transaction.sls | (library (system data odbc odbc-transaction)
(export is?
odbc-transaction?
rollback
commit
isolation-level
connection)
(import (ironscheme-clr-port))
(define (is? a) (clr-is System.Data.Odbc.OdbcTransaction a))
(define (odbc-transaction? a)
(clr-is System.Data.Odbc.OdbcTransaction a))
(define-method-port
rollback
System.Data.Odbc.OdbcTransaction
Rollback
(System.Void))
(define-method-port
commit
System.Data.Odbc.OdbcTransaction
Commit
(System.Void))
(define-field-port
isolation-level
#f
#f
(property:)
System.Data.Odbc.OdbcTransaction
IsolationLevel
System.Data.IsolationLevel)
(define-field-port
connection
#f
#f
(property:)
System.Data.Odbc.OdbcTransaction
Connection
System.Data.Odbc.OdbcConnection))
| false |
bde95f36140add5f5bd4aaf4ca9bcac802abd923 | 41603755faf14b42f5ebfe68909cfbee8b8620eb | /implementation-helpers.vicare.sls | d7791df6f63d6da15d69f424191e257b1ed79fba | [
"MIT"
]
| permissive | lhtin/scheme-to-c | 49c845c1b93571b575b2f81d1cc91cb1cfd8ecdf | 7f96a1064adf85a40baf285222b96ca100a3a02d | refs/heads/master | 2020-03-28T20:27:16.317269 | 2018-09-17T05:20:48 | 2018-09-17T05:20:48 | 149,072,293 | 1 | 0 | MIT | 2018-09-17T05:16:23 | 2018-09-17T05:16:23 | null | UTF-8 | Scheme | false | false | 163 | sls | implementation-helpers.vicare.sls | (library (implementation-helpers)
(export printf format system pretty-print)
(import (only (vicare) printf format pretty-print) (only (vicare posix) system)))
| false |
dab850cb823234fb5444772dd914f0f1df9f3312 | d6121a780f97ae1f3afb265812e9296d23574f78 | /primenocturne/scheme/C-07.scm | 5d760e433bf76c66da0e4a23a8227c089b508af8 | []
| no_license | phasetr/mathcodes | 6ac2efd6bffe719c1edf5eabc4b14487f3ad600a | e97261641d203ff3cca54742fd4a77390940eddb | refs/heads/master | 2022-10-19T13:24:26.473230 | 2022-10-05T12:05:26 | 2022-10-05T12:05:26 | 65,594,078 | 13 | 0 | null | 2021-06-02T12:01:59 | 2016-08-13T02:00:46 | Jupyter Notebook | UTF-8 | Scheme | false | false | 4,506 | scm | C-07.scm | (load "./lib")
"P.555"
"C.7 関数型言語の基礎"
"C.7.1 チャーチの数字"
"zero = KI"
"\mathbb{C}_k"
(define zero (lambda (s) (lambda (z) z)))
(define one (lambda (s) (lambda (z) (s z))))
(define two (lambda (s) (lambda (z) (s(s z)))))
(define three (lambda (s) (lambda (z) (s(s(s z))))))
"P.556"
((two add1) 0)
(add1 (add1 0))
((zero add1) 0)
((one add1) 0)
((two add1) 0)
((three add1) 0)
"compose は B コンビネータと同じ"
;;;(define compose
;;; (lambda (f g)
;;; (lambda (x) (f (g x)))))
(define repeated
(lambda (f n)
(if (zero? n)
(lambda (x) x)
(compose f (repeated f (-- n))))))
((repeated add1 7) 3)
"P.557"
"C.7.2 後任関数"
"単位元"
(define Succ
(lambda (v) (lambda (s) (lambda (z)
(s ((v s) z))))))
((two add1) 0)
(((Succ two) add1) 0)
(define Succ%
(lambda (v s z) (s ((v s) z))))
(Succ% two add1 0)
"P.559"
"定理と定義"
"P.560"
"C.7.3 加算関数"
"P.561"
(define Plus
(lambda (u v) (lambda (s) (lambda (z)
((u s) ((v s) z))))))
(((Plus two three) add1) 0)
"P.562"
"C.7.4 乗算関数"
(define Mult
(lambda (u v) (lambda (s) (lambda (z)
((u (v s)) z)))))
(((Mult two three) add1) 0 )
"P.564"
"C.7.5 累乗関数"
"P.565"
"数学的帰納法による証明"
"P.566"
(define Pows (lambda (u v) (u v)))
(((Pows three two) add1) 0)
"一次関数のラムダ項"
"P.567"
(define Linear
(lambda (a x b) (lambda (s) (lambda (z)
((b s) ((a (x s)) z))))))
(((Linear two three one) add1) 0)
"C.7.6 条件分岐"
(define *true (lambda (x) (lambda (y) x)))
(define *false (lambda (x) (lambda (y) y)))
(define *if (lambda (c m n) ((c m) n)))
(define *zero?
(lambda (m)
((m (lambda (n) *false)) *true)))
"P.569"
(define *cons (lambda (x y) (lambda (c) ((c x) y))))
(define *car (lambda (x) (x *true)))
(define *cdr (lambda (x) (x *false)))
(*car (*cons 3 5))
(*cdr (*cons 'a 'b))
"C.7.7 前任関数"
"P.571"
(define Pred
(lambda (m)
(lambda (s)
(lambda (z)
(((m (lambda (p) (lambda (q) (q (p s)))))
(lambda (v) z))
(lambda (v) v))))))
(((Pred three) add1) 0)
"P.572"
(define Mins
(lambda (u v) ((v Pred) u)))
(((Mins three two) add1) 0)
"C.7.8 Yコンビネータ"
"P.573"
(define Sn
(lambda (n)
(if (zero? n)
0
(+ n (Sn (-- n))))))
(map Sn (iota 0 9))
"Y の動きを追う"
"P.574"
(define fact
(lambda (n)
(if (zero? n)
1
(* n (fact (-- n))))))
(fact 3)
"P.575"
"Scheme における Y"
(define Sn
(lambda (f)
(lambda (n)
((*if (*zero? n)
(lambda () zero)
(lambda () (Plus n (f (Pred n)))))))))
"P.576"
"この Y は実際は Z コンビネーター"
"本にはタイポがあるので注意: cf. https://tnomura9.exblog.jp/26145667/"
(define Y
(lambda (g)
((lambda (x) (g (lambda (s) ((x x) s))))
(lambda (x) (g (lambda (s) ((x x) s)))))))
((((Y Sn) three) add1) 0)
(define Fact
(lambda (f)
(lambda (n)
((*if (*zero? n)
(lambda () one)
(lambda () (Mult n (f (Pred n)))))))))
((((Y Fact) two) add1) 0)
"通常の四則による Y"
(define Fact
(lambda (f)
(lambda (n)
(if (zero? n)
1
(* n (f (-- n)))))))
((Y Fact) 5)
((Y (lambda (f)
(lambda (n)
(if (zero? n)
1
(* n (f (-- n))))))) 5)
"P.577"
"C.7.9 Y の導出への再帰"
"再びYを探す"
(define Fact
(lambda (y)
(if (zero? y) 1 (* y (Fact (-- y))))))
(Fact 5)
(define Fact
(lambda (f)
(lambda (y)
(if (zero? y) 1 (* y (f (-- y)))))))
((Y Fact) 5)
"P.578"
(define Fact
(lambda (f)
(lambda (y)
(if (zero? y) 1 (* y ((f f) (-- y)))))))
((Fact Fact) 3)
"P.579"
(((lambda (f)
(lambda (y)
(if (zero? y) 1 (* y ((f f) (-- y))))))
(lambda (f)
(lambda (y)
(if (zero? y) 1 (* y ((f f) (-- y))))))) 3)
(define w (lambda (x) (x x)))
((w (lambda (f)
(lambda (y)
(if (zero? y) 1 (* y ((f f) (-- y))))))) 3)
"さらに二重化"
(lambda (x) (lambda (s) ((x x) s)))
"P.580"
(lambda (f) (lambda (y) (if (zero? y) 1 (* y (f (-- y))))))
(define Y
(lambda (g)
((lambda (x) (g (lambda (s) ((x x) s))))
(lambda (x) (g (lambda (s) ((x x) s)))))))
(define quine
(lambda (x) (list x (list (quote quote) x))))
(quine 'quine)
(quote quote)
(list (quote quote) 999)
(list 999 (list (quote quote) 999))
(list 'x)
(quote x)
| false |
4da195b348e99d1aa57f159f05270ac4363923e3 | b13ba2793dbf455e2a6b5b50de6a1c253dd6b794 | /behave.scm | 98fe945c7ef701bfa7bddb5402b6e6f9948e2a3b | []
| no_license | jmax315/missbehave | ca924a7e9272948e54b73385a9d2206d39324cdc | 5ceee8e0ef1b96362b4a28400b227cc1406a7fbb | refs/heads/master | 2021-01-07T19:47:53.572758 | 2020-02-20T05:31:53 | 2020-02-20T05:31:53 | 241,802,990 | 0 | 0 | null | 2020-07-28T08:21:28 | 2020-02-20T05:40:07 | Scheme | UTF-8 | Scheme | false | false | 10,788 | scm | behave.scm | ;;
;; %%HEADER%%
;;
(use missbehave fmt fmt-color data-structures chicken-syntax args posix files regex)
(define use-colors #t)
(define command-line-options
(list (args:make-option (h help) #:none "Display this help" (usage port: (current-output-port) status: 0))
(args:make-option (n nocolor) #:none "Don't display colors" (set! use-colors #f))
(args:make-option (t tags) (required: "TAG") "Tags to filter. Can be used multiple times" )))
(define (usage #!key (port (current-error-port)) (status 1))
(with-output-to-port port
(lambda ()
(print "Usage: " (car (argv)) " [options ...] file ...")
(newline)
(print (args:usage command-line-options))))
(exit status))
(when (= 1 (length (argv)))
(usage))
(define-record report-agenda failed successful pending failed-examples pending-examples indentation-factor)
(define-record failure result index)
(define (make-pretty-reporter)
(let ((agenda (make-report-agenda 0 0 0 (list) #f 0)))
(lambda (data #!key (mode 'adhoc))
(case mode
((adhoc) (report-adhoc! data agenda))
((summary) (report-summary! data agenda))))))
(define (count-parents context)
(let loop ((parent (context-parent context)) (count 0))
(cond
(parent
(loop (context-parent parent) (+ count 1)))
(else count))))
(define (report-adhoc! data agenda)
(cond
((context? data)
(let* ((parents (count-parents data))
(ifactor (if (or (not parents) (zero? parents)) 1 parents)))
(report-agenda-indentation-factor-set! agenda parents)
(if use-colors
(indent (* 2 ifactor) (fmt #f (fmt-bold (context-description data))))
(indent (* 2 ifactor) (fmt #f (context-description data))))
(newline)))
((example? data) #t)
((example-result? data)
(cond
((example-failed? data)
(let ((failure-index (+ 1 (report-agenda-failed agenda))))
(report-example 'failed data agenda failure-index)
(report-agenda-failed-examples-set!
agenda
(cons (make-failure data failure-index)
(report-agenda-failed-examples agenda)))
(agenda-increment-failed! agenda)))
((example-pending? data)
(report-example 'pending data agenda)
(agenda-increment-pending! agenda))
(else
(report-example 'success data agenda)
(agenda-increment-successful! agenda))))))
(define (report-summary! data agenda)
(if use-colors
(report-summary-with-colors! data agenda)
(report-summary-plain! data agenda)))
(define (report-summary-with-colors! data agenda)
(let ((failure-count (report-agenda-failed agenda)))
(unless (zero? failure-count)
(newline)
(newline)
(if (= failure-count 1)
(fmt #t (fmt-red (fmt-bold "There has been 1 failure ")))
(fmt #t (fmt-red (cat (fmt-bold (cat "There have been " (report-agenda-failed agenda) " failures"))))))
(newline)
(newline)
(report-failures (report-agenda-failed-examples agenda))))
(newline)
(newline)
(fmt #t (cat
(fmt-bold
(cat
"Total: "
(+ (report-agenda-failed agenda)
(report-agenda-pending agenda)
(report-agenda-successful agenda))))
" "
(fmt-green (fmt-bold
(cat
"Successful: "
(report-agenda-successful agenda)
" ")))
(fmt-yellow (fmt-bold
(cat
"Pending: "
(report-agenda-pending agenda)
" ")))
(fmt-red (fmt-bold
(cat
"Failures: "
(report-agenda-failed agenda)
" ")))))
(newline)
(zero? (report-agenda-failed agenda)))
(define (report-summary-plain! data agenda)
(let ((failure-count (report-agenda-failed agenda)))
(unless (zero? failure-count)
(newline)
(newline)
(if (= failure-count 1)
(printf "There has been 1 failure~%")
(printf "There have been ~A failures ~%" (report-agenda-failed agenda)))
(newline))
(report-failures (report-agenda-failed-examples agenda)))
(newline)
(newline)
(printf "Total: ~A Successful: ~A Pending: ~A Failures: ~A"
(+ (report-agenda-failed agenda)
(report-agenda-pending agenda)
(report-agenda-successful agenda))
(report-agenda-successful agenda)
(report-agenda-pending agenda)
(report-agenda-failed agenda))
(newline)
(zero? (report-agenda-failed agenda)))
(define (report-example status result agenda #!optional (failure-index #f))
(if use-colors
(report-example-colors status result agenda failure-index)
(report-example-plain status result agenda failure-index)))
(define (indent n str)
(let ((indention (make-string n #\space)))
(display indention)
(display (irregex-replace/all "\n" str (string-append "\n" indention)))))
(define (report-example-colors status result agenda #!optional (failure-index #f))
(let ((example (example-result-example result))
(ifactor (report-agenda-indentation-factor agenda)))
(if (or (not ifactor) (zero? ifactor))
(set! ifactor 1))
(case status
((success)
(indent (* ifactor 3) (fmt #f (fmt-green (cat "It " (example-description example)))))
(newline))
((pending)
(indent (* ifactor 3) (fmt #f (fmt-yellow (cat "[P] It " (example-description example)))))
(newline))
(else
(indent (* ifactor 3) (fmt #f (fmt-red (cat "[F][" (number->string failure-index) "] It " (example-description example) ))))
(newline)
(indent (* ifactor 4) (fmt #f (fmt-red (example-result-messages result))))
(newline)))))
(define (report-example-plain status result agenda #!optional (failure-index #f))
(let ((example (example-result-example result))
(ifactor (report-agenda-indentation-factor agenda)))
(case status
((success)
(indent (* ifactor 3) (fmt #f (cat "It " (example-description example))))
(newline))
((pending)
(indent (* ifactor 3) (fmt #f (cat "[P] It " (example-description example))))
(newline))
(else
(indent (* ifactor 3) (fmt #f (cat "[F][" (number->string failure-index) "] It " (example-description example))))
(newline)
(indent (* ifactor 4) (fmt #f (example-result-messages result)))
(newline)))))
(define (report-failures failures)
(for-each
(if use-colors report-failure-colors report-failure-plain)
(reverse failures)))
(define (report-failure-plain failure)
(let* ((result (failure-result failure))
(file (example-result-spec-file result))
(example (example-result-example result)))
(printf "~A) in ~A~%" (failure-index failure) (relativize-path file))
(printf "[F][~A] It ~A~%" (failure-index failure) (example-description example))
(printf "~A~%" (example-result-messages result))
(newline)))
(define (report-failure-colors failure)
(let* ((result (failure-result failure))
(file (example-result-spec-file result))
(example (example-result-example result)))
(fmt #t (fmt-bold (fmt-red (cat (failure-index failure) ") in " (relativize-path file)))))
(newline)
(indent 2 (fmt #f (fmt-red (cat "[F][" (number->string (failure-index failure)) "] It " (example-description example)))))
(newline)
(indent 4 (fmt #f (fmt-red (example-result-messages result))))
(newline)
(newline)))
(define (agenda-increment-successful! agenda)
(report-agenda-successful-set! agenda (+ 1 (report-agenda-successful agenda))))
(define (agenda-increment-failed! agenda)
(report-agenda-failed-set! agenda (+ 1 (report-agenda-failed agenda))))
(define (agenda-increment-pending! agenda)
(report-agenda-pending-set! agenda (+ 1 (report-agenda-pending agenda))))
(define (run-files files #!optional (include-filter #f) (exclude-filter #f))
(run-specification
(call-with-specification
(make-empty-specification)
(lambda () (for-each eval-spec-file files)))
include: include-filter
exclude: exclude-filter
reporter: (make-pretty-reporter)))
(define (eval-spec-file file)
(let ((content (read-file file)))
(unless (null? content)
(eval (decorate-content content file)))))
(define (decorate-content content file)
`(begin
(use missbehave missbehave-matchers)
(parameterize ((current-spec-file ,file))
,@content)))
(define (absolutize-path path)
(let ((cwd (current-directory)))
(if (absolute-pathname? path)
(normalize-pathname path)
(normalize-pathname (conc cwd "/" path)))))
(define (relativize-path path)
(pathname-strip-directory (string-substitute (regexp-escape (current-directory)) "" path)))
(define (extract-tags options)
(fold (lambda (element tags)
(if (eq? (car element) 't)
(cons (string-split (cdr element) ":") tags)
tags))
'()
options))
(define (create-include-filter tags)
(fold (lambda (tag filter)
(let ((label (string-translate* (car tag) '(("@" . "")))))
(if (not (equal? "~" (string-take label 1)))
(if (= 1 (length tag))
(cons (list (string->symbol label)) filter)
(cons (list (string->symbol label) (string->symbol (cadr tag))) filter))
filter)))
'()
tags))
(define (create-exclude-filter tags)
(fold (lambda (tag filter)
(let ((label (string-translate* (car tag) '(("@" . "")))))
(if (equal? "~" (string-take label 1))
(if (= 1 (length tag))
(cons (list (string->symbol (string-drop label 1))) filter)
(cons (list (string->symbol (string-drop label 1)) (string->symbol (cadr tag))) filter))
filter)))
'()
tags))
(receive (options files) (args:parse (command-line-arguments) command-line-options)
(let* ((tags (extract-tags options))
(include-filter (create-include-filter tags))
(exclude-filter (create-exclude-filter tags))
(files-absolute (map absolutize-path files)))
(for-each (lambda (file)
(unless (file-exists? file)
(fprintf (current-error-port) "The spec-file ~A does not exist~%" file)
(exit 1)))
files-absolute)
(if (run-files
files-absolute
(if (null? include-filter) #f include-filter)
(if (null? exclude-filter) #f exclude-filter))
(exit 0)
(exit 2))))
| false |
51593a5a7fac9b1a9c2cae7f1e8cbf346412f622 | 30834f7acf1b5f9969e5114f3837e0e05abc171e | /ex3.22.scm | e711baf8f978007516e523b512a1dea0e2577bbc | []
| no_license | rbarraud/sicp-2 | 1407a292e2c130ee68fa004f55867383d9a836a3 | 057c5467d4b638678247ea7b3cdf5f9137debb27 | refs/heads/master | 2020-12-03T03:41:27.848469 | 2012-05-20T02:01:47 | 2012-05-20T02:01:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,315 | scm | ex3.22.scm | (define (make-queue)
(let ((front-ptr '())
(rear-ptr '()))
(define (empty?)
(null? front-ptr))
(define (front)
(if (empty?)
(error "FRONT called with empty queue")
(car front-ptr)))
(define (print)
front-ptr)
(define (insert! item)
(let ((new-pair (cons item '())))
(cond ((empty?)
(set! front-ptr new-pair)
(set! rear-ptr new-pair)
(print))
(else
(set-cdr! rear-ptr new-pair)
(set! rear-ptr new-pair)
(print)))))
(define (delete!)
(cond ((empty?)
(error "DELETE called with empty queue"))
(else
(set! front-ptr (cdr front-ptr))
(print))))
(define (dispatch m)
(cond ((eq? m 'front) front)
((eq? m 'insert!) insert!)
((eq? m 'print) print)
((eq? m 'delete!) delete!)
(else
(error "Bad message for dispatch" m))))
dispatch))
(define q (make-queue))
(define (front-queue q)
((q 'front)))
(define (insert-queue q item)
((q 'insert!) item))
(define (print-queue q)
((q 'print)))
(define (delete-queue! q)
((q 'delete!)))
(insert-queue q 'a)
(insert-queue q 'b)
(delete-queue! q)
| false |
47ec6217f7372f8fb5dc83055e0f78037ecfed69 | 120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193 | /packages/irregex/error.scm | 564e4f25ec0d95c049f038858407a63cceaaf813 | [
"MIT"
]
| permissive | evilbinary/scheme-lib | a6d42c7c4f37e684c123bff574816544132cb957 | 690352c118748413f9730838b001a03be9a6f18e | refs/heads/master | 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 | MIT | 2022-06-16T05:54:55 | 2016-12-13T06:27:36 | Scheme | UTF-8 | Scheme | false | false | 119 | scm | error.scm |
(define (error msg . args)
(display msg)
(for-each (lambda (x) (display " ") (write x)) args)
(newline)
(0))
| false |
57f3d085f3c66e65740d50d9129b3a7f15219ff4 | ac2a3544b88444eabf12b68a9bce08941cd62581 | /gsc/_t-univ-3.scm | 9eea7a93dd09dfae4e95a2823a5dceb12fac1690 | [
"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 | 131,576 | scm | _t-univ-3.scm | ;;============================================================================
;;; File: "_t-univ-3.scm"
;;; Copyright (c) 2011-2019 by Marc Feeley, All Rights Reserved.
;;; Copyright (c) 2012 by Eric Thivierge, All Rights Reserved.
(include "generic.scm")
(include-adt "_envadt.scm")
(include-adt "_gvmadt.scm")
(include-adt "_ptreeadt.scm")
(include-adt "_sourceadt.scm")
(include-adt "_univadt.scm")
;;----------------------------------------------------------------------------
(define (univ-defs fields methods classes inits all)
(vector fields methods classes inits all))
(define (univ-defs-fields defs) (vector-ref defs 0))
(define (univ-defs-methods defs) (vector-ref defs 1))
(define (univ-defs-classes defs) (vector-ref defs 2))
(define (univ-defs-inits defs) (vector-ref defs 3))
(define (univ-defs-all defs) (vector-ref defs 4))
(define (univ-make-empty-defs)
(univ-defs '() '() '() '() '()))
(define (univ-add-field defs field)
(univ-defs (cons field (univ-defs-fields defs))
(univ-defs-methods defs)
(univ-defs-classes defs)
(univ-defs-inits defs)
(cons field (univ-defs-all defs))))
(define (univ-add-method defs method)
(univ-defs (univ-defs-fields defs)
(cons method (univ-defs-methods defs))
(univ-defs-classes defs)
(univ-defs-inits defs)
(cons method (univ-defs-all defs))))
(define (univ-add-class defs class)
(univ-defs (univ-defs-fields defs)
(univ-defs-methods defs)
(cons class (univ-defs-classes defs))
(univ-defs-inits defs)
(cons class (univ-defs-all defs))))
(define (univ-add-init defs init)
(univ-defs (univ-defs-fields defs)
(univ-defs-methods defs)
(univ-defs-classes defs)
(cons init (univ-defs-inits defs))
(cons init (univ-defs-all defs))))
(define (univ-defs-combine defs1 defs2)
(univ-defs (append (univ-defs-fields defs2)
(univ-defs-fields defs1))
(append (univ-defs-methods defs2)
(univ-defs-methods defs1))
(append (univ-defs-classes defs2)
(univ-defs-classes defs1))
(append (univ-defs-inits defs2)
(univ-defs-inits defs1))
(append (univ-defs-all defs2)
(univ-defs-all defs1))))
(define (univ-defs-combine-list lst)
(let loop ((lst lst) (defs (univ-make-empty-defs)))
(if (pair? lst)
(loop (cdr lst) (univ-defs-combine defs (car lst)))
defs)))
(define (univ-emit-var-decl ctx var-descr)
(case (target-name (ctx-target ctx))
((java go)
(^decl
(univ-field-type var-descr)
(univ-field-name var-descr)))
(else
(univ-field-name var-descr))))
(define (univ-rts-type-alias ctx type-name)
(case type-name
((absent) 'Absent)
((bignum) 'Bignum)
((boolean) 'Boolean)
((box) 'Box)
((char) 'Char)
((chr) 'Chr)
((closure) 'Closure)
((continuation) 'Continuation)
((cpxnum) 'Cpxnum)
((ctrlpt) 'ControlPoint)
((deleted) 'Deleted)
((entrypt) 'EntryPoint)
((eof) 'Eof)
((fixnum) 'Fixnum)
((flonum) 'Flonum)
((foreign) 'Foreign)
((frame) 'Frame)
((hashtable) 'HashTable)
((hashtable_base) 'HashTableBase)
((hashtable_weak_keys) 'HashTableWeakKeys)
((hashtable_weak_values) 'HashTableWeakValues)
((hashtable_weak_keys_values) 'HashTableWeakKeysValues)
((jumpable) 'Jumpable)
((key) 'Key)
((keyword) 'Keyword)
((modlinkinfo) 'ModLinkInfo)
((null) 'Null)
((optional) 'Optional)
((pair) 'Pair)
((parententrypt) 'ParentEntryPoint)
((promise) 'Promise)
((ratnum) 'Ratnum)
((rest) 'Rest)
((returnpt) 'ReturnPoint)
((scmobj) 'ScmObj)
((string) 'ScmString) ;; to avoid clashes with host's String class
((structure) 'Structure)
((symbol) 'Symbol)
((u8vector) 'U8Vector)
((u16vector) 'U16Vector)
((u32vector) 'U32Vector)
((u64vector) 'U64Vector)
((s8vector) 'S8Vector)
((s16vector) 'S16Vector)
((s32vector) 'S32Vector)
((s64vector) 'S64Vector)
((f32vector) 'F32Vector)
((f64vector) 'F64Vector)
((unbound) 'Unbound)
((unused) 'Unused)
((values) 'Values)
((vector) 'Vector)
((void) 'Void)
((will) 'Will)
(else #f)))
(define (univ-emit-decl ctx type name)
(define (decl type)
(decl* type #t))
(define (decl* type ptr?)
(define (ptr type-name)
(base (^ "*" type-name)))
(define (base type-name)
(if name
(case (target-name (ctx-target ctx))
((java) (^ type-name " " name))
((go) (^ name " " type-name))
(else (error "univ-emit-decl unhandled case")))
type-name))
(define (map-type type)
(if (and (pair? type) (eq? (car type) 'array))
(univ-array-constructor ctx (cadr type))
(let ((x (univ-rts-type-alias ctx type)))
;;(pp (list 'xxxxxxxxxxxxxx x))
(if x
(begin
(univ-use-rtlib ctx type)
(let* ((type-name
(^rts-class-ref type))
(mapped-type
(case (target-name (ctx-target ctx))
((go)
(let ((interface-types
'(scmobj)))
(if (and ptr?
(not (memq type interface-types)))
(^ "*" type-name)
type-name)))
(else
type-name))))
(if name
(tt"111"mapped-type)
(tt"222"mapped-type))))
type))))
(case (target-name (ctx-target ctx))
((js php python ruby)
(if (and (pair? type) (eq? (car type) 'nonptr))
(decl* (cadr type) #f)
(if name
name
(map-type type))))
((java)
(cond ((and (pair? type) (eq? (car type) 'array))
(^ (decl (cadr type)) "[]"))
((and (pair? type) (eq? (car type) 'dict))
(base (^ "HashMap<"
(if (eq? (cadr type) 'int)
"Integer"
(^type (cadr type)))
","
(^type (caddr type)) ">")))
((and (pair? type) (eq? (car type) 'generic))
(base (^ (cadr type) "<" (univ-separated-list "," (map (lambda (x) (^type x)) (cddr type))) ">")))
(else
(case type
((frm) (decl '(array scmobj)))
((noresult) (base 'void))
((int) (base 'int))
((long) (base 'long))
((chr) (base 'char))
((u8) (base 'byte)) ;;TODO: byte is signed (-128..127)
((u16) (base 'short)) ;;TODO: short is signed
((u32) (decl 'int)) ;;TODO: int is signed
((u64) (decl 'scmobj));;TODO: long is signed
((s8) (base 'byte))
((s16) (base 'short))
((s32) (decl 'int))
((s64) (decl 'scmobj))
((f32) (base 'float))
((f64) (base 'double))
((bool) (base 'boolean))
((unicode) (base 'int)) ;; Unicode needs 21 bit wide integers
((bigdigit) (base 'short))
((str) (base 'String))
((object) (base 'Object))
(else (base (map-type type)))))))
((go)
(cond ((and (pair? type) (eq? (car type) 'nonptr))
(decl* (cadr type) #f))
((and (pair? type) (eq? (car type) 'array))
(base (^ "[" (if (pair? (cddr type)) (caddr type) "") "]"
(^type (cadr type)))))
((and (pair? type) (eq? (car type) 'dict))
(base (^ "map[" (^type (cadr type)) "]" (^type (caddr type)))))
((and (pair? type) (eq? (car type) 'fn))
(univ-emit-fn-decl ctx #f (caddr type) (cadr type) #f))
(else
(case type
((frm) (decl* '(array scmobj) #f))
((noresult) (^))
((int) (base 'int))
((long) (base 'int64))
((u8) (base 'uint8))
((u16) (base 'uint16))
((u32) (base 'uint32))
((u64) (base 'uint64))
((s8) (base 'int8))
((s16) (base 'int16))
((s32) (base 'int32))
((s64) (base 'int64))
((f32) (base 'float32))
((f64) (base 'float64))
((bool) (base 'bool))
((unicode) (base 'rune))
((bigdigit) (base 'uint16))
((str) (base 'string))
(else (base (map-type type)))))))
(else
(compiler-internal-error
"univ-emit-decl, unknown target"))))
(if type
(decl type)
(or name "")))
(define (univ-emit-type ctx type)
(univ-emit-decl ctx type #f))
(define (univ-emit-procedure-declaration
ctx
global?
proc-type
root-name
params
attribs
body)
(univ-emit-defs
ctx
global?
(univ-jumpable-declaration-defs
ctx
global?
root-name
proc-type
params
attribs
body)))
(define (univ-emit-defs ctx global? defs)
(define (emit-method m)
(univ-emit-function-declaration
ctx
#t
(univ-method-name m)
(univ-method-result-type m)
(univ-method-params m)
(univ-method-attribs m)
(univ-method-body m)
(univ-method-modifier m)
#t))
(define (emit-class c)
(univ-emit-class-declaration
ctx
(univ-class-root-name c)
(univ-class-properties c)
(univ-class-extends c)
(univ-class-class-fields c)
(univ-class-instance-fields c)
(univ-class-class-methods c)
(univ-class-instance-methods c)
(univ-class-class-classes c)
(univ-class-constructor c)
(univ-class-inits c)))
(define (emit-field f)
(let* ((public? (memq 'public (univ-field-properties f)))
(name1 (univ-field-name f))
(name2 (^prefix name1 public?))
(name (if global? (^global-var name2) (^local-var name2))))
(^
(univ-emit-var-declaration
ctx
(univ-field-type f)
name
(univ-field-init f))
(if (eq? (univ-field-type f) 'jumpable)
(univ-emit-function-attribs
ctx
name
(univ-field-properties f))
(^)))))
(define (emit-init i)
(let ((code (i ctx)))
(if (eq? (target-name (ctx-target ctx)) 'go)
(begin
(univ-add-module-init ctx code)
"")
code)))
(let loop ((lst
(if (eq? (target-name (ctx-target ctx)) 'java)
(append (reverse (univ-defs-classes defs))
(reverse (univ-defs-methods defs))
(reverse (univ-defs-fields defs))
(reverse (univ-defs-inits defs)))
(reverse (univ-defs-all defs))))
(code
(^)))
(if (pair? lst)
(let ((x (car lst)))
(loop (cdr lst)
(^ code
(case (univ-def-kind x)
((class) (emit-class x))
((method) (emit-method x))
((field) (emit-field x))
((init) (emit-init x)))
"\n")))
code)))
(define (univ-capitalize code)
(define (cap-string str)
(string-append (string (char-upcase (string-ref str 0)))
(substring str 1 (string-length str))))
(cond ((string? code)
(cap-string code))
((symbol? code)
(cap-string (symbol->string code)))
((and (pair? code) (eq? (car code) univ-bb-prefix))
(cons univ-capitalized-bb-prefix (cdr code)))
(else
(error "cannot capitalize" code))))
(define (univ-jumpable-declaration-defs
ctx
global?
root-name
jumpable-type
params
attribs
body)
(case (univ-procedure-representation ctx)
((class)
(let ((capitalized-root-name
(tt"333"(^prefix-class (univ-capitalize root-name)))))
(univ-add-field
(univ-add-class
(univ-make-empty-defs)
(univ-class
capitalized-root-name ;; root-name
'() ;; properties
(and jumpable-type (^rts-class-use jumpable-type)) ;; extends
'() ;; class-fields
attribs ;; instance-fields
'() ;; class-methods
(list ;; instance-methods
(univ-method
'jump
'(public)
'jumpable
'()
'()
body))
'() ;; class-classes
#f ;; constructor
'())) ;; inits
(univ-field
root-name
capitalized-root-name
(^new* capitalized-root-name '())
'()))))
((struct)
(let* ((prefixed-root-name
(^prefix root-name))
(jump-meth
(^ prefixed-root-name "_jump_")))
(univ-add-init
(univ-add-method
(univ-add-field
(univ-make-empty-defs)
(univ-field
root-name
#f
(univ-construct-nested
ctx
(univ-jumpable-inheritance ctx jumpable-type)
(cons (univ-field 'jump '(fn () jumpable) (^null))
attribs))))
(univ-method
jump-meth
'()
'jumpable
params
'()
body))
(lambda (ctx)
(^ (^assign
(^member prefixed-root-name (^public 'jump))
jump-meth)
(^assign
(^member prefixed-root-name (^public 'parent))
(univ-force-init ctx (univ-field-init (list-ref attribs 1)))))))))
(else
(if (univ-mod-jumpable-is-field? ctx)
(univ-add-field
(univ-make-empty-defs)
(univ-field
root-name
'jumpable
(univ-emit-fn-decl ctx #f 'jumpable params body)
attribs))
(univ-add-method
(univ-make-empty-defs)
(univ-method
(^prefix root-name) ;;;;;;;;;;;;;;;;;;;;(^mod-method (ctx-module-name ctx) root-name)
'()
'jumpable
params
attribs
body))))))
(define (univ-force-init ctx init)
(if (procedure? init)
(init ctx)
init))
(define (univ-jumpable-inheritance ctx jumpable-type)
(define jumpable-structure '(jumpable jump))
(define ctrlpt-structure '(ctrlpt id parent))
(define returnpt-structure '(returnpt fs link))
(define entrypt-structure '(entrypt nfree))
(define parententrypt-structure '(parententrypt name ctrlpts info))
(case jumpable-type
((jumpable)
(list jumpable-structure))
((ctrlpt)
(list ctrlpt-structure
jumpable-structure))
((returnpt)
(list returnpt-structure
ctrlpt-structure
jumpable-structure))
((entrypt)
(list entrypt-structure
ctrlpt-structure
jumpable-structure))
((parententrypt)
(list parententrypt-structure
entrypt-structure
ctrlpt-structure
jumpable-structure))
(else
(compiler-internal-error
"univ-jumpable-inheritance, unknown jumpable type" jumpable-type))))
(define (univ-construct-nested ctx inheritance attribs)
(define (construct jumpable-type super args)
(let ((inits
(map (lambda (f)
(if (memq (univ-field-name f) '(parent))
(^null)
(univ-force-init ctx (univ-field-init f))))
args)))
(^construct* (^rts-class-use jumpable-type)
(if super
(cons super inits)
inits))))
(define (nest inh lst cont)
(if (pair? inh)
(nest (cdr inh)
lst
(lambda (super lst)
(let ((structure (car inh)))
(let loop ((lst lst)
(fields (cdr structure))
(rev-args '()))
(if (pair? fields)
(if (pair? lst)
(loop (cdr lst)
(cdr fields)
(cons (car lst) rev-args))
(begin
(pp (list inheritance attribs))
(compiler-internal-error
"univ-construct-nested, missing attributes for"
inheritance)))
(let ((args (reverse rev-args)))
(cont (construct (car structure) super args)
lst)))))))
(cont #f
lst)))
(nest inheritance
attribs
(lambda (super lst) super)))
(define (univ-jump-method-name ctx)
(if (eq? (univ-procedure-representation ctx) 'host)
'__invoke ;; for PHP when using repr-procedure = host
'jump))
(define (univ-emit-function-attribs ctx name attribs)
(case (target-name (ctx-target ctx))
((js python)
(if (null? attribs)
(^)
(^ "\n"
(map (lambda (attrib)
(let ((val (univ-force-init ctx (univ-field-init attrib))))
(^assign
(^member name (^public (univ-field-name attrib)))
val)))
attribs))))
((php)
(if (null? attribs)
(^)
(^ "static "
(univ-separated-list
", "
(map (lambda (attrib)
(let ((val (univ-force-init ctx (univ-field-init attrib))))
(^assign-expr
(^local-var (univ-field-name attrib))
val)))
attribs))
"; ")))
((ruby)
(if (null? attribs)
(^)
(^ "class << " name "; attr_accessor :" (univ-field-name (car attribs))
(map (lambda (attrib)
(^ ", :" (univ-field-name attrib)))
(cdr attribs))
"; end\n"
(map (lambda (attrib)
(let ((val (univ-force-init ctx (univ-field-init attrib))))
(^assign (^member name (^public (univ-field-name attrib)))
val)))
attribs))))
((java)
(^))
((go)
(^ "~~~TODO3:univ-emit-function-attribs~~~"))
(else
(compiler-internal-error
"univ-emit-function-attribs, unknown target"))))
(define (univ-emit-function-declaration
ctx
global?
root-name
result-type
params
attribs
body
modifier
#!optional
(prim? #f))
(let* ((prn
root-name)
(name
(if prim?
prn
(if global?
(^global-var prn)
(^local-var root-name)))))
;;(pp (list root-name prn));;;;;;;;;;;;;
(case (target-name (ctx-target ctx))
((js go)
(^ (univ-emit-fn-decl ctx name result-type params body modifier)
(if (null? attribs)
(^ "\n")
(^ "\n"
(univ-emit-function-attribs ctx name attribs)))))
((php)
(let ((decl
(^ (univ-emit-fn-decl
ctx
(and (or prim? (univ-php-pre53? ctx))
prn)
result-type
params
(and body
(^ (if (and (not prim?)
(univ-php-pre53? ctx))
(^)
(univ-emit-function-attribs ctx name attribs))
body))
modifier)
"\n")))
(cond (prim?
decl)
((univ-php-pre53? ctx)
(^ decl
"\n"
(^assign name
(^ "create_function('"
(univ-separated-list
","
(map (lambda (x)
(^ (^local-var (univ-field-name x))
(if (univ-field-init x) (^ "=" (^bool #f)) (^))))
params))
"','"
(univ-emit-function-attribs ctx name attribs)
"return "
prn
"("
(univ-separated-list "," (map univ-field-name params))
");')"))))
(else
(^assign name decl)))))
((python)
(^ (univ-emit-fn-decl ctx name result-type params body modifier)
(if (null? attribs)
(^)
(^ "\n"
(univ-emit-function-attribs ctx name attribs)))))
((ruby)
(^ (if prim?
(^ (univ-emit-fn-decl ctx name result-type params body modifier)
"\n")
(let ((parameters
(univ-separated-list
","
(map (lambda (x)
(^ (^local-var (univ-field-name x))
(if (univ-field-init x) (^ "=" (^bool #f)) (^))))
params))))
(^assign
name
(univ-emit-fn-decl ctx #f result-type params body modifier))))
(univ-emit-function-attribs ctx name attribs)))
((java);;TODO adapt to Java
(^ (univ-emit-fn-decl ctx name result-type params body modifier)
"\n"
(univ-emit-function-attribs ctx name attribs)))
(else
(compiler-internal-error
"univ-emit-function-declaration, unknown target")))))
(define (univ-emit-fn-decl
ctx
name
result-type
params
body
#!optional
(modifier #f))
(case (target-name (ctx-target ctx))
((js)
(let ((formals
(univ-separated-list
","
(map univ-field-name params))))
(^ "function " (or name "") "(" formals ") {"
(if body
(univ-indent body)
"")
"}")))
((php)
(let ((formals
(univ-separated-list
","
(map (lambda (x)
(^ (^local-var (univ-field-name x))
(if (univ-field-init x) (^ "=" (^bool #f)) (^))))
params))))
(^ "function " (or name "") "(" formals ")"
(if body
(^ " {"
(univ-indent body)
"}")
";"))))
((python)
(let ((formals
(univ-separated-list
","
(map (lambda (x)
(^ (^local-var (univ-field-name x))
(if (univ-field-init x) (^ "=" (^bool #f)) (^))))
params))))
(^ "def " name "(" formals "):"
(univ-indent
(or body
"\npass\n")))))
((ruby)
(let ((formals
(univ-separated-list
","
(map (lambda (x)
(^ (^local-var (univ-field-name x))
(if (univ-field-init x) (^ "=" (^bool #f)) (^))))
params))))
(if name
(^ "def " name (if (null? params) (^) (^ "(" formals ")"))
(if body
(univ-indent body)
"\n")
"end")
(^ "lambda {" (if (null? params) (^) (^ "|" formals "|"))
(if body
(univ-indent body)
"")
"}"))))
((java)
(let ((formals
(univ-separated-list
","
(map (lambda (var-descr)
(univ-emit-var-decl ctx var-descr))
params))))
(^ (if result-type (^ (^type result-type) " ") (^))
(or name "") "(" formals ")"
(if body
(^ " {"
(univ-indent body)
"}")
";"))))
((go)
(let ((formals
(univ-separated-list
","
(map (lambda (var-descr)
(univ-emit-var-decl ctx var-descr))
params))))
(^ (if (eq? modifier 'virtual)
""
(^ "func "
(if modifier
(^ (^parens (^ (^this) " " modifier)) " ")
"")))
(or name "") "(" formals ")"
(if (and result-type (not (eq? result-type 'noresult)))
(^ " " (^type result-type))
(^))
(if body
(^ " {"
(univ-indent body)
"}")
(^)))))
(else
(compiler-internal-error
"univ-emit-fn-decl, unknown target"))))
(define (univ-emit-fn-body ctx header gen-body)
(and gen-body
(univ-call-with-globals
ctx
gen-body
(lambda (ctx body globals)
(^ header globals body)))))
(define (univ-call-with-globals ctx gen cont)
(with-new-resources-used
ctx
(lambda (ctx)
(define (global-decl globals)
(^ "global "
(univ-separated-list
", "
globals)))
(let* ((result
(gen ctx))
(globals
(if (eq? (univ-module-representation ctx) 'class)
'()
(let ((globals
(reverse (resource-set-stack (ctx-globals-used ctx)))))
#;
(begin
;;TODO: remove
(define (used? x)
(or (resource-set-member? (ctx-resources-used-rd ctx) x)
(resource-set-member? (ctx-resources-used-wr ctx) x)))
(define (add! x)
(set! globals (cons x globals)))
(let loop ((num (- (univ-nb-gvm-regs ctx) 1)))
(if (>= num 0)
(begin
(if (used? num) (add! (gvm-state-reg ctx num)))
(loop (- num 1)))))
(if (used? 'sp) (add! (gvm-state-sp ctx)))
(if (used? 'stack) (add! (gvm-state-stack ctx)))
(if (used? 'peps) (add! (gvm-state-peps ctx)))
(if (used? 'glo) (add! (gvm-state-glo ctx)))
(if (used? 'nargs) (add! (gvm-state-nargs ctx)))
(if (used? 'pollcount) (add! (gvm-state-pollcount ctx))))
globals))))
(cont ctx
result
(if (null? globals)
(^)
(case (target-name (ctx-target ctx))
((php)
(^ (global-decl globals) ";\n"))
((python)
(^ (global-decl globals) "\n"))
(else
(^)))))))))
(define (univ-field-param ctx name)
(if (eq? (target-name (ctx-target ctx)) 'java)
(^ "_" name)
name))
(define (univ-emit-class-declaration
ctx
root-name
#!optional
(properties #f)
(extends #f)
(class-fields '())
(instance-fields '())
(class-methods '())
(instance-methods '())
(class-classes '())
(constructor #f)
(inits '()))
(let ((name (tt"444"root-name)) ;; (^prefix-class root-name);;TODO: fix ^prefix
(abstract? (memq 'abstract properties)))
(define (qualifiers additional-properties decl)
(let ((all (append additional-properties (univ-decl-properties decl))))
(^ (case (target-name (ctx-target ctx))
((python go)
"")
(else
(if (memq 'public all) "public " "")))
(case (target-name (ctx-target ctx))
((python go)
"")
(else
(if (memq 'static all) "static " "")))
(case (target-name (ctx-target ctx))
((python go)
"")
(else
(if (and (univ-method? decl) (not (univ-method-body decl)))
"abstract "
"")))
(if (memq 'classmethod all) "@classmethod\n" ""))))
(define (field-decl additional-properties field)
(let* ((type (univ-field-type field))
(public? (memq 'public (univ-field-properties field)))
(name1 (univ-field-name field))
(name (if public? (^public name1) name1))
(init (univ-field-init field)))
(^ (qualifiers additional-properties field)
(case (target-name (ctx-target ctx))
((go)
(^ (^local-var name) (if type (^ " " (^type type)) "") "\n"))
(else
(univ-emit-var-declaration ctx type (^local-var name) (except-this init)))))))
(define (except-this v)
(case (target-name (ctx-target ctx))
((php) (if (eq? v (^this))
(^null)
v))
(else v)))
(define (qualified-field-decls additional-properties fields)
(let ((fields
(keep (lambda (x) (not (univ-field-inherited? x)))
fields)))
(if (pair? fields)
(^ "\n"
(map (lambda (field)
(field-decl additional-properties field))
fields))
(^))))
(define (qualified-method-decls additional-properties methods)
(map (lambda (method)
(^ "\n"
(qualifiers additional-properties method)
(univ-emit-function-declaration
ctx
#t
(univ-method-name method)
(univ-method-result-type method)
(if (eq? (target-name (ctx-target ctx)) 'python)
(cons (univ-field (^this) 'object)
(univ-method-params method))
(univ-method-params method))
(univ-method-attribs method)
(univ-method-body method)
(univ-method-modifier method)
#t)
(if (eq? (target-name (ctx-target ctx)) 'python)
"" ;; avoid repeated empty lines
"\n")))
methods))
(define (qualified-class-decls additional-properties classes)
(map (lambda (class)
(^ "\n"
(qualifiers additional-properties class)
(univ-emit-class-declaration
ctx
(univ-class-root-name class)
(univ-class-properties class)
(univ-class-extends class)
(univ-class-class-fields class)
(univ-class-instance-fields class)
(univ-class-class-methods class)
(univ-class-instance-methods class)
(univ-class-class-classes class)
(univ-class-constructor class)
(univ-class-inits class))))
classes))
(define (ruby-attr-accessors fields)
(^ "\n"
"attr_accessor " ;; allow read/write on all fields
(univ-separated-list
","
(map (lambda (field) (^ ":" (univ-field-name field)))
fields))
"\n"))
(define (initless fields)
(keep (lambda (field) (not (univ-field-init field)))
fields))
(define (gen-inits ctx inits)
(let ((code
(if (null? inits)
'()
(^ "\n"
(map (lambda (i) (i ctx)) inits)))))
(if (eq? (target-name (ctx-target ctx)) 'go)
(begin
(univ-add-module-init ctx code)
"")
code)))
(define (assign-field-decls obj fields)
(map (lambda (field)
(let* ((public? (memq 'public (univ-field-properties field)))
(name1 (univ-field-name field))
(name (if public? (^public name1) name1))
(val (univ-force-init ctx (univ-field-init field))))
(^assign (^member obj name)
(or val (^local-var (univ-field-param ctx name1))))))
fields))
(define (js-class-declaration
ctx
obj
name
properties
extends
class-fields
instance-fields
class-methods
instance-methods
class-classes
constructor
inits)
(define (assign-method-decls obj methods)
(map (lambda (method)
(^ "\n"
(^assign (^member obj (univ-method-name method))
(univ-emit-fn-decl
ctx
#f
(univ-method-result-type method)
(univ-method-params method)
(univ-method-body method)))
(univ-emit-function-attribs
ctx
(^member obj (univ-method-name method))
(univ-method-attribs method))))
methods))
(define (assign-class-decls obj classes)
(map (lambda (class)
(^ "\n"
(js-class-declaration
ctx
obj
(univ-class-root-name class)
(univ-class-properties class)
(univ-class-extends class)
(univ-class-class-fields class)
(univ-class-instance-fields class)
(univ-class-class-methods class)
(univ-class-instance-methods class)
(univ-class-class-classes class)
(univ-class-constructor class)
(univ-class-inits class))))
classes))
(define (fn-decl name)
(univ-emit-fn-decl
ctx
name
#f
(initless instance-fields)
(univ-emit-fn-body
ctx
"\n"
(lambda (ctx)
(if (or constructor
(not (null? instance-fields)))
(^ (assign-field-decls (^this) instance-fields)
(if constructor (constructor ctx) (^)))
(^))))))
(let ((objname name)) ;;(if obj (^member obj name) name)))
;;(pp (list obj name objname))
(^ (if obj
(^assign objname (fn-decl #f))
(^ (fn-decl name)
"\n"))
(if extends
(begin ;;(pp (list 'extends extends (^type extends)))
(^ "\n"
(^assign (^member objname 'prototype)
(^call-prim (^member "Object" 'create)
(^member (^type extends) 'prototype))))
)
(^))
(assign-method-decls (^member objname 'prototype) instance-methods)
(assign-class-decls objname class-classes)
(assign-method-decls objname class-methods)
(if (pair? class-fields)
(^ "\n" (assign-field-decls objname class-fields))
(^))
(gen-inits ctx inits))))
(case (target-name (ctx-target ctx))
((js)
(js-class-declaration
ctx
#f
root-name
properties
extends
class-fields
instance-fields
class-methods
instance-methods
class-classes
constructor
inits))
((php)
(let* ((c-classes
(qualified-class-decls '() class-classes))
(c-fields
(qualified-field-decls '(static) class-fields))
(i-fields
(qualified-field-decls '() instance-fields))
(all-fields
(append c-fields i-fields))
(constr
(if (and (not abstract?)
(or constructor (not (null? instance-fields))))
(^ (univ-emit-fn-decl
ctx
(if (univ-php-pre53? ctx) name "__construct")
#f
(map (lambda (field)
(univ-field
(univ-field-param ctx (univ-field-name field))
(univ-field-type field)
(univ-field-init field)
(univ-field-properties field)))
(initless instance-fields))
(univ-emit-fn-body
ctx
"\n"
(lambda (ctx)
(^ (assign-field-decls (^this) instance-fields)
(if constructor (constructor ctx) (^))))))
"\n")
'()))
(c-methods
(qualified-method-decls
(if abstract? '(abstract static) '(static))
class-methods))
(i-methods
(qualified-method-decls
(if abstract? '(abstract) '())
instance-methods))
(all-methods
(append constr
c-methods
i-methods))
(c-inits
(gen-inits ctx inits)))
(^ c-classes
(if abstract? "abstract " "") "class " name
(if extends (^ " extends " (^type extends)) "")
" {"
(univ-indent
(^ (if (and (null? all-fields)
(null? all-methods)
(null? c-inits))
""
"\n")
all-fields
(if (null? all-methods)
""
"\n")
all-methods
(if (null? c-inits)
(^)
(^ "static {"
(univ-indent c-inits)
"}\n"))))
"}\n")))
((python)
(let* ((c-classes
(qualified-class-decls '(static) class-classes))
(c-fields
(qualified-field-decls '(static) class-fields))
(c-methods
(qualified-method-decls '(classmethod) class-methods))
(i-methods
(qualified-method-decls '() instance-methods))
(c-inits
(gen-inits ctx inits)))
(^ "class " name
(if extends (^ "(" (^type extends) ")") "")
":\n"
(univ-indent
(if (and (not abstract?)
(or constructor
(not (null? c-classes))
(not (null? c-fields))
(not (null? c-methods))
(not (null? instance-fields))
(not (null? i-methods))
(not (null? c-inits))))
(^ c-classes
c-fields
c-methods
(if (or constructor
(not (null? instance-fields)))
(^ "\n"
(univ-emit-fn-decl
ctx
"__init__"
#f
(cons (univ-field (^this) 'object)
(initless instance-fields))
(univ-emit-fn-body
ctx
"\n"
(lambda (ctx)
(if (and (null? instance-fields) (not constructor))
"pass\n"
(^ (assign-field-decls (^this) instance-fields)
(if constructor (constructor ctx) (^))))))))
(^))
i-methods)
"pass\n"))
c-inits))) ;; class inits are outside of class definition in case there are self dependencies
((ruby)
(^ "class " name
(if extends (^ " < " (^type extends)) "")
(univ-indent
(if (or constructor
(not (null? class-fields))
(not (null? instance-fields))
(not (null? class-methods))
(not (null? instance-methods)))
(^ "\n"
(let ((meta-attributes (keep (lambda (x)
(and (pair? x)
(eq? (car x) 'alias_method)))
properties)))
(if (not (null? meta-attributes))
(^ "\n"
(map (lambda (attr)
(^ (car attr) " " (univ-separated-list "," (cdr attr)) "\n"))
meta-attributes)
"\n")
(^)))
(if (or (not (null? class-fields))
(not (null? class-methods)))
(^ "\n"
"class << " (^this)
(univ-indent
(^ (ruby-attr-accessors class-fields)
(qualified-method-decls '() class-methods)))
"end\n"
"\n"
(assign-field-decls 'self-class class-fields))
(^))
(if (pair? instance-fields)
(ruby-attr-accessors instance-fields)
(^))
(if (or constructor
(not (null? instance-fields)))
(^ "\n"
"def initialize("
(univ-separated-list
","
(map univ-field-name
(initless instance-fields)))
")\n"
(univ-indent
(^ (assign-field-decls (^this) instance-fields)
(if constructor (constructor ctx) (^))))
"end\n")
(^))
(qualified-method-decls '() instance-methods))
(^)))
"\nend\n"))
((java)
(let* ((c-classes
(qualified-class-decls '(static) class-classes))
(c-fields
(qualified-field-decls '(static) class-fields))
(i-fields
(qualified-field-decls '() instance-fields))
(all-fields
(append c-fields i-fields))
(constr
(if (and (not abstract?)
(or constructor (not (null? instance-fields))))
(list "\n"
(univ-emit-fn-decl
ctx
name
#f
(map (lambda (field)
(univ-field
(univ-field-param ctx (univ-field-name field))
(univ-field-type field)
(univ-field-init field)
(univ-field-properties field)))
(initless instance-fields))
(univ-emit-fn-body
ctx
"\n"
(lambda (ctx)
(^ (assign-field-decls (^this) instance-fields)
(if constructor (constructor ctx) (^))))))
"\n")
'()))
(c-methods
(qualified-method-decls
(if abstract? '(abstract static) '(static))
class-methods))
(i-methods
(qualified-method-decls
(if abstract? '(abstract) '())
instance-methods))
(all-methods
(append constr c-methods i-methods))
(c-inits
(gen-inits ctx inits))
(generic
(assq 'generic properties)))
(^ (if abstract? "abstract " "") "class "
name (if generic (^ "<" (univ-separated-list ", " (map (lambda (x) (^type x)) (cdr generic))) "> ") "")
(if extends (^ " extends " (^type extends)) "")
" {"
(univ-indent
(^ (if (and (null? c-classes)
(or abstract?
(null? all-methods)))
""
"\n")
c-classes
all-fields
all-methods
(if (null? c-inits)
(^)
(^ "static {"
(univ-indent c-inits)
"}\n"))))
"}\n")))
((go)
(let* ((c-classes
'()) ;;(qualified-class-decls '(static) class-classes))
(c-fields
'()) ;;(qualified-field-decls '(static) class-fields))
(i-fields
(qualified-field-decls '() instance-fields))
(all-fields
(append c-fields i-fields))
(virtual-i-methods
(qualified-method-decls
'()
(keep (lambda (m) (not (univ-method-body m)))
instance-methods)))
(concrete-i-methods
(qualified-method-decls
'()
(keep (lambda (m) (univ-method-body m))
instance-methods)))
(interface?
(memq 'interface properties))
(defs-in-type
(append all-fields
virtual-i-methods))
(all-defs-in-type
(append (if extends
(list (^ "\n"
(^type extends)
(if (null? defs-in-type) "\n" "")))
'())
defs-in-type)))
(^ "type " name " "
(if interface? "interface" "struct")
(if (null? all-defs-in-type)
"{}\n"
(^ " {"
(univ-indent all-defs-in-type)
"}\n"))
concrete-i-methods)))
(else
(compiler-internal-error
"univ-emit-class-declaration, unknown target")))))
(define (univ-emit-comment ctx comment)
;; generates a single line comment
(^ (univ-single-line-comment-prefix (target-name (ctx-target ctx)))
" "
comment))
(define (univ-single-line-comment-prefix targ-name)
(case targ-name
((js php java go)
"//")
((python ruby)
"#")
(else
(compiler-internal-error
"univ-single-line-comment-prefix, unknown target"))))
(define (univ-emit-return-poll ctx expr poll? call?)
(define (ret)
(if (or call? (univ-always-return-jump? ctx))
(^return-jump expr)
(^return expr)))
(univ-emit-poll-or-continue ctx expr poll? ret))
(define (univ-emit-poll-or-continue ctx expr poll? cont)
(if poll?
(^inc-by (gvm-state-pollcount-use ctx 'rdwr)
-1
(lambda (inc)
(^if (^= inc (^int 0))
(^return-call-prim
(^rts-method-use 'poll)
expr) ;;(^upcast* '??? 'ctrlpt expr)
(cont))))
(cont)))
(define (univ-emit-return-call-prim ctx expr . params)
(^return
(apply univ-emit-call-prim (cons ctx (cons expr params)))))
(define (univ-emit-return-jump ctx expr)
(^return
(if (not (univ-never-return-jump? ctx))
(^jump (univ-unstringify-method expr))
expr)))
(define (univ-emit-return ctx expr)
(case (target-name (ctx-target ctx))
((js php java)
(^ "return " expr ";\n"))
((python ruby go)
(^ "return " expr "\n"))
(else
(compiler-internal-error
"univ-emit-return, unknown target"))))
(define (univ-emit-null ctx)
;; generates a null reference
(case (target-name (ctx-target ctx))
((js java)
(univ-constant "null"))
((python)
(univ-constant "None"))
((ruby go)
(univ-constant "nil"))
((php)
(univ-constant "NULL"))
(else
(compiler-internal-error
"univ-emit-null, unknown target"))))
(define (univ-emit-null? ctx expr)
(^eq? expr (^null)))
(define (univ-emit-null-obj ctx)
(case (univ-null-representation ctx)
((class)
(^rts-field-use 'null_obj))
(else
(^null))))
(define (univ-emit-null-obj? ctx expr)
(case (univ-null-representation ctx)
((class)
(^instanceof (^type 'null) expr))
(else
(^null? expr))))
(define (univ-emit-void ctx)
(case (target-name (ctx-target ctx))
((js)
(univ-constant "void 0")) ;; JavaScript's "undefined" value
(else
(^null))))
(define (univ-emit-void? ctx expr)
(^eq? expr (^void)))
(define (univ-emit-void-obj ctx)
(case (univ-void-representation ctx)
((class)
(^rts-field-use 'void_obj))
(else
(^void))))
(define (univ-emit-str->string ctx expr)
(^string-box (^str-to-codes expr)))
(define (univ-emit-string->str ctx expr)
(case (univ-string-representation ctx)
((class)
(^tostr expr))
((host)
expr)))
(define (univ-emit-void-obj? ctx expr)
(case (univ-void-representation ctx)
((class)
(^instanceof (^type 'void) expr))
(else
(case (target-name (ctx-target ctx))
((js) (^void? expr))
(else (^null? expr))))))
(define (univ-emit-str? ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^typeof "string" expr))
((php)
(^call-prim "is_string" expr))
((python)
(^instanceof "str" expr))
((ruby)
(^instanceof "String" expr))
(else
(compiler-internal-error
"univ-emit-str?, unknown target"))))
(define (univ-emit-float? ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^typeof "number" expr))
((php)
(^ "is_float(" expr ")"))
((python)
(^ "isinstance(" expr ", float)"))
((ruby)
(^ expr ".instance_of?(Float)"))
(else
(compiler-internal-error
"univ-emit-float?, unknown target"))))
(define (univ-emit-int? ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^typeof "number" expr))
((php)
(^call-prim "is_int" expr))
((python)
(^and (^instanceof "int" expr)
(^not (^instanceof "bool" expr))))
((ruby)
(^instanceof "Fixnum" expr))
(else
(compiler-internal-error
"univ-emit-int?, unknown target"))))
(define (univ-emit-eof ctx)
(case (univ-eof-representation ctx)
((class)
(^rts-field-use 'eof_obj))
(else
(compiler-internal-error
"univ-emit-eof, host representation not implemented"))))
(define (univ-emit-absent ctx)
(case (univ-absent-representation ctx)
((class)
(^rts-field-use 'absent_obj))
(else
(compiler-internal-error
"univ-emit-absent, host representation not implemented"))))
(define (univ-emit-deleted ctx)
(case (univ-deleted-representation ctx)
((class)
(^rts-field-use 'deleted_obj))
(else
(compiler-internal-error
"univ-emit-deleted, host representation not implemented"))))
(define (univ-emit-unused ctx)
(case (univ-unused-representation ctx)
((class)
(^rts-field-use 'unused_obj))
(else
(compiler-internal-error
"univ-emit-unused, host representation not implemented"))))
(define (univ-emit-unbound1 ctx)
(case (univ-unbound-representation ctx)
((class)
(^rts-field-use 'unbound1_obj))
(else
(compiler-internal-error
"univ-emit-unbound1, host representation not implemented"))))
(define (univ-emit-unbound2 ctx)
(case (univ-unbound-representation ctx)
((class)
(^rts-field-use 'unbound2_obj))
(else
(compiler-internal-error
"univ-emit-unbound2, host representation not implemented"))))
(define (univ-emit-unbound? ctx expr)
(case (univ-unbound-representation ctx)
((class)
(^instanceof (^type 'unbound) (^cast*-scmobj expr)))
(else
(compiler-internal-error
"univ-emit-unbound?, host representation not implemented"))))
(define (univ-emit-optional ctx)
(case (univ-optional-representation ctx)
((class)
(^rts-field-use 'optional_obj))
(else
(compiler-internal-error
"univ-emit-optional, host representation not implemented"))))
(define (univ-emit-key ctx)
(case (univ-key-representation ctx)
((class)
(^rts-field-use 'key_obj))
(else
(compiler-internal-error
"univ-emit-key, host representation not implemented"))))
(define (univ-emit-rest ctx)
(case (univ-rest-representation ctx)
((class)
(^rts-field-use 'rest_obj))
(else
(compiler-internal-error
"univ-emit-rest, host representation not implemented"))))
(define (univ-emit-bool ctx val)
(case (target-name (ctx-target ctx))
((js ruby php java go)
(univ-constant (if val "true" "false")))
((python)
(univ-constant (if val "True" "False")))
(else
(compiler-internal-error
"univ-emit-bool, unknown target"))))
(define (univ-emit-bool? ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^typeof "boolean" expr))
((php)
(^call-prim "is_bool" expr))
((python)
(^instanceof "bool" expr))
((ruby)
(^or (^instanceof "FalseClass" expr)
(^instanceof "TrueClass" expr)))
(else
(compiler-internal-error
"univ-emit-bool?, unknown target"))))
(define (univ-emit-boolean-obj ctx obj)
(case (univ-boolean-representation ctx)
((class)
(univ-box
(^rts-field-use (if obj 'true_obj 'false_obj))
(^bool obj)))
(else
(^bool obj))))
(define (univ-emit-boolean-box ctx expr)
(case (univ-boolean-representation ctx)
((class)
(univ-box
(^if-expr 'scmobj
expr
(^boolean-obj #t)
(^boolean-obj #f))
expr))
(else
expr)))
(define (univ-emit-boolean-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-boolean-representation ctx)
((class)
(^member (^cast* 'boolean expr) (^public 'val)))
(else
(^downcast* 'bool expr)))))
(define (univ-emit-boolean? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_boolean) expr))
(else
(case (univ-boolean-representation ctx)
((class)
(^instanceof (^type 'boolean) (^cast*-scmobj expr)))
(else
(^bool? expr))))))
(define (univ-emit-chr ctx val)
(univ-constant (char->integer val)))
(define (univ-emit-char-obj ctx obj force-var?)
(case (univ-char-representation ctx)
((class)
(let ((x (^chr obj)))
(univ-box
(univ-obj-use
ctx
obj
force-var?
(lambda ()
(^char-box x)))
x)))
(else
(compiler-internal-error
"univ-emit-char-obj, host representation not implemented"))))
(define (univ-emit-char-box ctx expr)
(case (univ-char-representation ctx)
((class)
(univ-box
(^call-prim
(^rts-method-use 'make_interned_char)
expr)
expr))
(else
(^char-box-uninterned expr))))
(define (univ-emit-char-box-uninterned ctx expr)
(case (univ-char-representation ctx)
((class)
(^new 'char expr))
(else
expr)))
(define (univ-emit-char-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-char-representation ctx)
((class)
(^member (^cast* 'char expr) (^public 'code)))
(else
(^downcast* 'chr expr)))))
(define (univ-emit-chr-fromint ctx expr)
(case (target-name (ctx-target ctx))
((js php python ruby)
expr)
((java)
(^cast* 'unicode expr))
((go)
(^conv* 'rune expr))
(else
(compiler-internal-error
"univ-emit-chr-fromint, unknown target"))))
(define (univ-emit-chr-toint ctx expr)
(case (target-name (ctx-target ctx))
((js php python ruby)
expr)
((java)
(^cast* 'int expr))
((go)
(^conv* 'int expr))
(else
(compiler-internal-error
"univ-emit-chr-toint, unknown target"))))
(define (univ-emit-chr-tostr ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^call-prim (^member "String" 'fromCharCode) expr))
((php)
(^call-prim "chr" expr))
((python)
(^call-prim "unichr" expr))
((ruby)
(^ expr ".chr"))
((java)
(^call-prim (^member 'String 'valueOf) expr))
((go)
(^conv* 'str expr))
(else
(compiler-internal-error
"univ-emit-chr-tostr, unknown target"))))
(define (univ-emit-char? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_char) expr))
(else
(case (univ-char-representation ctx)
((class)
(^instanceof (^type 'char) (^cast*-scmobj expr)))
(else
(compiler-internal-error
"univ-emit-char?, host representation not implemented"))))))
(define (univ-emit-int ctx val)
(univ-constant val))
(define (univ-emit-num-of-type ctx type val)
(declare (generic))
(case (target-name (ctx-target ctx))
((java)
(case type
((f32)
(^cast* 'f32 (^float val)))
((f64)
(^float val))
((s8 s16 s32)
(^int val))
((u8)
(^int
(if (>= val 128)
(- val 256)
val)))
((u16)
(^int
(if (>= val 32768)
(- val 65536)
val)))
((u32)
(^int
(if (>= val 32768)
(- val 4294967296)
val)))
;; ((u64)
;; (^int
;; (if (>= val 9223372036854775808)
;; (- val 18446744073709551616)
;; val)))
(else
(univ-emit-obj* ctx val #f))))
(else
(case type
((f32)
(^cast* 'f32 (^float val)))
((f64)
(^float val))
((s8 s16 s32 u8 u16 u32)
(^int val))
(else
(univ-emit-obj* ctx val #f))))))
(define (univ-emit-fixnum-box ctx expr)
(case (univ-fixnum-representation ctx)
((class)
(univ-box
(^call-prim
(^rts-method-use 'make_fixnum)
expr)
expr))
(else
expr)))
(define (univ-emit-fixnum-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-fixnum-representation ctx)
((class)
(^member (^cast* 'fixnum expr) (^public 'val)))
(else
(^downcast* 'int expr)))))
(define (univ-emit-fixnum? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_fixnum) expr))
(else
(case (univ-fixnum-representation ctx)
((class)
(^instanceof (^type 'fixnum) (^cast*-scmobj expr)))
(else
(^int? expr))))))
(define (univ-emit-empty-dict ctx type)
(case (target-name (ctx-target ctx))
((js python ruby)
(^ "{}"))
((php)
(^ "array()"))
((java)
(^new type))
((go)
(^ (^type type) "{}"))
(else
(compiler-internal-error
"univ-emit-empty-dict, unknown target"))))
;;TODO:remove
#;
(define (univ-emit-dict ctx alist)
(define (dict alist sep open close)
(^ open
(univ-separated-list
","
(map (lambda (x) (^ (^str (car x)) sep (cdr x))) alist))
close))
(case (target-name (ctx-target ctx))
((js python)
(dict alist ":" "{" "}"))
((php)
(dict alist "=>" "array(" ")"))
((ruby)
(dict alist "=>" "{" "}"))
((go)
(^ (^type type) (dict alist ":" "{" "}")))
(else
(compiler-internal-error
"univ-emit-dict, unknown target"))))
(define (univ-emit-dict-key-exists? ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js php python ruby)
(^prop-index-exists? expr1 expr2))
((java)
(^call-prim
(^member expr1 'containsKey)
expr2))
((go)
(^ "~~~TODO3:univ-emit-dict-key-exists?~~~"))
(else
(compiler-internal-error
"univ-emit-dict-key-exists?, unknown target"))))
(define (univ-emit-dict-get ctx type expr1 expr2 expr3)
(case (target-name (ctx-target ctx))
((js php python ruby go)
(^prop-index type expr1 expr2 expr3))
((java)
(if (and expr3
(not (equal? expr3 (^null))))
(if (univ-java-pre7? ctx)
(^if-expr type
(^dict-key-exists? expr1 expr2)
(^dict-get type expr1 expr2)
expr3)
(^call-prim (^member expr1 'getOrDefault) expr2 expr3))
(^call-prim (^member expr1 'get) expr2)))
(else
(compiler-internal-error
"univ-emit-dict-get, unknown target"))))
(define (univ-emit-dict-get-or-null ctx type expr1 expr2)
(case (target-name (ctx-target ctx))
((go)
(^prop-index-or-null type expr1 expr2))
(else
(^prop-index type expr1 expr2 (^null)))))
(define (univ-emit-dict-set ctx type expr1 expr2 expr3)
(case (target-name (ctx-target ctx))
((js php python ruby go)
(^assign (^prop-index type expr1 expr2) expr3))
((java)
(^expr-statement (^call-prim (^member expr1 'put) expr2 expr3)))
(else
(compiler-internal-error
"univ-emit-dict-set, unknown target"))))
(define (univ-emit-dict-delete ctx expr1 expr2)
(^expr-statement
(case (target-name (ctx-target ctx))
((js)
(^ "delete " (^prop-index 'scmobj expr1 expr2)))
((python)
(^ "del " (^prop-index 'scmobj expr1 expr2)))
((ruby)
(^call-member expr1 'delete expr2))
((php)
(^call-prim 'unset (^prop-index 'scmobj expr1 expr2)))
((java)
(^call-member expr1 'remove expr2))
((go)
(^ "~~~TODO3:univ-emit-dict-delete~~~"))
(else
(compiler-internal-error
"univ-emit-dict-delete, unknown target")))))
(define (univ-emit-dict-length ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^array-length (^call-prim (^member 'Object 'keys) expr)))
((python ruby php)
(^array-length expr))
((java)
(^call-member expr 'size))
((go)
(^ "~~~TODO3:univ-emit-dict-length~~~"))
(else
(compiler-internal-error
"univ-emit-dict-length, unknown target"))))
(define (univ-emit-member ctx expr name)
(case (target-name (ctx-target ctx))
((js python)
(^ expr "." name))
((php)
(^ expr "->" name))
((ruby)
(cond ((eq? expr (^this)) ;; optimize access to "self"
(^ "@" name))
((eq? expr 'self-class) ;; for univ-emit-class-declaration
(^ "@@" name))
(else
(^ expr "." name))))
((java)
(cond ((eq? expr (^this)) ;; optimize access to "this"
name)
(else
(^ expr "." name))))
((go)
(^ expr "." name))
(else
(compiler-internal-error
"univ-emit-member, unknown target"))))
(define (univ-emit-public ctx name)
(case (target-name (ctx-target ctx))
((go)
(^ "G_" name)) ;; exported names must start with a capital letter
(else
name)))
(define (univ-with-ctrlpt-attribs ctx assign? ctrlpt thunk)
(case (univ-procedure-representation ctx)
((class)
(thunk))
((struct)
(thunk))
(else
(case (target-name (ctx-target ctx))
((js python ruby)
(thunk))
((php)
(let ((attribs-var
(^ ctrlpt "_attribs"))
(attribs-array
(^ "new ReflectionFunction(" ctrlpt ")")))
(^ (if assign?
(^assign attribs-var attribs-array)
(^var-declaration 'object attribs-var attribs-array))
(^assign attribs-var (^ attribs-var "->getStaticVariables()"))
(thunk))))
(else
(compiler-internal-error
"univ-with-ctrlpt-attribs, unknown target"))))))
(define (univ-get-ctrlpt-attrib ctx ctrlpt attrib)
(case (univ-procedure-representation ctx)
((class struct)
(^member ctrlpt (^public attrib)))
(else
(case (target-name (ctx-target ctx))
((js python ruby)
(^member ctrlpt (^public attrib)))
((php)
(let ((attribs-var (^ ctrlpt "_attribs")))
(^prop-index 'scmobj attribs-var (^str attrib))))
(else
(compiler-internal-error
"univ-get-ctrlpt-attrib, unknown target"))))))
(define (univ-set-ctrlpt-attrib ctx ctrlpt attrib val)
(case (univ-procedure-representation ctx)
((class)
(^assign (^member ctrlpt (^public attrib)) val))
((struct)
(^assign (^member (cdr ctrlpt) (^public attrib)) val))
(else
(case (target-name (ctx-target ctx))
((js python ruby)
(^assign (^member ctrlpt (^public attrib)) val))
((php)
(let ((attribs-var (^ ctrlpt "_attribs")))
(^assign (^prop-index 'scmobj attribs-var (^str attrib)) val)))
(else
(compiler-internal-error
"univ-set-ctrlpt-attrib, unknown target"))))))
(define (univ-call-with-ctrlpt-attrib ctx expr type-name attrib return)
(let ((ctrlpt (^local-var (univ-gensym ctx 'ctrlpt))))
(^ (^var-declaration
type-name
ctrlpt
(^cast* type-name expr))
(univ-with-ctrlpt-attribs
ctx
#f
ctrlpt
(lambda ()
(return
(univ-get-ctrlpt-attrib ctx ctrlpt attrib)))))))
(define (univ-emit-pair? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_pair) expr))
(else
(^instanceof (^type 'pair) (^cast*-scmobj expr)))))
(define (univ-emit-cons ctx expr1 expr2)
(^new 'pair expr1 expr2))
(define (univ-emit-getcar ctx expr)
(^member (^cast* 'pair expr) (^public 'car)))
(define (univ-emit-getcdr ctx expr)
(^member (^cast* 'pair expr) (^public 'cdr)))
(define (univ-emit-setcar ctx expr1 expr2)
(^assign (^member (^cast* 'pair expr1) (^public 'car)) expr2))
(define (univ-emit-setcdr ctx expr1 expr2)
(^assign (^member (^cast* 'pair expr1) (^public 'cdr)) expr2))
(define (univ-emit-float ctx val)
;; TODO: generate correct syntax
(univ-constant
(cond
((not (finite? val))
(cond ((nan? val)
(case (target-name (ctx-target ctx))
((js) "Number.NaN")
((java) "Double.NaN")
((php) "NAN")
((python) "float('nan')")
((ruby) "Float::NAN")
((go) "math.NaN")
(else
(compiler-internal-error
"univ-emit-float, unknown target"))))
((positive? val)
(case (target-name (ctx-target ctx))
((js) "Number.POSITIVE_INFINITY")
((java) "Double.POSITIVE_INFINITY")
((php) "INF")
((python) "float('inf')")
((ruby) "Float::INFINITY")
((go) "math.Inf(+1)")
(else
(compiler-internal-error
"univ-emit-float, unknown target"))))
(else
(case (target-name (ctx-target ctx))
((js) "Number.NEGATIVE_INFINITY")
((java) "Double.NEGATIVE_INFINITY")
((php) "(-INF)")
((python) "(-float('inf'))")
((ruby) "(-Float::INFINITY)")
((go) "math.Inf(-1)")
(else
(compiler-internal-error
"univ-emit-float, unknown target"))))))
((eqv? val -0.0)
(case (target-name (ctx-target ctx))
((php) "(0.0*-1)") ;; in PHP -0.0 doesn't give negative zero
((go) "math.Copysign(0,-1)")
(else "-0.0")))
(else
(let ((str (number->string (abs val))))
(string-append
(if (negative? val) "-" "")
(if (char=? (string-ref str 0) #\.) "0" "") ;; .17 => 0.17
str
(if (char=? (string-ref str (- (string-length str) 1)) #\.) "0" ""))))))) ;; 22. => 22.0
(define (univ-emit-float-fromint ctx expr)
(case (target-name (ctx-target ctx))
((js)
expr)
((php)
(^ "(float)(" expr ")"))
((python)
(^ "float(" expr ")"))
((ruby)
(^ expr ".to_f"))
((java)
(^cast* 'f64 expr))
(else
(compiler-internal-error
"univ-emit-float-fromint, unknown target"))))
(define (univ-emit-float-toint ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^float-truncate expr))
((php)
(^ "(int)(" expr ")"))
((python)
(^ "int(" expr ")"))
((ruby)
(^ expr ".to_i"))
((java)
(^cast* 'int expr))
((go)
(^ "~~~TODO3:univ-emit-float-toint~~~"))
(else
(compiler-internal-error
"univ-emit-float-toint, unknown target"))))
(define (univ-emit-float-math ctx fn . params)
(univ-emit-call-prim-aux
ctx
(case (target-name (ctx-target ctx))
((js ruby java)
(^member 'Math fn))
((python)
(^member 'math fn))
((php)
fn)
((go)
(^ "~~~TODO3:univ-emit-float-math~~~"))
(else
(compiler-internal-error
"univ-emit-float-math, unknown target")))
params))
(define (univ-emit-float-abs ctx expr)
(case (target-name (ctx-target ctx))
((js java php)
(^float-math 'abs expr))
((python)
(^float-math 'fabs expr))
((ruby)
(^call-prim (^member expr 'abs)))
((go)
(^ "~~~TODO3:univ-emit-float-abs~~~"))
(else
(compiler-internal-error
"univ-emit-float-abs, unknown target"))))
(define (univ-emit-float-floor ctx expr)
(case (target-name (ctx-target ctx))
((js java php)
(^float-math 'floor expr))
((python)
(^parens
(univ-ident-when-special-float
ctx
expr
(^float-math 'floor expr))))
((ruby)
(^parens
(univ-ident-when-special-float
ctx
expr
(^float-fromint (^call-prim (^member expr 'floor))))))
((go)
(^ "~~~TODO3:univ-emit-float-floor~~~"))
(else
(compiler-internal-error
"univ-emit-float-floor, unknown target"))))
(define (univ-emit-float-ceiling ctx expr)
(case (target-name (ctx-target ctx))
((js java php)
(^float-math 'ceil expr))
((python)
(^if-expr 'f64
(^and (^float-finite? expr)
(^!= expr (^float targ-inexact-+0)))
(^float-math 'ceil expr)
expr))
((ruby)
(^if-expr 'f64
(^and (^float-finite? expr)
(^!= expr (^float targ-inexact-+0)))
(^float-fromint (^call-prim (^member expr 'ceil)))
expr))
((go)
(^ "~~~TODO3:univ-emit-float-ceiling~~~"))
(else
(compiler-internal-error
"univ-emit-float-ceiling, unknown target"))))
(define (univ-ident-when-special-float ctx expr1 expr2)
(^if-expr 'f64
(^and (^float-finite? expr1)
(^!= expr1 (^float targ-inexact-+0)))
expr2
expr1))
(define (univ-emit-float-truncate ctx expr)
(case (target-name (ctx-target ctx))
((js php java python)
(univ-ident-when-special-float
ctx
expr
(^parens
(^if-expr 'f64
(^< expr (^float targ-inexact-+0))
(^float-math 'ceil expr)
(^float-math 'floor expr)))))
((ruby)
(univ-ident-when-special-float
ctx
expr
(^float-fromint (^call-prim (^member expr 'truncate)))))
((go)
(^ "~~~TODO3:univ-emit-float-truncate~~~"))
(else
(compiler-internal-error
"univ-emit-float-truncate, unknown target"))))
(define (univ-emit-float-round-half-up ctx expr)
(case (target-name (ctx-target ctx))
((js java)
(^float-math 'round expr))
((go)
(^ "~~~TODO3:univ-emit-float-round-half-up~~~"))
(else
(compiler-internal-error
"univ-emit-float-round-half-up, unknown target"))))
(define (univ-emit-float-round-half-towards-0 ctx expr)
(case (target-name (ctx-target ctx))
((php python)
;; python v2 rounds towards 0
(^call-prim 'round expr))
((ruby)
(^call-prim (^member expr 'round)))
((go)
(^ "~~~TODO3:univ-emit-float-round-half-towards-0~~~"))
(else
(compiler-internal-error
"univ-emit-float-round-half-towards-0, unknown target"))))
(define (univ-emit-float-round-half-to-even ctx expr)
(define (use-round-half-up)
(^- (^float-round-half-up expr)
(^parens
(^if-expr 'f64
(^&& (^!= (^float-mod expr (^float targ-inexact-+2))
(^float targ-inexact-+1/2))
(^!= (^float-mod expr (^float targ-inexact-+2))
(^float -1.5))) ;;;;;;;;;;;;;;;;
(^float targ-inexact-+0)
(^float targ-inexact-+1)))))
(define (use-round-half-towards-0)
(^+ (^float-round-half-towards-0 expr)
(^- (^parens
(^if-expr 'f64
(^= (^float-mod expr (^float targ-inexact-+2))
(^float (- targ-inexact-+1/2))) ;;;;;;;;;;;;;;;;;
(^float targ-inexact-+1)
(^float targ-inexact-+0)))
(^parens
(^if-expr 'f64
(^= (^float-mod expr (^float targ-inexact-+2))
(^float targ-inexact-+1/2))
(^float targ-inexact-+1)
(^float targ-inexact-+0))))))
(case (target-name (ctx-target ctx))
((js)
(use-round-half-up))
((java)
(univ-ident-when-special-float
ctx
expr
(use-round-half-up)))
((php ruby)
(univ-ident-when-special-float
ctx
expr
(use-round-half-towards-0)))
((python)
(univ-ident-when-special-float
ctx
expr
(if (univ-python-pre3? ctx)
(use-round-half-towards-0)
(^call-prim 'round expr))))
((go)
(^ "~~~TODO3:use-round-half-towards-0~~~"))
(else
(compiler-internal-error
"univ-emit-float-round-half-to-even, unknown target"))))
#|
JS:
for (var i=-8; i<=8; i++) print(i*0.5," ",(i*0.5)%2," ",Math.round(i*0.5));
-4 0 -4
-3.5 -1.5 -3 -1
-3 -1 -3
-2.5 -0.5 -2
-2 0 -2
-1.5 -1.5 -1 -1
-1 -1 -1
-0.5 -0.5 0
0 0 0
0.5 0.5 1 -1
1 1 1
1.5 1.5 2
2 0 2
2.5 0.5 3 -1
3 1 3
3.5 1.5 4
4 0 4
PHP:
i*0.5, fmod(i*0.5,2), round(i*0.5)
-4 0 -4
-3.5 -1.5 -4
-3 -1 -3
-2.5 -0.5 -3 +1
-2 0 -2
-1.5 -1.5 -2
-1 -1 -1
-0.5 -0.5 -1 +1
0 0 0
0.5 0.5 1 -1
1 1 1
1.5 1.5 2
2 0 2
2.5 0.5 3 -1
3 1 3
3.5 1.5 4
4 0 4
Python:
for i in range(-8,8):
print '%f %f %f' % ((i*0.5),math.fmod(i*0.5,2),round(i*0.5))
-4 0 -4
-3.5 -1.5 -4
-3 -1 -3
-2.5 -0.5 -3 +1
-2 0 -2
-1.5 -1.5 -2
-1 -1 -1
-0.5 -0.5 -1 +1
0 0 0
0.5 0.5 1 -1
1 1 1
1.5 1.5 2
2 0 2
2.5 0.5 3 -1
3 1 3
3.5 1.5 4
4 0 4
Ruby:
(-8..8).each {|i| puts (i*0.5),(i*0.5).remainder(2),(i*0.5).round}
-4.0 -0.0 -4
-3.5 -1.5 -4
-3.0 -1.0 -3
-2.5 -0.5 -3 +1
-2.0 -0.0 -2
-1.5 -1.5 -2
-1.0 -1.0 -1
-0.5 -0.5 -1 +1
0.0 0.0 0
0.5 0.5 1 -1
1.0 1.0 1
1.5 1.5 2
2.0 0.0 2
2.5 0.5 3 -1
3.0 1.0 3
3.5 1.5 4
4.0 0.0 4
|#
(define (univ-emit-float-mod ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js java)
(^ expr1 " % " expr2))
((php)
(^ "fmod(" expr1 "," expr2 ")"))
((python)
(^ "math.fmod(" expr1 "," expr2 ")"))
((ruby)
(^ expr1 ".remainder(" expr2 ")"))
((go)
(^ "~~~TODO3:univ-emit-float-mod~~~"))
(else
(compiler-internal-error
"univ-emit-float-fmod, unknown target"))))
(define (univ-emit-float-exp ctx expr)
(^float-math 'exp expr))
(define (univ-emit-float-expm1 ctx expr)
(case (target-name (ctx-target ctx))
((js python php java)
(^float-math 'expm1 expr))
((go)
(^ "~~~TODO3:univ-emit-float-expm1~~~"))
(else
(^call-prim (^rts-method-use 'expm1) expr))))
(define (univ-emit-float-log ctx expr)
(^float-math 'log expr))
(define (univ-emit-float-log1p ctx expr)
(case (target-name (ctx-target ctx))
((js python php java)
(^float-math 'log1p expr))
((go)
(^ "~~~TODO3:univ-emit-float-log1p~~~"))
(else
(^call-prim (^rts-method-use 'log1p) expr))))
(define (univ-emit-float-sin ctx expr)
(^float-math 'sin expr))
(define (univ-emit-float-cos ctx expr)
(^float-math 'cos expr))
(define (univ-emit-float-tan ctx expr)
(^float-math 'tan expr))
(define (univ-emit-float-asin ctx expr)
(^float-math 'asin expr))
(define (univ-emit-float-acos ctx expr)
(^float-math 'acos expr))
(define (univ-emit-float-atan ctx expr)
(^float-math 'atan expr))
(define (univ-emit-float-atan2 ctx expr1 expr2)
(^float-math 'atan2 expr1 expr2))
(define (univ-emit-float-sinh ctx expr)
(^float-math 'sinh expr))
(define (univ-emit-float-cosh ctx expr)
(^float-math 'cosh expr))
(define (univ-emit-float-tanh ctx expr)
(^float-math 'tanh expr))
(define (univ-emit-float-asinh ctx expr)
(case (target-name (ctx-target ctx))
((js python php ruby)
(^float-math 'asinh expr))
((go)
(^ "~~~TODO3:univ-emit-float-asinh~~~"))
(else
(^call-prim (^rts-method-use 'asinh) expr))))
(define (univ-emit-float-acosh ctx expr)
(case (target-name (ctx-target ctx))
((js php)
(^float-math 'acosh expr))
((go)
(^ "~~~TODO3:univ-emit-float-acosh~~~"))
(else
(^call-prim (^rts-method-use 'acosh) expr))))
(define (univ-emit-float-atanh ctx expr)
(case (target-name (ctx-target ctx))
((js php)
(^float-math 'atanh expr))
((go)
(^ "~~~TODO3:univ-emit-float-atanh~~~"))
(else
(^call-prim (^rts-method-use 'atanh) expr))))
(define (univ-emit-float-expt ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js python php java)
(^float-math 'pow expr1 expr2))
((ruby)
(^ expr1 " ** " expr2))
((go)
(^ "~~~TODO3:univ-emit-float-expt~~~"))
(else
(compiler-internal-error
"univ-emit-float-expt, unknown target"))))
(define (univ-emit-float-sqrt ctx expr)
(^float-math 'sqrt expr))
(define (univ-emit-float-scalbn ctx expr1 expr2)
(case (target-name (ctx-target ctx))
;; scalbn(x,n) = x * FLT_RADIX^n
;; If FLT_RADIX is 2, scalbn is equivalent to ldexp
((js)
(^call-prim (^rts-method-use 'ldexp) expr1 expr2))
((python)
(^call-prim (^member 'math 'ldexp) expr1 expr2))
;; TODO : possible loss of precision here
((ruby)
(^parens (^ expr1 " * 2 **" expr2)))
((java)
(^parens (^ expr1 " * Math.pow(2, " expr2 ")")))
((php)
(^parens (^ expr1 " * pow(2, " expr2 ")")))
((go)
(^ "~~~TODO3:univ-emit-float-scalbn~~~"))
(else
(compiler-internal-error
"univ-emit-float-scalbn, unknown target"))))
;; Integer exponent of a floating-point value
(define (univ-emit-float-ilogb ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^call-prim (^rts-method-use 'ilogb) expr))
;; Since FLT_RADIX = 2, ilogb is one less than the exponent returned by frexp
((python)
(^parens (^ "math.frexp(" (^float-abs expr) ")[1] - 1")))
;; Most of the time, ilogb(expr) is equivalent to (int) floor(log2(abs(expr)))
;; FIXME : doesn't work with maximum double
((php)
(^call-prim 'floor (^call-prim 'log (^float-abs expr) 2)))
((ruby)
(^float-toint (^call-prim (^member 'Math 'log2) (^float-abs expr))))
((java)
(^cast 'int
(^/ (^call-prim (^member 'Math 'log) (^float-abs expr))
(^call-prim (^member 'Math 'log) (^float 2.0)))))
((go)
(^ "~~~TODO3:univ-emit-float-ilogb~~~"))
(else
(compiler-internal-error
"univ-emit-float-ilogb, unknown target"))))
#;
(
;; PHP Math functions
abs
acos
acosh
asin
asinh
atan2
atan
atanh
base_ convert
bindec
ceil
cos
cosh
decbin
dechex
decoct
deg2rad
exp
expm1
floor
fmod
getrandmax
hexdec
hypot
is_finite
is_infinite
is_nan
lcg_value
log10
log1p
log
max
min
mt_ getrandmax
mt_ rand
mt_ srand
octdec
pi
pow
rad2deg
rand
round
sin
sinh
sqrt
srand
tan
tanh
)
(define (univ-emit-float-integer? ctx expr)
(^&& (^not (^parens (^float-infinite? expr)))
(^= expr (^float-floor expr))))
(define (univ-emit-float-finite? ctx expr)
(case (target-name (ctx-target ctx))
((php)
(^call-prim "is_finite" expr))
((ruby)
(^call-prim (^member expr 'finite?)))
(else
;;TODO: move constants elsewhere
(^&& (^>= expr (^float -1.7976931348623151e308))
(^<= expr (^float 1.7976931348623151e308))))))
(define (univ-emit-float-infinite? ctx expr)
(case (target-name (ctx-target ctx))
((php)
(^call-prim "is_infinite" expr))
(else
;;TODO: move constants elsewhere
(^or (^< expr (^float -1.7976931348623151e308))
(^> expr (^float 1.7976931348623151e308))))))
(define (univ-emit-float-nan? ctx expr)
(case (target-name (ctx-target ctx))
((php)
(^call-prim "is_nan" expr))
((ruby)
(^call-prim (^member expr 'nan?)))
(else
(^!= expr expr))))
(define (univ-emit-float-copysign ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((java)
(^float-math 'copySign expr1 expr2))
(else
(^float-math 'copysign expr1 expr2))))
(define (univ-float-has-negative-sign? ctx expr)
(^parens
(^or (^parens (^< expr
(^float targ-inexact-+0)))
(^parens (^< (^/ (^float targ-inexact-+1)
expr)
(^float targ-inexact-+0))))))
(define (univ-floats-have-same-sign? ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((python java)
(^= (^float-copysign
(^float targ-inexact-+1)
expr1)
(^float-copysign
(^float targ-inexact-+1)
expr2)))
((ruby)
;; 0.0.angle => 0.0, -0.0.angle => 3.1415...
(^= (^call-prim (^member expr1 'angle))
(^call-prim (^member expr2 'angle))))
(else
(^= (univ-float-has-negative-sign? ctx expr1)
(univ-float-has-negative-sign? ctx expr2)))))
(define (univ-emit-float-eqv? ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js)
(^call-prim (^member "Object" 'is) expr1 expr2))
((php)
(^eq? (^call-prim "strval" expr1)
(^call-prim "strval" expr2)))
(else
(^parens
(^if-expr 'f64
(^= expr1 expr2)
(univ-floats-have-same-sign? ctx expr1 expr2)
(^and (^float-nan? expr1)
(^float-nan? expr2)))))))
(define (univ-emit-flonum-box ctx expr)
(case (univ-flonum-representation ctx)
((class)
(univ-box
(^new 'flonum expr)
expr))
(else
expr)))
(define (univ-emit-flonum-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-flonum-representation ctx)
((class)
(^member (^cast* 'flonum expr) (^public 'val)))
(else
(^downcast* 'float expr)))))
(define (univ-emit-flonum? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_flonum) expr))
(else
(case (univ-flonum-representation ctx)
((class)
(^instanceof (^type 'flonum) (^cast*-scmobj expr)))
(else
(^float? expr))))))
(define (univ-emit-cpxnum-make ctx expr1 expr2)
(^new 'cpxnum expr1 expr2))
(define (univ-emit-cpxnum? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_cpxnum) expr))
(else
(^instanceof (^type 'cpxnum) (^cast*-scmobj expr)))))
(define (univ-emit-ratnum-make ctx expr1 expr2)
(^new 'ratnum expr1 expr2))
(define (univ-emit-ratnum? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_ratnum) expr))
(else
(^instanceof (^type 'ratnum) (^cast*-scmobj expr)))))
(define (univ-emit-bignum ctx expr1)
(^new 'bignum expr1))
(define (univ-emit-bignum? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_bignum) expr))
(else
(^instanceof (^type 'bignum) (^cast*-scmobj expr)))))
(define (univ-emit-bignum-digits ctx val)
(^member (^cast* 'bignum val) (^public 'digits)))
(define (univ-emit-u32-box ctx n)
(^call-prim (^rts-method-use 'u32_box) n))
(define (univ-emit-u32-unbox ctx n)
(^call-prim (^rts-method-use 'u32_unbox) n))
(define (univ-emit-s32-box ctx n)
(^call-prim (^rts-method-use 's32_box) n))
(define (univ-emit-s32-unbox ctx n)
(^call-prim (^rts-method-use 's32_unbox) n))
(define (univ-emit-u64-box ctx n)
n)
(define (univ-emit-u64-unbox ctx n)
n)
(define (univ-emit-s64-box ctx n)
n)
(define (univ-emit-s64-unbox ctx n)
n)
(define (univ-emit-box? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_box) expr))
(else
(^instanceof (^type 'box) (^cast*-scmobj expr)))))
(define (univ-emit-box ctx expr)
(^new 'box expr))
(define (univ-emit-unbox ctx expr)
(^member (^cast* 'box expr) (^public 'val)))
(define (univ-emit-setbox ctx expr1 expr2)
(^assign (^member expr1 (^public 'val)) expr2))
(define (univ-emit-values-box ctx expr)
(case (univ-values-representation ctx)
((class)
(^new 'values expr))
(else
expr)))
(define (univ-emit-values-unbox ctx expr)
(case (univ-values-representation ctx)
((class)
(^member (^cast* 'values expr) (^public 'vals)))
(else
expr)))
(define (univ-emit-values? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_values) expr))
(else
(case (univ-values-representation ctx)
((class)
(^instanceof (^type 'values) (^cast*-scmobj expr)))
(else
(^array? expr))))))
(define (univ-emit-values-length ctx expr)
(^array-length (^values-unbox expr)))
(define (univ-emit-values-ref ctx expr1 expr2)
(^array-index (^values-unbox expr1) expr2))
(define (univ-emit-values-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^values-unbox expr1) expr2) expr3))
(define (univ-emit-vect-box ctx type expr)
(case type
((scmobj) (univ-emit-vector-box ctx expr))
((u8) (univ-emit-u8vector-box ctx expr))
((u16) (univ-emit-u16vector-box ctx expr))
((u32) (univ-emit-u32vector-box ctx expr))
((u64) (univ-emit-u64vector-box ctx expr))
((s8) (univ-emit-s8vector-box ctx expr))
((s16) (univ-emit-s16vector-box ctx expr))
((s32) (univ-emit-s32vector-box ctx expr))
((s64) (univ-emit-s64vector-box ctx expr))
((f32) (univ-emit-f32vector-box ctx expr))
((f64) (univ-emit-f64vector-box ctx expr))
(else
(compiler-internal-error
"univ-emit-vect-box, type not implemented"))))
(define (univ-emit-vect-unbox ctx type expr)
(case type
((scmobj) (univ-emit-vector-unbox ctx expr))
((u8) (univ-emit-u8vector-unbox ctx expr))
((u16) (univ-emit-u16vector-unbox ctx expr))
((u32) (univ-emit-u32vector-unbox ctx expr))
((u64) (univ-emit-u64vector-unbox ctx expr))
((s8) (univ-emit-s8vector-unbox ctx expr))
((s16) (univ-emit-s16vector-unbox ctx expr))
((s32) (univ-emit-s32vector-unbox ctx expr))
((s64) (univ-emit-s64vector-unbox ctx expr))
((f32) (univ-emit-f32vector-unbox ctx expr))
((f64) (univ-emit-f64vector-unbox ctx expr))
(else
(compiler-internal-error
"univ-emit-vect-unbox, type not implemented"))))
(define (univ-emit-vect? ctx type expr)
(case type
((scmobj) (univ-emit-vector? ctx expr))
((u8) (univ-emit-u8vector? ctx expr))
((u16) (univ-emit-u16vector? ctx expr))
((u32) (univ-emit-u32vector? ctx expr))
((u64) (univ-emit-u64vector? ctx expr))
((s8) (univ-emit-s8vector? ctx expr))
((s16) (univ-emit-s16vector? ctx expr))
((s32) (univ-emit-s32vector? ctx expr))
((s64) (univ-emit-s64vector? ctx expr))
((f32) (univ-emit-f32vector? ctx expr))
((f64) (univ-emit-f64vector? ctx expr))
(else
(compiler-internal-error
"univ-emit-vect?, type not implemented"))))
(define (univ-emit-vector-box ctx expr)
(case (univ-vector-representation ctx)
((class)
(^new 'vector expr))
(else
expr)))
(define (univ-emit-vector-unbox ctx expr)
(case (univ-vector-representation ctx)
((class)
(^member (^cast* 'vector expr) (^public 'elems)))
(else
(^downcast* '(array scmobj) expr))))
(define (univ-emit-vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_vector) expr))
(else
(case (univ-vector-representation ctx)
((class)
(^instanceof (^type 'vector) (^cast*-scmobj expr)))
(else
(^array? expr))))))
(define (univ-emit-vector-length ctx expr)
(^array-length (^vector-unbox expr)))
(define (univ-emit-vector-shrink! ctx expr1 expr2)
(^array-shrink! (^vector-unbox expr1) expr2))
(define (univ-emit-vector-ref ctx expr1 expr2)
(^array-index (^vector-unbox expr1) expr2))
(define (univ-emit-vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^vector-unbox expr1) expr2) expr3))
(define (univ-emit-u8vector-box ctx expr)
(case (univ-u8vector-representation ctx)
((class)
(^new 'u8vector expr))
(else
expr)))
(define (univ-emit-u8vector-unbox ctx expr)
(case (univ-u8vector-representation ctx)
((class)
(^member (^cast* 'u8vector expr) (^public 'elems)))
(else
(^downcast* '(array u8) expr))))
(define (univ-emit-u8vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_u8vector) expr))
(else
(case (univ-u8vector-representation ctx)
((class)
(^instanceof (^type 'u8vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array u8)) expr))))))
(define (univ-emit-u8vector-length ctx expr)
(^array-length (^u8vector-unbox expr)))
(define (univ-shrink-by-copying-elems! ctx type expr1 expr2)
(^assign (^member (^cast* type expr1) (^public 'elems))
(case (target-name (ctx-target ctx))
((js)
(^call-prim (^member (^member (^cast* type expr1) (^public 'elems)) 'subarray)
(^int 0)
expr2))
(else
(^subarray (^member (^cast* type expr1) (^public 'elems))
0
expr2)))))
(define (univ-emit-u8vector-shrink! ctx expr1 expr2)
(case (univ-u8vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 'u8vector expr1 expr2))
(else
(^array-shrink! (^u8vector-unbox expr1) expr2))))
(define (univ-emit-u8vector-ref ctx expr1 expr2)
(let ((code (^array-index (^u8vector-unbox expr1) expr2)))
(case (target-name (ctx-target ctx))
((java) (^parens (^bitand (^int #xff) code)))
(else code))))
(define (univ-emit-u8vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^u8vector-unbox expr1) expr2) expr3))
(define (univ-emit-u16vector-box ctx expr)
(case (univ-u16vector-representation ctx)
((class)
(^new 'u16vector expr))
(else
(^downcast* '(array u16) expr))))
(define (univ-emit-u16vector-unbox ctx expr)
(case (univ-u16vector-representation ctx)
((class)
(^member (^cast* 'u16vector expr) (^public 'elems)))
(else
expr)))
(define (univ-emit-u16vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_u16vector) expr))
(else
(case (univ-u16vector-representation ctx)
((class)
(^instanceof (^type 'u16vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array u16)) expr))))))
(define (univ-emit-u16vector-length ctx expr)
(^array-length (^u16vector-unbox expr)))
(define (univ-emit-u16vector-shrink! ctx expr1 expr2)
(case (univ-u16vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 'u16vector expr1 expr2))
(else
(^array-shrink! (^u16vector-unbox expr1) expr2))))
(define (univ-emit-u16vector-ref ctx expr1 expr2)
(let ((code (^array-index (^u16vector-unbox expr1) expr2)))
(case (target-name (ctx-target ctx))
((java) (^parens (^bitand (^int #xffff) code)))
(else code))))
(define (univ-emit-u16vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^u16vector-unbox expr1) expr2) expr3))
(define (univ-emit-u32vector-box ctx expr)
(case (univ-u32vector-representation ctx)
((class)
(^new 'u32vector expr))
(else
expr)))
(define (univ-emit-u32vector-unbox ctx expr)
(case (univ-u32vector-representation ctx)
((class)
(^member (^cast* 'u32vector expr) (^public 'elems)))
(else
(^downcast* '(array u32) expr))))
(define (univ-emit-u32vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_u32vector) expr))
(else
(case (univ-u32vector-representation ctx)
((class)
(^instanceof (^type 'u32vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array u32)) expr))))))
(define (univ-emit-u32vector-length ctx expr)
(^array-length (^u32vector-unbox expr)))
(define (univ-emit-u32vector-shrink! ctx expr1 expr2)
(case (univ-u32vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 'u32vector expr1 expr2))
(else
(^array-shrink! (^u32vector-unbox expr1) expr2))))
(define (univ-emit-u32vector-ref ctx expr1 expr2)
(^array-index (^u32vector-unbox expr1) expr2))
(define (univ-emit-u32vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^u32vector-unbox expr1) expr2) expr3))
(define (univ-emit-u64vector-box ctx expr)
(case (univ-u64vector-representation ctx)
((class)
(^new 'u64vector expr))
(else
expr)))
(define (univ-emit-u64vector-unbox ctx expr)
(case (univ-u64vector-representation ctx)
((class)
(^member (^cast* 'u64vector expr) (^public 'elems)))
(else
(^downcast* '(array u64) expr))))
(define (univ-emit-u64vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_u64vector) expr))
(else
(case (univ-u64vector-representation ctx)
((class)
(^instanceof (^type 'u64vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array u64)) expr))))))
(define (univ-emit-u64vector-length ctx expr)
(^array-length (^u64vector-unbox expr)))
(define (univ-emit-u64vector-shrink! ctx expr1 expr2)
(case (univ-u64vector-representation ctx)
;; ((class)
;; (univ-shrink-by-copying-elems! ctx 'u64vector expr1 expr2))
(else
(^array-shrink! (^u64vector-unbox expr1) expr2))))
(define (univ-emit-u64vector-ref ctx expr1 expr2)
(^array-index (^u64vector-unbox expr1) expr2))
(define (univ-emit-u64vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^u64vector-unbox expr1) expr2) expr3))
(define (univ-emit-s8vector-box ctx expr)
(case (univ-s8vector-representation ctx)
((class)
(^new 's8vector expr))
(else
expr)))
(define (univ-emit-s8vector-unbox ctx expr)
(case (univ-s8vector-representation ctx)
((class)
(^member (^cast* 's8vector expr) (^public 'elems)))
(else
(^downcast* '(array s8) expr))))
(define (univ-emit-s8vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_s8vector) expr))
(else
(case (univ-s8vector-representation ctx)
((class)
(^instanceof (^type 's8vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array s8)) expr))))))
(define (univ-emit-s8vector-length ctx expr)
(^array-length (^s8vector-unbox expr)))
(define (univ-emit-s8vector-shrink! ctx expr1 expr2)
(case (univ-s8vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 's8vector expr1 expr2))
(else
(^array-shrink! (^s8vector-unbox expr1) expr2))))
(define (univ-emit-s8vector-ref ctx expr1 expr2)
(^array-index (^s8vector-unbox expr1) expr2))
(define (univ-emit-s8vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^s8vector-unbox expr1) expr2) expr3))
(define (univ-emit-s16vector-box ctx expr)
(case (univ-s16vector-representation ctx)
((class)
(^new 's16vector expr))
(else
expr)))
(define (univ-emit-s16vector-unbox ctx expr)
(case (univ-s16vector-representation ctx)
((class)
(^member (^cast* 's16vector expr) (^public 'elems)))
(else
(^downcast* '(array s16) expr))))
(define (univ-emit-s16vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_s16vector) expr))
(else
(case (univ-s16vector-representation ctx)
((class)
(^instanceof (^type 's16vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array s16)) expr))))))
(define (univ-emit-s16vector-length ctx expr)
(^array-length (^s16vector-unbox expr)))
(define (univ-emit-s16vector-shrink! ctx expr1 expr2)
(case (univ-s16vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 's16vector expr1 expr2))
(else
(^array-shrink! (^s16vector-unbox expr1) expr2))))
(define (univ-emit-s16vector-ref ctx expr1 expr2)
(^array-index (^s16vector-unbox expr1) expr2))
(define (univ-emit-s16vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^s16vector-unbox expr1) expr2) expr3))
(define (univ-emit-s32vector-box ctx expr)
(case (univ-s32vector-representation ctx)
((class)
(^new 's32vector expr))
(else
expr)))
(define (univ-emit-s32vector-unbox ctx expr)
(case (univ-s32vector-representation ctx)
((class)
(^member (^cast* 's32vector expr) (^public 'elems)))
(else
(^downcast* '(array s32) expr))))
(define (univ-emit-s32vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_s32vector) expr))
(else
(case (univ-s32vector-representation ctx)
((class)
(^instanceof (^type 's32vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array s32)) expr))))))
(define (univ-emit-s32vector-length ctx expr)
(^array-length (^s32vector-unbox expr)))
(define (univ-emit-s32vector-shrink! ctx expr1 expr2)
(case (univ-s32vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 's32vector expr1 expr2))
(else
(^array-shrink! (^s32vector-unbox expr1) expr2))))
(define (univ-emit-s32vector-ref ctx expr1 expr2)
(^array-index (^s32vector-unbox expr1) expr2))
(define (univ-emit-s32vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^s32vector-unbox expr1) expr2) expr3))
(define (univ-emit-s64vector-box ctx expr)
(case (univ-s64vector-representation ctx)
((class)
(^new 's64vector expr))
(else
expr)))
(define (univ-emit-s64vector-unbox ctx expr)
(case (univ-s64vector-representation ctx)
((class)
(^member (^cast* 's64vector expr) (^public 'elems)))
(else
(^downcast* '(array s64) expr))))
(define (univ-emit-s64vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_s64vector) expr))
(else
(case (univ-s64vector-representation ctx)
((class)
(^instanceof (^type 's64vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array s64)) expr))))))
(define (univ-emit-s64vector-length ctx expr)
(^array-length (^s64vector-unbox expr)))
(define (univ-emit-s64vector-shrink! ctx expr1 expr2)
(case (univ-s64vector-representation ctx)
;; ((class)
;; (univ-shrink-by-copying-elems! ctx 's64vector expr1 expr2))
(else
(^array-shrink! (^s64vector-unbox expr1) expr2))))
(define (univ-emit-s64vector-ref ctx expr1 expr2)
(^array-index (^s64vector-unbox expr1) expr2))
(define (univ-emit-s64vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^s64vector-unbox expr1) expr2) expr3))
(define (univ-emit-f32vector-box ctx expr)
(case (univ-f32vector-representation ctx)
((class)
(^new 'f32vector expr))
(else
expr)))
(define (univ-emit-f32vector-unbox ctx expr)
(case (univ-f32vector-representation ctx)
((class)
(^member (^cast* 'f32vector expr) (^public 'elems)))
(else
(^downcast* '(array f32) expr))))
(define (univ-emit-f32vector? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_f32vector) expr))
(else
(case (univ-f32vector-representation ctx)
((class)
(^instanceof (^type 'f32vector) (^cast*-scmobj expr)))
(else
(^instanceof (^type '(array f32)) expr))))))
(define (univ-emit-f32vector-length ctx expr)
(^array-length (^f32vector-unbox expr)))
(define (univ-emit-f32vector-shrink! ctx expr1 expr2)
(case (univ-f32vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 'f32vector expr1 expr2))
(else
(^array-shrink! (^f32vector-unbox expr1) expr2))))
(define (univ-emit-f32vector-ref ctx expr1 expr2)
(^array-index (^f32vector-unbox expr1) expr2))
(define (univ-emit-f32vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^f32vector-unbox expr1) expr2) expr3))
(define (univ-emit-f64vector-box ctx expr)
(case (univ-f64vector-representation ctx)
((class)
(^new 'f64vector expr))
(else
expr)))
(define (univ-emit-f64vector-unbox ctx expr)
(case (univ-f64vector-representation ctx)
((class)
(^member (^cast* 'f64vector expr) (^public 'elems)))
(else
(^downcast* '(array f64) expr))))
(define (univ-emit-f64vector? ctx expr)
(case (univ-f64vector-representation ctx)
((class)
(^instanceof (^type 'f64vector) (^cast*-scmobj expr)))
(else
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_f64vector) expr))
(else
(^instanceof (^type '(array f64)) expr))))))
(define (univ-emit-f64vector-length ctx expr)
(^array-length (^f64vector-unbox expr)))
(define (univ-emit-f64vector-shrink! ctx expr1 expr2)
(case (univ-f64vector-representation ctx)
((class)
(univ-shrink-by-copying-elems! ctx 'f64vector expr1 expr2))
(else
(^array-shrink! (^f64vector-unbox expr1) expr2))))
(define (univ-emit-f64vector-ref ctx expr1 expr2)
(^array-index (^f64vector-unbox expr1) expr2))
(define (univ-emit-f64vector-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^f64vector-unbox expr1) expr2) expr3))
(define (univ-emit-structure-box ctx expr)
(case (univ-structure-representation ctx)
((class)
(^new 'structure expr))
(else
(compiler-internal-error
"univ-emit-structure-box, host representation not implemented"))))
(define (univ-emit-structure-unbox ctx expr)
(case (univ-structure-representation ctx)
((class)
(^member (^cast* 'structure expr) (^public 'slots)))
(else
(compiler-internal-error
"univ-emit-structure-unbox, host representation not implemented"))))
(define (univ-emit-structure? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_structure) expr))
(else
(case (univ-structure-representation ctx)
((class)
(^instanceof (^type 'structure) (^cast*-scmobj expr)))
(else
(compiler-internal-error
"univ-emit-structure?, host representation not implemented"))))))
(define (univ-emit-structure-ref ctx expr1 expr2)
(^array-index (^structure-unbox expr1) expr2))
(define (univ-emit-structure-set! ctx expr1 expr2 expr3)
(^assign (^array-index (^structure-unbox expr1) expr2) expr3))
(define (univ-emit-str ctx val)
(univ-constant
(case (target-name (ctx-target ctx))
((js java go)
(cdr (univ-convert-string val #\" #\")))
((php)
(let ((val-utf8
(list->string
(map integer->char
(u8vector->list
(call-with-output-u8vector
(list init: '#u8() char-encoding: 'UTF-8)
(lambda (port) (univ-display val port))))))))
(cdr (univ-convert-string val-utf8 #\" #\$))))
((python)
(let ((x (univ-convert-string val #\" #\")))
(if (car x) (cons "u" (cdr x)) (cdr x))))
((ruby)
(cdr (univ-convert-string val #\" #\#)))
(else
(compiler-internal-error
"univ-emit-str, unknown target")))))
(define (univ-convert-string str delim special)
(let ((unicode? #f))
(let loop ((i 0) (j 0) (rev-chunks (list (string delim))))
(define (done rev-chunks)
(cons unicode? (reverse (cons (string delim) rev-chunks))))
(define (add i j)
(if (= i j)
rev-chunks
(cons (substring str i j) rev-chunks)))
(if (= j (string-length str))
(done (add i j))
(let ((next-j (+ j 1))
(c (string-ref str j)))
(if (or (char=? c #\\)
(char=? c delim)
(char=? c special))
(loop next-j
next-j
(cons (string #\\ c)
(add i j)))
(let ((n (char->integer c)))
(cond ((< n #x100)
(if (or (< n 32) (>= n 127))
(let ((x (number->string (+ #x100 n) 16)))
(loop next-j
next-j
(cons (string-append "\\x"
(substring x 1 3))
(add i j))))
(loop i
(+ j 1)
rev-chunks)))
((< n #x10000)
(let ((x (number->string (+ #x10000 n) 16)))
(set! unicode? #t)
(loop next-j
next-j
(cons (string-append "\\u"
(substring x 1 5))
(add i j)))))
(else
(let* ((hi (quotient (- n #x10000) #x400))
(lo (modulo n #x400))
(hi-x (number->string (+ #xd800 hi) 16))
(lo-x (number->string (+ #xdc00 lo) 16)))
(set! unicode? #t)
(loop next-j
next-j
(cons (string-append "\\u" hi-x "\\u" lo-x)
(add i j)))))))))))))
(define (univ-emit-str-to-codes ctx str)
(case (univ-string-representation ctx)
((class)
(^call-prim
(^rts-method-use 'str2codes)
str))
(else
str)))
(define (univ-str-to-array-literal ctx str)
(^array-literal
'unicode
(map (lambda (c) (^int (char->integer c)))
(string->list str))))
(define (univ-emit-str-length ctx str)
(case (target-name (ctx-target ctx))
((js ruby)
(^ str ".length"))
((php)
(^ "strlen(" str ")"))
((python go)
(^ "len(" str ")"))
((java)
(^ str ".length()"))
(else
(compiler-internal-error
"univ-emit-str-length, unknown target"))))
(define (univ-emit-str-index-code ctx str i)
(case (target-name (ctx-target ctx))
((js)
(^call-prim (^member str 'charCodeAt) i))
((php)
(^call-prim "ord" (^call-prim "substr" str i (^int 1))));;TODO fix for unicode characters
((python)
(^call-prim "ord" (^ str "[" i "]")))
((ruby)
(^ str "[" i "]" ".ord"))
((java)
(^call-prim (^member str 'codePointAt) i))
((go)
(^ str "[" i "]"))
(else
(compiler-internal-error
"univ-emit-str-index-code, unknown target"))))
(define (univ-emit-string-obj ctx obj force-var?)
(case (univ-string-representation ctx)
((class)
(let ((x (univ-str-to-array-literal ctx obj)))
(univ-obj-use
ctx
obj
force-var?
(lambda ()
(^string-box x)))))
(else
(case (target-name (ctx-target ctx))
((go)
(univ-str-to-array-literal ctx obj))
(else
(^str obj))))))
(define (univ-emit-string-box ctx expr)
(case (univ-string-representation ctx)
((class)
(^new 'string expr))
(else
expr)))
(define (univ-emit-string-unbox ctx expr)
(case (univ-string-representation ctx)
((class)
(^member (^cast* 'string expr) (^public 'codes)))
(else
(case (target-name (ctx-target ctx))
((go)
(^downcast* '(array unicode) expr))
(else
expr)))))
(define (univ-emit-string? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_string) expr))
(else
(case (univ-string-representation ctx)
((class)
(^instanceof (^type 'string) (^cast*-scmobj expr)))
(else
(^str? expr))))))
(define (univ-emit-string-length ctx expr)
(case (univ-string-representation ctx)
((class)
(^array-length (^string-unbox expr)))
(else
(compiler-internal-error
"univ-emit-string-length, host representation not implemented"))))
(define (univ-emit-string-shrink! ctx expr1 expr2)
(case (univ-string-representation ctx)
((class)
(^array-shrink! (^string-unbox expr1) expr2))
(else
(compiler-internal-error
"univ-emit-string-shrink!, host representation not implemented"))))
(define (univ-emit-string-ref ctx expr1 expr2)
(case (univ-string-representation ctx)
((class)
(^array-index expr1 expr2))
(else
(^str-index-code expr1 expr2))))
(define (univ-emit-string-set! ctx expr1 expr2 expr3)
(case (univ-string-representation ctx)
((class)
(^assign (^array-index expr1 expr2) expr3))
(else
;; mutable strings do not exist in js, php, python and ruby
(compiler-internal-error
"univ-emit-string-set!, host representation not implemented"))))
(define (univ-emit-substring ctx expr1 expr2 expr3)
(case (target-name (ctx-target ctx))
((js python ruby)
(^subarray expr1 expr2 expr3))
((php)
(^call-prim 'substr expr1 expr2 expr3))
;; TODO : Java
((go)
(^ "~~~TODO3:univ-emit-substring~~~"))
(else
(compiler-internal-error
"univ-emit-substring, unknown target"))))
(define (univ-emit-str-toint ctx expr)
(case (target-name (ctx-target ctx))
((js php)
(^ "+" expr))
((python)
(^call-prim 'int expr))
((ruby)
(^call-member expr 'to_i))
((java)
(^call-member 'Integer 'parseInt expr))
((go)
(^ "~~~TODO3:univ-emit-str-toint~~~"))
(else
(compiler-internal-error
"univ-emit-str-toint, unknown target"))))
(define (univ-emit-str-tofloat ctx expr)
(case (target-name (ctx-target ctx))
((js php)
(^ "+" expr))
((python)
(^call-prim 'float expr))
((ruby)
(^call-member expr 'to_f))
((java)
(^call-member 'Float 'parseFloat expr))
((go)
(^ "~~~TODO3:univ-emit-str-tofloat~~~"))
(else
(compiler-internal-error
"univ-emit-str-tofloat, unknown target"))))
(define (univ-emit-symbol-obj ctx obj force-var?)
(case (univ-symbol-representation ctx)
((class)
(let ((x (^str (symbol->string obj))))
(univ-box
(univ-obj-use
ctx
obj
force-var?
(lambda ()
(^symbol-box x)))
x)))
(else
(case (target-name (ctx-target ctx))
((js php python)
(^str (symbol->string obj)))
((ruby)
(univ-constant (^ ":" (^str (symbol->string obj)))))
((go)
(^ "~~~TODO3:univ-emit-symbol-obj~~~"))
(else
(compiler-internal-error
"univ-emit-symbol-obj, unknown target"))))))
(define (univ-emit-symbol-box ctx name)
(case (univ-symbol-representation ctx)
((class)
(univ-box
(^call-prim
(^rts-method-use 'make_interned_symbol)
name)
name))
(else
(^symbol-box-uninterned name #f))))
(define (univ-emit-symbol-box-uninterned ctx name hash)
(case (univ-symbol-representation ctx)
((class)
(univ-box
(^new 'symbol name hash (^obj #f))
name))
(else
(case (target-name (ctx-target ctx))
((js php python)
name)
((ruby)
(^ name ".to_sym"))
(else
(compiler-internal-error
"univ-emit-symbol-box-uninterned, unknown target"))))))
(define (univ-emit-symbol-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-symbol-representation ctx)
((class)
(^member (^cast* 'symbol expr) (^public 'name)))
(else
(case (target-name (ctx-target ctx))
((js php python)
expr)
((ruby)
(^ expr ".to_s"))
((go)
(^ "~~~TODO3:univ-emit-symbol-unbox~~~"))
(else
(compiler-internal-error
"univ-emit-symbol-unbox, unknown target")))))))
(define (univ-emit-symbol? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_symbol) expr))
(else
(case (univ-symbol-representation ctx)
((class)
(^instanceof (^type 'symbol) (^cast*-scmobj expr)))
(else
(case (target-name (ctx-target ctx))
((js)
(^typeof "string" expr))
((php)
(^call-prim "is_string" expr))
((python)
(^instanceof "str" expr))
((ruby)
(^instanceof "Symbol" expr))
(else
(compiler-internal-error
"univ-emit-symbol?, unknown target"))))))))
(define (univ-emit-keyword-obj ctx obj force-var?)
(case (univ-keyword-representation ctx)
((class)
(let ((x (^str (keyword->string obj))))
(univ-box
(univ-obj-use
ctx
obj
force-var?
(lambda ()
(^keyword-box x)))
x)))
(else
(compiler-internal-error
"univ-emit-keyword-box, host representation not implemented"))))
(define (univ-emit-keyword-box ctx name)
(case (univ-keyword-representation ctx)
((class)
(univ-box
(^call-prim
(^rts-method-use 'make_interned_keyword)
name)
name))
(else
(^keyword-box-uninterned name #f))))
(define (univ-emit-keyword-box-uninterned ctx name hash)
(case (univ-keyword-representation ctx)
((class)
(univ-box
(^new 'keyword name hash (^obj #f))
name))
(else
(case (target-name (ctx-target ctx))
((js php python)
name)
((ruby)
(^ name ".to_sym"))
(else
(compiler-internal-error
"univ-emit-keyword-box-uninterned, unknown target"))))))
(define (univ-emit-keyword-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-keyword-representation ctx)
((class)
(^member (^cast* 'keyword expr) (^public 'name)))
(else
(compiler-internal-error
"univ-emit-keyword-unbox, host representation not implemented")))))
(define (univ-emit-keyword? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_keyword) expr))
(else
(case (univ-keyword-representation ctx)
((class)
(^instanceof (^type 'keyword) (^cast*-scmobj expr)))
(else
(compiler-internal-error
"univ-emit-keyword?, host representation not implemented"))))))
(define (univ-emit-frame-box ctx expr)
(case (univ-frame-representation ctx)
((class)
(univ-box
(^new 'frame expr)
expr))
(else
expr)))
(define (univ-emit-frame-unbox ctx expr)
(or (univ-unbox expr)
(case (univ-frame-representation ctx)
((class)
(^member (^cast* 'frame expr)
(^public 'slots)))
(else
(^downcast* 'frm expr)))))
(define (univ-emit-frame-slots ctx expr)
(or (univ-unbox expr)
(case (univ-frame-representation ctx)
((class)
(^member expr
(^public 'slots)))
(else
expr))))
(define (univ-emit-frame? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_frame) expr))
(else
(case (univ-frame-representation ctx)
((class)
(^instanceof (^type 'frame) (^cast*-scmobj expr)))
(else
(^array? expr))))))
(define (univ-emit-new-continuation ctx expr1 expr2)
(^new 'continuation expr1 expr2))
(define (univ-emit-continuation? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_continuation) expr))
(else
(^instanceof (^type 'continuation) (^cast*-scmobj expr)))))
(define (univ-emit-function? ctx expr)
(case (target-name (ctx-target ctx))
((js)
(^typeof "function" expr))
((php)
(^call-prim "is_callable" expr))
((python)
(^ "hasattr(" expr ", '__call__')"))
((ruby)
(^instanceof "Proc" expr))
((go)
(^ "~~~TODO3:univ-emit-function?~~~"))
(else
(compiler-internal-error
"univ-emit-function?, unknown target"))))
(define (univ-emit-procedure? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_procedure) expr))
(else
(case (univ-procedure-representation ctx)
((class)
;; this accounts for procedure control-points and closures
(^instanceof (^type 'jumpable) (^cast*-scmobj expr)))
(else
(^function? expr))))))
(define (univ-emit-return? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_return) expr))
(else
(case (univ-procedure-representation ctx)
((class)
(^instanceof (^type 'returnpt) (^cast*-scmobj expr)))
(else
(^bool #f)))))) ;;TODO: implement
(define (univ-emit-closure? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_closure) expr))
(else
(case (univ-procedure-representation ctx)
((class)
(^instanceof (^type 'closure) (^cast*-scmobj expr)))
(else
(case (target-name (ctx-target ctx))
((js)
(^not (^prop-index-exists? expr (^str "id"))))
((php)
(^instanceof (^type 'closure) expr))
((python)
(^not
(^call-prim
"hasattr"
expr
(^str "id"))))
((ruby)
(^= (^ expr ".instance_variables.length") (^int 0)))
(else
(compiler-internal-error
"univ-emit-closure?, unknown target"))))))))
(define (univ-emit-closure-length ctx expr)
(^array-length (univ-clo-slots ctx expr)))
(define (univ-emit-closure-code ctx expr)
(^array-index (univ-clo-slots ctx expr) 0))
(define (univ-emit-closure-ref ctx expr1 expr2)
(^array-index (univ-clo-slots ctx expr1) expr2))
(define (univ-emit-closure-set! ctx expr1 expr2 expr3)
(^assign (^array-index (univ-clo-slots ctx expr1) expr2) expr3))
(define (univ-emit-new-delay-promise ctx expr)
(^new 'promise expr))
(define (univ-emit-promise? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_promise) expr))
(else
(^instanceof (^type 'promise) (^cast*-scmobj expr)))))
(define (univ-emit-new-will ctx expr1 expr2)
(^new 'will expr1 expr2))
(define (univ-emit-will? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_will) expr))
(else
(^instanceof (^type 'will) (^cast*-scmobj expr)))))
(define (univ-emit-new-foreign ctx expr1 expr2)
(^new 'foreign expr1 expr2))
(define (univ-emit-foreign? ctx expr)
(case (target-name (ctx-target ctx))
((go)
(^call-prim (^rts-method-use 'is_foreign) expr))
(else
(^instanceof (^type 'foreign) (^cast*-scmobj expr)))))
(define (univ-emit-call-prim ctx expr . params)
(univ-emit-call-prim-aux ctx expr params))
(define (univ-emit-call-member ctx expr fct . params)
(let ((name
(case (target-name (ctx-target ctx))
((ruby)
;; Avoid (^member (^this) fct) => @fct
(^ expr "." fct))
(else (^member expr fct)))))
(univ-emit-call-prim-aux ctx name params)))
(define (univ-emit-call-prim-aux ctx expr params)
(if (and (null? params)
(eq? (target-name (ctx-target ctx)) 'ruby))
expr
(univ-emit-apply-aux ctx expr params "(" ")")))
(define (univ-emit-jump ctx proc . params)
(case (univ-procedure-representation ctx)
((class struct)
(univ-emit-call-prim-aux ctx (^member (^parens proc) (^public 'jump)) params))
(else
(univ-emit-call-aux ctx proc params))))
(define (univ-emit-call-aux ctx expr params)
(if (eq? (target-name (ctx-target ctx)) 'ruby)
(univ-emit-apply-aux ctx expr params "[" "]")
(univ-emit-apply-aux ctx expr params "(" ")")))
(define (univ-emit-apply ctx expr params)
(univ-emit-apply-aux ctx expr params "(" ")"))
(define (univ-emit-apply-aux ctx expr params open close)
(^ expr
open
(univ-separated-list "," params)
close))
(define (univ-emit-this ctx)
(case (target-name (ctx-target ctx))
((js java go)
"this") ;; this is a normal identifier in go
((php)
"$this")
((python ruby)
"self")
(else
(compiler-internal-error
"univ-emit-this, unknown target"))))
(define (univ-emit-new ctx type . params)
(univ-emit-new* ctx (^type (list 'nonptr type)) params))
(define (univ-emit-new* ctx class params)
(case (target-name (ctx-target ctx))
((go)
(^ "&" (^construct* class params)))
(else
(^construct* class params))))
(define (univ-emit-construct ctx type . params)
(univ-emit-construct* ctx (^type (list 'nonptr type)) params))
(define (univ-emit-construct* ctx class params)
(case (target-name (ctx-target ctx))
((js php java)
(^parens-php (^ "new " (^apply class params))))
((python)
(^apply class params))
((ruby)
(^apply (^ class ".new") params))
((go)
(^ class "{" (univ-separated-list "," params) "}"))
(else
(compiler-internal-error
"univ-emit-consruct*, unknown target"))))
(define (univ-emit-typeof ctx type expr)
(case (target-name (ctx-target ctx))
((js)
(^= (^ "typeof " expr) (^str type)))
(else
(compiler-internal-error
"univ-emit-typeof, unknown target"))))
(define (univ-emit-instanceof ctx class expr)
(case (target-name (ctx-target ctx))
((js java)
(^ expr " instanceof " class))
((php)
;; PHP raises a syntax error when expr is a constant, so this case
;; is handled specially by generating (0?0:expr) which fools the compiler
(^ (if (univ-box? expr)
(^if-expr 'int (^int 0) (^int 0) expr)
expr)
" instanceof "
class))
((python)
(^call-prim "isinstance" expr class))
((ruby)
(^ expr ".kind_of?(" class ")"))
((go)
(^ "~~~TODO3:univ-emit-instanceof~~~"))
(else
(compiler-internal-error
"univ-emit-instanceof, unknown target"))))
(define (univ-emit-host-primitive? ctx expr)
(case (target-name (ctx-target ctx))
((python)
(^ "(type(" expr ") == int or type(" expr ") == float or type(" expr ") == bool or " expr " is None)"))
((php)
(^not
(^call-prim 'is_object expr)))
(else
(compiler-internal-error
"univ-emit-host-primitive?, unknown target"))))
(define (univ-throw ctx expr)
(case (target-name (ctx-target ctx))
((js php)
(^ "throw " expr ";\n"))
((python)
(^ "raise Exception(" expr ")\n"))
((ruby)
(^ "raise " expr "\n"))
((go)
(^ "~~~TODO3:univ-throw~~~"))
(else
(compiler-internal-error
"univ-throw, unknown target"))))
(define (univ-fxquotient ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js)
(^ (^parens (^/ expr1 expr2)) " | 0"))
((php)
(^float-toint (^/ expr1 expr2)))
((python ruby)
(^float-toint (^parens (^/ (^float-fromint expr1) (^float-fromint expr2)))))
((java)
(^/ expr1 expr2))
((go)
(^ "~~~TODO3:univ-fxquotient~~~"))
(else
(compiler-internal-error
"univ-fxquotient, unknown target"))))
(define (univ-fxmodulo ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js php java)
(^ (^parens (^ (^parens (^ expr1 " % " expr2)) " + " expr2)) " % " expr2))
((python ruby)
(^ expr1 " % " expr2))
((go)
(^ "~~~TODO3:univ-fxmodulo~~~"))
(else
(compiler-internal-error
"univ-fxmodulo, unknown target"))))
(define (univ-fxremainder ctx expr1 expr2)
(case (target-name (ctx-target ctx))
((js php java)
(^ expr1 " % " expr2))
((python)
(^- expr1
(^* (^call-prim "int" (^/ (^call-prim "float" expr1)
(^call-prim "float" expr2)))
expr2)))
((ruby)
(^ expr1 ".remainder(" expr2 ")"))
((go)
(^ "~~~TODO3:univ-fxremainder~~~"))
(else
(compiler-internal-error
"univ-fxremainder, unknown target"))))
(define (univ-define-prim
name
proc-safe?
apply-gen
#!optional
(ifjump-gen #f)
(jump-gen #f))
(let ((prim (univ-prim-info* (string->canonical-symbol name))))
(if apply-gen
(begin
(proc-obj-inlinable?-set!
prim
(lambda (env)
(or proc-safe?
(not (safe? env)))))
(proc-obj-inline-set! prim apply-gen)))
(if ifjump-gen
(begin
(proc-obj-testable?-set!
prim
(lambda (env)
(or proc-safe?
(not (safe? env)))))
(proc-obj-test-set! prim ifjump-gen)))
(if jump-gen
(begin
(proc-obj-jump-inlinable?-set!
prim
(lambda (env)
#t))
(proc-obj-jump-inline-set!
prim
jump-gen)))))
(define (univ-define-prim-bool name proc-safe? ifjump-gen)
(univ-define-prim
name
proc-safe?
(lambda (ctx return . opnds)
(apply ifjump-gen
(cons ctx
(cons (lambda (result) (return (^boolean-box result)))
opnds))))
ifjump-gen))
;; =============================================================================
;;; Primitive procedures
;; TODO move elsewhere
(define (univ-fold-left
op0
op1
op2
#!optional
(unbox (lambda (ctx x) x))
(box (lambda (ctx x) x)))
(make-translated-operand-generator
(lambda (ctx return . args)
(return
(cond ((null? args)
(box ctx (op0 ctx)))
((null? (cdr args))
(box ctx (op1 ctx (unbox ctx (car args)))))
(else
(let loop ((lst (cddr args))
(res (op2 ctx
(unbox ctx (car args))
(unbox ctx (cadr args)))))
(if (null? lst)
(box ctx res)
(loop (cdr lst)
(op2 ctx
(^parens res)
(unbox ctx (car lst))))))))))))
(define (univ-fold-left-compare
op0
op1
op2
#!optional
(unbox (lambda (ctx x) x))
(box (lambda (ctx x) x)))
(make-translated-operand-generator
(lambda (ctx return . args)
(return
(cond ((null? args)
(box ctx (op0 ctx)))
((null? (cdr args))
(box ctx (op1 ctx (unbox ctx (car args)))))
(else
(let loop ((lst (cdr args))
(res (op2 ctx
(unbox ctx (car args))
(unbox ctx (cadr args)))))
(let ((rest (cdr lst)))
(if (null? rest)
(box ctx res)
(loop rest
(^&& (^parens res)
(op2 ctx
(unbox ctx (car lst))
(unbox ctx (car rest))))))))))))))
(define (make-translated-operand-generator proc)
(lambda (ctx return opnds)
(apply proc (cons ctx (cons return (univ-emit-getopnds ctx opnds))))))
;;;============================================================================
| false |
9e7a9759308a2f3be8f1e61a874a086f80ef4066 | ac2a3544b88444eabf12b68a9bce08941cd62581 | /tests/unit-tests/01-fixnum/fixnump.scm | e48d6c67406f9885e3e82c2fb5e4666f8bac6bb3 | [
"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 | 1,547 | scm | fixnump.scm | (include "#.scm")
(check-true (##fixnum? 0))
(check-false (##fixnum? 0.5))
(check-false (##fixnum? 1+2i))
(check-false (##fixnum? +inf.0))
(check-false (##fixnum? -inf.0))
(check-false (##fixnum? +nan.0))
(check-true (##fixnum? ##max-fixnum))
(check-true (##fixnum? ##min-fixnum))
(check-false (##fixnum? (+ ##max-fixnum 1)))
(check-false (##fixnum? (- ##min-fixnum 1)))
(check-false (##fixnum? "test"))
(check-false (##fixnum? #\a))
(check-false (##fixnum? #!eof))
(check-false (##fixnum? #t))
(check-false (##fixnum? #f))
(check-false (##fixnum? #!void))
(check-false (##fixnum? '()))
(check-false (##fixnum? (lambda () #f)))
(check-false (##fixnum? '(1 . 2)))
(check-false (##fixnum? '#(1)))
(check-false (##fixnum? 'test))
(check-false (##fixnum? (box 1)))
(check-true (fixnum? 0))
(check-false (fixnum? 0.5))
(check-false (fixnum? 1+2i))
(check-false (fixnum? +inf.0))
(check-false (fixnum? -inf.0))
(check-false (fixnum? +nan.0))
(check-true (fixnum? ##max-fixnum))
(check-true (fixnum? ##min-fixnum))
(check-false (fixnum? (+ ##max-fixnum 1)))
(check-false (fixnum? (- ##min-fixnum 1)))
(check-false (fixnum? "test"))
(check-false (fixnum? #\a))
(check-false (fixnum? #!eof))
(check-false (fixnum? #t))
(check-false (fixnum? #f))
(check-false (fixnum? #!void))
(check-false (fixnum? '()))
(check-false (fixnum? (lambda () #f)))
(check-false (fixnum? '(1 . 2)))
(check-false (fixnum? '#(1)))
(check-false (fixnum? 'test))
(check-false (fixnum? (box 1)))
| false |
91687b67f3f604b46eab0f35f880fe75088d6d99 | 81d1b95e884f89ec9cbda45b70c500e7acb2b55e | /scheme/lambda/run.ss | c8f8e8db59901905c6af038de320fe6da3a93857 | []
| no_license | eraserhd/ehk | 3ec065adc5a06f4948c8ea2ad539eec5cffd0055 | bde0c07d33f6d5498d61361a838dbe1848a6300e | refs/heads/master | 2022-12-21T21:50:03.325068 | 2022-12-13T14:53:48 | 2022-12-13T14:53:48 | 24,571,764 | 9 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 213 | ss | run.ss | (library (lambda run)
(export run)
(import (rnrs)
(lambda boolean)
(lambda parens)
(lambda reduce))
(define (run E)
(reduce normal-order (booleans (parenthesize E))))
)
| false |
e9848a9ef236e4db4739464631333d533089c5e5 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /mscorlib/system/security/cryptography/md5.sls | 5ffc2f3ec5a0fef8c7a590114cf463b2eb3cd725 | []
| 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 | 422 | sls | md5.sls | (library (system security cryptography md5)
(export is? md5? create)
(import (ironscheme-clr-port))
(define (is? a) (clr-is System.Security.Cryptography.MD5 a))
(define (md5? a) (clr-is System.Security.Cryptography.MD5 a))
(define-method-port
create
System.Security.Cryptography.MD5
Create
(static: System.Security.Cryptography.MD5 System.String)
(static: System.Security.Cryptography.MD5)))
| false |
4b9c65e13625b26b86e9af242968c0056eb0968c | 120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193 | /packages/dharmalab/infix/tokenizer.sls | 7493653be8253900da2b30e8e123e1e2e4309d69 | [
"MIT"
]
| permissive | evilbinary/scheme-lib | a6d42c7c4f37e684c123bff574816544132cb957 | 690352c118748413f9730838b001a03be9a6f18e | refs/heads/master | 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 | MIT | 2022-06-16T05:54:55 | 2016-12-13T06:27:36 | Scheme | UTF-8 | Scheme | false | false | 39,403 | sls | tokenizer.sls | ;; Copyright 2016 Eduardo Cavazos
;;
;; 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.
#!r6rs
(library (dharmalab infix tokenizer)
(export lexer lexer-init)
(import (rnrs) (rnrs r5rs) (rnrs mutable-strings))
; *** This file starts with a copy of the file multilex.scm ***
; SILex - Scheme Implementation of Lex
; Copyright (C) 2001 Danny Dube'
;
; 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, write to the Free Software
; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
;
; Gestion des Input Systems
; Fonctions a utiliser par l'usager:
; lexer-make-IS, lexer-get-func-getc, lexer-get-func-ungetc,
; lexer-get-func-line, lexer-get-func-column et lexer-get-func-offset
;
; Taille initiale par defaut du buffer d'entree
(define lexer-init-buffer-len 1024)
; Numero du caractere newline
(define lexer-integer-newline (char->integer #\newline))
; Constructeur d'IS brut
(define lexer-raw-IS-maker
(lambda (buffer read-ptr input-f counters)
(let ((input-f input-f) ; Entree reelle
(buffer buffer) ; Buffer
(buflen (string-length buffer))
(read-ptr read-ptr)
(start-ptr 1) ; Marque de debut de lexeme
(start-line 1)
(start-column 1)
(start-offset 0)
(end-ptr 1) ; Marque de fin de lexeme
(point-ptr 1) ; Le point
(user-ptr 1) ; Marque de l'usager
(user-line 1)
(user-column 1)
(user-offset 0)
(user-up-to-date? #t)) ; Concerne la colonne seul.
(letrec
((start-go-to-end-none ; Fonctions de depl. des marques
(lambda ()
(set! start-ptr end-ptr)))
(start-go-to-end-line
(lambda ()
(let loop ((ptr start-ptr) (line start-line))
(if (= ptr end-ptr)
(begin
(set! start-ptr ptr)
(set! start-line line))
(if (char=? (string-ref buffer ptr) #\newline)
(loop (+ ptr 1) (+ line 1))
(loop (+ ptr 1) line))))))
(start-go-to-end-all
(lambda ()
(set! start-offset (+ start-offset (- end-ptr start-ptr)))
(let loop ((ptr start-ptr)
(line start-line)
(column start-column))
(if (= ptr end-ptr)
(begin
(set! start-ptr ptr)
(set! start-line line)
(set! start-column column))
(if (char=? (string-ref buffer ptr) #\newline)
(loop (+ ptr 1) (+ line 1) 1)
(loop (+ ptr 1) line (+ column 1)))))))
(start-go-to-user-none
(lambda ()
(set! start-ptr user-ptr)))
(start-go-to-user-line
(lambda ()
(set! start-ptr user-ptr)
(set! start-line user-line)))
(start-go-to-user-all
(lambda ()
(set! start-line user-line)
(set! start-offset user-offset)
(if user-up-to-date?
(begin
(set! start-ptr user-ptr)
(set! start-column user-column))
(let loop ((ptr start-ptr) (column start-column))
(if (= ptr user-ptr)
(begin
(set! start-ptr ptr)
(set! start-column column))
(if (char=? (string-ref buffer ptr) #\newline)
(loop (+ ptr 1) 1)
(loop (+ ptr 1) (+ column 1))))))))
(end-go-to-point
(lambda ()
(set! end-ptr point-ptr)))
(point-go-to-start
(lambda ()
(set! point-ptr start-ptr)))
(user-go-to-start-none
(lambda ()
(set! user-ptr start-ptr)))
(user-go-to-start-line
(lambda ()
(set! user-ptr start-ptr)
(set! user-line start-line)))
(user-go-to-start-all
(lambda ()
(set! user-ptr start-ptr)
(set! user-line start-line)
(set! user-column start-column)
(set! user-offset start-offset)
(set! user-up-to-date? #t)))
(init-lexeme-none ; Debute un nouveau lexeme
(lambda ()
(if (< start-ptr user-ptr)
(start-go-to-user-none))
(point-go-to-start)))
(init-lexeme-line
(lambda ()
(if (< start-ptr user-ptr)
(start-go-to-user-line))
(point-go-to-start)))
(init-lexeme-all
(lambda ()
(if (< start-ptr user-ptr)
(start-go-to-user-all))
(point-go-to-start)))
(get-start-line ; Obtention des stats du debut du lxm
(lambda ()
start-line))
(get-start-column
(lambda ()
start-column))
(get-start-offset
(lambda ()
start-offset))
(peek-left-context ; Obtention de caracteres (#f si EOF)
(lambda ()
(char->integer (string-ref buffer (- start-ptr 1)))))
(peek-char
(lambda ()
(if (< point-ptr read-ptr)
(char->integer (string-ref buffer point-ptr))
(let ((c (input-f)))
(if (char? c)
(begin
(if (= read-ptr buflen)
(reorganize-buffer))
(string-set! buffer point-ptr c)
(set! read-ptr (+ point-ptr 1))
(char->integer c))
(begin
(set! input-f (lambda () 'eof))
#f))))))
(read-char
(lambda ()
(if (< point-ptr read-ptr)
(let ((c (string-ref buffer point-ptr)))
(set! point-ptr (+ point-ptr 1))
(char->integer c))
(let ((c (input-f)))
(if (char? c)
(begin
(if (= read-ptr buflen)
(reorganize-buffer))
(string-set! buffer point-ptr c)
(set! read-ptr (+ point-ptr 1))
(set! point-ptr read-ptr)
(char->integer c))
(begin
(set! input-f (lambda () 'eof))
#f))))))
(get-start-end-text ; Obtention du lexeme
(lambda ()
(substring buffer start-ptr end-ptr)))
(get-user-line-line ; Fonctions pour l'usager
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-line))
user-line))
(get-user-line-all
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-all))
user-line))
(get-user-column-all
(lambda ()
(cond ((< user-ptr start-ptr)
(user-go-to-start-all)
user-column)
(user-up-to-date?
user-column)
(else
(let loop ((ptr start-ptr) (column start-column))
(if (= ptr user-ptr)
(begin
(set! user-column column)
(set! user-up-to-date? #t)
column)
(if (char=? (string-ref buffer ptr) #\newline)
(loop (+ ptr 1) 1)
(loop (+ ptr 1) (+ column 1)))))))))
(get-user-offset-all
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-all))
user-offset))
(user-getc-none
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-none))
(if (< user-ptr read-ptr)
(let ((c (string-ref buffer user-ptr)))
(set! user-ptr (+ user-ptr 1))
c)
(let ((c (input-f)))
(if (char? c)
(begin
(if (= read-ptr buflen)
(reorganize-buffer))
(string-set! buffer user-ptr c)
(set! read-ptr (+ read-ptr 1))
(set! user-ptr read-ptr)
c)
(begin
(set! input-f (lambda () 'eof))
'eof))))))
(user-getc-line
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-line))
(if (< user-ptr read-ptr)
(let ((c (string-ref buffer user-ptr)))
(set! user-ptr (+ user-ptr 1))
(if (char=? c #\newline)
(set! user-line (+ user-line 1)))
c)
(let ((c (input-f)))
(if (char? c)
(begin
(if (= read-ptr buflen)
(reorganize-buffer))
(string-set! buffer user-ptr c)
(set! read-ptr (+ read-ptr 1))
(set! user-ptr read-ptr)
(if (char=? c #\newline)
(set! user-line (+ user-line 1)))
c)
(begin
(set! input-f (lambda () 'eof))
'eof))))))
(user-getc-all
(lambda ()
(if (< user-ptr start-ptr)
(user-go-to-start-all))
(if (< user-ptr read-ptr)
(let ((c (string-ref buffer user-ptr)))
(set! user-ptr (+ user-ptr 1))
(if (char=? c #\newline)
(begin
(set! user-line (+ user-line 1))
(set! user-column 1))
(set! user-column (+ user-column 1)))
(set! user-offset (+ user-offset 1))
c)
(let ((c (input-f)))
(if (char? c)
(begin
(if (= read-ptr buflen)
(reorganize-buffer))
(string-set! buffer user-ptr c)
(set! read-ptr (+ read-ptr 1))
(set! user-ptr read-ptr)
(if (char=? c #\newline)
(begin
(set! user-line (+ user-line 1))
(set! user-column 1))
(set! user-column (+ user-column 1)))
(set! user-offset (+ user-offset 1))
c)
(begin
(set! input-f (lambda () 'eof))
'eof))))))
(user-ungetc-none
(lambda ()
(if (> user-ptr start-ptr)
(set! user-ptr (- user-ptr 1)))))
(user-ungetc-line
(lambda ()
(if (> user-ptr start-ptr)
(begin
(set! user-ptr (- user-ptr 1))
(let ((c (string-ref buffer user-ptr)))
(if (char=? c #\newline)
(set! user-line (- user-line 1))))))))
(user-ungetc-all
(lambda ()
(if (> user-ptr start-ptr)
(begin
(set! user-ptr (- user-ptr 1))
(let ((c (string-ref buffer user-ptr)))
(if (char=? c #\newline)
(begin
(set! user-line (- user-line 1))
(set! user-up-to-date? #f))
(set! user-column (- user-column 1)))
(set! user-offset (- user-offset 1)))))))
(reorganize-buffer ; Decaler ou agrandir le buffer
(lambda ()
(if (< (* 2 start-ptr) buflen)
(let* ((newlen (* 2 buflen))
(newbuf (make-string newlen))
(delta (- start-ptr 1)))
(let loop ((from (- start-ptr 1)))
(if (< from buflen)
(begin
(string-set! newbuf
(- from delta)
(string-ref buffer from))
(loop (+ from 1)))))
(set! buffer newbuf)
(set! buflen newlen)
(set! read-ptr (- read-ptr delta))
(set! start-ptr (- start-ptr delta))
(set! end-ptr (- end-ptr delta))
(set! point-ptr (- point-ptr delta))
(set! user-ptr (- user-ptr delta)))
(let ((delta (- start-ptr 1)))
(let loop ((from (- start-ptr 1)))
(if (< from buflen)
(begin
(string-set! buffer
(- from delta)
(string-ref buffer from))
(loop (+ from 1)))))
(set! read-ptr (- read-ptr delta))
(set! start-ptr (- start-ptr delta))
(set! end-ptr (- end-ptr delta))
(set! point-ptr (- point-ptr delta))
(set! user-ptr (- user-ptr delta)))))))
(list (cons 'start-go-to-end
(cond ((eq? counters 'none) start-go-to-end-none)
((eq? counters 'line) start-go-to-end-line)
((eq? counters 'all ) start-go-to-end-all)))
(cons 'end-go-to-point
end-go-to-point)
(cons 'init-lexeme
(cond ((eq? counters 'none) init-lexeme-none)
((eq? counters 'line) init-lexeme-line)
((eq? counters 'all ) init-lexeme-all)))
(cons 'get-start-line
get-start-line)
(cons 'get-start-column
get-start-column)
(cons 'get-start-offset
get-start-offset)
(cons 'peek-left-context
peek-left-context)
(cons 'peek-char
peek-char)
(cons 'read-char
read-char)
(cons 'get-start-end-text
get-start-end-text)
(cons 'get-user-line
(cond ((eq? counters 'none) #f)
((eq? counters 'line) get-user-line-line)
((eq? counters 'all ) get-user-line-all)))
(cons 'get-user-column
(cond ((eq? counters 'none) #f)
((eq? counters 'line) #f)
((eq? counters 'all ) get-user-column-all)))
(cons 'get-user-offset
(cond ((eq? counters 'none) #f)
((eq? counters 'line) #f)
((eq? counters 'all ) get-user-offset-all)))
(cons 'user-getc
(cond ((eq? counters 'none) user-getc-none)
((eq? counters 'line) user-getc-line)
((eq? counters 'all ) user-getc-all)))
(cons 'user-ungetc
(cond ((eq? counters 'none) user-ungetc-none)
((eq? counters 'line) user-ungetc-line)
((eq? counters 'all ) user-ungetc-all))))))))
; Construit un Input System
; Le premier parametre doit etre parmi "port", "procedure" ou "string"
; Prend un parametre facultatif qui doit etre parmi
; "none", "line" ou "all"
(define lexer-make-IS
(lambda (input-type input . largs)
(let ((counters-type (cond ((null? largs)
'line)
((memq (car largs) '(none line all))
(car largs))
(else
'line))))
(cond ((and (eq? input-type 'port) (input-port? input))
(let* ((buffer (make-string lexer-init-buffer-len #\newline))
(read-ptr 1)
(input-f (lambda () (read-char input))))
(lexer-raw-IS-maker buffer read-ptr input-f counters-type)))
((and (eq? input-type 'procedure) (procedure? input))
(let* ((buffer (make-string lexer-init-buffer-len #\newline))
(read-ptr 1)
(input-f input))
(lexer-raw-IS-maker buffer read-ptr input-f counters-type)))
((and (eq? input-type 'string) (string? input))
(let* ((buffer (string-append (string #\newline) input))
(read-ptr (string-length buffer))
(input-f (lambda () 'eof)))
(lexer-raw-IS-maker buffer read-ptr input-f counters-type)))
(else
(let* ((buffer (string #\newline))
(read-ptr 1)
(input-f (lambda () 'eof)))
(lexer-raw-IS-maker buffer read-ptr input-f counters-type)))))))
; Les fonctions:
; lexer-get-func-getc, lexer-get-func-ungetc,
; lexer-get-func-line, lexer-get-func-column et lexer-get-func-offset
(define lexer-get-func-getc
(lambda (IS) (cdr (assq 'user-getc IS))))
(define lexer-get-func-ungetc
(lambda (IS) (cdr (assq 'user-ungetc IS))))
(define lexer-get-func-line
(lambda (IS) (cdr (assq 'get-user-line IS))))
(define lexer-get-func-column
(lambda (IS) (cdr (assq 'get-user-column IS))))
(define lexer-get-func-offset
(lambda (IS) (cdr (assq 'get-user-offset IS))))
;
; Gestion des lexers
;
; Fabrication de lexer a partir d'arbres de decision
(define lexer-make-tree-lexer
(lambda (tables IS)
(letrec
(; Contenu de la table
(counters-type (vector-ref tables 0))
(<<EOF>>-pre-action (vector-ref tables 1))
(<<ERROR>>-pre-action (vector-ref tables 2))
(rules-pre-actions (vector-ref tables 3))
(table-nl-start (vector-ref tables 5))
(table-no-nl-start (vector-ref tables 6))
(trees-v (vector-ref tables 7))
(acc-v (vector-ref tables 8))
; Contenu du IS
(IS-start-go-to-end (cdr (assq 'start-go-to-end IS)))
(IS-end-go-to-point (cdr (assq 'end-go-to-point IS)))
(IS-init-lexeme (cdr (assq 'init-lexeme IS)))
(IS-get-start-line (cdr (assq 'get-start-line IS)))
(IS-get-start-column (cdr (assq 'get-start-column IS)))
(IS-get-start-offset (cdr (assq 'get-start-offset IS)))
(IS-peek-left-context (cdr (assq 'peek-left-context IS)))
(IS-peek-char (cdr (assq 'peek-char IS)))
(IS-read-char (cdr (assq 'read-char IS)))
(IS-get-start-end-text (cdr (assq 'get-start-end-text IS)))
(IS-get-user-line (cdr (assq 'get-user-line IS)))
(IS-get-user-column (cdr (assq 'get-user-column IS)))
(IS-get-user-offset (cdr (assq 'get-user-offset IS)))
(IS-user-getc (cdr (assq 'user-getc IS)))
(IS-user-ungetc (cdr (assq 'user-ungetc IS)))
; Resultats
(<<EOF>>-action #f)
(<<ERROR>>-action #f)
(rules-actions #f)
(states #f)
(final-lexer #f)
; Gestion des hooks
(hook-list '())
(add-hook
(lambda (thunk)
(set! hook-list (cons thunk hook-list))))
(apply-hooks
(lambda ()
(let loop ((l hook-list))
(if (pair? l)
(begin
((car l))
(loop (cdr l)))))))
; Preparation des actions
(set-action-statics
(lambda (pre-action)
(pre-action final-lexer IS-user-getc IS-user-ungetc)))
(prepare-special-action-none
(lambda (pre-action)
(let ((action #f))
(let ((result
(lambda ()
(action "")))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-special-action-line
(lambda (pre-action)
(let ((action #f))
(let ((result
(lambda (yyline)
(action "" yyline)))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-special-action-all
(lambda (pre-action)
(let ((action #f))
(let ((result
(lambda (yyline yycolumn yyoffset)
(action "" yyline yycolumn yyoffset)))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-special-action
(lambda (pre-action)
(cond ((eq? counters-type 'none)
(prepare-special-action-none pre-action))
((eq? counters-type 'line)
(prepare-special-action-line pre-action))
((eq? counters-type 'all)
(prepare-special-action-all pre-action)))))
(prepare-action-yytext-none
(lambda (pre-action)
(let ((get-start-end-text IS-get-start-end-text)
(start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda ()
(let ((yytext (get-start-end-text)))
(start-go-to-end)
(action yytext))))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-yytext-line
(lambda (pre-action)
(let ((get-start-end-text IS-get-start-end-text)
(start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda (yyline)
(let ((yytext (get-start-end-text)))
(start-go-to-end)
(action yytext yyline))))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-yytext-all
(lambda (pre-action)
(let ((get-start-end-text IS-get-start-end-text)
(start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda (yyline yycolumn yyoffset)
(let ((yytext (get-start-end-text)))
(start-go-to-end)
(action yytext yyline yycolumn yyoffset))))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-yytext
(lambda (pre-action)
(cond ((eq? counters-type 'none)
(prepare-action-yytext-none pre-action))
((eq? counters-type 'line)
(prepare-action-yytext-line pre-action))
((eq? counters-type 'all)
(prepare-action-yytext-all pre-action)))))
(prepare-action-no-yytext-none
(lambda (pre-action)
(let ((start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda ()
(start-go-to-end)
(action)))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-no-yytext-line
(lambda (pre-action)
(let ((start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda (yyline)
(start-go-to-end)
(action yyline)))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-no-yytext-all
(lambda (pre-action)
(let ((start-go-to-end IS-start-go-to-end)
(action #f))
(let ((result
(lambda (yyline yycolumn yyoffset)
(start-go-to-end)
(action yyline yycolumn yyoffset)))
(hook
(lambda ()
(set! action (set-action-statics pre-action)))))
(add-hook hook)
result))))
(prepare-action-no-yytext
(lambda (pre-action)
(cond ((eq? counters-type 'none)
(prepare-action-no-yytext-none pre-action))
((eq? counters-type 'line)
(prepare-action-no-yytext-line pre-action))
((eq? counters-type 'all)
(prepare-action-no-yytext-all pre-action)))))
; Fabrique les fonctions de dispatch
(prepare-dispatch-err
(lambda (leaf)
(lambda (c)
#f)))
(prepare-dispatch-number
(lambda (leaf)
(let ((state-function #f))
(let ((result
(lambda (c)
state-function))
(hook
(lambda ()
(set! state-function (vector-ref states leaf)))))
(add-hook hook)
result))))
(prepare-dispatch-leaf
(lambda (leaf)
(if (eq? leaf 'err)
(prepare-dispatch-err leaf)
(prepare-dispatch-number leaf))))
(prepare-dispatch-<
(lambda (tree)
(let ((left-tree (list-ref tree 1))
(right-tree (list-ref tree 2)))
(let ((bound (list-ref tree 0))
(left-func (prepare-dispatch-tree left-tree))
(right-func (prepare-dispatch-tree right-tree)))
(lambda (c)
(if (< c bound)
(left-func c)
(right-func c)))))))
(prepare-dispatch-=
(lambda (tree)
(let ((left-tree (list-ref tree 2))
(right-tree (list-ref tree 3)))
(let ((bound (list-ref tree 1))
(left-func (prepare-dispatch-tree left-tree))
(right-func (prepare-dispatch-tree right-tree)))
(lambda (c)
(if (= c bound)
(left-func c)
(right-func c)))))))
(prepare-dispatch-tree
(lambda (tree)
(cond ((not (pair? tree))
(prepare-dispatch-leaf tree))
((eq? (car tree) '=)
(prepare-dispatch-= tree))
(else
(prepare-dispatch-< tree)))))
(prepare-dispatch
(lambda (tree)
(let ((dicho-func (prepare-dispatch-tree tree)))
(lambda (c)
(and c (dicho-func c))))))
; Fabrique les fonctions de transition (read & go) et (abort)
(prepare-read-n-go
(lambda (tree)
(let ((dispatch-func (prepare-dispatch tree))
(read-char IS-read-char))
(lambda ()
(dispatch-func (read-char))))))
(prepare-abort
(lambda (tree)
(lambda ()
#f)))
(prepare-transition
(lambda (tree)
(if (eq? tree 'err)
(prepare-abort tree)
(prepare-read-n-go tree))))
; Fabrique les fonctions d'etats ([set-end] & trans)
(prepare-state-no-acc
(lambda (s r1 r2)
(let ((trans-func (prepare-transition (vector-ref trees-v s))))
(lambda (action)
(let ((next-state (trans-func)))
(if next-state
(next-state action)
action))))))
(prepare-state-yes-no
(lambda (s r1 r2)
(let ((peek-char IS-peek-char)
(end-go-to-point IS-end-go-to-point)
(new-action1 #f)
(trans-func (prepare-transition (vector-ref trees-v s))))
(let ((result
(lambda (action)
(let* ((c (peek-char))
(new-action
(if (or (not c) (= c lexer-integer-newline))
(begin
(end-go-to-point)
new-action1)
action))
(next-state (trans-func)))
(if next-state
(next-state new-action)
new-action))))
(hook
(lambda ()
(set! new-action1 (vector-ref rules-actions r1)))))
(add-hook hook)
result))))
(prepare-state-diff-acc
(lambda (s r1 r2)
(let ((end-go-to-point IS-end-go-to-point)
(peek-char IS-peek-char)
(new-action1 #f)
(new-action2 #f)
(trans-func (prepare-transition (vector-ref trees-v s))))
(let ((result
(lambda (action)
(end-go-to-point)
(let* ((c (peek-char))
(new-action
(if (or (not c) (= c lexer-integer-newline))
new-action1
new-action2))
(next-state (trans-func)))
(if next-state
(next-state new-action)
new-action))))
(hook
(lambda ()
(set! new-action1 (vector-ref rules-actions r1))
(set! new-action2 (vector-ref rules-actions r2)))))
(add-hook hook)
result))))
(prepare-state-same-acc
(lambda (s r1 r2)
(let ((end-go-to-point IS-end-go-to-point)
(trans-func (prepare-transition (vector-ref trees-v s)))
(new-action #f))
(let ((result
(lambda (action)
(end-go-to-point)
(let ((next-state (trans-func)))
(if next-state
(next-state new-action)
new-action))))
(hook
(lambda ()
(set! new-action (vector-ref rules-actions r1)))))
(add-hook hook)
result))))
(prepare-state
(lambda (s)
(let* ((acc (vector-ref acc-v s))
(r1 (car acc))
(r2 (cdr acc)))
(cond ((not r1) (prepare-state-no-acc s r1 r2))
((not r2) (prepare-state-yes-no s r1 r2))
((< r1 r2) (prepare-state-diff-acc s r1 r2))
(else (prepare-state-same-acc s r1 r2))))))
; Fabrique la fonction de lancement du lexage a l'etat de depart
(prepare-start-same
(lambda (s1 s2)
(let ((peek-char IS-peek-char)
(eof-action #f)
(start-state #f)
(error-action #f))
(let ((result
(lambda ()
(if (not (peek-char))
eof-action
(start-state error-action))))
(hook
(lambda ()
(set! eof-action <<EOF>>-action)
(set! start-state (vector-ref states s1))
(set! error-action <<ERROR>>-action))))
(add-hook hook)
result))))
(prepare-start-diff
(lambda (s1 s2)
(let ((peek-char IS-peek-char)
(eof-action #f)
(peek-left-context IS-peek-left-context)
(start-state1 #f)
(start-state2 #f)
(error-action #f))
(let ((result
(lambda ()
(cond ((not (peek-char))
eof-action)
((= (peek-left-context) lexer-integer-newline)
(start-state1 error-action))
(else
(start-state2 error-action)))))
(hook
(lambda ()
(set! eof-action <<EOF>>-action)
(set! start-state1 (vector-ref states s1))
(set! start-state2 (vector-ref states s2))
(set! error-action <<ERROR>>-action))))
(add-hook hook)
result))))
(prepare-start
(lambda ()
(let ((s1 table-nl-start)
(s2 table-no-nl-start))
(if (= s1 s2)
(prepare-start-same s1 s2)
(prepare-start-diff s1 s2)))))
; Fabrique la fonction principale
(prepare-lexer-none
(lambda ()
(let ((init-lexeme IS-init-lexeme)
(start-func (prepare-start)))
(lambda ()
(init-lexeme)
((start-func))))))
(prepare-lexer-line
(lambda ()
(let ((init-lexeme IS-init-lexeme)
(get-start-line IS-get-start-line)
(start-func (prepare-start)))
(lambda ()
(init-lexeme)
(let ((yyline (get-start-line)))
((start-func) yyline))))))
(prepare-lexer-all
(lambda ()
(let ((init-lexeme IS-init-lexeme)
(get-start-line IS-get-start-line)
(get-start-column IS-get-start-column)
(get-start-offset IS-get-start-offset)
(start-func (prepare-start)))
(lambda ()
(init-lexeme)
(let ((yyline (get-start-line))
(yycolumn (get-start-column))
(yyoffset (get-start-offset)))
((start-func) yyline yycolumn yyoffset))))))
(prepare-lexer
(lambda ()
(cond ((eq? counters-type 'none) (prepare-lexer-none))
((eq? counters-type 'line) (prepare-lexer-line))
((eq? counters-type 'all) (prepare-lexer-all))))))
; Calculer la valeur de <<EOF>>-action et de <<ERROR>>-action
(set! <<EOF>>-action (prepare-special-action <<EOF>>-pre-action))
(set! <<ERROR>>-action (prepare-special-action <<ERROR>>-pre-action))
; Calculer la valeur de rules-actions
(let* ((len (quotient (vector-length rules-pre-actions) 2))
(v (make-vector len)))
(let loop ((r (- len 1)))
(if (< r 0)
(set! rules-actions v)
(let* ((yytext? (vector-ref rules-pre-actions (* 2 r)))
(pre-action (vector-ref rules-pre-actions (+ (* 2 r) 1)))
(action (if yytext?
(prepare-action-yytext pre-action)
(prepare-action-no-yytext pre-action))))
(vector-set! v r action)
(loop (- r 1))))))
; Calculer la valeur de states
(let* ((len (vector-length trees-v))
(v (make-vector len)))
(let loop ((s (- len 1)))
(if (< s 0)
(set! states v)
(begin
(vector-set! v s (prepare-state s))
(loop (- s 1))))))
; Calculer la valeur de final-lexer
(set! final-lexer (prepare-lexer))
; Executer les hooks
(apply-hooks)
; Resultat
final-lexer)))
; Fabrication de lexer a partir de listes de caracteres taggees
(define lexer-make-char-lexer
(let* ((char->class
(lambda (c)
(let ((n (char->integer c)))
(list (cons n n)))))
(merge-sort
(lambda (l combine zero-elt)
(if (null? l)
zero-elt
(let loop1 ((l l))
(if (null? (cdr l))
(car l)
(loop1
(let loop2 ((l l))
(cond ((null? l)
l)
((null? (cdr l))
l)
(else
(cons (combine (car l) (cadr l))
(loop2 (cddr l))))))))))))
(finite-class-union
(lambda (c1 c2)
(let loop ((c1 c1) (c2 c2) (u '()))
(if (null? c1)
(if (null? c2)
(reverse u)
(loop c1 (cdr c2) (cons (car c2) u)))
(if (null? c2)
(loop (cdr c1) c2 (cons (car c1) u))
(let* ((r1 (car c1))
(r2 (car c2))
(r1start (car r1))
(r1end (cdr r1))
(r2start (car r2))
(r2end (cdr r2)))
(if (<= r1start r2start)
(cond ((< (+ r1end 1) r2start)
(loop (cdr c1) c2 (cons r1 u)))
((<= r1end r2end)
(loop (cdr c1)
(cons (cons r1start r2end) (cdr c2))
u))
(else
(loop c1 (cdr c2) u)))
(cond ((> r1start (+ r2end 1))
(loop c1 (cdr c2) (cons r2 u)))
((>= r1end r2end)
(loop (cons (cons r2start r1end) (cdr c1))
(cdr c2)
u))
(else
(loop (cdr c1) c2 u))))))))))
(char-list->class
(lambda (cl)
(let ((classes (map char->class cl)))
(merge-sort classes finite-class-union '()))))
(class-<
(lambda (b1 b2)
(cond ((eq? b1 'inf+) #f)
((eq? b2 'inf-) #f)
((eq? b1 'inf-) #t)
((eq? b2 'inf+) #t)
(else (< b1 b2)))))
(finite-class-compl
(lambda (c)
(let loop ((c c) (start 'inf-))
(if (null? c)
(list (cons start 'inf+))
(let* ((r (car c))
(rstart (car r))
(rend (cdr r)))
(if (class-< start rstart)
(cons (cons start (- rstart 1))
(loop c rstart))
(loop (cdr c) (+ rend 1))))))))
(tagged-chars->class
(lambda (tcl)
(let* ((inverse? (car tcl))
(cl (cdr tcl))
(class-tmp (char-list->class cl)))
(if inverse? (finite-class-compl class-tmp) class-tmp))))
(charc->arc
(lambda (charc)
(let* ((tcl (car charc))
(dest (cdr charc))
(class (tagged-chars->class tcl)))
(cons class dest))))
(arc->sharcs
(lambda (arc)
(let* ((range-l (car arc))
(dest (cdr arc))
(op (lambda (range) (cons range dest))))
(map op range-l))))
(class-<=
(lambda (b1 b2)
(cond ((eq? b1 'inf-) #t)
((eq? b2 'inf+) #t)
((eq? b1 'inf+) #f)
((eq? b2 'inf-) #f)
(else (<= b1 b2)))))
(sharc-<=
(lambda (sharc1 sharc2)
(class-<= (caar sharc1) (caar sharc2))))
(merge-sharcs
(lambda (l1 l2)
(let loop ((l1 l1) (l2 l2))
(cond ((null? l1)
l2)
((null? l2)
l1)
(else
(let ((sharc1 (car l1))
(sharc2 (car l2)))
(if (sharc-<= sharc1 sharc2)
(cons sharc1 (loop (cdr l1) l2))
(cons sharc2 (loop l1 (cdr l2))))))))))
(class-= eqv?)
(fill-error
(lambda (sharcs)
(let loop ((sharcs sharcs) (start 'inf-))
(cond ((class-= start 'inf+)
'())
((null? sharcs)
(cons (cons (cons start 'inf+) 'err)
(loop sharcs 'inf+)))
(else
(let* ((sharc (car sharcs))
(h (caar sharc))
(t (cdar sharc)))
(if (class-< start h)
(cons (cons (cons start (- h 1)) 'err)
(loop sharcs h))
(cons sharc (loop (cdr sharcs)
(if (class-= t 'inf+)
'inf+
(+ t 1)))))))))))
(charcs->tree
(lambda (charcs)
(let* ((op (lambda (charc) (arc->sharcs (charc->arc charc))))
(sharcs-l (map op charcs))
(sorted-sharcs (merge-sort sharcs-l merge-sharcs '()))
(full-sharcs (fill-error sorted-sharcs))
(op (lambda (sharc) (cons (caar sharc) (cdr sharc))))
(table (list->vector (map op full-sharcs))))
(let loop ((left 0) (right (- (vector-length table) 1)))
(if (= left right)
(cdr (vector-ref table left))
(let ((mid (quotient (+ left right 1) 2)))
(if (and (= (+ left 2) right)
(= (+ (car (vector-ref table mid)) 1)
(car (vector-ref table right)))
(eqv? (cdr (vector-ref table left))
(cdr (vector-ref table right))))
(list '=
(car (vector-ref table mid))
(cdr (vector-ref table mid))
(cdr (vector-ref table left)))
(list (car (vector-ref table mid))
(loop left (- mid 1))
(loop mid right))))))))))
(lambda (tables IS)
(let ((counters (vector-ref tables 0))
(<<EOF>>-action (vector-ref tables 1))
(<<ERROR>>-action (vector-ref tables 2))
(rules-actions (vector-ref tables 3))
(nl-start (vector-ref tables 5))
(no-nl-start (vector-ref tables 6))
(charcs-v (vector-ref tables 7))
(acc-v (vector-ref tables 8)))
(let* ((len (vector-length charcs-v))
(v (make-vector len)))
(let loop ((i (- len 1)))
(if (>= i 0)
(begin
(vector-set! v i (charcs->tree (vector-ref charcs-v i)))
(loop (- i 1)))
(lexer-make-tree-lexer
(vector counters
<<EOF>>-action
<<ERROR>>-action
rules-actions
'decision-trees
nl-start
no-nl-start
v
acc-v)
IS))))))))
; Fabrication d'un lexer a partir de code pre-genere
(define lexer-make-code-lexer
(lambda (tables IS)
(let ((<<EOF>>-pre-action (vector-ref tables 1))
(<<ERROR>>-pre-action (vector-ref tables 2))
(rules-pre-action (vector-ref tables 3))
(code (vector-ref tables 5)))
(code <<EOF>>-pre-action <<ERROR>>-pre-action rules-pre-action IS))))
(define lexer-make-lexer
(lambda (tables IS)
(let ((automaton-type (vector-ref tables 4)))
(cond ((eq? automaton-type 'decision-trees)
(lexer-make-tree-lexer tables IS))
((eq? automaton-type 'tagged-chars-lists)
(lexer-make-char-lexer tables IS))
((eq? automaton-type 'code)
(lexer-make-code-lexer tables IS))))))
;
; Table generated from the file calculator.l by SILex 1.0
;
(define lexer-default-table
(vector
'line
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(list-ref '(#f) 0)
))
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(begin
(display "Error: Invalid token.")
(newline)
'error)
))
(vector
#f
(lambda (yycontinue yygetc yyungetc)
(lambda (yyline)
;; skip blanks, tabs and newlines
(yycontinue)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->number (string-append "+" yytext))
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->number yytext)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->number yytext)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->number yytext)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->symbol yytext)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string->symbol yytext)
))
#f
(lambda (yycontinue yygetc yyungetc)
(lambda (yyline)
(string-ref "," 0)
))
#t
(lambda (yycontinue yygetc yyungetc)
(lambda (yytext yyline)
(string-ref yytext 0)
)))
'decision-trees
0
0
'#((48 (38 (33 (11 (10 err 1) (32 err 1)) (35 (34 8 err) (36 2 (37 8
7)))) (43 (40 (39 8 err) (42 10 7)) (45 (44 6 9) (46 5 (47 4 7))))) (92
(61 (59 (58 3 8) (60 err 8)) (64 (62 7 8) (65 err (91 8 err)))) (96 (94
(93 7 err) (95 7 8)) (123 (97 err 8) (= 126 8 err))))) (11 (10 err 1)
(= 32 1 err)) (89 (79 (= 66 11 err) (80 12 (88 err 13))) (111 (= 98 11
err) (120 (112 12 err) (121 13 err)))) (69 (47 (46 err 15) (48 err (58
3 err))) (102 (70 16 (101 err 16)) (= 105 14 err))) (48 err (58 17
err)) (106 (105 err 19) (= 110 18 err)) (106 (105 err 21) (= 110 20
err)) err (59 (38 (34 (33 err 8) (= 36 8 err)) (46 (39 8 err) (= 47 err
8))) (95 (61 (60 err 8) (62 err (91 8 err))) (123 (= 96 err 8) (= 126 8
err)))) err err (48 err (50 22 err)) (48 err (56 23 err)) (65 (48 err
(58 24 err)) (97 (71 24 err) (103 24 err))) err (58 (48 err 17) (= 105
14 err)) (45 (= 43 25 err) (48 (46 25 err) (58 26 err))) (70 (58 (48
err 17) (69 err 27)) (102 (101 err 27) (= 105 14 err))) (= 97 28 err)
(= 110 29 err) (= 97 30 err) (= 110 31 err) (50 (48 err 22) (= 105 14
err)) (56 (48 err 23) (= 105 14 err)) (71 (58 (48 err 24) (65 err 24))
(103 (97 err 24) (= 105 14 err))) (48 err (58 26 err)) (58 (48 err 26)
(= 105 14 err)) (45 (= 43 32 err) (48 (46 32 err) (58 33 err))) (= 110
34 err) (= 102 35 err) (= 110 36 err) (= 116 37 err) (48 err (58 33
err)) (58 (48 err 33) (= 105 14 err)) (= 46 38 err) (= 46 39 err) (= 46
40 err) (= 46 41 err) (= 48 42 err) (= 48 43 err) (= 48 42 err) (= 48
43 err) err err)
'#((#f . #f) (0 . 0) (#f . #f) (2 . 2) (#f . #f) (5 . 5) (5 . 5) (5 . 5)
(6 . 6) (7 . 7) (8 . 8) (#f . #f) (#f . #f) (#f . #f) (1 . 1) (2 . 2)
(#f . #f) (2 . 2) (#f . #f) (#f . #f) (#f . #f) (#f . #f) (2 . 2) (2 .
2) (2 . 2) (#f . #f) (2 . 2) (#f . #f) (#f . #f) (#f . #f) (#f . #f)
(#f . #f) (#f . #f) (2 . 2) (#f . #f) (#f . #f) (#f . #f) (#f . #f) (#f
. #f) (#f . #f) (#f . #f) (#f . #f) (3 . 3) (4 . 4))))
;
; User functions
;
(define the-lexer #f)
(define (lexer) (the-lexer))
(define lexer-get-line #f)
(define lexer-getc #f)
(define lexer-ungetc #f)
(define lexer-init
(lambda (input-type input)
(let ((IS (lexer-make-IS input-type input 'line)))
(set! the-lexer (lexer-make-lexer lexer-default-table IS))
(set! lexer-get-line (lexer-get-func-line IS))
(set! lexer-getc (lexer-get-func-getc IS))
(set! lexer-ungetc (lexer-get-func-ungetc IS)))))
) | false |
10517036a2fd087e7959c0e5787f411fc3a1f437 | eb5e0350a91e71e50d08d67f1cbca826bacbfbe7 | /tagless/specialize.scm | 72f069c7048946b94c9a7f0b57c7d558f1385fc3 | [
"BSD-3-Clause"
]
| permissive | JacquesCarette/finally-tagless | d6f86649411f21ea40ed135c0255a050c138f0c1 | 964bd1b4c88d5713527e115529ec762ba3f0dd5f | refs/heads/master | 2020-04-07T22:09:30.759049 | 2018-11-28T20:20:23 | 2018-11-28T20:20:23 | 158,757,338 | 38 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 4,635 | scm | specialize.scm | ; Two helper macros to make defining and applying curried functions easier
; Neil Jones, in a message 14 Oct 2008, suggested a good example:
;;
;; ; program p such that p <n> a1 a2 ... an => a1+a2+...+an
;;
;; (define p
;; (lambda (t)
;; (((t
;; (lambda(acc) acc)
;; )
;; (lambda(n)(lambda(acc)(lambda(x)(n(+ acc x))))
;; ))
;; 0)))
;;
;; ; Examples
;; ;
;; ; > (p zero)
;; ; 0
;; ; > ((p one) 42)
;; ; 42
;; ; > (((p two) 9) 16)
;; ; 25
;; ; > ((((p three) 2) 3) 4)
;; ; 9
;; ;
;;
;; The result of specialising this p to say "two" should be something like
;;
;; \ x \ y (+ (+ 0 x) y)
;;
;; The test run was done using Church numerals, and the output was
;; ordinary numbers, for readability. That's not important, any
;; convenient variation would be fine.
(define-syntax lambda-c
(syntax-rules ()
((lambda-c () body) body)
((lambda-c (v . vs) body) (lambda (v) (lambda-c vs body)))))
(define-syntax @c
(syntax-rules ()
((@c f) f)
((@c f arg . args) (@c (f arg) . args))))
; Church-encoding of pairs
(define rfst (lambda-c (a b) a))
(define rsnd (lambda-c (a b) b))
(define rcons (lambda-c (a b sel) (@c sel a b)))
; Operations on lists that are Church-encoded as folds
; http://okmij.org/ftp/Computation/Continuations.html#cdr-fstream
(define church-nil
(lambda-c (cons nil) nil))
(define church-cons
(lambda-c (car cdr cons nil)
(@c cons car (@c cdr cons nil))))
(define (church-car l)
(@c l (lambda-c (car cadr) car)
'undefined))
(define (church-case l)
(@c l (lambda-c (car case-cdr sk fk)
(@c sk car (lambda-c (cons nil)
(@c case-cdr (lambda-c (cadr cddr)
(@c cons cadr (@c cddr cons nil)))
nil))))
(lambda-c (sk fk) fk)))
(define (church-cdr l)
(@c church-case l (lambda-c (car cdr) cdr)
'undefined))
(define church-append
(lambda-c (l1 l2 cons nil)
(@c l1 cons (@c l2 cons nil))))
(define church-map
(lambda-c (f l cons)
(l (lambda-c (car map-f-cdr) (@c cons (f car) map-f-cdr)))))
(define church-ref-length
(lambda-c (l-index l)
(church-car (@c l-index (lambda-c (car) church-cdr) l))))
; To convert HOAS to de Bruijn indices use appD and lamD below to build the
; expression and apply the result to church-nil, then Z, S, A, and L. The
; Church-encoded list argument ("envD" below), initialized thus to church-nil,
; contains the variables currently in scope, from outermost to innermost (!).
; Example:
; > (unparse1 (@c lamD (lambda (x) (let ((axx (@c appD x x))) (@c appD axx (lamD (lambda (y) (@c appD y axx)))))) church-nil))
; (L (A (A Z Z) (L (A Z (A (S Z) (S Z))))))
(define appD
(lambda-c (c1 c2 envD)
(let ((e1 (c1 envD))
(e2 (c2 envD)))
(lambda-c (Z S A L)
(@c A (@c e1 Z S A L) (@c e2 Z S A L))))))
(define lamD
(lambda-c (f envD)
(let ((body
(@c f (church-ref-length envD)
(@c church-append (@c church-map (lambda-c (c Z S A L)
(S (@c c Z S A L)))
envD)
(@c church-cons (lambda-c (Z S A L) Z)
church-nil)))))
(lambda-c (Z S A L) (L (@c body Z S A L))))))
(define (unparse1 t)
(@c t
'Z
(lambda-c (e1) `(S ,e1))
(lambda-c (e1 e2) `(A ,e1 ,e2))
(lambda-c (e1) `(L ,e1))))
; Offline specializer for a two-level language using de Bruijn indices
(define (spec t)
(let ((env0 (lambda (x) x))
(Z (lambda-c (env) (env rfst)))
(S (lambda-c (v env) (v (env rsnd))))
(As (lambda-c (e1 e2 env) ((e1 env) (e2 env))))
(Ls (lambda-c (e env x) (e (@c rcons x env))))
(Ad (lambda-c (e1 e2 env) (@c appD (e1 env) (e2 env))))
(Ld (lambda-c (e env) (lamD (lambda (x) (e (@c rcons x env)))))))
(@c t Z S As Ls Ad Ld env0)))
; Actually put in some tests right in here
; helper functions
(define (cout . args) (for-each display args))
(define nl #\newline)
; for unparsing
(cout "test0: "
(unparse1 (@c lamD (lambda (x) (let ((axx (@c appD x x))) (@c appD axx (lamD (lambda (y) (@c appD y axx)))))) church-nil))
nl )
; for the actual specializer
(cout "stress 1: "
(unparse1 ((spec (lambda-c (Z S As Ls Ad Ld) (@c As (Ls (Ld (@c Ad Z (S Z)))) (Ld Z)))) church-nil))
nl )
(cout "stress 2: "
(unparse1 ((spec (lambda-c (Z S As Ls Ad Ld) (Ld (@c As (Ls (Ld (S Z))) Z)))) church-nil))
nl )
| true |
7a4b150a6a3e51059a30df18e278331f80e1be9b | ab2b756cdeb5aa94b8586eeb8dd5948b7f0bba27 | /src/lisp/tests/square_each_macro.scm | 512bb1dcc2cbc59ccf2adb563025209df3f35b4f | []
| no_license | stjordanis/chalang | 48ff69d8bc31da1696eae043e66c628f41035b5a | a728e6bb9a60ac6eca189ee7d6873a891825fa9a | refs/heads/master | 2021-07-31T22:26:45.299432 | 2021-03-09T13:06:56 | 2021-03-09T13:06:56 | 142,876,387 | 0 | 0 | null | 2018-07-30T13:03:00 | 2018-07-30T13:03:00 | null | UTF-8 | Scheme | false | false | 611 | scm | square_each_macro.scm | (import (core/eqs.scm))
(macro square (X) (* X X))
;(macro eqs (A B)
; '(nop A B === swap drop swap drop))
(macro sqr (X)
(cond (((= X ()) '(nil))
((is_list X) '(cons (square ,(car X))
(sqr ,(cdr X))))
(true X))))
(macro tree (X)
(cond (((= X ()) '(nil))
((not (is_list X)) X)
((is_list (car X)) '(cons ,(tree (car X))
,(tree (cdr X))))
(true '(cons ,(car X)
,(tree (cdr X)))))))
;(cons 4 (cons 9 nil))
(= (sqr (2 3))
(tree (4 9)))
;(and
; (= '(sqr (2 3))
; '(cons 4 (cons 9 nil)))
; (= '(tree (4 9))
; '(cons 4 (cons 9 nil))))
| false |
6a69615a15478700088634cf813c5e8fdc04eaca | 648776d3a0d9a8ca036acaf6f2f7a60dcdb45877 | /queries/supercollider/indents.scm | 41241c6ecb103f201c63747ef4e235af0d4cecfe | [
"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 | 467 | scm | indents.scm | [
(function_block)
(binary_expression)
(collection)
(indexed_collection)
(parameter_call_list)
(function_call)
(class_def)
(classvar)
(const)
(instance_var)
(variable_definition)
(variable_definition_sequence (variable_definition))
(control_structure)
(return_statement)
] @indent.begin
[
(parameter_call_list (argument_calls))
"("
")"
"{"
"}"
"["
"]"
] @indent.branch
[
(block_comment)
(line_comment)
] @indent.ignore
| false |
6eaba6790204a9e110df46761d222cc6b219a3ab | 222b42ba803bfecd4ec31166dd2be107a840f2bd | /misc/identity.scm | 85c175d3dca7b8e0f8641d769039d39cd54d4697 | []
| no_license | ab3250/ablib | 83512c2c2cadd0eb49ad534548c058e3ed119d4c | 887c8661ce99e8edfe89bcf707400e55c3943dd4 | refs/heads/master | 2023-06-12T13:36:49.487467 | 2021-07-11T13:29:45 | 2021-07-11T13:29:45 | 384,955,137 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 57 | scm | identity.scm | ; (identity x) => x
(define identity
(lambda (x) x))
| false |
d51ebef91c4537166eb689052c8105d7cecfca68 | 8a0660bd8d588f94aa429050bb8d32c9cd4290d5 | /sitelib/util/hashtables.scm | f0089f2270eb9cf9924f1402120f023ca8134dd4 | [
"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 | 2,342 | scm | hashtables.scm | ;;; -*- mode: scheme; coding: utf-8 -*-
;;;
;;; hashtables.scm - hashtable utilities
;;;
;;; Copyright (c) 2000-2011 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.
;;;
(library (util hashtables)
(export hashtable-for-each
hashtable-map
hashtable->alist
alist->hashtable
hashtable-keys-list
hashtable-values-list)
(import (rnrs)
(sagittarius control)
(only (core base) hashtable-for-each hashtable-map
hashtable->alist)
(only (sagittarius) hashtable-keys-list hashtable-values-list))
(define (create-hashtable compare hasher)
(cond ((eq? compare eq?)
(make-eq-hashtable))
((eq? compare eqv?)
(make-eqv-hashtable))
(else
(make-hashtable hasher compare))))
(define (alist->hashtable alist
:key (compare eq?)
(hasher symbol-hash))
(let ((ht (create-hashtable compare hasher)))
(for-each (lambda (k/v)
(hashtable-set! ht (car k/v) (cdr k/v))) alist)
ht))
) | false |
197b7d0eac490bfb59e7ec2ec25ecad1cbad538b | f04768e1564b225dc8ffa58c37fe0213235efe5d | /Assignment8/8.ss | c4cbfc84add60c667725ef100689486c06e7d739 | []
| no_license | FrancisMengx/PLC | 9b4e507092a94c636d784917ec5e994c322c9099 | e3ca99cc25bd6d6ece85163705b321aa122f7305 | refs/heads/master | 2021-01-01T05:37:43.849357 | 2014-09-09T23:27:08 | 2014-09-09T23:27:08 | 23,853,636 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 4,085 | ss | 8.ss | ;Francis Meng Assignment 8
;Question1.a
(define (slist-map proc slist)
(if (null? slist)
'()
(if (list? (car slist))
(cons (slist-map proc (car slist)) (slist-map proc (cdr slist)))
(cons (proc (car slist)) (slist-map proc (cdr slist))))))
;Question1.b
(define (slist-reverse ls)
(let reversels ([rls (reverse ls)])
(if (null? rls)
'()
(if (list? (car rls))
(cons (slist-reverse (car rls)) (reversels (cdr rls)))
(cons (car rls) (reversels (cdr rls))))))
)
;Question1.c
(define (slist-paren-count slist)
(if (null? slist)
2
(if (list? (car slist))
(+ (slist-paren-count (car slist)) (slist-paren-count (cdr slist)))
(slist-paren-count (cdr slist)))))
;Question1.d
(define (slist-depth slist)
(if (null? slist)
1
(let getDepth ([curlist slist])
(if (null? curlist)
0
(if (and (null? (car curlist)) (null? (cdr curlist)))
2
(+ 1 (getDepth (concatenate curlist)))))
))
)
(define (concatenate slist)
(if (null? slist)
'()
(let concat ([result '()] [curlist slist])
(if (null? curlist)
result
(if (list? (car curlist))
(concat (append result (car curlist)) (cdr curlist))
(concat result (cdr curlist))))))
)
;Question1.e
(define (slist-symbols-at-depth slist d)
(if (equal? d 1)
(get-current-level slist)
(slist-symbols-at-depth (concatenate slist) (- d 1))))
(define (get-current-level slist)
(let curlevel ([result '()] [curlist slist])
(if (null? curlist)
result
(if (list? (car curlist))
(curlevel result (cdr curlist))
(curlevel (append result (cons (car curlist) '())) (cdr curlist)))))
)
;Question2
(define (subst-leftmost new old slist equality-pred?)
(if (null? slist)
'()
(if (list? (car slist))
(let ([cdr-sub (subst-leftmost new old (car slist) equality-pred?)])
(if (null? cdr-sub)
(cons (car slist) (subst-leftmost new old (cdr slist) equality-pred?))
(cons cdr-sub (cdr slist))))
(if (equality-pred? (car slist) old)
(cons new (cdr slist))
(cons (car slist) (subst-leftmost new old (cdr slist) equality-pred?)))))
)
;Question3.1
(define (bt-leaf-sum t)
(cond ((not (list? t)) t)
((null? t) 0)
((and (null? (cadr t)) (null? (caddr t))) (car t))
(else (+ (bt-leaf-sum (cadr t)) (bt-leaf-sum (caddr t)))
)
))
;Question3.2
(define (bt-inorder-list t)
(if (or (null? t) (number? t))
'()
(if (and (and (null? (cadr t)) (null? (caddr t))) (not (or (list? (cadr t)) (null? (caddr t)))))
(cons (car t) '())
(append (bt-inorder-list (cadr t)) (append (cons (car t) '()) (bt-inorder-list (caddr t))))
))
)
;Question3.3
(define (bt-max t)
(let getnmlist ([curT t])
(if (number? curT)
curT
(max (getnmlist (cadr curT)) (getnmlist (caddr curT))))
)
)
;Question3.4
(define (bt-max-interior t)
(car (max-helper t))
)
(define (max-helper t)
(cond ((and (number? (cadr t)) (number? (caddr t))) (cons (car t) (cons (+ (cadr t) (caddr t)) '())))
((number? (cadr t)) (if (positive? (cadr t))
(list (car t) (+ (cadr t) (cadr (max-helper (caddr t)))))
(max-helper (caddr t))))
((number? (caddr t)) (if (positive? (caddr t))
(list (car t) (+ (caddr t) (cadr (max-helper (cadr t)))))
(max-helper (cadr t))))
(else (cond ((and (positive? (cadr (max-helper (cadr t)))) (positive? (cadr (max-helper (caddr t)))))
(if (equal? (car (cadr t)) (car (max-helper (cadr t))))
(list (car t) (+ (cadr (max-helper (cadr t))) (cadr (max-helper (caddr t)))))
(max-helper (cadr t))))
((positive? (cadr (max-helper (cadr t)))) (max-helper (cadr t)))
((positive? (cadr (max-helper (caddr t)))) (max-helper (caddr t)))
(else (if (> (cadr (max-helper (cadr t))) (cadr (max-helper (caddr t))))
(max-helper (cadr t))
(max-helper (caddr t))))))
)
)
| false |
e248d921bd067e94d799b42a4b897dd9076c7eae | eef5f68873f7d5658c7c500846ce7752a6f45f69 | /spheres/structure/vlist.scm | 51ec0e51d24dcc97283d93da73b5e3bd1b027002 | [
"MIT"
]
| permissive | alvatar/spheres | c0601a157ddce270c06b7b58473b20b7417a08d9 | 568836f234a469ef70c69f4a2d9b56d41c3fc5bd | refs/heads/master | 2021-06-01T15:59:32.277602 | 2021-03-18T21:21:43 | 2021-03-18T21:21:43 | 25,094,121 | 13 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 18,707 | scm | vlist.scm | ;;!!! This module provides an implementations of vlists, a functional list-like
;; data structure described by Phil Bagwell in "Fast Functional Lists,
;; Hash-Lists, Dequeues and Variable-Length Arrays", EPFL Technical Report,
;; 2002.
;; .author Ludovic Courtès, 2009-2012
;; .author Ivan Raikov, 2012
;; .author Alvaro Castro-Castilla, 2015
;; .license LGPL
;;
;; The idea is to store vlist elements in increasingly large contiguous blocks
;; (implemented as vectors here). These blocks are linked to one another using
;; a pointer to the next block (called `block-base' here) and an offset within
;; that block (`block-offset' here). The size of these blocks form a geometric
;; series with ratio `block-growth-factor'.
;;
;; In the best case (e.g., using a vlist returned by `list->vlist'),
;; elements from the first half of an N-element vlist are accessed in O(1)
;; (assuming `block-growth-factor' is 2), and `vlist-length' takes only
;; O(ln(N)). Furthermore, the data structure improves data locality since
;; vlist elements are adjacent, which plays well with caches.
(define block-growth-factor (make-parameter 2))
(define (make-block base offset size hash-tab?)
;; Return a block (and block descriptor) of SIZE elements pointing to BASE
;; at OFFSET. If HASH-TAB? is true, a "hash table" is also added.
;; We could improve locality here by having a single vector but currently
;; the extra arithmetic outweighs the benefits (!).
(vector (make-vector size)
base offset size 0
(and hash-tab? (make-vector size #f))))
(define-syntax vlist%define-block-accessor
(syntax-rules ()
((_ name index)
(define (name block)
(vector-ref block index)))))
(vlist%define-block-accessor block-content 0)
(vlist%define-block-accessor block-base 1)
(vlist%define-block-accessor block-offset 2)
(vlist%define-block-accessor block-size 3)
(vlist%define-block-accessor block-next-free 4)
(vlist%define-block-accessor block-hash-table 5)
(define (increment-block-next-free! block)
(vector-set! block 4
(+ (block-next-free block) 1)))
(define (block-append! block value)
;; This is not thread-safe. To fix it, see Section 2.8 of the paper.
(let ((offset (block-next-free block)))
(increment-block-next-free! block)
(vector-set! (block-content block) offset value)
#t))
(define (block-ref block offset)
(vector-ref (block-content block) offset))
(define (block-ref* block offset)
(let ((v (block-ref block offset)))
(if (block-hash-table block)
(car v) ;; hide the vhash link
v)))
(define (block-hash-table-ref block offset)
(vector-ref (block-hash-table block) offset))
(define (block-hash-table-set! block offset value)
(vector-set! (block-hash-table block) offset value))
(define block-null
;; The null block.
(make-block #f 0 0 #f))
;;-------------------------------------------------------------------------------
;;!! Vlist
(define-record-type <vlist>
;; A vlist is just a base+offset pair pointing to a block.
;; Allocating a <vlist> record in addition to the block at each
;; `vlist-cons' call is inefficient. However, Bagwell's hack to avoid it
;; (Section 2.2) would require GC_ALL_INTERIOR_POINTERS, which would be a
;; performance hit for everyone.
(make-vlist base offset)
vlist?
(base vlist-base)
(offset vlist-offset))
(define vlist-null
;; The empty vlist.
(make-vlist block-null 0))
(define (block-cons item vlist hash-tab?)
(let loop ((base (vlist-base vlist))
(offset (+ 1 (vlist-offset vlist))))
(if (and (< offset (block-size base))
(= offset (block-next-free base))
(block-append! base item))
(make-vlist base offset)
(let ((size (cond ((eq? base block-null) 1)
((< offset (block-size base))
;; new vlist head
1)
(else
(* (block-growth-factor)
(block-size base))))))
;; Prepend a new block pointing to BASE.
(loop (make-block base (- offset 1) size hash-tab?)
0)))))
;;! Return a new vlist with {item} as its head and {vlist} as its tail
(define (vlist-cons item vlist)
;; Note: Calling `vlist-cons' on a vhash will not do the right thing: it
;; doesn't box ITEM so that it can have the hidden "next" link used by
;; vhash items, and it passes `#f' as the HASH-TAB? argument to
;; `block-cons'. However, inserting all the checks here has an important
;; performance penalty, hence this choice.
(block-cons item vlist #f))
;;! Return the head of {vlist}.
(define (vlist-head vlist)
(let ((base (vlist-base vlist))
(offset (vlist-offset vlist)))
(block-ref* base offset)))
;;! Return the tail of {vlist}.
(define (vlist-tail vlist)
(let ((base (vlist-base vlist))
(offset (vlist-offset vlist)))
(if (> offset 0)
(make-vlist base (- offset 1))
(make-vlist (block-base base)
(block-offset base)))))
;; Return true if {vlist} is empty.
(define (vlist-null? vlist)
(let ((base (vlist-base vlist)))
(and (not (block-base base))
(= 0 (block-size base)))))
;;! Return a new vlist whose contents correspond to {lst}.
(define (list->vlist lst)
(vlist-reverse (fold vlist-cons vlist-null lst)))
;;! Fold over {vlist}, calling {proc} for each element.
(define (vlist-fold proc init vlist)
;; FIXME: Handle multiple lists.
(let loop ((base (vlist-base vlist))
(offset (vlist-offset vlist))
(result init))
(if (eq? base block-null)
result
(let* ((next (- offset 1))
(done? (< next 0)))
(loop (if done? (block-base base) base)
(if done? (block-offset base) next)
(proc (block-ref* base offset) result))))))
;;! Fold over {vlist}, calling {proc} for each element, starting from the last element.
(define (vlist-fold-right proc init vlist)
(define len (vlist-length vlist))
(let loop ((index (- len 1))
(result init))
(if (< index 0)
result
(loop (- index 1)
(proc (vlist-ref vlist index) result)))))
;;! Return a new {vlist} whose content are those of {vlist} in reverse order.
(define (vlist-reverse vlist)
(vlist-fold vlist-cons vlist-null vlist))
;;! Map {proc} over the elements of {vlist} and return a new vlist.
(define (vlist-map proc vlist)
(vlist-fold (lambda (item result)
(vlist-cons (proc item) result))
vlist-null
(vlist-reverse vlist)))
;;! Return a new list whose contents match those of {vlist}.
(define (vlist->list vlist)
(vlist-fold-right cons '() vlist))
;;! Return the element at index {index} in {vlist}.
(define (vlist-ref vlist index)
(let loop ((index index)
(base (vlist-base vlist))
(offset (vlist-offset vlist)))
(if (<= index offset)
(block-ref* base (- offset index))
(loop (- index offset 1)
(block-base base)
(block-offset base)))))
;;! Return a new vlist that does not contain the {count} first elements of {vlist}.
(define (vlist-drop vlist count)
(let loop ((count count)
(base (vlist-base vlist))
(offset (vlist-offset vlist)))
(if (<= count offset)
(make-vlist base (- offset count))
(loop (- count offset 1)
(block-base base)
(block-offset base)))))
;;! Return a new vlist that contains only the {count} first elements of {vlist}.
(define (vlist-take vlist count)
(let loop ((count count)
(vlist vlist)
(result vlist-null))
(if (= 0 count)
(vlist-reverse result)
(loop (- count 1)
(vlist-tail vlist)
(vlist-cons (vlist-head vlist) result)))))
;;! Return a new vlist containing all the elements from {vlist} that satisfy {pred}.
(define (vlist-filter pred vlist)
(vlist-fold-right (lambda (e v)
(if (pred e)
(vlist-cons e v)
v))
vlist-null
vlist))
;;! Return a new vlist corresponding to {vlist} without the elements {equal?} to {x}.
(define (vlist-delete x vlist #!optional (equal? equal?))
(vlist-filter (lambda (e)
(not (equal? e x)))
vlist))
;;! Return the length of {vlist}.
(define (vlist-length vlist)
(let loop ((base (vlist-base vlist))
(len (vlist-offset vlist)))
(if (eq? base block-null)
len
(loop (block-base base)
(+ len 1 (block-offset base))))))
;;! Return a new vlist. See the description of SRFI-1 `unfold' for details.
(define (vlist-unfold p f g seed
#!optional (tail-gen (lambda (x) vlist-null)))
(let uf ((seed seed))
(if (p seed)
(tail-gen seed)
(vlist-cons (f seed)
(uf (g seed))))))
;;! Return a new vlist. See the description of SRFI-1 `unfold-right' for details.
(define (vlist-unfold-right p f g seed #!optional (tail vlist-null))
(let uf ((seed seed) (lis tail))
(if (p seed)
lis
(uf (g seed) (vlist-cons (f seed) lis)))))
;;! Append the given lists.
(define (vlist-append . vlists)
(if (null? vlists)
vlist-null
(fold-right (lambda (vlist result)
(vlist-fold-right (lambda (e v)
(vlist-cons e v))
result
vlist))
vlist-null
vlists)))
;;! Call {proc} on each element of {vlist}. The result is unspecified.
(define (vlist-for-each proc vlist)
(vlist-fold (lambda (item x)
(proc item))
(if #f #f)
vlist))
;;-------------------------------------------------------------------------------
;;!! Hash Lists, aka. `VHash'
;; Assume keys K1 and K2, H = hash(K1) = hash(K2), and two values V1 and V2
;; associated with K1 and K2, respectively. The resulting layout is a
;; follows:
;;
;; ,--------------------.
;; | ,-> (K1 . V1) ---. |
;; | | | |
;; | | (K2 . V2) <--' |
;; | | |
;; +-|------------------+
;; | | |
;; | | |
;; | `-- O <---------------H
;; | |
;; `--------------------'
;;
;; The bottom part is the "hash table" part of the vhash, as returned by
;; `block-hash-table'; the other half is the data part. O is the offset of
;; the first value associated with a key that hashes to H in the data part.
;; The (K1 . V1) pair has a "hidden" link to the (K2 . V2) pair; hiding the
;; link is handled by `block-ref'.
;;
;; This API potentially requires users to repeat which hash function and which
;; equality predicate to use. This can lead to unpredictable results if they
;; are used in consistenly, e.g., between `vhash-cons' and `vhash-assoc', which
;; is undesirable, as argued in http://savannah.gnu.org/bugs/?22159 . OTOH, two
;; arguments can be made in favor of this API:
;;
;; - It's consistent with how alists are handled in SRFI-1.
;;
;; - In practice, users will probably consistenly use either the `q', the `v',
;; or the plain variant (`vlist-cons' and `vlist-assoc' without any optional
;; argument), i.e., they will rarely explicitly pass a hash function or
;; equality predicate.
;;! Return true if {obj} is a hash list.
(define (vhash? obj)
(and (vlist? obj)
(let ((base (vlist-base obj)))
(and base
(vector? (block-hash-table base))))))
;;! Return a new hash list based on {vhash} where {key} is associated
;; with {value}. Use {hash} to compute {key}'s hash.
(define (vhash-cons key value vhash #!optional (hash hash))
(let* ((key+value (cons key value))
(entry (cons key+value #f))
(vlist (block-cons entry vhash #t))
(base (vlist-base vlist))
(khash (hash key (block-size base))))
(let ((o (block-hash-table-ref base khash)))
(if o (set-cdr! entry o)))
(block-hash-table-set! base khash
(vlist-offset vlist))
vlist))
(define vhash-consq (cut vhash-cons <> <> <> eq?-hash))
(define vhash-consv (cut vhash-cons <> <> <> eqv?-hash))
(define (%vhash-fold* proc init key vhash equal? hash)
;; Fold over all the values associated with KEY in VHASH.
(define khash
(let ((size (block-size (vlist-base vhash))))
(and (> size 0) (hash key size))))
(let loop ((base (vlist-base vhash))
(khash khash)
(offset (and khash
(block-hash-table-ref (vlist-base vhash)
khash)))
(max-offset (vlist-offset vhash))
(result init))
(let ((answer (and offset (block-ref base offset))))
(cond ((and (pair? answer)
(<= offset max-offset)
(let ((answer-key (caar answer)))
(equal? key answer-key)))
(let ((result (proc (cdar answer) result))
(next-offset (cdr answer)))
(loop base khash next-offset max-offset result)))
((and (pair? answer) (cdr answer))
=>
(lambda (next-offset)
(loop base khash next-offset max-offset result)))
(else
(let ((next-base (block-base base)))
(if (and next-base (> (block-size next-base) 0))
(let* ((khash (hash key (block-size next-base)))
(offset (block-hash-table-ref next-base khash)))
(loop next-base khash offset (block-offset base)
result))
result)))))))
;;! Fold over all the values associated with {key} in {vhash}, with
;; each call to {proc} having the form {(proc value result)},
;; where {result} is the result of the previous call to {proc} and
;; {init} the value of {result} for the first call to {proc}."
(define (vhash-fold* proc init key vhash
#!optional (equal? equal?) (hash hash))
(%vhash-fold* proc init key vhash equal? hash))
;;! Same as {vhash-fold*}, but using {eq?-hash} and {eq?}.
(define (vhash-foldq* proc init key vhash)
(%vhash-fold* proc init key vhash eq? eq?-hash))
;;! Same as {vhash-fold*}, but using {eqv?-hash} and {eqv?}.
(define (vhash-foldv* proc init key vhash)
(%vhash-fold* proc init key vhash eqv? eqv?-hash))
;;! A specialization of `vhash-fold*' that stops when the first value
;; associated with KEY is found or when the end-of-list is reached.
;; Inline to make sure `vhash-assq' gets to use the `eq?' instruction
;; instead of calling the `eq?' subr.
(define (%vhash-assoc key vhash equal? hash)
(define khash
(let ((size (block-size (vlist-base vhash))))
(and (> size 0) (hash key size))))
(let loop ((base (vlist-base vhash))
(khash khash)
(offset (and khash
(block-hash-table-ref (vlist-base vhash)
khash)))
(max-offset (vlist-offset vhash)))
(let ((answer (and offset (block-ref base offset))))
(cond ((and (pair? answer)
(<= offset max-offset)
(let ((answer-key (caar answer)))
(equal? key answer-key)))
(car answer))
((and (pair? answer) (cdr answer))
=>
(lambda (next-offset)
(loop base khash next-offset max-offset)))
(else
(let ((next-base (block-base base)))
(and next-base
(> (block-size next-base) 0)
(let* ((khash (hash key (block-size next-base)))
(offset (block-hash-table-ref next-base khash)))
(loop next-base khash offset
(block-offset base))))))))))
;;! Return the first key/value pair from {vhash} whose key is equal to
;; {key} according to the {equal?} equality predicate.
(define (vhash-assoc key vhash #!optional (equal? equal?) (hash hash))
(%vhash-assoc key vhash equal? hash))
;;! Return the first key/value pair from {vhash} whose key is {eq?} to
;; {key}.
(define (vhash-assq key vhash)
(%vhash-assoc key vhash eq? eq?-hash))
;;! Return the first key/value pair from {vhash} whose key is {eqv?} to
;; {key}.
(define (vhash-assv key vhash)
(%vhash-assoc key vhash eqv? eqv?-hash))
;;! Remove all associations from {vhash} with {key}, comparing keys with {equal?}.
(define (vhash-delete key vhash #!optional (equal? equal?) (hash hash))
(if (vhash-assoc key vhash equal? hash)
(vlist-fold (lambda (k+v result)
(let ((k (car k+v))
(v (cdr k+v)))
(if (equal? k key)
result
(vhash-cons k v result hash))))
vlist-null
vhash)
vhash))
(define vhash-delq (cut vhash-delete <> <> eq? eq?-hash))
(define vhash-delv (cut vhash-delete <> <> eqv? eqv?-hash))
;;! Fold over the key/pair elements of {vhash} from left to right, with
;; each call to {proc} having the form {({proc} key value result)},
;; where {result} is the result of the previous call to {proc} and
;; {init} the value of {result} for the first call to {proc}.
(define (vhash-fold proc init vhash)
(vlist-fold (lambda (key+value result)
(proc (car key+value) (cdr key+value)
result))
init
vhash))
;;! Fold over the key/pair elements of {vhash} from right to left, with
;; each call to {proc} having the form {({proc} key value result)},
;; where {result} is the result of the previous call to {proc} and
;; {init} the value of {result} for the first call to {proc}.
(define (vhash-fold-right proc init vhash)
(vlist-fold-right (lambda (key+value result)
(proc (car key+value) (cdr key+value)
result))
init
vhash))
;;! Return the vhash corresponding to {alist}, an association list.
(define (alist->vhash alist #!optional (hash hash))
(fold-right (lambda (pair result)
(vhash-cons (car pair) (cdr pair) result hash))
vlist-null
alist))
| true |
d5172a1c24dbf6d61b54b432875ac547ff705b33 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System.Data/system/data/sql-client/sql-command-builder.sls | 4fd5628557af53ab24cb5fd3d22148e0e98efa5a | []
| 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 | 3,455 | sls | sql-command-builder.sls | (library (system data sql-client sql-command-builder)
(export new
is?
sql-command-builder?
derive-parameters
unquote-identifier
get-delete-command
quote-identifier
get-insert-command
get-update-command
data-adapter-get
data-adapter-set!
data-adapter-update!
quote-prefix-get
quote-prefix-set!
quote-prefix-update!
quote-suffix-get
quote-suffix-set!
quote-suffix-update!
catalog-separator-get
catalog-separator-set!
catalog-separator-update!
schema-separator-get
schema-separator-set!
schema-separator-update!
catalog-location-get
catalog-location-set!
catalog-location-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Data.SqlClient.SqlCommandBuilder a ...)))))
(define (is? a) (clr-is System.Data.SqlClient.SqlCommandBuilder a))
(define (sql-command-builder? a)
(clr-is System.Data.SqlClient.SqlCommandBuilder a))
(define-method-port
derive-parameters
System.Data.SqlClient.SqlCommandBuilder
DeriveParameters
(static: System.Void System.Data.SqlClient.SqlCommand))
(define-method-port
unquote-identifier
System.Data.SqlClient.SqlCommandBuilder
UnquoteIdentifier
(System.String System.String))
(define-method-port
get-delete-command
System.Data.SqlClient.SqlCommandBuilder
GetDeleteCommand
(System.Data.SqlClient.SqlCommand System.Boolean)
(System.Data.SqlClient.SqlCommand))
(define-method-port
quote-identifier
System.Data.SqlClient.SqlCommandBuilder
QuoteIdentifier
(System.String System.String))
(define-method-port
get-insert-command
System.Data.SqlClient.SqlCommandBuilder
GetInsertCommand
(System.Data.SqlClient.SqlCommand System.Boolean)
(System.Data.SqlClient.SqlCommand))
(define-method-port
get-update-command
System.Data.SqlClient.SqlCommandBuilder
GetUpdateCommand
(System.Data.SqlClient.SqlCommand System.Boolean)
(System.Data.SqlClient.SqlCommand))
(define-field-port
data-adapter-get
data-adapter-set!
data-adapter-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
DataAdapter
System.Data.SqlClient.SqlDataAdapter)
(define-field-port
quote-prefix-get
quote-prefix-set!
quote-prefix-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
QuotePrefix
System.String)
(define-field-port
quote-suffix-get
quote-suffix-set!
quote-suffix-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
QuoteSuffix
System.String)
(define-field-port
catalog-separator-get
catalog-separator-set!
catalog-separator-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
CatalogSeparator
System.String)
(define-field-port
schema-separator-get
schema-separator-set!
schema-separator-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
SchemaSeparator
System.String)
(define-field-port
catalog-location-get
catalog-location-set!
catalog-location-update!
(property:)
System.Data.SqlClient.SqlCommandBuilder
CatalogLocation
System.Data.Common.CatalogLocation))
| true |
03e6c0bd69b89a5851d655c4c257de62ae7f64d3 | 26aaec3506b19559a353c3d316eb68f32f29458e | /modules/ssax/stx-engine.sch | 302f10b49417a7e584bd48390f232ab327fb8202 | [
"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 | 758 | sch | stx-engine.sch |
; A helper for stx:xsl->stx
(define-macro stx:call-function
(lambda (name type tpl-node $-env)
`(let ((fn (,$-env
(string->symbol ,name))))
(if
(eq? fn '*LT-NOT-FOUND*)
(apply stx:error
(append
(list "Undefined " ,type " with name " ,name " is called by:" nl)
(sxml:clean-feed (sxml:sxml->xml ',tpl-node))
(list nl "Valid names: ") (map car (,$-env))
))
(call-with-err-handler
(lambda()
(sxml:clean-feed
(fn current-node stx:templates current-root (,$-env '*LT-ADD*
`(stx:param ,',tpl-node)))))
(lambda (mes)
(apply stx:error
(list ,type " evaluation ERROR"
nl mes nl "for:" nl
(sxml:clean-feed
(sxml:sxml->xml ',tpl-node))))))))))
| false |
65dc32e1fe753eb4c6729c4d24d0cf2ca5faf44e | 46244bb6af145cb393846505f37bf576a8396aa0 | /sicp/2_69.scm | da3f36e6fd87f8554ea1b5968311d606207bec5e | []
| no_license | aoeuidht/homework | c4fabfb5f45dbef0874e9732c7d026a7f00e13dc | 49fb2a2f8a78227589da3e5ec82ea7844b36e0e7 | refs/heads/master | 2022-10-28T06:42:04.343618 | 2022-10-15T15:52:06 | 2022-10-15T15:52:06 | 18,726,877 | 4 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 5,490 | scm | 2_69.scm | #lang racket
(define (make-leaf symbol weight)
(list 'leaf symbol weight))
(define (leaf? object)
(eq? (car object) 'leaf))
(define (symbol-leaf x) (cadr x))
(define (weight-leaf x) (caddr x))
(define (make-code-tree left right)
(list left
right
(append (symbols left) (symbols right))
(+ (weight left) (weight right))))
(define (left-branch tree) (car tree))
(define (right-branch tree) (cadr tree))
(define (symbols tree)
(if (leaf? tree)
(list (symbol-leaf tree))
(caddr tree)))
(define (weight tree)
(if (leaf? tree)
(weight-leaf tree)
(cadddr tree)))
(define (decode bits tree)
(define (decode-1 bits current-branch)
(if (null? bits)
'()
(let ((next-branch
(choose-branch (car bits) current-branch)))
(if (leaf? next-branch)
(cons (symbol-leaf next-branch)
(decode-1 (cdr bits) tree))
(decode-1 (cdr bits) next-branch)))))
(decode-1 bits tree))
(define (choose-branch bit branch)
(cond ((= bit 0) (left-branch branch))
((= bit 1) (right-branch branch))
(else (error "bad bit -- CHOOSE-BRANCH" bit))))
(define (adjoin-set x set)
(cond ((null? set) (list x))
((< (weight x) (weight (car set))) (cons x set))
(else (cons (car set)
(adjoin-set x (cdr set))))))
(define (make-leaf-set pairs)
(if (null? pairs)
'()
(let ((pair (car pairs)))
(adjoin-set (make-leaf (car pair)
(cadr pair)) ; frequency
(make-leaf-set (cdr pairs))))))
(define (msg-in-tree msg tree)
(cond ((null? tree) #f)
((leaf? tree) (eq? (symbol-leaf tree) msg))
(else (memq msg (symbols tree)))))
(define (encode-symbol msg tree)
(define (encode-symbol1 prefix msg tree)
(cond ((null? tree) (error "bad tree -- maybe invalid message"))
((eq? #f (msg-in-tree msg tree)) #f)
((leaf? tree) prefix)
((msg-in-tree msg (left-branch tree)) (encode-symbol1 (append prefix '(0)) msg (left-branch tree)))
(else (encode-symbol1 (append prefix '(1)) msg (right-branch tree)))))
(encode-symbol1 '() msg tree))
(define (encode message tree)
(if (null? message)
'()
(append (encode-symbol (car message) tree)
(encode (cdr message) tree))))
; Encode-symbol is a procedure, which you must write, that returns the list of bits that encodes a given symbol
; according to a given tree. You should design encode-symbol so that it signals an error
; if the symbol is not in the tree at all.
; Test your procedure by encoding the result you obtained in exercise 2.67 with the sample tree
; and seeing whether it is the same as the original sample message.
(define sample-tree
(make-code-tree (make-leaf 'A 4)
(make-code-tree
(make-leaf 'B 2)
(make-code-tree (make-leaf 'D 1)
(make-leaf 'C 1)))))
(define sample-message '(0 1 1 0 0 1 0 1 0 1 1 1 0))
(encode-symbol 'A sample-tree)
(encode-symbol 'B sample-tree)
(encode-symbol 'C sample-tree)
(encode-symbol 'D sample-tree)
(encode '(A D A B B C A) sample-tree)
(encode (decode sample-message sample-tree) sample-tree)
; Exercise 2.69. The following procedure takes as its argument a list of symbol-frequency pairs
; (where no symbol appears in more than one pair) and generates a Huffman encoding tree according to the Huffman algorithm.
;(define (generate-huffman-tree pairs)
; (successive-merge (make-leaf-set pairs)))
; Make-leaf-set is the procedure given above that transforms the list of pairs
; into an ordered set of leaves. Successive-merge is the procedure you must write,
; using make-code-tree to successively
; merge the smallest-weight elements of the set until there is only one element left,
; which is the desired Huffman tree. (This procedure is slightly tricky, but not really complicated.
; If you find yourself designing a complex procedure, then you are almost certainly doing something wrong.
; You can take significant advantage of the fact that we are using an ordered set representation.)
; Answer
; To make a huffman tree, you should merge 2 smallest weight leafs/trees into a new tree
; so to build a huffman tree, we have to do 2 steps recursivly:
; 1. the first 2 leafs/trees to one
; 2. sort the nodes by weight
; step 1. write a producer get the weight of leof/tree
(define (weight-of-node node)
(cond ((leaf? node) (weight-leaf node))
(else (weight node))))
; step 2. insert a node to the order list
(define (adjoin-node x nodes)
(cond ((null? nodes) (list x))
((< (weight-of-node x) (weight-of-node (car nodes))) (cons x nodes))
(else (cons (car nodes)
(adjoin-node x (cdr nodes))))))
; step 3. done!
(define (successive-merge nodes)
(if (null? (cdr nodes))
(car nodes) ; only one node left, return it
(successive-merge (adjoin-node (make-code-tree (car nodes)
(cadr nodes))
(cddr nodes)))))
(define (generate-huffman-tree pairs)
(successive-merge (make-leaf-set pairs)))
(define htree (generate-huffman-tree '((A 4) (C 1) (B 2) (D 1))))
(encode '(A D A B B C A) sample-tree)
(encode '(A D A B B C A) htree)
(encode (decode sample-message sample-tree) sample-tree)
(encode (decode sample-message htree) htree) | false |
04bcb4333bbd2c4e781f71d8c9c7a5f46b513353 | 665da87f9fefd8678b0635e31df3f3ff28a1d48c | /srfi/sorting/vmsort.scm | 2144716cd75ac3096dfe688722eabcf350718796 | [
"MIT"
]
| permissive | justinethier/cyclone | eeb782c20a38f916138ac9a988dc53817eb56e79 | cc24c6be6d2b7cc16d5e0ee91f0823d7a90a3273 | refs/heads/master | 2023-08-30T15:30:09.209833 | 2023-08-22T02:11:59 | 2023-08-22T02:11:59 | 31,150,535 | 862 | 64 | MIT | 2023-03-04T15:15:37 | 2015-02-22T03:08:21 | Scheme | UTF-8 | Scheme | false | false | 9,462 | scm | vmsort.scm | ;;; The sort package -- stable vector merge & merge sort -*- Scheme -*-
;;; Copyright (c) 1998 by Olin Shivers.
;;; This code is open-source; see the end of the file for porting and
;;; more copyright information.
;;; Olin Shivers 10/98.
;;; Exports:
;;; (vector-merge < v1 v2 [start1 end1 start2 end2]) -> vector
;;; (vector-merge! < v v1 v2 [start0 start1 end1 start2 end2]) -> unspecific
;;;
;;; (vector-merge-sort < v [start end temp]) -> vector
;;; (vector-merge-sort! < v [start end temp]) -> unspecific
;;; Merge
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; (vector-merge < v1 v2 [start1 end1 start2 end2]) -> vector
;;; (vector-merge! < v v1 v2 [start start1 end1 start2 end2]) -> unspecific
;;;
;;; Stable vector merge -- V1's elements come out ahead of equal V2 elements.
(define (vector-merge < v1 v2 . maybe-starts+ends)
(call-with-values
(lambda () (vectors-start+end-2 v1 v2 maybe-starts+ends))
(lambda (start1 end1 start2 end2)
(let ((ans (make-vector (+ (- end1 start1) (- end2 start2)))))
(%vector-merge! < ans v1 v2 0 start1 end1 start2 end2)
ans))))
(define (vector-merge! < v v1 v2 . maybe-starts+ends)
(call-with-values
(lambda ()
(if (pair? maybe-starts+ends)
(values (car maybe-starts+ends)
(cdr maybe-starts+ends))
(values 0
'())))
(lambda (start rest)
(call-with-values
(lambda () (vectors-start+end-2 v1 v2 rest))
(lambda (start1 end1 start2 end2)
(%vector-merge! < v v1 v2 start start1 end1 start2 end2))))))
;;; This routine is not exported. The code is tightly bummed.
;;;
;;; If these preconditions hold, the routine can be bummed to run with
;;; unsafe vector-indexing and fixnum arithmetic ops:
;;; - V V1 V2 are vectors.
;;; - START START1 END1 START2 END2 are fixnums.
;;; - (<= 0 START END0 (vector-length V),
;;; where end0 = start + (end1 - start1) + (end2 - start2)
;;; - (<= 0 START1 END1 (vector-length V1))
;;; - (<= 0 START2 END2 (vector-length V2))
;;; If you put these error checks in the two client procedures above, you can
;;; safely convert this procedure to use unsafe ops -- which is why it isn't
;;; exported. This will provide *huge* speedup.
(define (%vector-merge! elt< v v1 v2 start start1 end1 start2 end2)
(letrec ((vblit (lambda (fromv j i end) ; Blit FROMV[J,END) to V[I,?].
(let lp ((j j) (i i))
(vector-set! v i (vector-ref fromv j))
(let ((j (+ j 1)))
(if (< j end) (lp j (+ i 1))))))))
(cond ((<= end1 start1) (if (< start2 end2) (vblit v2 start2 start end2)))
((<= end2 start2) (vblit v1 start1 start end1))
;; Invariants: I is next index of V to write; X = V1[J]; Y = V2[K].
(else (let lp ((i start)
(j start1) (x (vector-ref v1 start1))
(k start2) (y (vector-ref v2 start2)))
(let ((i1 (+ i 1))) ; "i+1" is a complex number in R4RS!
(if (elt< y x)
(let ((k (+ k 1)))
(vector-set! v i y)
(if (< k end2)
(lp i1 j x k (vector-ref v2 k))
(vblit v1 j i1 end1)))
(let ((j (+ j 1)))
(vector-set! v i x)
(if (< j end1)
(lp i1 j (vector-ref v1 j) k y)
(vblit v2 k i1 end2))))))))))
;;; (vector-merge-sort < v [start end temp]) -> vector
;;; (vector-merge-sort! < v [start end temp]) -> unspecific
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Stable natural vector merge sort
(define (vector-merge-sort! < v . maybe-args)
(call-with-values
(lambda () (vector-start+end v maybe-args))
(lambda (start end)
(let ((temp (if (and (pair? maybe-args) ; kludge
(pair? (cdr maybe-args))
(pair? (cddr maybe-args)))
(caddr maybe-args)
(vector-copy v))))
(%vector-merge-sort! < v start end temp)))))
(define (vector-merge-sort < v . maybe-args)
(call-with-values
(lambda () (vector-start+end v maybe-args))
(lambda (start end)
(let ((ans (r7rs-vector-copy v start end)))
(vector-merge-sort! < ans)
ans))))
;;; %VECTOR-MERGE-SORT! is not exported.
;;; Preconditions:
;;; V TEMP vectors
;;; START END fixnums
;;; START END legal indices for V and TEMP
;;; If these preconditions are ensured by the cover functions, you
;;; can safely change this code to use unsafe fixnum arithmetic and vector
;;; indexing ops, for *huge* speedup.
;;; This merge sort is "opportunistic" -- the leaves of the merge tree are
;;; contiguous runs of already sorted elements in the vector. In the best
;;; case -- an already sorted vector -- it runs in linear time. Worst case
;;; is still O(n lg n) time.
(define (%vector-merge-sort! elt< v0 l r temp0)
(define (xor a b) (not (eq? a b)))
;; Merge v1[l,l+len1) and v2[l+len1,l+len1+len2) into target[l,l+len1+len2)
;; Merge left-to-right, so that TEMP may be either V1 or V2
;; (that this is OK takes a little bit of thought).
;; V2=TARGET? is true if V2 and TARGET are the same, which allows
;; merge to punt the final blit half of the time.
(define (merge target v1 v2 l len1 len2 v2=target?)
(letrec ((vblit (lambda (fromv j i end) ; Blit FROMV[J,END) to TARGET[I,?]
(let lp ((j j) (i i)) ; J < END. The final copy.
(vector-set! target i (vector-ref fromv j))
(let ((j (+ j 1)))
(if (< j end) (lp j (+ i 1))))))))
(let* ((r1 (+ l len1))
(r2 (+ r1 len2)))
; Invariants:
(let lp ((n l) ; N is next index of
(j l) (x (vector-ref v1 l)) ; TARGET to write.
(k r1) (y (vector-ref v2 r1))) ; X = V1[J]
(let ((n+1 (+ n 1))) ; Y = V2[K]
(if (elt< y x)
(let ((k (+ k 1)))
(vector-set! target n y)
(if (< k r2)
(lp n+1 j x k (vector-ref v2 k))
(vblit v1 j n+1 r1)))
(let ((j (+ j 1)))
(vector-set! target n x)
(if (< j r1)
(lp n+1 j (vector-ref v1 j) k y)
(if (not v2=target?) (vblit v2 k n+1 r2))))))))))
;; Might hack GETRUN so that if the run is short it pads it out to length
;; 10 with insert sort...
;; Precondition: l < r.
(define (getrun v l r)
(let lp ((i (+ l 1)) (x (vector-ref v l)))
(if (>= i r)
(- i l)
(let ((y (vector-ref v i)))
(if (elt< y x)
(- i l)
(lp (+ i 1) y))))))
;; RECUR: Sort V0[L,L+LEN) for some LEN where 0 < WANT <= LEN <= (R-L).
;; That is, sort *at least* WANT elements in V0 starting at index L.
;; May put the result into either V0[L,L+LEN) or TEMP0[L,L+LEN).
;; Must not alter either vector outside this range.
;; Return:
;; - LEN -- the number of values we sorted
;; - ANSVEC -- the vector holding the value
;; - ANS=V0? -- tells if ANSVEC is V0 or TEMP
;;
;; LP: V[L,L+PFXLEN) holds a sorted prefix of V0.
;; TEMP = if V = V0 then TEMP0 else V0. (I.e., TEMP is the other vec.)
;; PFXLEN2 is a power of 2 <= PFXLEN.
;; Solve RECUR's problem.
(if (< l r) ; Don't try to sort an empty range.
(call-with-values
(lambda ()
(let recur ((l l) (want (- r l)))
(let ((len (- r l)))
(let lp ((pfxlen (getrun v0 l r)) (pfxlen2 1)
(v v0) (temp temp0)
(v=v0? #t))
(if (or (>= pfxlen want) (= pfxlen len))
(values pfxlen v v=v0?)
(let ((pfxlen2 (let lp ((j pfxlen2))
(let ((j*2 (+ j j)))
(if (<= j pfxlen) (lp j*2) j))))
(tail-len (- len pfxlen)))
;; PFXLEN2 is now the largest power of 2 <= PFXLEN.
;; (Just think of it as being roughly PFXLEN.)
(call-with-values
(lambda ()
(recur (+ pfxlen l) pfxlen2))
(lambda (nr-len nr-vec nrvec=v0?)
(merge temp v nr-vec l pfxlen nr-len
(xor nrvec=v0? v=v0?))
(lp (+ pfxlen nr-len) (+ pfxlen2 pfxlen2)
temp v (not v=v0?))))))))))
(lambda (ignored-len ignored-ansvec ansvec=v0?)
(if (not ansvec=v0?)
(r7rs-vector-copy! v0 l temp0 l r))))))
;;; Copyright
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; This code is
;;; Copyright (c) 1998 by Olin Shivers.
;;; The terms are: You may do as you please with this code, as long as
;;; you do not delete this notice or hold me responsible for any outcome
;;; related to its use.
;;;
;;; Blah blah blah. Don't you think source files should contain more lines
;;; of code than copyright notice?
;;; Code tuning & porting
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; This code is *tightly* bummed as far as I can go in portable Scheme.
;;;
;;; The two internal primitives that do the real work can be converted to
;;; use unsafe vector-indexing and fixnum-specific arithmetic ops *if* you
;;; alter the four small cover functions to enforce the invariants. This should
;;; provide *big* speedups. In fact, all the code bumming I've done pretty
;;; much disappears in the noise unless you have a good compiler and also
;;; can dump the vector-index checks and generic arithmetic -- so I've really
;;; just set things up for you to exploit.
;;;
;;; The optional-arg parsing, defaulting, and error checking is done with a
;;; portable R4RS macro. But if your Scheme has a faster mechanism (e.g.,
;;; Chez), you should definitely port over to it. Note that argument defaulting
;;; and error-checking are interleaved -- you don't have to error-check
;;; defaulted START/END args to see if they are fixnums that are legal vector
;;; indices for the corresponding vector, etc.
| false |
e635db09cf260cd1f21957881a2702cdac4dbbb9 | 7aeb920de21547a1d9c714b029bbf3a9e7df449e | /scheme/documentation/more.scm | 63bddc068a1072da97da5508eaf3d31dc20df680 | [
"BSD-2-Clause"
]
| permissive | ft/chip-remote | f8ac5a2d7597d24f44ac287836be3422a32283d4 | 2a64df611214f7e3eb55d4ead76e270351158cdb | refs/heads/master | 2023-04-30T08:38:16.483240 | 2023-01-05T04:01:44 | 2023-01-05T04:01:44 | 117,028,633 | 2 | 1 | null | null | null | null | UTF-8 | Scheme | false | false | 1,494 | scm | more.scm | ;; Copyright (c) 2018-2021 chip-remote workers, All rights reserved.
;;
;; Terms for redistribution and use can be found in doc/LICENCE.
(define-module (documentation more)
#:use-module (ice-9 documentation)
#:export (inlinable?
add-macro-docstring
define-variable
maybe-topdir
variable-documentation))
(define (inlinable? mod name)
(catch #t
(lambda ()
(eval-string (symbol->string name) (resolve-module mod)))
(lambda (k . a)
#f)))
(define (add-macro-docstring name docstring)
(let ((var (module-variable (current-module)
name)))
(set-procedure-property! (macro-transformer (variable-ref var))
'documentation
docstring)))
(define-syntax define-variable
(lambda (x)
(syntax-case x ()
((kw name value docstring)
#'(begin (define name value)
(set-object-property! (module-variable (current-module)
'name)
'documentation
docstring))))))
(define (variable-documentation mod name)
(catch #t
(lambda ()
(or (object-property (module-variable (resolve-module mod) name)
'documentation)
'undocumented))
(lambda (k . a)
'undocumented)))
(define (maybe-topdir fallback)
(or (getenv "TOPDIR") fallback))
| true |
7aaf2b510d20435b785247641a46509cfbc31fcc | d074b9a2169d667227f0642c76d332c6d517f1ba | /sicp/ch_4/exercise.4.77.scm | 4431106e60d9f47074e33327bdc2b6ba1078e1c1 | []
| 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 | 770 | scm | exercise.4.77.scm | #!/usr/bin/env csi -s
(require rackunit)
;;; Exercise 4.77
;; In section *Note 4-4-3:: we saw that `not' and
;; `lisp-value' can cause the query language to give "wrong" answers
;; if these filtering operations are applied to frames in which
;; variables are unbound. Devise a way to fix this shortcoming. One
;; idea is to perform the filtering in a "delayed" manner by
;; appending to the frame a "promise" to filter that is fulfilled
;; only when enough variables have been bound to make the operation
;; possible. We could wait to perform filtering until all other
;; operations have been performed. However, for efficiency's sake, we
;; would like to perform filtering as soon as possible so as to cut
;; down on the number of intermediate frames generated.
| false |
f74d6120285d3c75508b56eeb8c5a2bd2f26f31e | 958488bc7f3c2044206e0358e56d7690b6ae696c | /scheme/digital/global-test.scm | 489a4e93f239955488041aa7b0f3800506f2b340 | []
| 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 | 3,191 | scm | global-test.scm | (load "global.scm")
(define (global-test)
(define a (make-global-object))
(define b (make-global-object))
(display "global: starting unit test\n")
;; unit-test?
(if (not (eq? (a 'unit-test?) #f)) (display "global: unit-test 1 failing\n"))
(if (not (eq? (b 'unit-test?) #f)) (display "global: unit-test 2 failing\n"))
(a 'unit-test-true!) ; this should impact b
(if (not (eq? (a 'unit-test?) #t)) (display "global: unit-test 3 failing\n"))
(if (not (eq? (b 'unit-test?) #t)) (display "global: unit-test 4 failing\n"))
(b 'unit-test-false!) ; this should impact a
(if (not (eq? (a 'unit-test?) #f)) (display "global: unit-test 5 failing\n"))
(if (not (eq? (b 'unit-test?) #f)) (display "global: unit-test 6 failing\n"))
;; debug?
(if (not (eq? (a 'debug?) #f)) (display "global: unit-test 7 failing\n"))
(if (not (eq? (b 'debug?) #f)) (display "global: unit-test 8 failing\n"))
(a 'debug-true!) ; this should impact b
(if (not (eq? (a 'debug?) #t)) (display "global: unit-test 9 failing\n"))
(if (not (eq? (b 'debug?) #t)) (display "global: unit-test 10 failing\n"))
(b 'debug-false!) ; this should impact a
(if (not (eq? (a 'debug?) #f)) (display "global: unit-test 11 failing\n"))
(if (not (eq? (b 'debug?) #f)) (display "global: unit-test 12 failing\n"))
;; error-count
(if (not (= (a 'error-count) 0)) (display "global: unit-test 13 failing\n"))
(if (not (= (b 'error-count) 0)) (display "global: unit-test 14 failing\n"))
((a 'error!) "") ; should increase counter by 1 for both a and b
(if (not (= (a 'error-count) 1)) (display "global: unit-test 15 failing\n"))
(if (not (= (b 'error-count) 1)) (display "global: unit-test 16 failing\n"))
((b 'error!) "") ; should increase counter by 1 for both a and b
(if (not (= (a 'error-count) 2)) (display "global: unit-test 17 failing\n"))
(if (not (= (b 'error-count) 2)) (display "global: unit-test 18 failing\n"))
(a 'error-count-reset!) ; impacts b
(if (not (= (a 'error-count) 0)) (display "global: unit-test 19 failing\n"))
(if (not (= (b 'error-count) 0)) (display "global: unit-test 20 failing\n"))
;; main-agenda
(if (not (= (a 'now) 0)) (display "global: unit-test 21 failing\n"))
(if (not (= (b 'now) 0)) (display "global: unit-test 22 failing\n"))
((a 'add-event!) 1 (lambda () 'done)) ; impacts b
(if (not (= (a 'now) 0)) (display "global: unit-test 22 failing\n"))
(if (not (= (b 'now) 0)) (display "global: unit-test 23 failing\n"))
(b 'propagate!) ; this should move the clock of both a and b
(if (not (= (a 'now) 1)) (display "global: unit-test 24 failing\n"))
(if (not (= (b 'now) 1)) (display "global: unit-test 25 failing\n"))
((b 'add-event!) 3 (lambda () 'done)) ; impacts a
(a 'propagate!) ; this should move the clock of both a and b
(if (not (= (a 'now) 4)) (display "global: unit-test 26 failing\n"))
(if (not (= (b 'now) 4)) (display "global: unit-test 27 failing\n"))
(a 'time-reset!) ; impacts b
(if (not (= (a 'now) 0)) (display "global: unit-test 28 failing\n"))
(if (not (= (b 'now) 0)) (display "global: unit-test 29 failing\n"))
(display "global: unit test complete\n"))
(global-test)
(exit 0)
| false |
2d7d40ca1f36ba9b93a0b1de3581af5058e07b76 | 0b90add00a39e266f63ee7868b4b6499d58bbb31 | /combinators/macros.sls | 3c19e3e3d4e4028c7a9dc080f9916740d20e68f6 | []
| no_license | okuoku/dharmalab | e295b7fb6fda704d73b9865841fb6dc6605e78a5 | 9ac64b8de3067a73c812f3534bd6710f6a7d3109 | refs/heads/master | 2021-01-16T20:01:25.538104 | 2010-07-04T08:58:54 | 2011-01-17T16:53:18 | 756,061 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,261 | sls | macros.sls |
(library (dharmalab combinators macros)
(export identity
constant
compose
ifte
cleave
spread
nary@)
(import (rnrs))
(define (identity x) x)
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-syntax constant
(syntax-rules ()
( (constant x args)
(let ((x* x))
(lambda args
x*)) )
( (constant x)
(constant x (y)) )))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-syntax compose
(syntax-rules (<=>)
( (compose (f) (x ...))
(lambda (x ...)
(f x ...)) )
( (compose (f g ...) (x ...))
(lambda (x ...)
(f ((compose (g ...) (x ...)) x ...))) )
( (compose (f ...))
(compose (f ...) (x)) )
( (compose (f) <=>) f )
( (compose (f g ...) <=>)
(lambda args
(call-with-values
(lambda ()
(apply (compose (g ...) <=>) args))
f)) )))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (define-syntax ifte
;; (syntax-rules ()
;; ( (ifte f g h (x ...))
;; (lambda (x ...)
;; (if (f x ...)
;; (g x ...)
;; (h x ...))) )
;; ( (ifte f g h)
;; (ifte f g h (x)) )
;; ( (ifte f g h args)
;; (lambda args
;; (if (apply f args)
;; (apply g args)
;; (apply h args))) )
;; ))
(define-syntax ifte
(syntax-rules ()
( (ifte f g h (x ...))
(let ((f* f)
(g* g)
(h* h))
(lambda (x ...)
(if (f* x ...)
(g* x ...)
(h* x ...)))) )
( (ifte f g h)
(ifte f g h (x)) )
( (ifte f g h args)
(let ((f* f)
(g* g)
(h* h))
(lambda args
(if (apply f args)
(apply g args)
(apply h args)))) )))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (define-syntax cleave
;; (syntax-rules ()
;; ( (cleave (f ...) c (x ...))
;; (lambda (x ...)
;; (c (f x ...)
;; ...)) )
;; ( (cleave (f ...) c)
;; (cleave (f ...) c (x)) )))
(define-syntax cleave
(syntax-rules ()
( (cleave (f ...) (x ...) c)
(lambda (x ...)
(c (f x ...)
...)) )
( (cleave (f ...) c)
(cleave (f ...) (x) c) )))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-syntax spread
(lambda (stx)
(syntax-case stx ()
( (spread (f ...) c)
(with-syntax ( ( (x ...) (generate-temporaries (syntax (f ...))) ) )
(syntax
(lambda (x ...)
(c (f x)
...)))) ))))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-syntax nary@
(syntax-rules ()
( (nary@ f (x ...) c)
(lambda (x ...)
(c (f x)
...)) )))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
) | true |
49f9f5ea67884fa6a71f3ce3a09b2b4a3e9c32ea | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System/system/text/regular-expressions/syntax/capture-assertion.sls | 15106934807ad0412d862b9c57126d39090877a6 | []
| 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,268 | sls | capture-assertion.sls | (library (system text regular-expressions syntax capture-assertion)
(export new
is?
capture-assertion?
compile
is-complex?
capturing-group-get
capturing-group-set!
capturing-group-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Text.RegularExpressions.Syntax.CaptureAssertion
a
...)))))
(define (is? a)
(clr-is System.Text.RegularExpressions.Syntax.CaptureAssertion a))
(define (capture-assertion? a)
(clr-is System.Text.RegularExpressions.Syntax.CaptureAssertion a))
(define-method-port
compile
System.Text.RegularExpressions.Syntax.CaptureAssertion
Compile
(System.Void
System.Text.RegularExpressions.ICompiler
System.Boolean))
(define-method-port
is-complex?
System.Text.RegularExpressions.Syntax.CaptureAssertion
IsComplex
(System.Boolean))
(define-field-port
capturing-group-get
capturing-group-set!
capturing-group-update!
(property:)
System.Text.RegularExpressions.Syntax.CaptureAssertion
CapturingGroup
System.Text.RegularExpressions.Syntax.CapturingGroup))
| true |
de399bff0d8b55fc0dd9db622e3a4b4ea4b74126 | 4a1ff5a0f674ff41bd384301ab82b3197f5ca0c8 | /problems/0892/main.scm | 35de1be59a1201a35493451b72e3a0062508ed36 | []
| no_license | MiyamonY/yukicoder | e0a323d68c4d3b41bdb42fb3ed6ab105619ca7e9 | 1bb8882ac76cc302428ab0417f90cfa94f7380c8 | refs/heads/master | 2020-05-09T12:13:31.627382 | 2019-10-06T17:01:45 | 2019-10-06T17:01:45 | 181,105,911 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 924 | scm | main.scm | ;;; File: main.scm
;; Author: ymiyamoto
;;
;; Created on Sat Sep 28 23:42:04 2019
;;
(define-syntax read-number
(syntax-rules ()
((_ nums)
(define-values nums
(apply values (map string->number (string-split (read-line) #\space)))))))
(define-syntax read-numbers
(syntax-rules ()
((_ as)
(define as (map string->number (string-split (read-line) #\space))))
((_ as n)
(define as (map (lambda (_) (map string->number (string-split (read-line) #\space))) (iota n))))))
(define-syntax prlist
(syntax-rules ()
((_ lis)
(print (string-join (map number->string lis) " ")))))
(define-syntax 1+ (syntax-rules () ((_ x) (+ x 1))))
(define-syntax 1- (syntax-rules () ((_ x) (- x 1))))
(define MOD 1000000007)
(define (solve)
(read-number (a1 b1 a2 b2 a3 b3))
(print (if (even? (+ (expt-mod a1 b1 2) (expt-mod a2 b2 2) (expt-mod a3 b3 2)))
":-)"
":-(")))
(solve)
| true |
06b50d60c530bee9fed835dbcc1520a962a4c98f | 87b5179843c54c7f755476e0e3fd4597a3319fef | /AmbQuery.scm | c4839fe3edeb00db539264eb925dfea63829926b | []
| no_license | Marti2203/Guile-SiCP | cd87186cce4b1ba471fbab2d6d66af903785129c | bf511564eb3db7407baf6e6ab8867de3b94bcc47 | refs/heads/master | 2021-01-19T21:21:47.998024 | 2017-07-24T12:59:21 | 2017-07-24T12:59:21 | 88,643,407 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 11,613 | scm | AmbQuery.scm | (load "table.base.scm")
(define query-input-prompt ";;; Query input:")
(define query-output-prompt ";;; Query results:")
(define (query-driver-loop)
(prompt-for-input query-input-prompt)
(let ((q (query-syntax-process (read))))
(cond
((eq? q 'try-again) (amb))
((assertion-to-be-added? q) (add-rule-or-assertion! (add-assertion-body q))
(newline)
(display "Assertion added to data base.")
(query-driver-loop))
(else (newline) (display query-output-prompt)
(let ((frame (qeval q '())))
(require (not (null? frame)))
(display (instantiate q (qeval q '()) (lambda (v f) (contract-question-mark v))))
(query-driver-loop)))))
(define (query-driver-start input)
(let ((q input))
(cond
((eq? q 'try-again) (amb))
((assertion-to-be-added? q) (add-rule-or-assertion! (add-assertion-body q))
(newline)
(display "Assertion added to data base.")
(query-driver-loop))
(else (newline) (display query-output-prompt)
(let ((frame (qeval q '())))
(require (not (null? frame)))
(display (instantiate q (qeval q '()) (lambda (v f) (contract-question-mark v))))
(query-driver-loop))))))
(define (instantiate exp frame unbound-var-handler)
(define (copy exp)
(cond
((var? exp) (let ((binding (binding-in-frame exp frame)))
(if binding
(copy (binding-value binding))
(unbound-var-handler exp frame))))
((pair? exp) (cons (copy (car exp)) (copy (cdr exp))))
(else exp)))
(copy exp))
(define (qeval query frame)
(let ((qproc (get (type query) 'qeval)))
(if qproc
(qproc (contents query) frame)
(simple-query query frame))))
(define (simple-query query-pattern frame)
(ramb (find-assertions query-pattern frame)
(apply-rules query-pattern frame)))
(define (conjoin conjuncts frame)
(if (empty-conjunction? conjuncts)
'()
(conjoin (rest-conjuncts conjuncts)
(qeval (first-conjunct conjuncts)
frame))))
(put 'and 'qeval conjoin)
(define (disjoin disjuncts frame)
(if (empty-disjunction? disjuncts)
'()
(ramb (qeval (first-disjunct disjuncts) frame)
(disjoin (rest-disjuncts disjuncts) frame))))
(put 'or 'qeval disjoin)
(define (negate operands frame)
(require (stream-null? (qeval (negated-query operands) frame)))
frame)
(put 'not 'qeval negate)
(define (lisp-value call frame)
(require (execute (instantiate call frame (lambda (v f) (error "Unknown pat var -- LISP-VALUE" v)))))
frame)
(put 'lisp-value 'qeval lisp-value)
(define (execute exp)
(apply (eval (predicate exp) user-initial-environment)
(args exp)))
(define (always-true ignore frame) frame)
(put 'always-true 'qeval always-true)
(define (find-assertions pattern frame) (check-an-assertion (a-random-element-of (fetch-assertions pattern frame)) pattern frame))
(define (check-an-assertion assertion query-pat query-frame)
(let ((match-result (pattern-match query-pat assertion query-frame)))
(require (not (eq? match-result 'failed)))
match-result))
(define (pattern-match pat dat frame)
(cond
((eq? frame 'failed) 'failed)
((equal? pat dat) frame)
((var? pat) (extend-if-consistent pat dat frame))
((and (pair? pat) (pair? dat)) (pattern-match (cdr pat)
(cdr dat)
(pattern-match (car pat)
(car dat)
frame)))
(else 'failed)))
(define (extend-if-consistent var dat frame)
(let ((binding (binding-in-frame var frame)))
(if binding
(pattern-match (binding-value binding) dat frame)
(extend var dat frame))))
(define (apply-rules pattern frame)
(apply-a-rule (a-random-element-of (fetch-rules pattern frame)) pattern frame))
(define (apply-a-rule rule query-pattern query-frame)
(let ((clean-rule (rename-variables-in rule)))
(let ((unify-result
(unify-match query-pattern
(conclusion clean-rule)
query-frame)))
(require (not (eq? unify-result 'failed)))
(qeval (rule-body clean-rule)
unify-result))))
(define (rename-variables-in rule)
(let ((rule-application-id (new-rule-application-id)))
(define (tree-walk exp)
(cond
((var? exp) (make-new-variable exp rule-application-id))
((pair? exp)(cons (tree-walk (car exp))
(tree-walk (cdr exp))))
(else exp)))
(tree-walk rule)))
(define (unify-match p1 p2 frame)
(cond
((eq? frame 'failed) 'failed)
((equal? p1 p2) frame)
((var? p1) (extend-if-possible p1 p2 frame))
((var? p2) (extend-if-possible p2 p1 frame)) ; ***
((and (pair? p1) (pair? p2))
(unify-match (cdr p1)
(cdr p2)
(unify-match (car p1)
(car p2)
frame)))
(else 'failed)))
(define (extend-if-possible var val frame)
(let ((binding (binding-in-frame var frame)))
(cond
(binding (unify-match (binding-value binding) val frame))
((var? val) ; ***
(let ((binding (binding-in-frame val frame)))
(if binding
(unify-match var (binding-value binding) frame)
(extend var val frame))))
((depends-on? val var frame) 'failed)
(else (extend var val frame)))))
(define (depends-on? exp var frame)
(define (tree-walk e)
(cond
((var? e) (if (equal? var e)
true
(let ((b (binding-in-frame e frame)))
(if b
(tree-walk (binding-value b))
false))))
((pair? e) (or (tree-walk (car e))
(tree-walk (cdr e))))
(else false)))
(tree-walk exp))
(define THE-ASSERTIONS '())
(define (fetch-assertions pattern frame)
(if (use-index? pattern)
(get-indexed-assertions pattern)
(get-all-assertions)))
(define (get-all-assertions) THE-ASSERTIONS)
(define (get-indexed-assertions pattern)
(get (index-key-of pattern) 'assertion-stream))
(define (get-stream key1 key2)
(let ((s (get key1 key2)))
(if s s '())))
(define THE-RULES '())
(define (fetch-rules pattern frame)
(if (use-index? pattern)
(get-indexed-rules pattern)
(get-all-rules)))
(define (get-all-rules) THE-RULES)
(define (get-indexed-rules pattern)
(append
(get-stream (index-key-of pattern) 'rule-stream)
(get-stream '? 'rule-stream)))
(define (add-rule-or-assertion! assertion)
(if (rule? assertion)
(add-rule! assertion)
(add-assertion! assertion)))
(define (add-assertion! assertion)
(store-assertion-in-index assertion)
(let ((old-assertions THE-ASSERTIONS))
(set! THE-ASSERTIONS
(cons assertion old-assertions))
'ok))
(define (add-rule! rule)
(store-rule-in-index rule)
(let ((old-rules THE-RULES))
(set! THE-RULES (cons rule old-rules))
'ok))
(define (store-assertion-in-index assertion)
(if (indexable? assertion)
(let ((key (index-key-of assertion)))
(let ((current-assertion-stream (get-stream key 'assertion-stream)))
(put key 'assertion-stream
(cons assertion current-assertion-stream))))))
(define (store-rule-in-index rule)
(let ((pattern (conclusion rule)))
(if (indexable? pattern)
(let ((key (index-key-of pattern)))
(let ((current-rule-stream (get-stream key 'rule-stream)))
(put key 'rule-stream
(cons rule current-rule-stream)))))))
(define (indexable? pat)
(or (constant-symbol? (car pat))
(var? (car pat))))
(define (index-key-of pat)
(let ((key (car pat)))
(if (var? key) '? key)))
(define (use-index? pat) (constant-symbol? (car pat)))
(define (type exp)
(if (pair? exp)
(car exp)
(error "Unknown expression TYPE" exp)))
(define (contents exp)
(if (pair? exp)
(cdr exp)
(error "Unknown expression CONTENTS" exp)))
(define (assertion-to-be-added? exp) (eq? (type exp) 'assert!))
(define (add-assertion-body exp) (car (contents exp)))
(define (empty-conjunction? exps) (null? exps))
(define (first-conjunct exps) (car exps))
(define (rest-conjuncts exps) (cdr exps))
(define (empty-disjunction? exps) (null? exps))
(define (first-disjunct exps) (car exps))
(define (rest-disjuncts exps) (cdr exps))
(define (negated-query exps) (car exps))
(define (predicate exps) (car exps))
(define (args exps) (cdr exps))
(define (rule? statement) (tagged-list? statement 'rule))
(define (conclusion rule) (cadr rule))
(define (rule-body rule)
(if (null? (cddr rule)) '(always-true)
(caddr rule)))
(define (query-syntax-process exp)
(map-over-symbols expand-question-mark exp))
(define (map-over-symbols proc exp)
(cond
((pair? exp) (cons (map-over-symbols proc (car exp))
(map-over-symbols proc (cdr exp))))
((symbol? exp) (proc exp))
(else exp)))
(define (expand-question-mark symbol)
(let ((chars (symbol->string symbol)))
(if (string=? (substring chars 0 1) "?")
(list '? (string->symbol(substring chars 1 (string-length chars))))
symbol)))
(define (var? exp) (tagged-list? exp '?))
(define (constant-symbol? exp) (symbol? exp))
(define rule-counter 0)
(define (new-rule-application-id) (set! rule-counter (+ 1 rule-counter)) rule-counter)
(define (make-new-variable var rule-application-id)
(cons '? (cons rule-application-id (cdr var))))
(define (contract-question-mark variable)
(string->symbol (string-append "?"
(if (number? (cadr variable))
(string-append (symbol->string (caddr variable))
"-"
(number->string (cadr variable)))
(symbol->string (cadr variable))))))
(define (make-binding variable value)
(cons variable value))
(define (binding-variable binding)
(car binding))
(define (binding-value binding)
(cdr binding))
(define (binding-in-frame variable frame)
(assoc variable frame))
(define (extend variable value frame)
(cons (make-binding variable value) frame))
(define (extend-with-binding binding frame)
(cons binding frame))
(define (uniquely-asserted exp frame) (qeval (car exp) frame))
(put 'unique 'qeval uniquely-asserted)
(define (query-import file-name)
(define port (open-input-file file-name))
(define (work number)
(let ((line (read port)))
(if (eof-object? line)
'done
(let ((q (query-syntax-process line)))
(cond
((assertion-to-be-added? q) (add-rule-or-assertion! (add-assertion-body q)))
(else (stream-map (lambda (frame) (instantiate q frame (lambda (v f) (contract-question-mark v)))) (qeval q (singleton-stream '())))))
; (display number) (display "\t") (display line) (newline)
(work (+ 1 number))))))
(work 0)
(close-input-port port))
(query-import "Microshaft.scm")
(define (first-binding frame) (car frame))
(define (rest-bindings frame) (cdr frame))
(define (combine-frames frame-1 frame-2)
(require (not (eq? frame-2 'failed)))
(cond
((null? frame-1) frame-2)
((binding-in-frame (binding-variable (first-binding frame-1)) frame-2)
(let ((variable (binding-variable (first-binding frame-1))))
(combine-frames (rest-bindings frame-1) (if (same? (binding-in-frame variable frame-1) (binding-in-frame variable frame-2))
frame-2
'failed))))
(else (combine-frames (rest-bindings frame-1) (extend-with-binding (first-binding frame-1) frame-2)))))
(define (same? x y)
(cond
((and (null? x) (null? y)) true)
((and (pair? x) (pair? y)) (and (same? (car x) (car y)) (same? (cdr x) (cdr y))))
((and (not (pair? x)) (not (pair? y))) (eq? x y))
(else false)))
(define (conjoin-faster conjuncts frame) (if (null? conjuncts) '()
(combine-frames (qeval (first-conjunct conjuncts) frame)
(conjoin-faster (rest-conjuncts conjuncts) frame))))
(define (exit-query ignore stream) (exit))
(put 'and-f 'qeval conjoin-faster)
(put 'exit 'qeval exit-query)
| false |
4fd56fabd00c52d7e2d9ad23418cd9448b11a914 | ee10242f047e9b4082a720c48abc7d94fe2b64a8 | /plot.sch | e4509159d971306d2d23cc9a2aabdaa998b733c1 | [
"Apache-2.0"
]
| permissive | netguy204/brianscheme | 168c20139c31d5e7494e55033c78f59741c81eb9 | 1b7d7b35485ffdec3b76113064191062e3874efa | refs/heads/master | 2021-01-19T08:43:43.682516 | 2012-07-21T18:30:39 | 2012-07-21T18:30:39 | 1,121,869 | 5 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,058 | sch | plot.sch | (define *gnuplot-program* "gnuplot")
(define *gnuplot-handle* #f)
(define (plot:init)
"Initialize the plotting library."
(set! *gnuplot-handle*
(open-output-pipe *gnuplot-program*)))
(define (plot:raw . strings)
"Send bare strings to gnuplot without flushing."
(write-string (apply string-append strings) *gnuplot-handle*))
(define (plot:command command)
"Send a command to gnuplot."
(write-string command *gnuplot-handle*)
(write-char #\newline *gnuplot-handle*)
(flush-output *gnuplot-handle*))
(define (plot:send-vectors . vecs)
"Send vectors as columns to gunplot."
(dotimes (i (vector-length (car vecs)))
(for-each (lambda (vec)
(plot:raw (number->string (vector-ref vec i)) " ")) vecs)
(plot:raw "\n"))
(plot:command "e"))
(define (plot:send-list lst)
"Send a list to gunplot."
(for-each (compose plot:command number->string) lst)
(plot:command "e"))
(define (plot:vector vec)
"Plot a vector."
(plot:command "set style data lines")
(plot:command "plot '-'")
(plot:send-vectors vec))
(define (plot:list lst)
"Plot a list."
(plot:command "set style data lines")
(plot:command "plot '-'")
(plot:send-list lst))
(define (plot:hist lst . num-bins)
"Plot histogram of data."
(let* ((num-bins (if num-bins (car num-bins) 10))
(bins (make-vector num-bins 0))
(min (* 1.0 (apply min lst)))
(max (* 1.0 (apply max lst)))
(range (- max min))
(xs (make-vector num-bins 0)))
;; Generate x-data
(dotimes (i num-bins)
(vector-set! xs i (+ min (/ (* i range) num-bins))))
;; Generate y-data
(dolist (x lst)
(let ((i (floor (* (/ (- x min) range) (- num-bins 1)))))
(vector-set! bins i (+ 1 (vector-ref bins i)))))
(plot:command "set boxwidth 1 relative")
(plot:command "set style fill solid 1.0 border -1")
(plot:command "plot '-' with boxes lc rgb \"blue\"")
(plot:send-vectors xs bins)
bins))
(plot:init)
(push! plot:init *load-hooks*)
| false |
11fde4033f5fe80198fe81dc5fb77bff61dce57b | 355306b3af7b33911551c9114840ca032bfcb90f | /tests/sanity/custom.fpcore | 9eb4d0782f8b3704f88c3c4954686e8749d91d55 | [
"MIT"
]
| permissive | FPBench/FPBench | 80d22747454dc2e4964792bc72369d5dfb8f517c | 6feb1dd753e465ac8bce7bd19f837749982ffee8 | refs/heads/main | 2023-02-08T00:54:53.337027 | 2022-11-23T00:02:02 | 2022-11-23T00:02:02 | 50,637,596 | 42 | 18 | MIT | 2022-11-23T00:02:03 | 2016-01-29T04:34:28 | Racket | UTF-8 | Scheme | false | false | 4,923 | fpcore | custom.fpcore | ; -*- mode: scheme -*-
(FPCore ()
:name "Test let (1/5)"
:spec 1.0
(let ([a 1.0]) a))
(FPCore ()
:name "Test let (2/5)"
:spec 2.0
(let ([a 1.0] [b 1.0]) (+ a b)))
(FPCore ()
:name "Test let (3/5)"
:spec -1.0
(let ([a 1.0] [b 0.0] [c -1.0] [d 0])
(if (> a b) c d)))
(FPCore ()
:name "Test let (4/5)"
:spec 1.0
(let ([a 1.0] [b 0.0])
(let ([a b] [b a])
b)))
(FPCore ()
:name "Test let (5/5)"
:spec 0.0
(let ([a 1.0] [b 0.0])
(let ([a b] [b a])
(let ([a b] [b a])
b))))
(FPCore ()
:name "Test let* (1/5)"
:spec 1.0
(let* ([a 1.0]) a))
(FPCore ()
:name "Test let* (2/5)"
:spec 0.0
(let* ([a 1.0] [b -1.0]) (+ a b)))
(FPCore ()
:name "Test let* (3/5)"
:spec -1.0
(let* ([a 1.0] [b 0.0] [c -1.0] [d 0])
(if (> a b) c d)))
(FPCore ()
:name "Test let* (4/5)"
:spec 1.0
(let* ([a 1.0] [b a])
b))
(FPCore ()
:name "Test let* (5/5)"
:spec 5.0
(let* ([a 3.0] [b 1.0] [c -1.0])
(let* ([b a] [c (+ c (+ b a))])
(let* ([a c] [b a])
b))))
(FPCore ()
:name "Test while (1/7)"
:spec 0.0
(while FALSE ([a 0.0 (+ a 1.0)]) a))
(FPCore ()
:name "Test while (2/7)"
:spec 4.0
(while (< a 4) ([a 0.0 (+ a 1.0)]) a))
(FPCore ()
:name "Test while (3/7)"
:spec 8.0
(while (< a 3)
([a 0.0 (+ a 1.0)]
[b 1.0 (* b 2.0)])
b))
(FPCore ()
:name "Test while (4/7)"
:spec -6.0
(while (<= a 3)
([a 0.0 (+ a 1.0)]
[b 0.0 (- b a)])
b))
(FPCore ()
:name "Test while (5/7)"
:spec 1.0
(while (< i 3)
([i 0 (+ i 1)]
[a 0.0 b]
[b 1.0 a])
a))
(FPCore ()
:name "Test while (6/7)"
:spec 0.0
(while (< i 4)
([i 0 (+ i 1)]
[a 0.0 b]
[b 1.0 a])
a))
(FPCore ()
:name "Test while (7/7)"
:spec 6.0
(while (<= a 3)
([a 0.0 (+ a 1.0)]
[b 0.0 (while (<= i a)
([i 0 (+ i 1)]
[x 0.0 (+ x i)])
x)])
b))
(FPCore ()
:name "Test while* (1/7)"
:spec 0.0
(while* FALSE ([a 0.0 (+ a 1.0)]) a))
(FPCore ()
:name "Test while* (2/7)"
:spec 4.0
(while* (< a 4) ([a 0.0 (+ a 1.0)]) a))
(FPCore ()
:name "Test while* (3/7)"
:spec 8.0
(while* (< a 3)
([a 0.0 (+ a 1.0)]
[b 1.0 (* b 2.0)])
b))
(FPCore ()
:name "Test while* (4/7)"
:spec -10.0
(while* (<= a 3)
([a 0.0 (+ a 1.0)]
[b 0.0 (- b a)])
b))
(FPCore ()
:name "Test while* (5/7)"
:spec 1.0
(while* (< i 3)
([i 0.0 (+ i 1)]
[a 0.0 b]
[b 1.0 a])
a))
(FPCore ()
:name "Test while* (6/7)"
:spec 1.0
(while* (< i 4)
([i 0.0 (+ i 1)]
[a 0.0 b]
[b 1.0 a])
a))
(FPCore ()
:name "Test while* (7/7)"
:spec 15.0
(while* (<= a 3)
([a 0.0 (+ a 1.0)]
[b 0.0 (while* (<= i a)
([i 0 (+ i 1)]
[x 0.0 (+ x i)])
x)])
b))
(FPCore ()
:name "Test if (1/6)"
:spec 1.0
(if (> 1.0 0.0) 1.0 0.0))
(FPCore ()
:name "Test if (2/6)"
:spec 1.0
(if (< 1.0 0.0) 0.0 1.0))
(FPCore ()
:name "Test if (3/6)"
(if TRUE (let ([y 1]) y)
(if FALSE (let ([y 2]) y)
(let ([y 3]) y))))
(FPCore ()
:name "Test if (4/6)"
:spec 1.0
(if TRUE 1 (if (let ([t FALSE]) t) 0 0)))
(FPCore ()
:name "Test if (5/6)"
(if (let ([t FALSE]) t) 0
(if (let ([t TRUE]) t) 1
(if (let ([t TRUE]) t) 0 0))))
(FPCore ()
:name "Test if (6/6)"
:spec 1.0
(if FALSE 1.0 (if (let ([t (let ([y 1]) (> 2 y))]) t) 1 0)))
(FPCore ()
:name "Test cast (1/1)"
:spec 1.0
(cast 1.0))
(FPCore ()
:name "Test ! (1/1)"
:spec 1.0
(! :precision binary64 :round nearestEven 1.0))
(FPCore ident ()
:name "Test FPCore identifier (FPBench 2.0)"
:spec 1.0
1.0)
(FPCore (x)
:name "Test arguments (1/2)"
x)
(FPCore (x y)
:name "Test arguments (2/2)"
x)
(FPCore (x)
:name "Nested syntax (1/2)"
(+ 1 (if (< x 0) -1 1)))
(FPCore (x)
:name "Nested syntax (2/2)"
(+ 1 (let ([y 1]) (+ y x))))
| false |
995b585d93fe5b23cd070dd1b529112aa322a1e2 | 984c1388350023db96bde3ba12dbfdd5bdf3bdeb | /scratch/large.ss | 13da978fd7793f1949d843bfd342035e3a8a39a5 | []
| no_license | LeifAndersen/backend-coach | e5f11e4fd640be79d59c9e81a53c56c7aff47d0b | c788ac6865d7a46aebc4e2e43ff7ef524f523527 | refs/heads/master | 2021-01-20T01:31:38.258489 | 2017-05-18T21:25:38 | 2017-05-18T21:25:38 | 89,289,714 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 390 | ss | large.ss | #!r6rs
(import (rnrs))
(define (f x y z u v w)
(+ x y z))
(define a (make-list 10000000 (random 10)))
(define b (make-list 10000000 (random 10)))
(define c (make-list 10000000 (random 10)))
(define d (make-list 10000000 (random 10)))
(define e (make-list 10000000 (random 10)))
(define g (make-list 10000000 (random 10)))
(define val
(time (map f a b c d e g)))
(display (car val))
| false |
cce3ffdfc19e914e1a00e2bd213b44ec38c87e44 | 7301b8e6fbd4ac510d5e8cb1a3dfe5be61762107 | /ex-4.21.scm | 25e1269b3a75733ca2817667051621ef39fc682a | []
| no_license | jiakai0419/sicp-1 | 75ec0c6c8fe39038d6f2f3c4c6dd647a39be6216 | 974391622443c07259ea13ec0c19b80ac04b2760 | refs/heads/master | 2021-01-12T02:48:12.327718 | 2017-01-11T12:54:38 | 2017-01-11T12:54:38 | 78,108,302 | 0 | 0 | null | 2017-01-05T11:44:44 | 2017-01-05T11:44:44 | null | UTF-8 | Scheme | false | false | 2,421 | scm | ex-4.21.scm | ;;; Exercise 4.21. Amazingly, Louis's intuition in exercise 4.20 is correct.
;;; It is indeed possible to specify recursive procedures without using letrec
;;; (or even define), although the method for accomplishing this is much more
;;; subtle than Louis imagined. The following expression computes 10 factorial
;;; by applying a recursive factorial procedure: [27]
;;;
;;; ((lambda (n)
;;; ((lambda (fact)
;;; (fact fact n))
;;; (lambda (ft k)
;;; (if (= k 1)
;;; 1
;;; (* k (ft ft (- k 1)))))))
;;; 10)
;;; a. Check (by evaluating the expression) that this really does compute
;;; factorials. Devise an analogous expression for computing Fibonacci numbers.
(print ((lambda (n)
((lambda (fact)
(fact fact n))
(lambda (ft k)
(if (= k 1)
1
(* k (ft ft (- k 1)))))))
10))
;==> 3628800
(define fibonacci
(lambda (n)
((lambda (f)
(f f n))
(lambda (f k)
(cond ((= k 1) 1)
((= k 2) 1)
(else (+ (f f (- k 1)) (f f (- k 2)))))))))
(print (fibonacci 1)) ;==> 1
(print (fibonacci 2)) ;==> 1
(print (fibonacci 3)) ;==> 2
(print (fibonacci 4)) ;==> 3
(print (fibonacci 5)) ;==> 5
(print (fibonacci 6)) ;==> 8
(print (fibonacci 7)) ;==> 13
;;; b. Consider the following procedure, which includes mutually recursive
;;; internal definitions:
;;;
;;; (define (f x)
;;; (define (even? n)
;;; (if (= n 0)
;;; true
;;; (odd? (- n 1))))
;;; (define (odd? n)
;;; (if (= n 0)
;;; false
;;; (even? (- n 1))))
;;; (even? x))
;;;
;;; Fill in the missing expressions to complete an alternative definition of f,
;;; which uses neither internal definitions nor letrec:
;;;
;;; (define (f x)
;;; ((lambda (even? odd?)
;;; (even? even? odd? x))
;;; (lambda (ev? od? n)
;;; (if (= n 0) true (od? <??> <??> <??>)))
;;; (lambda (ev? od? n)
;;; (if (= n 0) false (ev? <??> <??> <??>)))))
(define (f x)
((lambda (even? odd?)
(even? even? odd? x))
(lambda (ev? od? n)
(if (= n 0) #t (od? ev? od? (- n 1))))
(lambda (ev? od? n)
(if (= n 0) #f (ev? ev? od? (- n 1))))))
(print (f 0)) ;==> #t
(print (f 1)) ;==> #f
(print (f 9)) ;==> #f
(print (f 10)) ;==> #t
| false |
b61aa89182e5d97c97099b5803002b38d8e1fb28 | 893a879c6b61735ebbd213fbac7e916fcb77b341 | /interpreter-cps/environment.ss | 9c39164669d7a3f5e86d7ec3459e44fdeedc4478 | []
| 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 | 620 | ss | environment.ss | ;-----------------------+
; |
; ENVIRONMENT |
; |
;-----------------------+
(define (empty-env)
(box (empty-env-record)))
(define (extend-env syms vals env)
(box (extended-env-record syms vals env)))
; succeed and fail are procedures applied if the var is or isn't found, respectively.
(define (apply-env env sym k)
(cases environment (unbox env)
(empty-env-record ()
(eopl:error 'apply-env "variable ~s is not bound" sym))
(extended-env-record (syms vals env)
(list-find-position sym syms (extended-env-record-k env vals sym k))))) | false |
21fc5c40dd83bdf35253f9f2ce812d369e80fb7d | defeada37d39bca09ef76f66f38683754c0a6aa0 | /mscorlib/system/runtime/remoting/messaging/call-context.sls | b606b211d2d49e6fa8767ffc7fd77a72edd80e3d | []
| 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,860 | sls | call-context.sls | (library (system runtime remoting messaging call-context)
(export is?
call-context?
set-data
get-headers
get-data
set-headers
free-named-data-slot
logical-set-data
logical-get-data
host-context-get
host-context-set!
host-context-update!)
(import (ironscheme-clr-port))
(define (is? a)
(clr-is System.Runtime.Remoting.Messaging.CallContext a))
(define (call-context? a)
(clr-is System.Runtime.Remoting.Messaging.CallContext a))
(define-method-port
set-data
System.Runtime.Remoting.Messaging.CallContext
SetData
(static: System.Void System.String System.Object))
(define-method-port
get-headers
System.Runtime.Remoting.Messaging.CallContext
GetHeaders
(static: System.Runtime.Remoting.Messaging.Header[]))
(define-method-port
get-data
System.Runtime.Remoting.Messaging.CallContext
GetData
(static: System.Object System.String))
(define-method-port
set-headers
System.Runtime.Remoting.Messaging.CallContext
SetHeaders
(static: System.Void System.Runtime.Remoting.Messaging.Header[]))
(define-method-port
free-named-data-slot
System.Runtime.Remoting.Messaging.CallContext
FreeNamedDataSlot
(static: System.Void System.String))
(define-method-port
logical-set-data
System.Runtime.Remoting.Messaging.CallContext
LogicalSetData
(static: System.Void System.String System.Object))
(define-method-port
logical-get-data
System.Runtime.Remoting.Messaging.CallContext
LogicalGetData
(static: System.Object System.String))
(define-field-port
host-context-get
host-context-set!
host-context-update!
(static: property:)
System.Runtime.Remoting.Messaging.CallContext
HostContext
System.Object))
| false |
5a4c764f3c04350d626abcf8dc514cd58329d427 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System.Data/system/data/unique-constraint.sls | 9b536924ff71d35755fcf6ad48bad9cabc868811 | []
| 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,136 | sls | unique-constraint.sls | (library (system data unique-constraint)
(export new
is?
unique-constraint?
get-hash-code
equals?
columns
is-primary-key?
table)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...) #'(clr-new System.Data.UniqueConstraint a ...)))))
(define (is? a) (clr-is System.Data.UniqueConstraint a))
(define (unique-constraint? a)
(clr-is System.Data.UniqueConstraint a))
(define-method-port
get-hash-code
System.Data.UniqueConstraint
GetHashCode
(System.Int32))
(define-method-port
equals?
System.Data.UniqueConstraint
Equals
(System.Boolean System.Object))
(define-field-port
columns
#f
#f
(property:)
System.Data.UniqueConstraint
Columns
System.Data.DataColumn[])
(define-field-port
is-primary-key?
#f
#f
(property:)
System.Data.UniqueConstraint
IsPrimaryKey
System.Boolean)
(define-field-port
table
#f
#f
(property:)
System.Data.UniqueConstraint
Table
System.Data.DataTable))
| true |
6e3ee2d82cd0c6d0ffebac5d49d9fdde414e1f13 | 429a20e228ae8faaa44f8f4624edf9c71ea61936 | /scheme/chez/json.scm | 11388a54fb48085d47ac53970ffda2531d0ae7df | []
| no_license | monpetit/dogma-snippets | 599bef1e5d8a4a431d6ca6ca95cac6b59c070019 | 675e3c8e5a2e080e89e527c267fbb3fb8159bb72 | refs/heads/master | 2022-05-07T17:35:21.862641 | 2017-08-29T04:40:28 | 2017-08-29T04:40:28 | 330,693 | 1 | 1 | null | 2022-04-01T16:52:48 | 2009-10-08T07:32:31 | C | UTF-8 | Scheme | false | false | 17,074 | scm | json.scm |
(define (prt* . args)
(for-each (lambda (x) (printf "~s " x)) args)
(newline))
(define-syntax while
(syntax-rules ()
((_ cond body ...)
(let loop ()
(when cond
(begin body ...
(loop)))))))
(define-syntax dotimes
(syntax-rules ()
((_ (var n res) . body)
(do ((limit n)
(var 0 (+ var 1)))
((>= var limit) res)
. body))
((_ (var n) . body)
(do ((limit n)
(var 0 (+ var 1)))
((>= var limit))
. body))
((_ . other)
(syntax-error "malformed dotimes" (dotimes . other)))))
(define-syntax json-define
(syntax-rules ()
((_ name n)
(define-syntax name (identifier-syntax n)))))
;; ------------------------------------------------------------------------
;; CONSTANTS
;; ------------------------------------------------------------------------
(json-define JSON:OBJECT 0)
(json-define JSON:ARRAY 1)
(json-define JSON:STRING 2)
(json-define JSON:INTEGER 3)
(json-define JSON:REAL 4)
(json-define JSON:TRUE 5)
(json-define JSON:FALSE 6)
(json-define JSON:NULL 7)
(json-define JSON:MAXREFCOUNT #xffffffffffffffff)
(json-define JSON:ERROR_TEXT_LENGTH 160)
(json-define JSON:ERROR_SOURCE_LENGTH 80)
(json-define JSON:REJECT_DUPLICATES #x1)
(json-define JSON:DISABLE_EOF_CHECK #x2)
(json-define JSON:DECODE_ANY #x4)
(json-define JSON:DECODE_INT_AS_REAL #x8)
(json-define JSON:ALLOW_NUL #x10)
(json-define JSON:MAX_INDENT #x1F)
(define (JSON:INDENT n) (bitwise-and n JSON:MAX_INDENT))
(json-define JSON:COMPACT #x20)
(json-define JSON:ENSURE_ASCII #x40)
(json-define JSON:SORT_KEYS #x80)
(json-define JSON:PRESERVE_ORDER #x100)
(json-define JSON:ENCODE_ANY #x200)
(json-define JSON:ESCAPE_SLASH #x400)
(define (JSON:REAL_PRECISION n) (bitwise-arithmetic-shift-left (bitwise-and n #x1f) 11))
(json-define JSON:EMBED #x10000)
;; 구조체 정의
(define-ftype json_type int)
(define-ftype json_int_t long-long)
(define-ftype json_t
(struct
(type json_type)
(refcount size_t)))
(define-ftype json_error_t
(struct
(line int)
(column int)
(position int)
(source (array 80 char))
(text (array 160 char))))
(define-syntax fptr-free
(syntax-rules ()
((_ ptr)
(begin
(foreign-free (ftype-pointer-address js)) ;; 구조체 변수 제거
(set! js (void))))))
(define NULL (make-ftype-pointer char 0))
;; (define (foreign-null-pointer type) (make-ftype-pointer type #x00000000))
(define-syntax json-prop-get
(syntax-rules ()
((_ (field) ptr) (ftype-ref json_t (field) ptr))))
(define-syntax json-prop-set!
(syntax-rules ()
((_ (field) ptr value) (ftype-set! json_t (field) ptr value))))
(define (js<t> ptr)
(json-prop-get (type) ptr))
(define (js<r> ptr)
(json-prop-get (refcount) ptr))
(define (js<t>! ptr value)
(json-prop-set! (type) ptr value))
(define (js<r>! ptr value)
(json-prop-set! (refcount) ptr value))
(define (not-nullptr? ptr)
(not (ftype-pointer-null? ptr)))
(define-ftype bvcopy_t (function (u8* void* size_t) void))
(define bvcopy-fptr (make-ftype-pointer bvcopy_t "memcpy"))
(define bvcopy (ftype-ref bvcopy_t () bvcopy-fptr))
(define-ftype bv_strcopy_t (function (u8* void*) void))
(define bv_strcopy-fptr (make-ftype-pointer bv_strcopy_t "strcpy"))
(define bv_strcopy (ftype-ref bv_strcopy_t () bv_strcopy-fptr))
(define (json-typeof js)
(if (ftype-pointer-null? js)
#f
(js<t> js)))
(define (json-object? js) (= (json-typeof js) JSON:OBJECT))
(define (json-array? js) (= (json-typeof js) JSON:ARRAY))
(define (json-string? js) (= (json-typeof js) JSON:STRING))
(define (json-integer? js) (= (json-typeof js) JSON:INTEGER))
(define (json-real? js) (= (json-typeof js) JSON:REAL))
(define (json-true? js) (= (json-typeof js) JSON:TRUE))
(define (json-false? js) (= (json-typeof js) JSON:FALSE))
(define (json-null? js) (= (json-typeof js) JSON:NULL))
(define json-boolean-value json-true?)
(define (json-incref! js)
(if (and (not-nullptr? js)
(not (= (js<r> js) JSON:MAXREFCOUNT)))
(js<r>! js (+ (js<r> js) 1)))
js)
(define json-delete%! (foreign-procedure "json_delete" ((* json_t)) void))
(define (json-decref! js)
(when (and (not-nullptr? js)
(not (= (js<r> js) JSON:MAXREFCOUNT)))
(js<r>! js (- (js<r> js) 1))
(if (zero? (js<r> js))
(json-delete%! js))))
;; (define json-incref (foreign-procedure "json_incref" ((* json_t)) (* json_t)))
;; (define json-decref (foreign-procedure "json_decref" ((* json_t)) void))
(define json-true (foreign-procedure "json_true" () (* json_t)))
(define json-false (foreign-procedure "json_false" () (* json_t)))
(define (json-boolean val)
(if val (json-true) (json-false)))
(define json-null (foreign-procedure "json_null" () (* json_t)))
(define json-string (foreign-procedure "json_string" (string) (* json_t)))
(define json-stringn (foreign-procedure "json_stringn" (string size_t) (* json_t)))
(define json-string-nocheck (foreign-procedure "json_string_nocheck" (string size_t) (* json_t)))
(define json-stringn-nocheck (foreign-procedure "json_stringn_nocheck" (string size_t) (* json_t)))
(define json-string-value (foreign-procedure "json_string_value" ((* json_t)) string))
(define json-string-length (foreign-procedure "json_string_length" ((* json_t)) size_t))
(define json-string-set! (foreign-procedure "json_string_set" ((* json_t) string) int))
(define json-string-setn! (foreign-procedure "json_string_setn" ((* json_t) string size_t) int))
(define json-string-set-nocheck! (foreign-procedure "json_string_set_nocheck" ((* json_t) string) int))
(define json-string-setn-nocheck! (foreign-procedure "json_string_setn_nocheck" ((* json_t) string size_t) int))
(define json-integer (foreign-procedure "json_integer" (json_int_t) (* json_t)))
(define json-integer-value (foreign-procedure "json_integer_value" ((* json_t)) json_int_t))
(define json-integer-set! (foreign-procedure "json_integer_set" ((* json_t) json_int_t) int))
(define json-real (foreign-procedure "json_real" (double) (* json_t)))
(define json-real-value (foreign-procedure "json_real_value" ((* json_t)) double))
(define json-real-set! (foreign-procedure "json_real_set" ((* json_t) double) int))
(define json-number-value (foreign-procedure "json_number_value" ((* json_t)) double))
(define json-array (foreign-procedure "json_array" () (* json_t)))
(define json-array-size (foreign-procedure "json_array_size" ((* json_t)) size_t))
(define json-array-get (foreign-procedure "json_array_get" ((* json_t) size_t) (* json_t)))
(define json-array-set-new! (foreign-procedure "json_array_set_new" ((* json_t) size_t (* json_t)) int))
(define (json-array-set! arr index js)
(json-array-set-new! arr index (json-incref! js)))
(define json-array-append-new! (foreign-procedure "json_array_append_new" ((* json_t) (* json_t)) int))
(define (json-array-append! arr js)
(json-array-append-new! arr (json-incref! js)))
(define json-array-insert-new! (foreign-procedure "json_array_insert_new" ((* json_t) size_t (* json_t)) int))
(define (json-array-insert! arr index js)
(json-array-insert-new! arr index (json-incref! js)))
(define json-array-remove! (foreign-procedure "json_array_remove" ((* json_t) size_t) int))
(define json-array-clear! (foreign-procedure "json_array_clear" ((* json_t)) int))
(define json-array-extend! (foreign-procedure "json_array_extend" ((* json_t) (* json_t)) int))
;; json_array_foreach(array, index, value)
(define-syntax json-array-foreach
(syntax-rules ()
((_ (array index value) body ...)
(let ((__array_len% (json-array-size array))
(value #f))
(let loop ((index 0))
(when (< index __array_len%)
(set! value (json-array-get array index))
body
...
(loop (+ index 1))))))
((_ (array value) body ...)
(let ((__array_len% (json-array-size array))
(value #f))
(let loop ((index 0))
(when (< index __array_len%)
(set! value (json-array-get array index))
body
...
(loop (+ index 1))))))))
(define json-object (foreign-procedure "json_object" () (* json_t)))
(define json-object-size (foreign-procedure "json_object_size" ((* json_t)) size_t))
(define json-object-get (foreign-procedure "json_object_get" ((* json_t) string) (* json_t)))
(define json-object-set-new! (foreign-procedure "json_object_set_new" ((* json_t) string (* json_t)) int))
(define (json-object-set! object key value)
(json-object-set-new! object key (json-incref! value)))
(define json-object-set-new-nocheck! (foreign-procedure "json_object_set_new_nocheck" ((* json_t) string (* json_t)) int))
(define (json-object-set-nocheck! object key value)
(json-object-set-new-nocheck! object key (json-incref! value)))
(define json-object-del! (foreign-procedure "json_object_del" ((* json_t) string) int))
(define json-object-clear! (foreign-procedure "json_object_clear" ((* json_t)) int))
(define json-object-update! (foreign-procedure "json_object_update" ((* json_t) (* json_t)) int))
(define json-object-update-existing! (foreign-procedure "json_object_update_existing" ((* json_t) (* json_t)) int))
(define json-object-update-missing! (foreign-procedure "json_object_update_missing" ((* json_t) (* json_t)) int))
;; json_object_foreach(object, key, value)
;; json_object_foreach_safe(object, tmp, key, value)
(define json-object-iter (foreign-procedure "json_object_iter" ((* json_t)) void*))
(define json-object-iter-at (foreign-procedure "json_object_iter_at" ((* json_t) string) void*))
(define json-object-iter-next (foreign-procedure "json_object_iter_next" ((* json_t) void*) void*))
(define json-object-iter-key (foreign-procedure "json_object_iter_key" (void*) string))
(define json-object-iter-value (foreign-procedure "json_object_iter_value" (void*) (* json_t)))
(define json-object-iter-set-new! (foreign-procedure "json_object_iter_set_new" ((* json_t) void* (* json_t)) int))
(define (json-object-iter-set! object iter value)
(json-object-iter-set-new! object iter (json-incref! value)))
(define json-object-key-to-iter (foreign-procedure "json_object_key_to_iter" (string) void*))
(define-syntax json-object-foreach
(syntax-rules ()
((_ (object key value) body ...)
(let ((key #f)
(value #f)
(iter (json-object-iter object)))
(while (not (= iter 0))
(set! key (json-object-iter-key iter))
(set! value (json-object-iter-value iter))
(when (and key value)
body
...)
(set! iter (json-object-iter-next object iter)))))))
(define (json-dump->utf8 js)
(let ((json-dumpb-get-size% (foreign-procedure "json_dumpb" ((* json_t) (* char) size_t size_t) size_t))
(json-dumpb-get-buffer% (foreign-procedure "json_dumpb" ((* json_t) u8* size_t size_t) size_t)))
(let* ((dp-size (json-dumpb-get-size% js NULL 0 0))
(buffer (make-bytevector dp-size 0)))
(if (positive? dp-size)
(json-dumpb-get-buffer% js buffer dp-size 0))
buffer)))
(define (json-dump->string js)
(utf8->string (json-dump->utf8 js)))
(define (json-dump->file js path)
(let ((json-dump-file% (foreign-procedure "json_dump_file" ((* json_t) string size_t) int)))
(json-dump-file% js path 0)))
(define (json-error->sexpr error)
(let ((error-source (make-bytevector JSON:ERROR_SOURCE_LENGTH 0))
(error-text (make-bytevector JSON:ERROR_TEXT_LENGTH 0))
(ht (make-hash-table)))
(put-hash-table! ht 'line (ftype-ref json_error_t (line) error))
(put-hash-table! ht 'column (ftype-ref json_error_t (column) error))
(put-hash-table! ht 'position (ftype-ref json_error_t (position) error))
(bv_strcopy error-source (ftype-pointer-address (ftype-&ref json_error_t (source) error)))
(bv_strcopy error-text (ftype-pointer-address (ftype-&ref json_error_t (text) error)))
(put-hash-table! ht 'source (utf8->string error-source))
(put-hash-table! ht 'text (utf8->string error-text))
ht))
;; private function
(define (json-load<-string% buffer flags)
(let ((json-loads (foreign-procedure "json_loads" (string size_t (* json_error_t)) (* json_t)))
(error (make-ftype-pointer json_error_t (foreign-alloc (ftype-sizeof json_error_t)))))
(let ((js (json-loads buffer flags error))
(result (void)))
(if (ftype-pointer-null? js) ;; 에러 발생(NULL)?
(let ((err (json-error->sexpr error)))
(hash-table-for-each err (lambda (key value) (prt* key value)))
(set! result (cons (void) err)))
(set! result (cons js (void))))
(foreign-free (ftype-pointer-address error)) ;; 구조체 변수 제거
result)))
;; PUBLIC FUCNTION
(define json-load<-string
(case-lambda
((buffer) (json-load<-string% buffer 0))
((buffer flags) (json-load<-string% buffer flags))))
;; private function
(define (json-load<-file% path flags)
(let ((json-load-file (foreign-procedure "json_load_file" (string size_t (* json_error_t)) (* json_t)))
(error (make-ftype-pointer json_error_t (foreign-alloc (ftype-sizeof json_error_t)))))
(let ((js (json-load-file path flags error))
(result (void)))
(if (ftype-pointer-null? js) ;; 에러 발생(NULL)?
(let ((err (json-error->sexpr error)))
(hash-table-for-each err (lambda (key value) (prt* key value)))
(set! result (cons (void) err)))
(set! result (cons js (void))))
(foreign-free (ftype-pointer-address error)) ;; 구조체 변수 제거
result)))
;; PUBLIC FUCNTION
(define json-load<-file
(case-lambda
((path) (json-load<-file% path 0))
((path flags) (json-load<-file% path flags))))
;; PUBLIC FUCNTION
(define (json->sexpr js)
(cond
((json-object? js) (let ((ht (make-hash-table)))
(json-object-foreach (js key value)
(put-hash-table! ht
(string->symbol key)
(json->sexpr value)))
ht))
((json-array? js) (let ((array '()))
(json-array-foreach (js value)
(set! array (cons (json->sexpr value) array)))
(reverse array)))
((json-string? js) (json-string-value js))
((json-integer? js) (json-integer-value js))
((json-real? js) (json-real-value js))
((json-true? js) (json-boolean-value js))
((json-false? js) (json-boolean-value js))
((json-null? js) '())))
(define (sexpr->json object)
(cond
((hash-table? object) (let ((js (json-object)))
(hash-table-for-each object
(lambda (key value)
(json-object-set-new! js (if (symbol? key)
(symbol->string key)
key)
(sexpr->json value))))
js))
((list? object) (let ((js (json-array))
(len (length object)))
(let loop ((n 0))
(when (< n len)
(json-array-append-new! js (sexpr->json (list-ref object n)))
(loop (+ n 1))))
js))
((vector? object) (sexpr->json (vector->list object)))
((string? object) (json-string object))
((integer? object) (json-integer object))
((real? object) (json-real object))
((boolean? object) (or (and (eq? object #t) (json-true)) (json-false)))
((null? object) (json-null))
((symbol? object) (sexpr->json (symbol->string object)))
(else (json-null))))
(define indent-margin 2)
(define (print-list ls depth)
;; (printf (make-string (* depth indent-margin) #\space))
(printf "(~%")
(let ((len (length ls)))
(let loop ((n 0))
(when (< n len)
(printf (make-string (* (+ depth 1) indent-margin) #\space))
(let ((value (list-ref ls n)))
(cond
((hash-table? value) (print-hash-table value (+ depth 1)))
((list? value) (print-list value (+ depth 1)))
(else (printf "~s~%" value))))
(loop (+ n 1)))))
(printf (make-string (* depth indent-margin) #\space))
(printf ")~%"))
(define (print-hash-table ht depth)
;; (printf (make-string (* depth indent-margin) #\space))
(printf "{~%")
(hash-table-for-each ht
(lambda (key value)
(printf (make-string (* (+ depth 1) indent-margin) #\space))
(printf "~s : " key)
(cond
((hash-table? value) (print-hash-table value (+ depth 1)))
((list? value) (print-list value (+ depth 1)))
(else (printf "~s~%" value)))))
(printf (make-string (* depth indent-margin) #\space))
(printf "}~%"))
| true |
8a440ae39335449f8a9040bc19cc7d81d28ad65e | 58381f6c0b3def1720ca7a14a7c6f0f350f89537 | /Chapter 4/4.4/4.62.scm | 7395c794266039b54542cdaa6ddf3924db6841e6 | []
| 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 | 159 | scm | 4.62.scm | #lang racket
(rule (last-pair (?x) (?x)))
(rule (last-pair (u? . v?) (?x))
(last-pair v? (?x)))
; There are an infinite amount of numbers ending with 3 | false |
8ced18e8e519faafacc1707e2e2d12476d5ff844 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /mscorlib/system/globalization/daylight-time.sls | 38c2a90edcab5ca19ec7931a9834230350cfbcf7 | []
| 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 | 804 | sls | daylight-time.sls | (library (system globalization daylight-time)
(export new is? daylight-time? start end delta)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Globalization.DaylightTime a ...)))))
(define (is? a) (clr-is System.Globalization.DaylightTime a))
(define (daylight-time? a)
(clr-is System.Globalization.DaylightTime a))
(define-field-port
start
#f
#f
(property:)
System.Globalization.DaylightTime
Start
System.DateTime)
(define-field-port
end
#f
#f
(property:)
System.Globalization.DaylightTime
End
System.DateTime)
(define-field-port
delta
#f
#f
(property:)
System.Globalization.DaylightTime
Delta
System.TimeSpan))
| true |
a2a7be7bd011ad91eefb432f1d58596b3dfd929d | 98fd12cbf428dda4c673987ff64ace5e558874c4 | /sicp/v3/1.2/shikhar/1.15.scm | 3de9dc1082d8a6aa7bf86b46ede615456f0c5c30 | [
"Unlicense"
]
| permissive | CompSciCabal/SMRTYPRTY | 397645d909ff1c3d1517b44a1bb0173195b0616e | a8e2c5049199635fecce7b7f70a2225cda6558d8 | refs/heads/master | 2021-12-30T04:50:30.599471 | 2021-12-27T23:50:16 | 2021-12-27T23:50:16 | 13,666,108 | 66 | 11 | Unlicense | 2019-05-13T03:45:42 | 2013-10-18T01:26:44 | Racket | UTF-8 | Scheme | false | false | 358 | scm | 1.15.scm | (define (cube x) (* x x x))
(define (p x)
(print x)
(- (* 3 x) (* 4 (cube x))))
(define (sine angle)
(if (not (> (abs angle) 0.1))
angle
(p (sine (/ angle 3.0)))))
;; a)
; > (sine 12.15)
; 0.05
; 0.1495
; 0.4351345505
; 0.975846533167877
; -0.789563114470823
; -0.39980345741334
;; b) log_3 n
| false |
575111620a6e003075bb28c2c40fb8037a6b1082 | 9b2eb10c34176f47f7f490a4ce8412b7dd42cce7 | /lib-compat/r7b-yuni/compat/eval.sls | 7dc78c10e2eca184524fc6cfd446ce403b57b3ff | [
"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 | 102 | sls | eval.sls | (library (r7b-yuni compat eval)
(export eval environment)
(import (r7b-impl eval)))
| false |
488c73364186bef3cee26a7e15bfca032616a165 | b7f6929575ae60469e07b132f8bc843922e16abd | /guile/aid-coverage.scm | 80ba3c12c30a32775eeae3e2f44f16af63b24f3f | [
"MIT"
]
| permissive | shima3/sch-script | 2136048cdcb0e9ec42b228819447a3a9859a73b3 | fa1e8ec5ee161a8b5702af68cc3d7ecd5376378b | refs/heads/master | 2021-01-23T06:20:59.407358 | 2020-08-04T15:43:18 | 2020-08-04T15:43:18 | 86,357,889 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 579 | scm | aid-coverage.scm | (use-modules
(system vm coverage)
(system vm vm))
(define org-exit exit)
(define exit-code 0)
(include "wrapper.scm")
(let ((args (cdr (command-line))))
(let ((args2 (cdr args)))
(load-from-path (car args2))
(call-with-values
(lambda ( )
(with-code-coverage
(lambda ( )
(call/cc
(lambda (cont)
(set! exit
(lambda (code)
(set! exit org-exit)
(cont code)))
(apply main-proc args2)
)))))
(lambda (data result)
(let ((port (open-output-file (car args))))
(coverage-data->lcov data port)
(close port)
)))
))
| false |
0ed7636b8b12796f12fee55c98cf40782fb6b4fe | b62560d3387ed544da2bbe9b011ec5cd6403d440 | /cogs/slack/main.scm | 1ac43f5ed40c7ab13830f9143dff36073cbc77f6 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"Apache-2.0"
]
| permissive | mattwparas/steel | c6fb91b20c4e613e6a8db9d9310d1e1c72313df2 | 700144a5a1aeb33cbdb2f66440bbe38cf4152458 | refs/heads/master | 2023-09-04T03:41:35.352916 | 2023-09-01T03:26:01 | 2023-09-01T03:26:01 | 241,949,362 | 207 | 10 | Apache-2.0 | 2023-09-06T04:31:21 | 2020-02-20T17:39:28 | Rust | UTF-8 | Scheme | false | false | 773 | scm | main.scm | (require "slack.scm")
(require "steel/time/time.scm"
(for-syntax "steel/time/time.scm"))
(require "steel/contracts/contract.scm"
(for-syntax "steel/contracts/contract.scm"))
(require "steel/logging/log.scm")
(define/c (process-message body)
(->c hash? any/c)
; (displayln body)
(log/info! body)
(define event-json (-> body (hash-get 'payload) (hash-get 'event)))
(define text (hash-try-get event-json 'text))
(define channel (hash-get event-json 'channel))
(when (and text (starts-with? text "!ping"))
(time! (send-message channel "pong!"))))
(define (process-message-timed body)
(time! (process-message body)))
(define *ws-url* (get-ws-url))
(event-loop *ws-url* (connect-to-slack-socket *ws-url*) process-message-timed) | false |
6140c68c5912f1c0f03585b24228b586dda0cd86 | 4b480cab3426c89e3e49554d05d1b36aad8aeef4 | /chapter-02/ex2.63-Yarra.scm | 0371924f288fd99feec67427c06debf26c06e733 | []
| 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 | 2,944 | scm | ex2.63-Yarra.scm | (define (entry tree) (car tree))
(define (left-branch tree) (cadr tree))
(define (right-branch tree) (caddr tree))
(define (make-tree entry left right)
(list entry left right))
(define (tree->list-1 tree)
(if (null? tree)
'()
(append (tree->list-1 (left-branch tree))
(cons (entry tree)
(tree->list-1 (right-branch tree))))))
(define (tree->list-2 tree)
(define (copy-to-list tree result-list)
(if (null? tree)
result-list
(copy-to-list (left-branch tree)
(cons (entry tree)
(copy-to-list (right-branch tree)
result-list)))))
(copy-to-list tree '() ))
(define (element-of-set? x set)
(cond ((null? set) #f)
((= x (entry set)) #t)
((< x (entry set))
(element-of-set? x (left-branch set)))
((> x (entry set))
(element-of-set? x (right-branch set)))))
(define (adjoin-set x set)
(cond ((null? set) (make-tree x '() '()))
((= x (entry set)) set)
((< x (entry set))
(make-tree (entry set)
(adjoin-set x (left-branch set))
(right-branch set)))
((> x (entry set))
(make-tree (entry set)
(left-branch set)
(adjoin-set x (right-branch set))))))
(define set1 (list 7
(list 3 (list 1 '() '()) (list 5 '() '()))
(list 9 '() (list 11 '() '()))))
(define set2 (list 3
(list 1 '() '())
(list 7
(list 5 '() '())
(list 9
'()
(list 11 '() '())))))
(define set3 (list 5
(list 3
(list 1 '() '())
'())
(list 9
(list 7 '() '())
(list 11 '() '()))))
(and
(equal? (tree->list-1 set1) (tree->list-2 set1))
(equal? (tree->list-1 set2) (tree->list-2 set2))
(equal? (tree->list-1 set3) (tree->list-2 set3))
)
(and
(equal? (tree->list-1 set1) (list 1 3 5 7 9 11))
(equal? (tree->list-1 set2) (list 1 3 5 7 9 11))
(equal? (tree->list-1 set3) (list 1 3 5 7 9 11))
)
;; 두 프로시저가 모두 좌우측 트리를 재귀호출을 통해 리스트로 바꾼후
;; 엔트리와 양쪽 서브트리를 연결하는 식으로 트리를 평평한 리스트로 변환한다.
;; tree->list-2 는 트리의 가장 루트에서 우측으로 먼 서브트리부터 빈 리스트에 차례차례 담아 답을 내는 반면, ==> O(n)
;; tree->list-1 은 서브트리를 계속 append를 통해 연결하므로 트리구조가 최악의 경우
;; (왼쪽으로 균형이 깨진) O(n^2)를 보일 수 있다.
| false |
8b5e4e95aeb4bd840d2b68fad0b231f0a4c5769e | 8f0c7a999b0cc7fdebd7df062aa5b14c8a809a08 | /harlan/front/expand-include.scm | 4dbf75c9772a443385ad470fbd4b9c6cbb4705db | [
"BSD-3-Clause-Open-MPI"
]
| permissive | sarvex/harlan-lang | 7ab0eb7d0982848f68d0e5e67b12c27b91fdb34c | a361a1dc1312b3f4a46cb81c8d07852a70f67233 | refs/heads/master | 2023-06-13T03:07:01.753792 | 2023-05-30T16:03:27 | 2023-05-30T16:03:27 | 32,276,436 | 0 | 0 | NOASSERTION | 2023-05-30T16:03:28 | 2015-03-15T18:22:04 | Scheme | UTF-8 | Scheme | false | false | 957 | scm | expand-include.scm | (library
(harlan front expand-include)
(export expand-include)
(import
(rnrs)
(only (elegant-weapons helpers) define-match)
(harlan driver)
(harlan compile-opts)
(elegant-weapons match))
(define-match expand-include
((module . ,decls)
`(module . ,(expand-decls (cons '(import core) decls) '()))))
(define (expand-decls decls libs)
(match decls
(((import ,name) . ,rest)
(if (memq name libs)
(expand-decls rest libs)
(expand-decls (append (load-include (string-append
(symbol->string name) ".kfc"))
rest)
(cons name libs))))
((,a . ,[d]) `(,a . ,d))
(() '())))
(define (load-include name)
(let-values (((source _)
(read-source (string-append (harlan-library-path) "/" name))))
(match source
((module . ,decls) decls))))
)
| false |
62716aa2da02ca5d45e1d92c8b0a68010d7a4844 | b9a78cfb8741183486b7d41c8798013e07c47574 | /hexdump/helpers.scm | 5691988b54be6fb9046617d8457c77c3e53811d9 | [
"MIT"
]
| permissive | BernardTatin/ChickenAndShout | 87229cc193eaff582782e1227805eac33929c3db | c715a5cd2ee45acfde386dad8fd66dc4415471c6 | refs/heads/master | 2020-12-30T09:49:53.935113 | 2019-12-05T09:19:09 | 2019-12-05T09:19:09 | 54,066,891 | 0 | 0 | null | 2017-01-01T20:51:06 | 2016-03-16T21:14:40 | Scheme | UTF-8 | Scheme | false | false | 2,285 | scm | helpers.scm | ;; ======================================================================
;; helpers.scm
;; date : 2016-03-18 22:03
;; author : bernard
;;
;; The MIT License (MIT)
;;
;; Copyright (c) 2016 Bernard Tatin
;;https://github.com/BernardTatin/ChickenAndShout.git
;; 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-library
(helpers)
(export dohelp doversion)
(cond-expand
(owl-lisp
(import (owl defmac)
(owl io)
(scheme base)
(scheme write)
(scheme process-context)
(slprintf slprintf)))
(else
(import (scheme base)
(scheme write)
(scheme process-context)
(slprintf slprintf))))
(begin
(define *app-name* (car (command-line)))
(define *app-vers* "0.0.1")
(define dohelp
(lambda (exit-code)
(slprintf "%s [--help] : this text and exits\n" *app-name*)
(slprintf "%s --version : show the version and exits\n" *app-name*)
(slprintf "%s file file ... : make an hexdump of all these files\n" *app-name*)
(exit exit-code)))
(define doversion
(lambda (exit-code)
(slprintf "%s version %s\n" *app-name* *app-vers*)
(slprintf " (more informations with : %s --help)\n" *app-name*)
(exit exit-code)))
))
| false |
4de09cc8988dbbd99d3c5c6257ec1a2a31ea5491 | db0f911e83225f45e0bbc50fba9b2182f447ee09 | /the-scheme-programming-language/3.5-internal-definitions/homeworks/3.5.4.scm | b75becc1734ee217acf859f3d3a257e022b97bc9 | []
| no_license | ZhengHe-MD/learn-scheme | 258941950302b4a55a1d5d04ca4e6090a9539a7b | 761ad13e6ee4f880f3cd9c6183ab088ede1aed9d | refs/heads/master | 2021-01-20T00:02:38.410640 | 2017-05-03T09:48:18 | 2017-05-03T09:48:18 | 89,069,898 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,180 | scm | 3.5.4.scm | (let ()
(define do-calc
(lambda (ek exp)
(cond
((number? exp) exp)
((and (list? exp) (= (length exp) 2))
(let ((op (car exp)) (args (cdr exp)))
(case op
((minus) (apply-op1 ek - args))
((sqrt) (apply-op1 ek sqrt args))
(else (complain ek "invalid unary operator" op)))))
((and (list? exp) (= (length exp) 3))
(let ((op (car exp)) (args (cdr exp)))
(case op
((add) (apply-op2 ek + args))
((sub) (apply-op2 ek - args))
((mul times) (apply-op2 ek * args))
((div) (apply-op2 ek / args))
((expt) (apply-op2 ek expt args))
(else (complain ek "invalid binary operator" op)))))
(else (complain ek "invalid expression" exp)))))
(define apply-op1
(lambda (ek op args)
(op (do-calc ek (car args)))))
(define apply-op2
(lambda (ek op args)
(op (do-calc ek (car args)) (do-calc ek (cadr args)))))
(define complain
(lambda (ek msg exp)
(ek (list msg exp))))
(set! calc
(lambda (exp)
(call/cc
(lambda (ek)
(do-calc ek exp))))))
| false |
66fa9f357b91e0cd58fd38f62198a4c6b11a989c | d369542379a3304c109e63641c5e176c360a048f | /brice/Chapter2/exercise-2.80.scm | a4580cb1236784da44524a8f34160c74c9253df5 | []
| no_license | StudyCodeOrg/sicp-brunches | e9e4ba0e8b2c1e5aa355ad3286ec0ca7ba4efdba | 808bbf1d40723e98ce0f757fac39e8eb4e80a715 | refs/heads/master | 2021-01-12T03:03:37.621181 | 2017-03-25T15:37:02 | 2017-03-25T15:37:02 | 78,152,677 | 1 | 0 | null | 2017-03-25T15:37:03 | 2017-01-05T22:16:07 | Scheme | UTF-8 | Scheme | false | false | 1,230 | scm | exercise-2.80.scm | #lang racket
(require "../utils.scm")
(require "../dispatch-table.scm")
(require "./arithmetic-operations.scm")
; Exercise 2.80
; =============
;
; Define a generic predicate =zero? that tests if its argument is zero,
; and install it in the generic arithmetic package. This operation should
; work for ordinary numbers, rational numbers, and complex numbers.
;
; ------------------------------------------------------------------------
; [Exercise 2.80]: http://sicp-book.com/book-Z-H-18.html#%_thm_2.80
; 2.5.1 Generic Arithmetic Operations - p193
; ------------------------------------------------------------------------
(module* main #f
(title "Exercise 2.80")
(assert "We can tell when a scheme number is 0"
(=zero? 0.0))
(assert "We can tell when a scheme number is not 0"
(not (=zero? 1.0)))
(assert "We can tell when a rational number is 0"
(=zero? (make-rational 0 1)))
(assert "We can tell when a rational number is not 0"
(not (=zero? (make-rational 1 3))))
(assert "We can tell when a complex number is 0"
(=zero? (make-complex-from-real-imag 0 0)))
(assert "We can tell when a complex number is not 0"
(not (=zero? (make-complex-from-real-imag 1 3))))
)
| false |
cd96f4cbc5dc238b22d1e472038a659fc1811bf7 | 8841d71d56929d83aa93fb6769cdb175eb69e747 | /tcp-server.scm | 681f97a4c77c37014f774de8a86f74be5113d771 | [
"LicenseRef-scancode-public-domain"
]
| permissive | jeffd/slime48 | bb1d25c9eac08d78c249affebeb890accde459ea | 67abfd0648d0f6dc99bedbdc2e3dc90b683eb2ca | refs/heads/master | 2021-01-13T02:36:29.157263 | 2007-06-07T06:08:50 | 2007-06-07T06:08:50 | 210,074 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 7,184 | scm | tcp-server.scm | ;;; -*- mode: scheme; scheme48-package: swank-tcp-servers -*-
;;;;;; SLIME for Scheme48
;;;;;; Swank back end TCP server
;;; This code is written by Taylor Campbell and placed in the Public
;;; Domain. All warranties are disclaimed.
(define (make-one-shot-swank-tcp-server world . port-number)
(let* ((socket (apply open-socket port-number))
(port-number (socket-port-number socket)))
(swank-log "(world ~S) Spawning one-shot TCP server on port ~A"
(swank-world-id world)
(socket-port-number socket))
(values port-number
(lambda (session-wrapper)
(receive (in out) (socket-accept socket)
(close-socket socket)
(spawn-swank-tcp-session in out world
session-wrapper))))))
(define-record-type* swank-tcp-server
(make-swank-tcp-server world socket)
(thread))
(define (spawn-swank-tcp-server world session-wrapper . port-number)
(let ((socket (apply open-socket port-number)))
(swank-log "(world ~S) Spawning TCP server on port ~A"
(swank-world-id world)
(socket-port-number socket))
(let* ((server (make-swank-tcp-server world socket))
(thread (spawn (lambda ()
(run-swank-tcp-server server
session-wrapper))
`(swank-tcp-server
,(swank-world-id world)
,(socket-port-number socket)))))
(set-swank-tcp-server-thread! server thread)
server)))
(define (close-swank-tcp-server server)
(let ((socket (swank-tcp-server-socket server)))
(swank-log "(world ~S) Closing TCP server on port ~A"
(swank-world-id (swank-tcp-server-world server))
(socket-port-number socket))
(terminate-thread! (swank-tcp-server-thread server))
(close-socket socket)))
(define (swank-tcp-server-port-number server)
(socket-port-number (swank-tcp-server-socket server)))
(define (run-swank-tcp-server server session-wrapper)
(let ((socket (swank-tcp-server-socket server))
(world (swank-tcp-server-world server)))
(let loop ()
(receive (in out) (socket-accept socket)
(spawn-swank-tcp-session in out world session-wrapper))
(loop))))
(define (spawn-swank-tcp-session in out world session-wrapper)
(let ((session-placeholder (make-placeholder))
(reader-placeholder (make-placeholder))
(writer-placeholder (make-placeholder)))
(let ((session
(session-wrapper session-placeholder
(lambda (init exit)
(spawn-swank-session world
;; These next two procedures will be called in other
;; threads, so we must be careful about synchronizing
;; access to the session descriptor and the two I/O
;; thread descriptors.
(lambda () ; session winder
(spawn-swank-tcp-i/o
in out
(placeholder-value session-placeholder)
reader-placeholder
writer-placeholder)
(init))
(lambda () ; session unwinder
(exit)
(terminate-thread!
(placeholder-value reader-placeholder))
(terminate-thread!
(placeholder-value writer-placeholder))
(close-input-port in)
(close-output-port out)))))))
(placeholder-set! session-placeholder session))))
(define (spawn-swank-tcp-i/o in out session
reader-placeholder
writer-placeholder)
(let ((reader (spawn (lambda ()
(run-swank-tcp-reader session in))
`(swank-tcp-reader ,session)))
(writer (spawn (lambda ()
(run-swank-tcp-writer session out))
`(swank-tcp-writer ,session))))
(placeholder-set! reader-placeholder reader)
(placeholder-set! writer-placeholder writer)))
(define (run-swank-tcp-reader session in)
(let loop ()
(send-incoming-swank-message session (decode-swank-message in))
(loop)))
(define-condition-type 'swank-protocol-error '(error))
(define swank-protocol-error?
(condition-predicate 'swank-protocol-error))
(define (swank-protocol-error-port error) (caddr error))
(define (decode-swank-message in)
(let* ((length (decode-swank-message-length in))
(string (make-string length))
(count-read (read-block string 0 length in)))
(if (not (= count-read length))
(signal 'swank-protocol-error
"number of bytes read does not match expected length"
in
`(expected ,length)
`(read ,count-read)))
(with-handler (lambda (condition punt)
(if (read-error? condition)
(signal 'swank-protocol-error
"malformed input expression"
in
condition)
(punt)))
(lambda ()
(read-from-string string)))))
(define (decode-swank-message-length port)
(do ((c 0 (+ c 1))
(i 0 (bitwise-ior (arithmetic-shift i 4)
(read-hex-digit port))))
((= c 6) i)))
(define (read-hex-digit port)
(let ((char (read-char port)))
(if (eof-object? char)
(signal 'swank-protocol-error
"premature end of file"
port)
(let ((ascii (char->ascii char)))
(cond ((char-between? #\0 char #\9)
(- ascii (char->ascii #\0)))
((char-between? #\a char #\f)
(+ 10 (- ascii (char->ascii #\a))))
((char-between? #\A char #\F)
(+ 10 (- ascii (char->ascii #\A))))
(else
(signal 'swank-protocol-error
"invalid hex digit for message length read"
port
char)))))))
(define (char-between? lower char upper)
;; Why isn't CHAR<=? n-ary?
(and (char<=? lower char)
(char<=? char upper)))
(define (run-swank-tcp-writer session out)
(let loop ()
(encode-swank-message (receive-outgoing-swank-message session)
out)
(loop)))
(define (encode-swank-message message out)
(let* ((string (write-to-string message)))
(write-string (encode-swank-message-length string) out)
(write-string string out)
(write-char #\newline out) ; Careful not to call NEWLINE!
(force-output out)))
(define (encode-swank-message-length string)
(let ((length (+ (string-length string) 1)))
(if (>= length (arithmetic-shift 2 24))
(error "message too long to be encoded in Swank" string)
(let ((hex (number->string length 16)))
(string-append (make-string (- 6 (string-length hex)) #\0)
hex)))))
| false |
fb3626e3d7a40e88b60ffd84485a6adaa2ab21e5 | 120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193 | /packages/slib/hashtab.scm | a42e473865172e36db613fadd3aa21b2c84ac194 | [
"MIT"
]
| permissive | evilbinary/scheme-lib | a6d42c7c4f37e684c123bff574816544132cb957 | 690352c118748413f9730838b001a03be9a6f18e | refs/heads/master | 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 | MIT | 2022-06-16T05:54:55 | 2016-12-13T06:27:36 | Scheme | UTF-8 | Scheme | false | false | 5,380 | scm | hashtab.scm | ; "hashtab.scm", hash tables for Scheme.
; Copyright (C) 1992, 1993, 2003 Aubrey Jaffer
;
;Permission to copy this software, to modify it, to redistribute it,
;to distribute modified versions, and to use it for any purpose is
;granted, subject to the following restrictions and understandings.
;
;1. Any copy made of this software must include this copyright notice
;in full.
;
;2. I have made no warranty or representation that the operation of
;this software will be error-free, and I am under no obligation to
;provide any services, by way of maintenance, update, or otherwise.
;
;3. In conjunction with products arising from the use of this
;material, there shall be no use of my name in any advertising,
;promotional, or sales literature without prior written consent in
;each case.
(require 'hash)
(require 'alist)
;;@code{(require 'hash-table)}
;;@ftindex hash-table
;;@body
;;Returns a hash function (like @code{hashq}, @code{hashv}, or
;;@code{hash}) corresponding to the equality predicate @var{pred}.
;;@var{pred} should be @code{eq?}, @code{eqv?}, @code{equal?}, @code{=},
;;@code{char=?}, @code{char-ci=?}, @code{string=?}, or
;;@code{string-ci=?}.
(define (predicate->hash pred)
(cond ((eq? pred eq?) hashq)
((eq? pred eqv?) hashv)
((eq? pred equal?) hash)
((eq? pred =) hashv)
((eq? pred char=?) hashv)
((eq? pred char-ci=?) hashv)
((eq? pred string=?) hash)
((eq? pred string-ci=?) hash)
(else (slib:error "unknown predicate for hash" pred))))
;;@noindent
;;A hash table is a vector of association lists.
;;@body
;;Returns a vector of @var{k} empty (association) lists.
(define (make-hash-table k) (make-vector k '()))
;;@noindent
;;Hash table functions provide utilities for an associative database.
;;These functions take an equality predicate, @var{pred}, as an argument.
;;@var{pred} should be @code{eq?}, @code{eqv?}, @code{equal?}, @code{=},
;;@code{char=?}, @code{char-ci=?}, @code{string=?}, or
;;@code{string-ci=?}.
;;@body
;;Returns a hash association function of 2 arguments, @var{key} and
;;@var{hashtab}, corresponding to @var{pred}. The returned function
;;returns a key-value pair whose key is @var{pred}-equal to its first
;;argument or @code{#f} if no key in @var{hashtab} is @var{pred}-equal to
;;the first argument.
(define (predicate->hash-asso pred)
(let ((hashfun (predicate->hash pred))
(asso (predicate->asso pred)))
(lambda (key hashtab)
(asso key
(vector-ref hashtab (hashfun key (vector-length hashtab)))))))
;;@body
;;Returns a procedure of 2 arguments, @var{hashtab} and @var{key}, which
;;returns the value associated with @var{key} in @var{hashtab} or
;;@code{#f} if @var{key} does not appear in @var{hashtab}.
(define (hash-inquirer pred)
(let ((hashfun (predicate->hash pred))
(ainq (alist-inquirer pred)))
(lambda (hashtab key)
(ainq (vector-ref hashtab (hashfun key (vector-length hashtab)))
key))))
;;@body
;;Returns a procedure of 3 arguments, @var{hashtab}, @var{key}, and
;;@var{value}, which modifies @var{hashtab} so that @var{key} and
;;@var{value} associated. Any previous value associated with @var{key}
;;will be lost.
(define (hash-associator pred)
(let ((hashfun (predicate->hash pred))
(asso (alist-associator pred)))
(lambda (hashtab key val)
(let* ((num (hashfun key (vector-length hashtab))))
(vector-set! hashtab num
(asso (vector-ref hashtab num) key val)))
hashtab)))
;;@body
;;Returns a procedure of 2 arguments, @var{hashtab} and @var{key}, which
;;modifies @var{hashtab} so that the association whose key is @var{key} is
;;removed.
(define (hash-remover pred)
(let ((hashfun (predicate->hash pred))
(arem (alist-remover pred)))
(lambda (hashtab key)
(let* ((num (hashfun key (vector-length hashtab))))
(vector-set! hashtab num
(arem (vector-ref hashtab num) key)))
hashtab)))
;;@args proc hash-table
;;Returns a new hash table formed by mapping @var{proc} over the
;;keys and values of @var{hash-table}. @var{proc} must be a function of 2
;;arguments which returns the new value part.
(define (hash-map proc ht)
(define nht (make-vector (vector-length ht)))
(do ((i (+ -1 (vector-length ht)) (+ -1 i)))
((negative? i) nht)
(vector-set!
nht i
(alist-map proc (vector-ref ht i)))))
;;@args proc hash-table
;;Applies @var{proc} to each pair of keys and values of @var{hash-table}.
;;@var{proc} must be a function of 2 arguments. The returned value is
;;unspecified.
(define (hash-for-each proc ht)
(do ((i (+ -1 (vector-length ht)) (+ -1 i)))
((negative? i))
(alist-for-each proc (vector-ref ht i))))
;;@body
;;@0 accepts a hash table predicate and returns a function of two
;;arguments @var{hashtab} and @var{new-k} which is specialized for
;;that predicate.
;;
;;This function is used for nondestrutively resizing a hash table.
;;@var{hashtab} should be an existing hash-table using @1, @var{new-k}
;;is the size of a new hash table to be returned. The new hash table
;;will have all of the associations of the old hash table.
(define (hash-rehasher pred)
(let ((hashfun (predicate->hash pred)))
(lambda (hashtab newk)
(let ((newtab (make-hash-table newk)))
(hash-for-each
(lambda (key value)
(let ((num (hashfun key newk)))
(vector-set! newtab num
(cons (cons key value)
(vector-ref newtab num)))))
hashtab)
newtab))))
| false |
3597fb000a711c1988928ed8e3aa3a29d9828cf8 | e82d67e647096e56cb6bf1daef08552429284737 | /ex3-76.scm | dd5baf683b57db54b62d87747f6145d5042c3bec | []
| no_license | ashishmax31/sicp-exercises | 97dfe101dd5c91208763dcc4eaac2c17977d1dc1 | 097f76a5637ccb1fba055839d389541a1a103e0f | refs/heads/master | 2020-03-28T11:16:28.197294 | 2019-06-30T20:25:18 | 2019-06-30T20:25:18 | 148,195,859 | 6 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 353 | scm | ex3-76.scm | #lang scheme
(define (make-zero-crossings smoothened-stream last-avg)
(cons-stream (sign-change-detector (stream-car smoothened-stream) last-avg)
(make-zero-crossings (stream-cdr smoothened-stream)
(stream-car smoothened-stream))))
(define (smooth input-stream)
(stream-map average
input-stream
(stream-cdr input-stream))) | false |
7eaa5ba65621333fdad1043a878861be76eb0599 | 6f86602ac19983fcdfcb2710de6e95b60bfb0e02 | /exercises/practice/trinary/trinary.scm | 31ca37982c52861533c0997e026edd6f97fefbf4 | [
"MIT",
"CC-BY-SA-3.0"
]
| permissive | exercism/scheme | a28bf9451b8c070d309be9be76f832110f2969a7 | d22a0f187cd3719d071240b1d5a5471e739fed81 | refs/heads/main | 2023-07-20T13:35:56.639056 | 2023-07-18T08:38:59 | 2023-07-18T08:38:59 | 30,056,632 | 34 | 37 | MIT | 2023-09-04T21:08:27 | 2015-01-30T04:46:03 | Scheme | UTF-8 | Scheme | false | false | 58 | scm | trinary.scm | (import (rnrs))
(define (to-decimal s)
'implement-me!)
| false |
8e6cb47f55ab2269b881ef0b4f69e5a4e3d782ad | 557c51d080c302a65e6ef37beae7d9b2262d7f53 | /workspace/comp-tester/tests/sstester.ss | 951ef6ffd2d819adebf73ace7e5bf390d7bf17bd | []
| no_license | esaliya/SchemeStack | 286a18a39d589773d33e628f81a23bcdd0fc667b | dcfa1bbfa63b928a7ea3fc244f305369763678ad | refs/heads/master | 2020-12-24T16:24:08.591437 | 2016-03-08T15:30:37 | 2016-03-08T15:30:37 | 28,023,003 | 3 | 4 | null | null | null | null | UTF-8 | Scheme | false | false | 782 | ss | sstester.ss | (define f
(lambda ()
10))
(define len
(lambda (ls)
(cond
[(null? ls) 0]
[else (add1 (len (cdr ls)))])))
(define cats
(lambda (s)
(define f
(lambda (e)
(match e
[(wow ,[g -> x* ...]) x*])))
(define g
(lambda (e)
(reverse e)))
(f s)))
(define simple
(lambda (s)
(match s
[(,[simple -> x ...] ,y) `(,y ,x)]
[,z 'boom])))
(case-sensitive #t)
(define mt
(lambda (s)
(define Prg
(lambda (p)
(match s
[(letrec ,tail)
`(code ,(Tail tail) ... ...)])))
(define Tail
(lambda (t)
'((bing boy) (sing song))))
(Prg s)))
;; (printf "\n*************\n~s\n*************\n" ef)
;;
(lambda (x) (if (eq? (modulo x 2) 0) x 0))
| false |
e5b8f4faffda61786e9ec050f297760e05b41a4d | f2a89a6c62c60082aeec115c2d4b5a1c947a4bd8 | /scheme/drscheme/ports.scm | 27b7969aa12437a5bf60bb775958bd28c4b9f36a | []
| no_license | offby1/anagrams | 13b83343d8f1ca8a0ab1cbc65aedac39c47ee1a9 | 0a7fbcff49a7dee6ed28333ecd354dd1fcff4bd6 | refs/heads/master | 2021-06-05T00:51:33.057068 | 2017-11-20T05:16:37 | 2017-11-20T05:16:37 | 89,620 | 9 | 5 | null | 2017-11-20T05:16:38 | 2008-12-12T17:57:46 | Scheme | UTF-8 | Scheme | false | false | 328 | scm | ports.scm | (module ports
mzscheme
(provide output-port
set-output-port!
status-port
set-status-port!)
(define output-port (current-output-port))
(define (set-output-port! p) (set! output-port p))
(define status-port (current-error-port))
(define (set-status-port! p) (set! status-port p))
) | false |
f7704bc820e3d547e57922d2cca0a1e028795264 | c369eb130ec92b2f313c55e62c30c68c7e6710ae | /src/ru/mik/tenorequal/shader-utils.scm | ea535e622c2576ea64ea4fe20caee933a0b6536a | []
| no_license | VyacheslavMik/10-or-equal | 80d1e307512e1ed4dbe20011850d79fbd61a022d | adf63d3ddc39c154c3d10b885ea6f72777da0041 | refs/heads/master | 2020-03-18T11:20:23.717377 | 2018-05-24T05:31:07 | 2018-05-24T05:31:07 | 134,665,037 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,598 | scm | shader-utils.scm | (require 'android-defs)
(require ru.mik.tenorequal.file-utils)
(define-alias gl-compile-status android.opengl.GLES20:GL_COMPILE_STATUS)
(define-alias gl-link-status android.opengl.GLES20:GL_LINK_STATUS)
(define gl-attach-shader
(lambda ((program :: int) (shader :: int))
(android.opengl.GLES20:glAttachShader program shader)))
(define gl-compile-shader
(lambda ((shader :: int))
(android.opengl.GLES20:glCompileShader shader)))
(define gl-create-program
(lambda ()
(android.opengl.GLES20:glCreateProgram)))
(define gl-create-shader
(lambda ((type :: int))
(android.opengl.GLES20:glCreateShader type)))
(define gl-delete-program
(lambda ((program :: int))
(android.opengl.GLES20:glDeleteProgram program)))
(define gl-delete-shader
(lambda ((shader :: int))
(android.opengl.GLES20:glDeleteShader shader)))
(define gl-get-programiv
(lambda ((program :: int) (pname :: int) (params :: int[]) (offset :: int))
(android.opengl.GLES20:glGetProgramiv program pname params offset)))
(define gl-get-shaderiv
(lambda ((shader :: int) (pname :: int) (params :: int[]) (offset :: int))
(android.opengl.GLES20:glGetShaderiv shader pname params offset)))
(define gl-link-program
(lambda ((program :: int))
(android.opengl.GLES20:glLinkProgram program)))
(define gl-shader-source
(lambda ((shader :: int) (string :: string))
(android.opengl.GLES20:glShaderSource shader string)))
(define create-program
(lambda (vertext-shader-id fragment-shader-id)
(let ((program-id (gl-create-program)))
(if (= program-id 0)
0
(begin
(gl-attach-shader program-id vertext-shader-id)
(gl-attach-shader program-id fragment-shader-id)
(gl-link-program program-id)
(let ((link-status (int[] length: 1)))
(gl-get-programiv program-id gl-link-status link-status 0)
(if (= (link-status 0) 0)
(begin
(gl-delete-program program-id)
0)
program-id)))))))
(define create-shader
(case-lambda
((context type shader-raw-id)
(create-shader type (read-text-from-raw context shader-raw-id)))
((type shader-text)
(let ((shader-id (gl-create-shader type)))
(if (= shader-id 0)
0
(begin
(gl-shader-source shader-id shader-text)
(gl-compile-shader shader-id)
(let ((compile-status (int[] 1)))
(gl-get-shaderiv shader-id gl-compile-status compile-status 0)
(if (= (compile-status 0) 0)
(begin
(gl-delete-shader shader-id)
0)
shader-id))))))))
| false |
d50ac905cdd2ba1537209bbae98f4941a736aedc | f5083e14d7e451225c8590cc6aabe68fac63ffbd | /cs/01-Programming/cs61a/course/lectures/3.3/append.scm | 06c8759d78af94ec3936265d298131a5fecbbc46 | []
| no_license | Phantas0s/playground | a362653a8feb7acd68a7637334068cde0fe9d32e | c84ec0410a43c84a63dc5093e1c214a0f102edae | refs/heads/master | 2022-05-09T06:33:25.625750 | 2022-04-19T14:57:28 | 2022-04-19T14:57:28 | 136,804,123 | 19 | 5 | null | 2021-03-04T14:21:07 | 2018-06-10T11:46:19 | Racket | UTF-8 | Scheme | false | false | 192 | scm | append.scm | (define x (list 1 2 3))
(define y (list 'a 'b 'c))
(define z (append x y))
;; Try:
;; > x
;; > y
;; > z
(set-car! x 'frog)
;; > x
;; > y
;; > z
(set-car! y 'strange)
;; > x
;; > y
;; > z
| false |
536b296011ec8855b851682c356d6fdda9e8578e | 4b480cab3426c89e3e49554d05d1b36aad8aeef4 | /chapter-05/ex5.13-dgoon.scm | c54b8bd8fdefb2956670e4b0d3a56f440371526f | []
| 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 | 4,932 | scm | ex5.13-dgoon.scm | (load "ex5.12-dgoon.scm")
(define (make-machine register-names ops controller-text)
(let ((machine (make-new-machine)))
; <----- COMMENT OUT!
;(for-each (lambda (register-name)
; ((machine 'allocate-register) register-name))
; register-names)
; ----->
((machine 'install-operations) ops)
((machine 'install-instruction-sequence)
(assemble controller-text machine))
machine))
(define (make-new-machine)
;(display "Copied from Exercise 5.12 and Modified for Exercise 5.13 by d-goon\n")
(let ((pc (make-register 'pc))
(flag (make-register 'flag))
(instruction-set '()) ; ex 5.12
(point-register-set '()) ; ex 5.12
(stack-register-set '()) ; ex 5.12
(register-source-set '()) ; ex 5.12
(stack-table '())
(the-instruction-sequence '()))
(let ((the-ops
(list (list 'initialize-stack
(lambda ()
(map (lambda (stack-entry)
(if stack-entry
((cadr stack-entry) 'initialize)
'())))
stack-table))))
(register-table
(list (list 'pc pc) (list 'flag flag))))
(define (allocate-register name)
(if (assoc name register-table)
(error "Multiply defined register: " name)
(begin
(set! register-table
(cons (list name (make-register name))
register-table))
(set! stack-table
(cons (list name (make-stack))
stack-table))))
'register-allocated)
(define (lookup-register name)
(let ((val (assoc name register-table)))
(if val
(cadr val)
;(error "Unknown register:" name)))) ; COMMENT OUT!
(begin
;(display "Allocate register and stack for ")(display name)(newline)
(allocate-register name) ; ex 5.13
(cadr (assoc name register-table)))))) ; ex 5.13
(define (execute)
(let ((insts (get-contents pc)))
(if (null? insts)
'done
(begin
((instruction-execution-proc (car insts)))
(execute)))))
(define (log-instruction inst)
(let ((entry (assoc (instruction-text inst)
instruction-set)))
(if entry
'()
(begin
;(display "Log-instruction:")
;(display (car inst))(newline)
(set! instruction-set
(cons (list (instruction-text inst) 'occurred)
instruction-set))))))
(define (log-register-source inst)
(let ((reg (cadr inst))
(src (caddr inst)))
(let ((key (list reg src)))
(let ((entry (assoc key register-source-set)))
(if entry
'()
(begin
;(display "Log-register-source:");(display key)(newline)
(set! register-source-set
(cons (list key '())
register-source-set))))))))
(define (log-point-register inst)
(if (eq? (caadr inst) 'reg)
(let ((reg (cadadr inst)))
(let ((entry (assoc reg point-register-set)))
(if entry
'()
(begin
;(display "Log-point-register:");(display reg)(newline)
(set! point-register-set
(cons (list reg 'point)
point-register-set))))))))
(define (log-stack-register inst)
(let ((reg (cadr inst)))
(let ((entry (assoc reg stack-register-set)))
(if entry
'()
(begin
;(display "Log-stack-register:");(display reg)(newline)
(set! stack-register-set
(cons (list reg 'stack)
stack-register-set)))))))
(define (dispatch message)
(cond ((eq? message 'start)
(set-contents! pc the-instruction-sequence)
(execute))
((eq? message 'install-instruction-sequence)
(lambda (seq) (set! the-instruction-sequence seq)))
((eq? message 'allocate-register) allocate-register)
((eq? message 'get-register) lookup-register)
((eq? message 'install-operations)
(lambda (ops) (set! the-ops (append the-ops ops))))
((eq? message 'stack) stack-table)
((eq? message 'log-instruction) log-instruction) ; ex 5.12
((eq? message 'log-point-register) log-point-register) ; ex 5.12
((eq? message 'log-stack-register) log-stack-register) ; ex 5.12
((eq? message 'log-register-source) log-register-source) ; ex 5.12
((eq? message 'instruction-set) instruction-set) ; ex 5.12
((eq? message 'point-register-set) point-register-set) ; ex 5.12
((eq? message 'stack-register-set) stack-register-set) ; ex 5.12
((eq? message 'register-source-set) register-source-set) ; ex 5.12
((eq? message 'operations) the-ops)
(else (error "Unknown request -- MACHINE" message))))
dispatch)))
(display "Ex5.13 with dgoon-fib.scm")(newline)
(load "dgoon-fib.scm")
(set-register-contents! fib-machine 'n 10)
(start fib-machine)
(display "fib(10) -> ")(display (get-register-contents fib-machine 'val))(newline)
| false |
1ef2dffd09989c1e49357f7b5c84be682b3fd857 | 27b46612047e4f2b0a2d47b6c35a0078d4b16ee9 | /examples/lambda-int.scm | 24e7de5520f5c040fdc6e4513294135110577283 | [
"BSD-2-Clause"
]
| permissive | narslan/pgg | f709705861e3d6a6b46fd9519d3635d073fb2c28 | 620f6596e8791e4ea94103a5b8ace6a30aadc0a8 | refs/heads/master | 2023-06-10T15:01:42.934875 | 2012-12-31T15:09:37 | 2012-12-31T15:09:37 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,998 | scm | lambda-int.scm | (define (int exp values)
(evaluate exp '() values))
(define (constant? x)
(or (number? x)
(boolean? x)
(and (pair? x)
(equal? 'quote (car x)))))
(define (exp->constant x)
(if (pair? x)
(if (equal? 'quote (car x))
(cadr x)
x)
x))
(define (env-lookup name env-names env-values)
(if (equal? name (car env-names))
(car env-values)
(env-lookup name (cdr env-names) (cdr env-values))))
(define (evaluate exp env-names env-values)
(cond
((constant? exp)
(exp->constant exp))
((not (pair? exp))
(env-lookup exp env-names env-values))
((equal? 'if (car exp))
(let ((condition (cadr exp))
(then-branch (caddr exp))
(else-branch (cadddr exp)))
(if (evaluate condition env-names env-values)
(evaluate then-branch env-names env-values)
(evaluate else-branch env-names env-values))))
((equal? 'lambda (car exp))
(let ((arg-name (caadr exp))
(body (caddr exp)))
(lambda (x)
(evaluate body
(cons arg-name env-names)
(cons x env-values)))))
((equal? 'apply (car exp))
(let ((operator (cadr exp))
(operand (caddr exp)))
((evaluate operator env-names env-values)
(evaluate operand env-names env-values))))
(else
(let ((operator (car exp))
(operands (cdr exp)))
(apply-primitive operator (evaluate* operands env-names env-values))))
))
(define (evaluate* exps env-names env-values)
(if (null? exps)
'()
(cons (evaluate (car exps) env-names env-values)
(evaluate* (cdr exps) env-names env-values))))
(define (apply-primitive operator operands)
(cond
((equal? 'null? operator) (null? (car operands)))
((equal? 'cons operator) (cons (car operands)
(cadr operands)))
((equal? 'car operator) (car (car operands)))
((equal? 'cdr operator) (cdr (car operands)))
((equal? '+ operator) (+ (car operands) (cadr operands)))
((equal? 'equal? operator) (equal? (car operands) (cadr operands)))))
| false |
429a3129b39b055686878e44abb944827e7b39e4 | 17a42034153044d635a3585d9f0c9ea18c565eee | /Chapter-2/exercise-2.8.2.ss | 17bf8441c5b3b0f5633c2a58ed8eb863c3994d44 | []
| no_license | al002/my-tspl4-answers | 2c15b0eb508553557fb0909fe1f46b5afa5b458e | 4dac628055360fd9356ff32ec1b978b91942e895 | refs/heads/master | 2021-05-27T23:14:28.514102 | 2013-04-22T00:18:25 | 2013-04-22T00:18:25 | 9,439,289 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 118 | ss | exercise-2.8.2.ss | (define append
(lambda (lst obj)
(if (null? lst)
obj
(cons (car lst) (append (cdr lst) obj)))))
| false |
3cc17b8e2812851f6b120b22bc968366679cb197 | 997ed3b1450002fbbfb566e1c2314f1ab40f8527 | /milc/compiler.scm | cd2637cb0b835674a2639c0ab3abc721994767e3 | []
| no_license | firephyz/Milos | eaa04391f075b84263cd26e262db3fc92365c8df | 0cd75147b62f4a3cdc6ef54dcc447ea1767bb944 | refs/heads/master | 2021-07-12T19:15:54.825057 | 2017-10-18T12:07:58 | 2017-10-18T12:07:58 | 105,528,430 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,579 | scm | compiler.scm | (define (flatten-code code pc result-start result-end)
(if (null? code)
result-start
(let ((next-segment-offset (+ pc (length code)))
(instr (car code)))
(if (eq? (car instr) 'FUNC)
(let ((func-body (cadr instr)))
(set-cdr! instr next-segment-offset)
(flatten-code (append (cdr code)
func-body)
next-segment-offset
result-start
(set-cdr! result-end (list instr))))
(flatten-code (cdr code)
pc
result-start
(set-cdr! result-end (list (instr))))))))
;; Main compile function
(define (machine-compile expr env)
(if (pair? expr)
(let ((token (car expr)))
(cond ((eq? token 'lambda)
(compile-function (caddr expr)
(cons (cadr expr)
env)))
((eq? token 'if)
(compile-if-statement (cadr expr)
(caddr expr)
(cadddr expr)
env))
(else (compile-application expr env))))
(if (symbol? expr)
(let ((built-in? (compile-built-in expr)))
(if (null? built-in?)
(let ((index (get-symbol-index expr env)))
(list (list 'LOOKUP
(car index)
(cdr index))))
built-in?))
(list (list 'NUM expr)))))
;; Function
(define (compile-function body env)
(list (append '(FUNC)
(machine-compile body env)
'((RET)))))
;; Application
(define (compile-application expr env)
(define (helper result expr)
(if (null? expr)
result
(helper (append (machine-compile (car expr) env)
result)
(cdr expr))))
(if (null? (compile-built-in (car expr)))
;; Not a built-in
(helper '((CALL)) expr)
;; Is a built-in
(helper '() expr)))
;; If statement
(define (compile-if-statement pred then else env)
(let ((pred-compiled (machine-compile pred env))
(then-compiled (machine-compile then env))
(else-complied (machine-compile else env)))
(append pred-compiled
(list 'JIF
(+ 1 (length then-compiled)))
then-compiled
(list 'JUMP
(+ 1 (length else-compiled)))
else-compiled)))
;; Find the environment index of a given symbol
(define (get-symbol-index var env)
(define (search-frame frame dist)
(if (null? frame)
'()
(if (eq? var (car frame))
dist
(search-frame (cdr frame) (+ dist 1)))))
(define (search-env env depth)
(if (null? env)
(error "Var not found!")
(let ((result (search-frame (car env) 0)))
(if (null? result)
(search-env (cdr env) (+ depth 1))
(cons depth result)))))
(search-env env 0))
;; Built-in functions
(define (compile-built-in expr)
(let ((result (cond ((eq? expr '+) '(ADD))
((eq? expr '-) '(SUB))
((eq? expr '*) '(MULT))
((eq? expr '/) '(DIV))
(else '()))))
(if (null? result)
'()
(list result))))
(define result (cons 'result '()))
(flatten-code (machine-compile '((lambda (g n) (+ n (g))) (lambda () 5) 3) '()) 0 result result) | false |
3a23b28ad4b3e0487d395712f6ae62a61b71e84f | e82d67e647096e56cb6bf1daef08552429284737 | /ex2-29.scm | 0a3320c5bcf05a79571c81c19d8f2ef83cd5083c | []
| no_license | ashishmax31/sicp-exercises | 97dfe101dd5c91208763dcc4eaac2c17977d1dc1 | 097f76a5637ccb1fba055839d389541a1a103e0f | refs/heads/master | 2020-03-28T11:16:28.197294 | 2019-06-30T20:25:18 | 2019-06-30T20:25:18 | 148,195,859 | 6 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 3,293 | scm | ex2-29.scm | #lang scheme
(define (make-binary-mobile left right)
(list left right))
(define (make-branch len structure)
(list len structure))
(define (left-branch mobile)
(car mobile))
(define (right-branch mobile)
(car (cdr mobile)))
(define (branch-length branch)
(car branch))
(define (branch-structure branch)
(car (cdr branch)))
(define (total-weight mobile)
(cond ((and (not (has-mobile? (left-branch mobile)))
(not (has-mobile? (right-branch mobile))))
(+ (left-branch-structure mobile) (right-branch-structure mobile)))
((and (not (has-mobile? (left-branch mobile)))
(has-mobile? (right-branch mobile)))
(+ (left-branch-structure mobile) (total-weight (right-branch-structure mobile))))
((and (has-mobile? (left-branch mobile))
(not (has-mobile? (right-branch mobile))))
(+ (right-branch-structure mobile) (total-weight (left-branch-structure mobile))))
(else (+ (total-weight (left-branch-structure mobile))
(total-weight (right-branch-structure mobile))))))
(define (has-mobile? branch)
(pair? (branch-structure branch)))
(define (left-branch-structure mobile)
(branch-structure (left-branch mobile)))
(define (right-branch-structure mobile)
(branch-structure (right-branch mobile)))
(define (branch-torque branch)
(torque (branch-length branch)
(branch-structure branch)))
(define (torque len weight)
(* len weight))
(define (balanced? mobile)
(cond ((and (not (has-mobile? (left-branch mobile)))
(not (has-mobile? (right-branch mobile))))
(equal? (branch-torque (left-branch mobile))
(branch-torque (right-branch mobile))))
((and (not (has-mobile? (left-branch mobile)))
(has-mobile? (right-branch mobile)))
(and (equal? (branch-torque (left-branch mobile))
(* (branch-length (right-branch mobile))
(total-weight (right-branch-structure mobile))))
(balanced? (right-branch-structure mobile))))
((and (has-mobile? (left-branch mobile))
(not (has-mobile? (right-branch mobile))))
(and (equal? (branch-torque (right-branch mobile))
(* (branch-length (left-branch mobile))
(total-weight (left-branch-structure mobile))))
(balanced? (left-branch-structure mobile))))
(else (and (nested-mobile-torque-equivalence? mobile)
(balanced? (left-branch-structure mobile))
(balanced? (right-branch-structure mobile))))))
(define (nested-mobile-torque-equivalence? nested-mobile)
(equal? (torque (branch-length (left-branch nested-mobile))
(total-weight (left-branch-structure nested-mobile)))
(torque (branch-length (right-branch nested-mobile))
(total-weight (right-branch-structure nested-mobile)))))
(define z (make-binary-mobile (make-branch 1 10) (make-branch 2 12)))
(define y (make-binary-mobile (make-branch 3 z ) (make-branch 7 z)))
(define x (make-binary-mobile (make-branch 3 y ) (make-branch 7 1)))
| false |
4b5923df2816b9954bda42dab699f96cbd54c648 | c09e550e00af73f4aa6ccd450a4c3b0d600a10af | /compiler/expander.ss | 6056ec218f2dc88e7c239b7fec4d3e5ebcf03f79 | []
| no_license | cgswords/sgc | 13771d904a844d21633fb2a5bbb922159cb7e63a | f6e41da7ec95bc16b3e18b364e0edd8daab6f26f | refs/heads/master | 2021-01-10T13:29:03.218473 | 2016-01-29T22:22:14 | 2016-01-29T22:22:14 | 48,896,956 | 7 | 3 | null | null | null | null | UTF-8 | Scheme | false | false | 17,157 | ss | expander.ss | (library (compiler expander)
(export
subst
wrap-syntax
constant?
wrap-syntax
strip
anti-mark
mk
lbl
identifier?
build-wrap
push-marks
do-subst
do-ext-subst
datum-to-syntax
expose
apply-subst
apply-ext-subst
resolve
get-marks
same-marks?
special
ext-env
expand
syn-parse
splice-syntax
build-transformer
eval-trans
empty-env
)
(import
(except (chezscheme) identifier? expand subst)
(framework match)
(framework helpers)
(except (compiler helpers) empty-env))
(define-record subst ((immutable symbol) (immutable marks) (immutable label) (immutable extensible)))
(define-record wrap ((immutable expr) (immutable marks) (immutable substs)))
(define (constant? x)
(or (memq x '(#t #f ()))
(and (and (integer? x) (exact? x))
(or (fixnum-range? x)
(errorf 'const "integer ~s is out of fixnum range" x)))))
(define wrap-syntax
(lambda (expr)
(match expr
[,k (guard (constant? k)) k]
[,id (guard (symbol? id)) (make-wrap id '() '())]
[(if ,[e1] ,[e2] ,[e3]) `(if ,e1 ,e2 ,e3)]
[(begin ,[e] ,[e*] ...) `(begin ,e ,e* ...)]
;; [(lambda ,args ,[e] ...) `(lambda ,(map syntax-object args) ,e ...)]
;; [(letrec ([,[v] ,[e*]] ...) ,[e] ...) `(letrec ([,v ,e*] ...) ,e)]
;; [(letrec-syntax ([,[v] ,[e*]] ...) ,[e] ...) `(letrec-syntax ([,v ,e*] ...) ,e)]
;; [(let ([,[v] ,[e*]] ...) ,[e] ...) `(let ([,v ,e*] ...) ,e)]
[(,[e] ,[e*] ...) `(,e ,e* ...)])))
(define strip
(lambda (expr)
(cond
[(constant? expr) expr]
[(symbol? expr) expr]
[(pair? expr) (cons (strip (car expr)) (strip (cdr expr)))]
[(wrap? expr) (strip (wrap-expr expr))])))
(define anti-mark #f)
(define mk (lambda () (string #\m)))
(define lbl (lambda () (string #\l)))
(define (identifier? x) (or (symbol? x) (and (wrap? x) (identifier? (wrap-expr x)))))
(define build-wrap
(lambda (expr marks substs)
(let loop ((expr expr) (marks marks) (substs substs))
(if (wrap? expr)
(loop (wrap-expr expr) (append marks (wrap-marks expr)) (append substs (wrap-substs expr)))
(make-wrap expr marks substs)))))
(define push-marks
(lambda (expr mark)
(cond
[(not (wrap? expr)) (build-wrap expr (list mark) '(shift))]
[else
(let ((marks (wrap-marks expr)))
(cond
[(and (not (null? marks)) (not (car marks))) ;; the car is the anit-mark
(build-wrap (wrap-expr expr) (cdr marks) (cdr (wrap-substs expr)))]
[else
(build-wrap (wrap-expr expr) (cons mark marks) (cons 'shift (wrap-substs expr)))]))])))
(define do-subst
(lambda (expr ident* label*)
(build-wrap
expr
'()
(list (make-subst
(list->vector (map (lambda (x) (if (wrap? x) (wrap-expr x) x)) ident*))
(list->vector (map (lambda (x) (if (wrap? x) (wrap-expr x) x)) ident*))
(list->vector label*)
#f)))))
(define do-ext-subst
(lambda (expr ident* label*)
(build-wrap
expr
'()
(list (make-subst
(box (map (lambda (x) (if (wrap? x) (wrap-expr x) x)) ident*)) ;; symbols
(box (map (lambda (x) (if (wrap? x) (wrap-marks x) '())) ident*)) ;; marks
(box label*)
#t)))))
(define datum-to-syntax
(lambda (stx-id datum)
(if (symbol? (wrap-expr stx-id))
(build-wrap datum (wrap-marks stx-id) (wrap-substs stx-id))
(error 'datum-to-syntax "Bad syntax identifier: ~s" (strip stx-id)))))
(define expose
(lambda (stx)
(cond
[(symbol? stx) stx]
[(wrap? stx)
(let ([expr (wrap-expr stx)])
(cond
[(symbol? expr) (build-wrap expr (wrap-marks stx) (wrap-substs stx))]
[(list? expr)
(map
(lambda (x) (build-wrap x (wrap-marks stx) (wrap-substs stx)))
expr)]
[else expr]))] ;; constant
[else stx]))) ;; constant
(trace-define apply-subst
(lambda (subst id marks)
(let ([symbol* (subst-symbol subst)]
[marks* (subst-marks subst)]
[label* (subst-label subst)])
(let ((symlen (vector-length symbol*)))
(let loop ([idx 0])
(cond
[(= idx symlen) #f]
[(and (eq? (vector-ref symbol* idx) id)
(same-marks? (vector-ref marks idx) marks))
(vector-ref label* idx)]
[else (loop (add1 idx))]))))))
(define apply-ext-subst
(lambda (subst id marks)
(let loop ([symbol* (unbox (subst-symbol subst))]
[marks* (unbox (subst-marks subst))]
[label* (unbox (subst-label subst))])
(cond
[(null? symbol*) #f]
[(and (eq? (car symbol*) id)
(same-marks? (car marks*) marks))
(car label*)]
[else (loop (cdr symbol*) (cdr marks*) (cdr label*))]))))
(trace-define resolve
(lambda (ident)
(trace-define resolve-loop
(lambda (ident marks substs)
(cond
[(null? substs) ident]
[(eq? (car substs) 'shift)
(resolve-loop ident (cdr marks) (cdr substs))]
[(and (subst? (car substs))
(subst-extensible (car substs))
(apply-ext-subst (car substs) ident marks))]
[(and (subst? (car substs))
(apply-subst (car substs) ident marks))]
[else (resolve-loop ident marks (cdr substs))])))
(cond
[(symbol? ident) ident]
[(wrap? ident)
(resolve-loop (wrap-expr ident)
(wrap-marks ident)
(wrap-substs ident))]
[else (error 'resolve "Bad identifier: ~s" ident)])))
(define get-marks
(lambda (ident)
(or (and (symbol? ident) '())
(and (wrap? ident) (wrap-marks ident))
(errorf 'get-marks "Bad identifier: ~s" ident))))
(define same-marks?
(lambda (marks1 marks2)
(and (= (length marks1) (length marks2))
(andmap eq? marks1 marks2))))
(define special (let ([spc (string #\s)]) (lambda () spc)))
(define ext-env
(lambda (x* a* oenv)
(let* ((x* (if (list? x*) x* (list x*)))
(a* (if (list? a*) a* (list a*))))
(append (zip x* a*) oenv))))
(define apply-env
(lambda (env y)
(cond
[(assq y env) => cdr]
[else (errorf 'expand "Invalid lookup: ~s" y)])))
(define empty-env
(let* ((core-forms '(let-syntax lambda quote quasiquote syntax if define
define-syntax letrec-syntax))
(marks (map (lambda (x) (special)) (iota (length core-forms)))))
(ext-env core-forms marks '())))
;; Expand :: Exp x Env -> Exp
;; expand (e,r) =
;; case (parse e r) of
;; (var i) -> var (resolve i)
;; (e1 e2) -> ((expand e1 r) (expand e2 r))
;; (sym e) -> (strip e)
;; (stx e) -> e
;; (\ i e) -> (\ s (expand (subst e i s) r'))
;; Where r' = r, (s := Var) and s is fresh
;; (\p i e) -> (\ s (expand (subst e i s) r'))
;; Where r' = r, (s := PVar) and s is fresh
;; (macro e) -> (expand (mark (trans (mark e m)) m) r)
;; Where t = (looup r (resolve i)) and m is fresh
;; (syn-bine i e1 e2) -> (expand (subst e2 i s) (ext-env s t r))
;; Where t = eval (expand e1 r) and s is fresh
;; (rec-syn i e1 e2) -> (expand (subst e2 i s) (ext-env s t r))
;; Where t = eval (expand (subst e1 i s) r) and s is fresh
(trace-define expand
(lambda (stx env)
(define-syntax core-form?
(syntax-rules ()
[(_ var name)
(and (identifier? var) (eq? (resolve var) 'name)
(eq? (apply-env env 'name) (special)))]
[(_ var) (and (identifier? var) (eq? (apply-env env (resolve var)) (special)))]))
(match (expose stx)
[(,lamb ,var* ,expr* ...) (guard (core-form? lamb lambda))
(let* ([var* (expose var*)]
[new-var* (map (lambda (var) (unique-name (strip var))) var*)]
[s* (map (lambda (_) (lbl)) var*)]
[expr* (do-subst expr* var* s*)])
`(lambda (,new-var* ...) ,(expand expr* (ext-env s* new-var* env))))]
[(,q ,stx) (guard (core-form? q quote)) `(quote ,(strip stx))]
[(,syn ,stx) (guard (core-form? syn syntax)) stx]
[(,qq ,stx) (guard (core-form? qq quasiquote))
(let recur ([stx stx] [level 0])
(match stx
[(,unq ,datum) (guard (core-form? unq unquote))
(if (zero? level)
(expand datum env)
(recur datum (sub1 level)))]
[(,[a] ,[d*] ...) `(list ,a ,d* ...)]
[,else `(quote ,(strip else))]))]
[(,fi ,[pred] ,[con] ,[alt]) (guard (core-form? fi if)) `(if ,pred ,con ,alt)]
[((,def ,id ,[expr]) ,e* ...) (guard (core-form? def define))
(let ((res (map (lambda (e) (expand e (ext-env id #f env))) e*)))
`((define ,id ,expr) ,res ...))]
[((,def-syn ,id ,[expr]) ,e* ...) (guard (core-form? def-syn define-syntax))
(let ((trans (build-transformer expr)))
(if (procedure? trans)
(let ((res (map (lambda (e) (expand e (ext-env def-syn trans env))) e*)))
`((void) ,e* ...))
(error 'expand "Invalid syntax: ~s" expr)))]
[(,let-syn ((,id ,rhs) ...) ,e* ...)
(guard (core-form? let-syn let-syntax) (and (set? (map expose `(,id ...)))))
(let* ([var* (expose `(,id ...))]
[s* (map (lambda (_) (lbl)) var*)])
(expand
(do-subst e* var* s*)
(ext-env s* (map (lambda (rhs) (eval-trans (expand rhs env))) `(,rhs ...)) env)))]
;; (rec-syn i e1 e2) -> (expand (subst e2 i s) (ext-env s t r))
;; Where t = eval (expand (subst e1 i s) r) and s is fresh
[(,core ,stx* ...) (guard (core-form? core))
(error 'expand "Bad syntax: ~s" `(,core ,stx* ...))]
[(,macro ,stx* ...)
(guard (identifier? macro) (procedure? (apply-env env (resolve macro))))
(expand (push-marks ((apply-env env (resolve macro)) (push-marks `(,macro ,stx* ...) anti-mark)) (mk)) env)]
[(,[rator] ,[rand*] ...) `(,rator ,rand* ...)]
[,id (guard (identifier? id))
(let ([r (apply-env env (resolve id))])
(if (procedure? r)
(expand (push-marks (r (push-marks id anti-mark)) (mk)) env)
r))]
[,wrapped (guard (wrap? wrapped)) (expand wrapped env)]
[,const const])))
;; [,k (guard (constant? k)) `(quote ,k)]
;; [,id (guard (symbol? id)) ((apply-env id env) env id)]
;; [(if ,[(Expr env) -> e1] ,[(Expr env) -> e2] ,[(Expr env) -> e3])
;; `(if ,e1 ,e2 ,e3)]
;; [(begin ,[(Expr env) -> e1] ,[(Expr env) -> e*] ...) `(,e1 ,e* ...)]
;; [(lambda ,args ,e ...)
;; `(lambda ,args ,((Expr (remove-vars args env)) e) ...)]
;; [(letrec ([,v* ,e*] ...) ,e ...)
;; (let ((newRHS (map (Expr (remove-vars v* env)) e*))
;; (newBody (map (Expr (remove-vars v* env)) e)))
;; `(letrec [(,v* ,newRHS) ...] ,newBody ...))]
;; [(let ([,v* ,[(Expr env) -> e*]] ...) ,e ...)
;; (let ((newBody (map (Expr (remove-vars v* env)) e)))
;; `(let ([,v* ,e*] ...) ,newBody ...))]
;; [(letrec-syntax [(,v* ,(build-transformer -> r*)) ...] ,e ...)
;; (map (Expr (ext-env* `((,v* ,r*) ...) env)) e)]
;; [(,id . ,stuff) (guard (symbol? id) (assq id env))
;; ((Expr env) (apply-env expr env))]
;; [(,[(Expr env) -> e1] ,[(Expr env) -> e*] ...) `(,e1 ,e* ...)]
;; [,x (errorf who "invalid Expr ~s" x)])))
(trace-define syn-parse
(lambda (expr pat keywords kt kf)
(trace-define cull-list
(lambda (e)
(cond
[(null? e) '()]
[(pair? e) (cons (car e) (cull-list (cdr e)))]
[else (kf expr)])))
;; Each success continuation takes a list of new bindings.
(define dispatch
(lambda (e p k)
(match p
[#t (k '())]
[,x (guard (memq x keywords) (eq? x e)) (k '())]
[,x (guard (symbol? x))
(if (not (null? e)) (k `((,x . ,e))) (kf expr))]
[(,pcar . ,pcdr)
(cond
[(and (pair? pcdr) (eq? (car pcdr) '...) (null? (cdr pcdr)))
(k `((,pcar . ,(cull-list e))))]
[(pair? e)
(dispatch (car e) pcar
(lambda (binds)
(dispatch (cdr e) pcdr
(lambda (binds^)
(k (append binds binds^))))))]
[else (kf expr)])]
[() (if (null? e) (k '()) (kf expr))]
[,x (equal? p e)])))
(dispatch expr pat kt)))
;; Make hygiene do what it should
;; Look for Kent's notes on Advanced Compilers
(trace-define splice-syntax
(lambda (keywords rhs)
(trace-lambda 'splicer (bindings)
(let* ((identifiers (map car bindings))
(binded (map cdr bindings))
(clean-names (map (lambda (x) (if (symbol? x) (unique-name x) x)) binded))
(bindings (zip identifiers clean-names)))
(trace-define rewriter
(lambda (e)
(match e
[,x (guard (memq x identifiers)) (cdr (assq x bindings))]
[(,ecar . ,ecdr)
(cond
[(and (pair? ecdr) (eq? (car ecdr) '...) (null? (cdr ecdr)))
(let ((f (and (memq ecar identifiers) (assq ecar bindings))))
(if (and f (list? (cdr f))) (cdr f)
(errorf 'expander "Invalid usage of ... in rhs: ~s" rhs)))]
[else (cons (rewriter ecar) (rewriter ecdr))])]
[() '()]
[,x x])))
(printf "~s~n" bindings)
`(let ,(filter (lambda (x) (symbol? (car x))) (zip clean-names binded)) ,(rewriter rhs))))))
(trace-define build-transformer
(lambda (expr)
(match (expose expr)
[(syntax-case ,x ,literals)
(lambda (e) (errorf 'expander "Invald syntax: ~s" expr))]
[(syntax-case ,x ,literals (,pat ,rhs) . ,rest)
(let ((kf (build-transformer `(syntax-case ,literals . ,rest)))
(splicer (splice-syntax literals rhs)))
(lambda (e) (syn-parse e pat literals splicer kf)))])))
(trace-define eval-trans
(lambda (expr)
(match (expose expr)
[(lambda ,args ,body) (build-transformer (expose body))])))
;; (syntax-rules ((_ e1 e2) (+ e1 e2)) ((_ e1 e2 e3) (+ e1 e2 e3)))
;; (define and-t (build-transformer
;; 'and
;; '(syntax-rules ()
;; ((_) #t)
;; ((_ e) e)
;; ((_ e e1 ...) (if e (and e1 ...) #f)))))
;; (define expand-syntax (lambda () (void)))
;; (define expand-syntax
;; (lambda (prog)
;; (define (ext-env* zipped env)
;; (cond
;; [(null? zipped) env]
;; [else
;; (let ([lhs (caar zipped)] [rhs (cdar zipped)])
;; (cons `(,lhs . ,(var-helper lhs rhs))
;; (ext-env* (cdr zipped) env)))]))
;; (define (extend-env x a env)
;; `((,x . ,(var-helper x a)) . ,env))
;; (define (apply-env y env)
;; (let ([lookup (assq y env)])
;; (if lookup
;; (cdr lookup)
;; (errorf who "Unbound variable ~s" y))))
;; (define remove-args
;; (lambda (args env)
;; (cond
;; [(null? args) env]
;; [else (remove-args (cdr args) (remove (assq (car args) env) env))])))
;; (define (Expr env)
;; (lambda (expr)
;; (match expr
;; [,k (guard (constant? k)) `(quote ,k)]
;; [,id (guard (symbol? id)) ((apply-env id env) env id)]
;; [(if ,[(Expr env) -> e1] ,[(Expr env) -> e2] ,[(Expr env) -> e3])
;; `(if ,e1 ,e2 ,e3)]
;; [(begin ,[(Expr env) -> e1] ,[(Expr env) -> e*] ...) `(,e1 ,e* ...)]
;; [(lambda ,args ,e ...)
;; `(lambda ,args ,((Expr (remove-vars args env)) e) ...)]
;; [(letrec ([,v* ,e*] ...) ,e ...)
;; (let ((newRHS (map (Expr (remove-vars v* env)) e*))
;; (newBody (map (Expr (remove-vars v* env)) e)))
;; `(letrec [(,v* ,newRHS) ...] ,newBody ...))]
;; [(let ([,v* ,[(Expr env) -> e*]] ...) ,e ...)
;; (let ((newBody (map (Expr (remove-vars v* env)) e)))
;; `(let ([,v* ,e*] ...) ,newBody ...))]
;; [(letrec-syntax [(,v* ,(build-transformer -> r*)) ...] ,e ...)
;; (map (Expr (ext-env* `((,v* ,r*) ...) env)) e)]
;; [(,id . ,stuff) (guard (symbol? id) (assq id env))
;; ((Expr env) (apply-env expr env))]
;; [(,[(Expr env) -> e1] ,[(Expr env) -> e*] ...) `(,e1 ,e* ...)]
;; [,x (errorf who "invalid Expr ~s" x)])))
;; (Expr prog)))
(print-gensym 'pretty/suffix)
)
| true |
34888455c2757ece5628890860ed379e77cc41da | 41cef4c35c07d1c023318e9870b9c7d83a102ff9 | /ooff/src/gen.scm | 0bcc42a6fc4c59a746128dc0c4248fa0f55f8217 | [
"MIT"
]
| permissive | michae2/michae2.xyz | 10579705ec9ddf6e7d8cbb757986f117fadbdc76 | 83412bf5d45c76f71c84a387109f097188363412 | refs/heads/main | 2022-05-06T02:54:48.248346 | 2022-03-31T04:16:56 | 2022-03-31T04:16:56 | 106,938,693 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,071 | scm | gen.scm | #!r6rs
;;; Object generators defined as weighted context-free grammars.
(library (gen)
(export gen-chooser-random
gen-chooser-trie
gen-grammar)
(import (rnrs base)
(rnrs control)
(rnrs syntax-case)
(only (chezscheme) random random-seed))
(define (gen-chooser-random)
(case-lambda
[() #f]
[(seed) (random-seed seed) #f]
[(sum partial-sums) (random sum)]))
(define (gen-chooser-trie)
(let ([key -1]
[suffix -1])
(case-lambda
[() (set! key (+ key 1)) (set! suffix key) #f]
[(seed) (set! key seed) (set! suffix key) #f]
[(sum partial-sums)
(let-values ([(d m) (div-and-mod suffix (vector-length partial-sums))])
(set! suffix d)
(vector-ref partial-sums m))])))
(define-syntax gen-grammar
(lambda (g)
(syntax-case g ()
[(_ (name) (nt ...) body ...)
#`(define (name chooser)
; Create a procedure for each nonterminal symbol.
#,@(map (lambda (nt)
(syntax-case nt (gen-rules)
[(gen-rules (name) [w e] ...)
(do ([ws #'(w ...) (cdr ws)]
[es #'(e ...) (cdr es)]
[sum 0.0 (+ sum (syntax->datum (car ws)))]
[sums '() (cons sum sums)]
[choices #'([else #f])
(cons #`[(>= choice #,sum) #,(car es)]
choices)])
((null? ws)
(let ([sums (reverse sums)])
#`(define (name)
(let ([choice (chooser #,sum '#(#,@sums))])
(cond
#,@choices))))))]))
#'(nt ...))
(case-lambda
[() (chooser) body ...]
[(seed) (chooser seed) body ...]))]))))
| true |
32dce8341b4cbf8be677bb57048779b2527c54fe | 370b378f48cb3ddd94297240ceb49ff4506bc122 | /exercises/3.1.scm | 31acd2073fd552cddc95c46c81d8e09878113cc3 | []
| no_license | valvallow/PAIP | 7c0c0702b8c601f4e706b02eea9615d8fdeb7131 | ee0a0bd445ef52c5fe38488533fd59a3eed287f0 | refs/heads/master | 2021-01-20T06:56:48.999920 | 2010-11-26T08:09:00 | 2010-11-26T08:09:00 | 798,236 | 0 | 0 | null | null | null | null | SHIFT_JIS | Scheme | false | false | 1,807 | scm | 3.1.scm | ;; PAIP excersise 3.1
;; let*式と等価なラムダ式を示せ
(define-syntax let*->lambda
(syntax-rules ()
((_ () body ...)
(let ()
body ...))
((_ ((var val)) body ...)
(let ((var val))
body ...))
((_ ((var1 val1)(var2 val2) ...) body ...)
(let*->lambda ((var1 val1))
(let*->lambda ((var2 val2) ...)
body ...)))))
(macroexpand '(let*->lambda ((a 10)(b a)(c (+ a b)))
(print a b c)))
;; (#<identifier user#let> ((a 10))
;; (#<identifier user#let*->lambda> ((b a) (c (+ a b)))
;; (print a b c)))
(define-syntax let->lambda
(syntax-rules ()
((_ () body ...)
((lambda ()
body ...)))
((_ ((var val)) body ...)
((lambda (var)
body ...) val))
((_ ((var1 val1)(var2 val2) ...) body ...)
(let->lambda ((var1 val1))
(let->lambda ((var2 val2) ...)
body ...)))))
(macroexpand '(let->lambda ((a 10))
(print a)))
;; ((#<identifier user#lambda> (a)
;; (print a)) 10)
(define-syntax let*->lambda
(syntax-rules ()
((_ () body ...)
(let->lambda ()
body ...))
((_ ((var val)) body ...)
(let->lambda ((var val))
body ...))
((_ ((var1 val1)(var2 val2) ...) body ...)
(let*->lambda ((var1 val1))
(let*->lambda ((var2 val2) ...)
body ...)))))
(macroexpand '(let*->lambda ((a 10)(b a)(c (+ a b)))
(print a b c)))
;; ((#<identifier user#lambda> (a)
;; (#<identifier user#let*->lambda> ((b a) (c (+ a b)))
;; (print a b c))) 10)
| true |
47214e7f44d870d8fccafea33462ff111eaa0bcd | 94d2ca317aaa5b4948c151832d38c0f0d484e7ad | /kanren-test.ss | c8e1ca29d713b3aeb4eac73f47f76e78e4a05dab | []
| no_license | kwannoel/gerbilKanren | 2b38012ed4e53d4f387cbcc4a3e18c3f5ecfcf45 | e49861ed2e5437855361cafcc33fef8314857f78 | refs/heads/master | 2023-04-09T03:15:23.286682 | 2021-04-17T05:16:42 | 2021-04-17T05:16:42 | 358,140,909 | 3 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,298 | ss | kanren-test.ss | (import :kanren)
(import :kanren-test-utils)
(test-equal? "test function success" 1 1)
(test-equal? "test function fail" 1 2)
(test-equal? "Lookup success"
(lookup (var 1) (list (cons (var 1) 1)))
1)
(test-equal? "Lookup fail"
(lookup (var 1) (list (cons (var 0) 1)))
#f)
(test-equal? "Lookup empty"
(lookup (var 1) '())
#f)
(test-equal? "walk around nowhere"
(walk (var 1) '())
(var 1))
(test-equal? "walk around somewhere"
(walk (var 0) (list (cons (var 0) 1)))
1)
(test-equal? "walk into var"
(walk (var 0) (list (cons (var 0) (var 2))))
(var 2))
(test-equal? "walk with prims"
(walk 1 '(list (cons 1 2)))
1)
(test-equal? "is var"
(var? (var 1))
#t)
(test-equal? "is not var"
(var? 1)
#f)
;; (test-equal? "cmp var, not var"
;; (var=? (var 0) 1)
;; #f)
(test-equal? "extends assocs"
(ext-assocs (var 0) 1 '())
(list (cons (var 0) 1)))
(test-equal? "unify vars"
(unify (var 0) (var 1) '())
(list (cons (var 0) (var 1))))
(test-equal? "unify with empty assocs-list"
(unify (var 0) 1 '())
(list (cons (var 0) 1)))
(test-equal? "== success"
((== (var 1) 1) state0)
(list (cons 0 (list (cons (var 1) 1)))))
(test-equal? "fresh success"
(let ((r (fresh (lambda (a) (== a 1)))))
(run* state0 r))
(list (cons 1 (list (cons (var 0) 1)))))
(test-equal? "conj success"
(let ((r (fresh (lambda (a)
(fresh (lambda (b)
(conj (== a 1)
(== a b))))))))
(run* state0 r))
(list (cons 2 (list (cons (var 1) 1) (cons (var 0) 1)))))
(test-equal? "disj success"
(let ((r (fresh (lambda (a)
(disj (== a 1)
(== a 2))))))
(run* state0 r))
(list (cons 1 (list (cons (var 0) 1)))
(cons 1 (list (cons (var 0) 2)))))
| false |
5cc1a2b544a22e2612c1eb18f7f71f117e856be0 | d074b9a2169d667227f0642c76d332c6d517f1ba | /sicp/ch_1/exercise.1.20.scm | 839c6ddc3fac046af7e0f3c07d0da04e244f763e | []
| 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 | 3,350 | scm | exercise.1.20.scm | #lang racket/base
;;; Exercise 1.20:
;; The process that a procedure generates is of course dependent on
;; the rules used by the interpreter. As an example, consider the
;; iterative `gcd' procedure given above. Suppose we were to interpret
;; this procedure using normal-order evaluation, as discussed in
;; section *Note 1-1-5::. (The normal-order-evaluation rule for `if'
;; is described in *Note Exercise 1-5::.) Using the substitution
;; method (for normal order), illustrate the process generated in
;; evaluating `(gcd 206 40)' and indicate the `remainder' operations
;; that are actually performed. How many `remainder' operations are
;; actually performed in the normal-order evaluation of `(gcd 206
;; 40)'? In the applicative-order evaluation?
(define (gcd a b)
(if (= b 0)
a
(gcd b (remainder a b))))
;; applicative order:
(gcd 206 40) ; > (remainder 206 40)
(gcd 40 6) ; > (remainder 40 6)
(gcd 6 4) ; > (remainder 6 4)
(gcd 4 2) ; > (remainder 4 2)
(gcd 2 0)
2
;; 4 calls to remainder
;; normal order:
;; shorten for readibility... not that it really helps... ugh
(define g gcd)
(define r remainder)
;; step 1
(g 206 40) ; expand/eval/substitute to:
(if (= 40 0) 206 (g 40 (r 206 40))) ; expands
(if #f 206 (g 40 (r 206 40))) ; evals and substitutes, and so on:
;; step 2
(g 40 (r 206 40))
(if (= (r 206 40) 0) 40 (g (r 206 40) (r 40 (r 206 40))))
(if (= 6 0) 40 (g (r 206 40) (r 40 (r 206 40))))
(if #f 40 (g (r 206 40) (r 40 (r 206 40))))
;; step 3
(g (r 206 40) (r 40 (r 206 40)))
(if (= (r 40 (r 206 40)) 0)
(r 206 40)
(g (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))
(if (= 4 0)
(r 206 40)
(g (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))
(if #f
(r 206 40)
(g (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))
;; step 4
(g (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40))))
(if (= (r (r 206 40) (r 40 (r 206 40))) 0)
(r 40 (r 206 40))
(g (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40))))))
(if (= 2 0)
(r 40 (r 206 40))
(g (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40))))))
(if #f
(r 40 (r 206 40))
(g (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40))))))
;; step 5
(g (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))
(if (= (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))) 0)
(r (r 206 40) (r 40 (r 206 40)))
(g (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))) (r (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))))
(if (= 0 0)
(r (r 206 40) (r 40 (r 206 40)))
(g (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))) (r (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))))
(if #t
(r (r 206 40) (r 40 (r 206 40)))
(g (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))) (r (r (r 206 40) (r 40 (r 206 40))) (r (r 40 (r 206 40)) (r (r 206 40) (r 40 (r 206 40)))))))
;; step 6 - finally done
(r (r 206 40) (r 40 (r 206 40)))
2
;; so... 18 calls to remainder? I think I counted that right.
;; and so on... ugh
| false |
28b9f93aa80d184ae1c10749974ea9bba7932f46 | defeada37d39bca09ef76f66f38683754c0a6aa0 | /System/system/net/configuration/web-proxy-script-element.sls | f251498179f936e0db684a3644e5cf2087ca8193 | []
| 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 | 848 | sls | web-proxy-script-element.sls | (library (system net configuration web-proxy-script-element)
(export new
is?
web-proxy-script-element?
download-timeout-get
download-timeout-set!
download-timeout-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.Net.Configuration.WebProxyScriptElement
a
...)))))
(define (is? a)
(clr-is System.Net.Configuration.WebProxyScriptElement a))
(define (web-proxy-script-element? a)
(clr-is System.Net.Configuration.WebProxyScriptElement a))
(define-field-port
download-timeout-get
download-timeout-set!
download-timeout-update!
(property:)
System.Net.Configuration.WebProxyScriptElement
DownloadTimeout
System.TimeSpan))
| true |
a0f28ae205e8f8e83bc6f7759babc8084887fe71 | abc7bd420c9cc4dba4512b382baad54ba4d07aa8 | /src/ws/scrap/analysis.ss | 78f7ea00880defecfe7250efcb5f6f3c97fcd65e | [
"BSD-3-Clause"
]
| permissive | rrnewton/WaveScript | 2f008f76bf63707761b9f7c95a68bd3e6b9c32ca | 1c9eff60970aefd2177d53723383b533ce370a6e | refs/heads/master | 2021-01-19T05:53:23.252626 | 2014-10-08T15:00:41 | 2014-10-08T15:00:41 | 1,297,872 | 10 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 1,078 | ss | analysis.ss |
;; Contiguity type:
;; <density> := bottom
;; | (contig-area ,diam ,area <density>)
;; | (sparse-area ,diam ,area <density>)
;; | top
;; | localval
;; | (area <contig>)
;; | (contig <diam> <area>)
;; Diameter and Area:
;; (<diam> <area>)
;; <diam> = bottom | <int> | wholediam | top
;; <area> = bottom | <int> | wholearea | top
;; (3 5)
;; (3 bottom)
;; (wholediam wholearea)
;; Approximation (node in the lattice)::
;; (<density-type> <diam+2area>)
(define transfer
(lambda (op args type)
(match (list fun args type)
[(rrcluster ,args ,denstype)
`[(contig-area ,denstype) (,diam ,area)]]
[(sparsify ,args
((,sparse-or-contig ,childtype)
(diam ,area)))
`[(sparse-area ,childtype) (,diam ,area)]]
[,other (error 'transfer "can't handle: ~s ~s ~s" op argsg type)])))
;(define cost
; (lambda (annotated-prog)
; (match type
; [localval 1]
; [
(define-testing test-this (default-unit-tester
"Analysis Pass: determine continuity"
these-tests))
| false |
31711dfac965fdc3ed13fe744331be866ee9d65d | e1c580145992634f089af18940508f5c26d2e264 | /umcu/packages/varscan.scm | bf30cd86f899ab357af4e6929a74e3003b9f6148 | []
| no_license | inijman/guix-additions | 8542592972e644a4ccd7b36ad4dd9b5631008fb5 | b8e0e3f3b9598aade3103e9f491307fa06ece03d | refs/heads/master | 2021-07-13T21:35:25.731179 | 2020-05-28T14:01:04 | 2020-05-28T14:01:04 | 142,980,977 | 0 | 0 | null | 2018-07-31T07:49:53 | 2018-07-31T07:49:53 | null | UTF-8 | Scheme | false | false | 4,704 | scm | varscan.scm | ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 Roel Janssen <[email protected]>
;;;
;;; This file is not officially part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
;; WARNING: This is non-free software. It will NEVER and SHOULD NEVER be
;; mainlined in GNU Guix. You should avoid using this package, and if you
;; can, please write a free replacement for it.
(define-module (umcu packages varscan)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix utils)
#:use-module (guix download)
#:use-module (guix build-system ant)
#:use-module (gnu packages))
(define (varscan version commit hash)
(let ((jar-file (string-append "varscan-" version ".jar")))
(package
(name "varscan")
(version version)
(source (origin
(method url-fetch)
(uri (string-append
"https://github.com/dkoboldt/varscan/raw/"
commit "/VarScan.v" version ".source.jar"))
(sha256 (base32 hash))))
(build-system ant-build-system)
(arguments
`(#:tests? #f ; No test target.
#:phases
(modify-phases %standard-phases
(replace 'unpack
(lambda _
(mkdir "source")
(chdir "source")
(and
;; Unpack the Java archive containing the source files.
(zero? (system* "jar" "xf" (assoc-ref %build-inputs "source")))
;; Remove existing compiled output.
(with-directory-excursion "net/sf/varscan/"
(for-each (lambda (file)
(unless (string= (string-take-right file 5) ".java")
(zero? (system* "rm" file))))
(find-files "." #:directories? #f))))))
(replace 'build
(lambda _
;; Keep a list of files to be included in the JAR.
(let ((out-files '("META-INF/MANIFEST.MF"))
(sources-dir "net/sf/varscan/"))
(and
(with-directory-excursion sources-dir
(for-each
(lambda (file)
(when (string= (string-take-right file 5) ".java")
;; Compile the source files.
(zero? (system* "javac" file))
;; Add to list of files to be included in the JAR.
(set! out-files
(append
out-files
(list (string-append sources-dir
(string-drop-right (string-drop file 2) 5)
".class"))))))
(find-files "." #:directories? #f)))
;; Construct the Java archive.
(let ((params (append '("jar" "cfm" ,jar-file) out-files)))
(zero? (apply system* params)))))))
(replace 'install
(lambda _
(let ((out (string-append (assoc-ref %outputs "out")
"/share/java/varscan/")))
(install-file ,jar-file out)))))))
(home-page "http://dkoboldt.github.io/varscan/")
(synopsis "Variant detection in massively parallel sequencing data")
(description "")
;; Free for non-commercial use by academic, government, and
;; non-profit/not-for-profit institutions
(license license:non-copyleft))))
(define-public varscan-2.4.0
(varscan "2.4.0" "ed3227992f31725548d6106dc7fcd0bd8879ff1e"
"1qyl93awj31qg4pbwaicm5vgq4zv5b9aqa10dpna9qrvbcqfdz90"))
(define-public varscan-2.4.1
(varscan "2.4.1" "91f116629b2addce523a2eabe118b1cd7a538444"
"0y45ympkza7qwcbcisg006286pwjbr5978n03hx5nvl09f0mapk8"))
(define-public varscan-2.4.2
(varscan "2.4.2" "18425ce00e3ced8afc624bd86de142b1cd1e0eb0"
"14f7fp0yaj3lsif1dpjdci7kz3b2fd9qic3299a2bvgk3rv3lp6n"))
| false |
519c5218f376f82f5f681eada2718d762ded780e | 51861d4b51fc7692449550da7fd2e0035eabca30 | /oldsrc/helpers-tests.scm | 4ff0412d424cdf04b257f2f8fc8e19cf986349e9 | [
"MIT"
]
| permissive | stjordanis/probKanren | e611429b197e236c5df1a10369f6bfb4a167c2c7 | 00cd62c8211a8a210099c36be961b8927b298ce8 | refs/heads/master | 2020-09-18T20:53:33.468153 | 2015-10-20T21:40:23 | 2015-10-20T21:40:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 876 | scm | helpers-tests.scm | (load "mk.scm")
(load "helpers.scm")
(load "test-check.scm")
(test-random "repeato-1"
(run-mh 10 (q) (repeato 3 (lambda (x) (flip 0.25 x)) q))
'((#f #f #f)
(#f #f #f)
(#f #f #f)
(#f #f #f)
(#f #f #f)
(#f #f #f)
(#f #f #f)
(#f #f #f)
(#t #f #f)
(#f #f #f)))
(test "seq-goalo-1"
(run-mh 4 (q) (fresh (x y z) (seq-goalo (lambda (x) (== x #t)) (list x y z)) (== (list x y z) q)))
'((#t #t #t) (#t #t #t) (#t #t #t) (#t #t #t)))
(test "map-goalo-1"
(run-mh 3 (q)
(map-goalo (lambda (x out)
(== x out))
(list 1 2 3)
q))
'((1 2 3) (1 2 3) (1 2 3)))
(define >o
(lambda (x y z)
(delayed-goal `(,x ,y)
(project (x y z)
(== (> x y) z)))))
(test "zipwitho-1"
(run-mh 4 (out) (zipwitho >o '(1 2 3) '(4 1 6) out))
'((#f #t #f) (#f #t #f) (#f #t #f) (#f #t #f)))
| false |
cf4008c0430bdc9ffe8316e53e578d6a3c042ad3 | 516d588aede7345408f2a4df414aff2762eef2cf | /tuile/pr.scm | 235fbddca286244cbd033a0c19a2cb48e6774ad9 | []
| no_license | tisannai/tuile | a29be5efe795d60525eb9e2c534f29a8dc5544ba | 849d3595a21cb0418e46dc77e55382401e670481 | refs/heads/master | 2023-09-03T02:00:25.405667 | 2023-08-16T20:26:16 | 2023-08-16T20:26:16 | 229,030,435 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 10,657 | scm | pr.scm | (define-module (tuile pr)
#:use-module ((ice-9 pretty-print) #:select (pretty-print))
#:use-module (rnrs records inspection)
#:use-module (rnrs records procedural)
#:export
(pr
pl
prp
pro
prpo
prd
prdl
ss
sp
si
pri
ds
pd
pde
pp
ppe
ppr
ppre
:lj
:rj
:cj
:ls
:rs
:lc
:rc
:jn
:sp
:ms
:in
:nl
:ow
expand-string-interpolation
))
;; ------------------------------------------------------------
;; Internal functions:
;; Flatten argument list to arbitraty depth.
(define (flat-args . args)
(if (pair? args)
(cond
((list? (car args))
;; (format #t "list?\n")
(append (apply flat-args (car args)) (apply flat-args (cdr args))))
((null? (car args))
;; (format #t "null?\n")
'())
((unspecified? (car args))
(flat-args (cdr args)))
(else
;; (format #t "else\n")
(cons (car args) (flat-args (cdr args)))))
'()))
;; Convert obj to string type.
(define (to-string obj)
(cond
((string? obj) obj)
((char? obj) (string obj))
(else (object->string obj))))
;; Macro to flatten args and convert all arguments to strings.
(define-syntax fa
(syntax-rules ()
((_ args)
(map to-string (apply flat-args args)))))
;; Char or string argument as char.
(define (ch-or-str-as-ch arg)
(if (char? arg)
arg
(car (string->list arg))))
;; Char or string argument as string.
(define (ch-or-str-as-str arg)
(if (string? arg)
arg
(make-string 1 arg)))
;; ------------------------------------------------------------
;; External functions:
;; String from args.
(define (ss . args)
(apply string-append (fa args)))
(define (sp datum)
(with-output-to-string (lambda ()
(pretty-print datum))))
;; Expand interpolation for a string.
;;
;; "Hello #{my-friend}!" -> ("Hello " my-friend "!")
;;
(define (expand-string-interpolation str)
(define (update-words words word)
(if (pair? word)
(cons (list->string (reverse word)) words)
words))
(let loop ((chars (string->list str))
(words '())
(word '())
(state 'in-string))
(if (null? chars)
;; Done.
(reverse (update-words words word))
;; Continue.
(let ((ch (car chars)))
(case state
((in-string)
(cond
;; Escape.
((char=? ch #\\)
(loop (cddr chars)
words
(cons (cadr chars) word)
state))
;; Interpolation (potentially).
((char=? ch #\#)
(if (char=? (cadr chars)
#\{)
;; Interpolation.
(loop (cddr chars)
(update-words words word)
'()
'in-interpolation)
(loop (cdr chars)
words
(cons ch word)
state)))
(else
(loop (cdr chars)
words
(cons ch word)
state))))
((in-interpolation)
(cond
;; Escape.
((char=? ch #\\)
(loop (cddr chars)
words
(cons (cadr chars) word)
state))
;; Terminate interpolation.
((char=? ch #\})
(let ((expr (read (open-input-string
(list->string (reverse word))))))
(loop (cdr chars)
(cons expr words)
'()
'in-string)))
(else
(loop (cdr chars)
words
(cons ch word)
state)))))))))
;; String interpolation (ruby style).
;;
;; (si "Hello #{my-friend}!")
;;
(define-syntax si
(lambda (x)
(let ((stx (syntax->datum x)))
#`(ss #,@(datum->syntax x (expand-string-interpolation (cadr stx)))))))
(define-syntax pri
(lambda (x)
(let ((stx (syntax->datum x)))
#`(pr #,@(datum->syntax x (expand-string-interpolation (cadr stx)))))))
;; (define-syntax-rule (pri s ...)
;; (pr (si s ...)))
;; Datum to string.
(define (ds datum)
(with-output-to-string (lambda ()
(write datum))))
(define (pd datum)
(pr (ds datum)))
(define (pde . datums)
(for-each pd datums)
(exit 0))
(define (pretty-print-including-records rec . initial-indent)
(define indent-step 2)
(define (space indent) (make-string indent #\ ))
(define (print-with-indent rec indent)
(define-syntax-rule (next-indent) (+ indent indent-step))
(cond
((list? rec)
(pr (space indent) "(")
(for-each (lambda (datum) (print-with-indent datum (next-indent))) rec)
(pr (space (next-indent)) ")"))
((vector? rec)
(pr (space indent) "[")
(for-each (lambda (datum) (print-with-indent datum (next-indent))) (vector->list rec))
(pr (space (next-indent)) "]"))
((record? rec)
(let ((rtd (record-rtd rec)))
;; (pr "IS REC")
(pr (space indent) (record-type-name rtd) " {")
(for-each (lambda (name-value)
(pr (space (next-indent)) (car name-value) ":")
(print-with-indent (cdr name-value) (+ indent (* indent-step 2))))
(let loop ((fields (vector->list (record-type-field-names rtd)))
(index 0)
(ret '()))
(if (pair? fields)
(loop (cdr fields)
(1+ index)
(cons (cons (car fields)
((record-accessor rtd index) rec))
ret))
(reverse ret))))
(pr (space (next-indent)) "}")))
(else
;; (pr "NOT REC")
(pretty-print rec #:per-line-prefix (space indent)))))
(print-with-indent rec (if (pair? initial-indent) (car initial-indent) 0)))
(define (pp . datums)
(for-each pretty-print-including-records datums))
(define (ppe . datums)
(apply pp datums)
(exit 0))
(define (ppr . datums)
(for-each pretty-print datums))
(define (ppre . datums)
(apply ppr datums)
(exit 0))
;; Line print from args.
(define (pr . args)
(display (apply ss args))
(newline)
;; (display "flush")
;; (newline)
;; (force-output)
)
;; Print lines from args.
(define (pl args)
(for-each pr args))
;; Print from args.
(define (prp . args)
(display (apply ss args)))
;; Line print from args to port.
(define (pro port . args)
(display (apply ss args) port)
(newline port))
;; Print from args.
(define (prpo port . args)
(display (apply ss args) port))
;; Printer for debugging. Alias to pr.
(define prd pr)
;; Printer for debugging a list.
(define (prdl lst)
(for-each (lambda (item)
(pr item))
lst))
;; Left justify with padding.
;;
;; left-just <width> <pad-str-or-ch> <strings>
(define (:lj width pad . rest)
(let* ((pad-ch (ch-or-str-as-ch pad))
(str (string-concatenate (fa rest)))
(pad-cnt (if (< (string-length str) width)
(- width (string-length str))
0)))
(string-append str (make-string pad-cnt pad-ch))))
;; Right justify with padding.
;;
;; right-just <width> <pad-str-or-ch> <strings>
(define (:rj width pad . rest)
(let* ((pad-ch (ch-or-str-as-ch pad))
(str (string-concatenate (fa rest)))
(pad-cnt (if (< (string-length str) width)
(- width (string-length str))
0)))
(string-append (make-string pad-cnt pad-ch) str)))
;; Center justify with padding.
;;
;; center-just <width> <pad-str-or-ch> <strings>
(define (:cj width pad . rest)
(let* ((str (string-concatenate (fa rest)))
(len (string-length str)))
(if (>= len width)
str
(let* ((pad-ch (ch-or-str-as-ch pad))
(lpad-cnt (quotient (- width len) 2))
(rpad-cnt (- width len lpad-cnt)))
(string-append (make-string lpad-cnt pad-ch)
str
(make-string rpad-cnt pad-ch))))))
;; Left-justify with space.
(define (:ls width . rest)
(:lj width #\ rest))
;; Right-justify with space.
(define (:rs width . rest)
(:rj width #\ rest))
(define (align-or-clip-with fn width pad rest)
(let ((str (string-concatenate (fa rest))))
(if (> (string-length str)
width)
(substring str 0 width)
(apply fn (append (list width pad)
rest)))))
;; Left-just-clip with pad.
(define (:lc width pad . rest)
(align-or-clip-with :lj width pad rest))
;; Right-just-clip with pad.
(define (:rc width pad . rest)
(align-or-clip-with :rj width pad rest))
;; Right-just-clip with pad.
#;
(define (:rc width pad . rest)
(let ((str (string-concatenate (fa rest))))
(if (> (string-length str)
width)
(let ((off (- (string-length str) width)))
(substring str off (+ width off)))
(apply :rj (append (list width pad)
rest)))))
;; Join with given string (or char).
(define (:jn join-str-or-char . rest)
(string-join (fa rest) (ch-or-str-as-str join-str-or-char)))
;; Join with space.
(define (:sp . args)
(string-join (fa args) " "))
;; Make string from template (string or char).
(define (:ms count char-or-str)
(if (char? char-or-str)
(make-string count char-or-str)
(string-concatenate (make-list count char-or-str))))
;; Space indentation by count.
(define (:in count)
(make-string count #\ ))
;; Newline string.
(define :nl "\n")
;; String overwrite with list of cons arguments. Each cons is a
;; (<index> . <overwrite>) pair.
(define (:ow str . rest)
(if (or (null? rest)
(not (car rest)))
str
(let loop ((mod rest)
(str str))
(if (pair? mod)
(loop (cdr mod)
(string-append (substring str
0
(caar mod))
(cdar mod)
(substring str
(+ (caar mod) (string-length (cdar mod))))))
str))))
| true |
8ca65ec942577a779566b6e8780927e6b2525ee4 | 0fb129f0bb28f55cb148d0e7fb1b8ca439c23e95 | /play.scm | 983478d4f2dba3f6dacdd48a01b841246068fd11 | []
| no_license | xieyuheng/sequent0 | b3b61f8554ae8dbb352ad157531309a68cebbc0e | c64986ad5e6eabfbf5dd2d4a4f9aaa8978df5f48 | refs/heads/master | 2020-09-28T10:52:24.191893 | 2017-07-30T17:05:17 | 2017-07-30T17:05:17 | 67,279,174 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 211 | scm | play.scm | ;; use chez scheme
(print-graph #t)
(print-graph #f)
(load "lib/helper.scm")
(include "lib/hat.scm")
(include "sequent0.scm")
(print-define+)
(type-check+)
;; (cover-check+)
;; (recur-check+)
;; (steper+)
| false |
a40b3a51cef8c2fa1c2bfe46d08fa99f5dff1080 | 6b8bee118bda956d0e0616cff9ab99c4654f6073 | /schcuda/channel_descriptor_h.ss | 531c4f26a31ceb0785293fb6a892663a27c6ecee | []
| 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 | 5,031 | ss | channel_descriptor_h.ss | (module channel_descriptor_h scheme
(require scheme/foreign)
#|
/*******************************************************************************
* *
* *
* *
*******************************************************************************/
|#
(unsafe!)
(provide cudaCreateChannelDesc)
(define (cudaCreateChannelDesc type)
(let* ([is (* (ctype-sizeof _int) 8)]
[e (* (ctype-sizeof type) 8)]
[s (malloc _int 4)])
(when (<= e (* 4 * is))
(for ([i (in-range 4)])
(ptr-set! s i (if (> e is) is e))
(set! e (if (> e is) (- e is) 0))))
(cudaCreateChannelDesc (ptr-ref s 0)
(ptr-ref s 1)
(ptr-ref s 2)
(ptr-ref s 3)
'cudaChannelFormatKindUnsigned))) ; need a way to define cudaCreateChannelDesc with 'cudaChannelFormatKindSinged. or Float
(define __SINGED_CHARS__ #t)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<char1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uchar1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<char2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uchar2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<char3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uchar3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<char4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uchar4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<short>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<unsigned short>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<short1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ushort1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<short2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ushort2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<short3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ushort3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<short4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ushort4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<int>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<unsigned int>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<int1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uint1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<int2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uint2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<int3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uint3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<int4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<uint4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<long>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<unsigned long>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<long1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ulong1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<long2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ulong2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<long3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ulong3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<long4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<ulong4>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<float>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<float1>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<float2>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<float3>(void)
;template<> __inline__ __host__ cudaChannelFormatDesc cudaCreateChannelDesc<float4>(void)
)
| false |
98a7d1f14127e54da13ef1f252deaedc123731fe | 0f9909b1ea2b247aa9dec923d58e4d0975b618e6 | /tests/format.scm | a7a801096f5942db64497972195436e6f6a503e5 | []
| no_license | suranap/sausage | 9898ad418e2bdbb7e7a1ac798b52f17c589a4cb4 | 9a03ff3c52cd69278ea75733491e95362cc8765d | refs/heads/master | 2016-09-10T19:31:11.990203 | 2013-05-01T14:48:50 | 2013-05-01T14:48:50 | 9,792,997 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 602 | scm | format.scm |
;;; partially evaluate a format string
(define evaluate-format-string
(match-lambda
(($ App ($ Var 'format) (($ Value F) As ...))
(normalize
(parse
(cons 'string-append
(letrec next ((Fs (parse-format-string F))
(As As))
(match (car Fs)
((? string? S)
(cons S (next (cdr Fs) As)))
(('directive D)
`((format/one ,D ,(car As))
,@(next (cdr Fs) (cdr As))))))))))))
(define format/one-string
(match-scheme
(('format/one "S" A) A)))
(define format/one-number
(match-scheme
(('format/one "D" A) `(number->string ,A))))
| false |
b53e80edcfd76365ab08735326eb6d992b3cc64d | f59b3ca0463fed14792de2445de7eaaf66138946 | /section-3/3_05.scm | 5fbc3fa8c459b792563f05c39528de168875bdb2 | []
| no_license | uryu1994/sicp | f903db275f6f8c2da0a6c0d9a90c0c1cf8b1e718 | b14c728bc3351814ff99ace3b8312a651f788e6c | refs/heads/master | 2020-04-12T01:34:28.289074 | 2018-06-26T15:17:06 | 2018-06-26T15:17:06 | 58,478,460 | 0 | 1 | null | 2018-06-20T11:32:33 | 2016-05-10T16:53:00 | Scheme | UTF-8 | Scheme | false | false | 1,731 | scm | 3_05.scm | (use srfi-27)
(define random random-real)
(define (estimate-pi trials)
(sqrt (/ 6 (monte-carlo trials cesaro-test))))
(define (random-gcd-test trials initial-x)
(define (iter trials-remaining trials-passed x)
(let ((x1 (rand-update x)))
(let ((x2 (rand-update x1)))
(cond ((= trials-remaining 0)
(/ trials-passed trials))
((= (gcd x1 x2) 1)
(iter (- trials-remaining 1)
(+ trials-passed 1)
x2))
(else
(iter (- trials-remaining 1)
trials-passed
x2))))))
(iter trials 0 initial-x))
(define (cesaro-test)
(= (gcd (rand) (rand)) 1))
(define (monte-carlo trials experiment)
(define (iter trials-remaining trials-passed)
(cond ((= trials-remaining 0)
(/ trials-passed trials))
((experiment)
(iter (- trials-remaining 1) (+ trials-passed 1)))
(else
(iter (- trials-remaining 1) trials-passed))))
(iter trials 0))
(define (random-in-range low high)
(let ((range (- high low)))
(+ low (random range))))
(define (estimate-integral P x1 x2 y1 y2 trails)
(define (experiment)
(P (random-in-range x1 x2)
(random-in-range y1 y2)))
(* (monte-carlo trails experiment) (* (- x2 x1) (- y2 y1))))
(define (pi-from-monte-carlo-simulation circle-area radius)
(display circle-area)
(newline)
(/ circle-area radius))
(define (p-test x y)
(<= (+ (square (- x 5)) (square (- y 7))) (square 3)))
(pi-from-monte-carlo-simulation (estimate-integral p-test 2 8 4 10 100000) (square 3))
(pi-from-monte-carlo-simulation (estimate-integral p-test 2 8 4 10 100000) (square 3))
| false |
808d1586ca84960c4f629093f864979cbd9574c6 | 3ce85064b70d921e46ac77b621ceb72bf1d149c7 | /test/sdl-no-plugins.scm | 46152520491c1cb1d780c4420b69dea7d3bf5774 | [
"Zlib"
]
| permissive | alvatar/sphere-fusion | 674b5e22aa4e66573d819d983ccbd728bb44081a | f0bd78be9bbd42955677f3b8d73ccce167f7e486 | refs/heads/master | 2021-01-10T20:10:33.834908 | 2014-11-10T10:53:45 | 2014-11-10T10:53:45 | 4,388,080 | 1 | 0 | null | 2014-11-10T10:53:47 | 2012-05-20T22:59:54 | C | UTF-8 | Scheme | false | false | 9,268 | scm | sdl-no-plugins.scm | ;;; Copyright (c) 2013 by Álvaro Castro Castilla
;;; OpenGL 2.1 2d skeleton
(define vertex-shader #<<end-of-shader
#version 120
attribute vec2 position;
attribute vec2 texCoord;
varying vec2 colorCoord;
uniform mat4 perspectiveMatrix;
void main()
{
colorCoord = texCoord;
gl_Position = perspectiveMatrix * vec4(position, 0.0, 1.0);
}
end-of-shader
)
(define fragment-shader #<<end-of-shader
#version 120
varying vec2 colorCoord;
uniform sampler2D colorTexture;
void main()
{
gl_FragColor = texture2D(colorTexture, colorCoord);
}
end-of-shader
)
(define (main)
(let ((init-screen-width 1280)
(init-screen-height 752)
(screen-width* (alloc-int* 1))
(screen-height* (alloc-int* 1)))
(when (< (SDL_Init SDL_INIT_VIDEO) 0) report: (fusion:error "Couldn't initialize SDL!"))
;; SDL
(let ((win (SDL_CreateWindow
""
SDL_WINDOWPOS_CENTERED
SDL_WINDOWPOS_CENTERED
(cond-expand (mobile 0) (else init-screen-width))
(cond-expand (mobile 0) (else init-screen-height))
SDL_WINDOW_OPENGL)))
(unless win (fusion:error "Unable to create render window" (SDL_GetError)))
(SDL_GetWindowSize win screen-width* screen-height*)
(let ((screen-width (*->int screen-width*))
(screen-height (*->int screen-height*))
(ctx (SDL_GL_CreateContext win)))
(SDL_Log (string-append "SDL screen size: " (object->string screen-width) " x " (object->string screen-height)))
;; OpenGL
(SDL_Log (string-append "OpenGL Version: " (*->string (glGetString GL_VERSION))))
(SDL_Log "Using API OpenGL Version: 2.1 - GL Shading Language Version: 1.2")
;; Glew: initialize extensions
(glewInit)
;; OpenGL viewport
(glViewport 0 0 screen-width screen-height)
(glScissor 0 0 screen-width screen-height)
;; Generate programs, buffers, textures
(let* ((perspective-matrix (matrix:* (make-translation-matrix -1.0 1.0 0.0)
(matrix:* (make-scaling-matrix (/ 2.0 screen-width) (/ -2.0 screen-height) 1.0)
(make-identity-matrix))))
(position-buffer-object-id* (alloc-GLuint* 1))
(main-vao-id* (alloc-GLuint* 1))
(surface-id* (alloc-GLuint* 1))
(texture-id* (alloc-GLuint* 1))
(texture-unit 0)
(sampler-id* (alloc-GLuint* 1))
(vertex-data-vector '#f32(
50.0 50.0 0.0 0.0
150.0 50.0 0.0 1.0
150.0 100.0 1.0 1.0
50.0 100.0 1.0 0.0))
(vertex-data (f32vector->GLfloat* vertex-data-vector))
(shaders (list (fusion:create-shader GL_VERTEX_SHADER vertex-shader)
(fusion:create-shader GL_FRAGMENT_SHADER fragment-shader)))
(shader-program (fusion:create-program shaders))
(texture-image* (SDL_LoadBMP "assets/128x128.bmp")))
;; Clean up shaders once the program has been compiled and linked
(for-each glDeleteShader shaders)
;; Texture
(glGenTextures 1 texture-id*)
(glBindTexture GL_TEXTURE_2D (*->GLuint texture-id*))
(glTexImage2D GL_TEXTURE_2D 0 3
(SDL_Surface-w texture-image*) (SDL_Surface-h texture-image*)
0 GL_BGR GL_UNSIGNED_BYTE
(SDL_Surface-pixels texture-image*))
(glTexParameteri GL_TEXTURE_2D GL_TEXTURE_BASE_LEVEL 0)
(glTexParameteri GL_TEXTURE_2D GL_TEXTURE_MAX_LEVEL 0)
(glBindTexture GL_TEXTURE_2D 0)
(SDL_FreeSurface texture-image*)
;; Uniforms
(glUseProgram shader-program)
(glUniformMatrix4fv (glGetUniformLocation shader-program "perspectiveMatrix")
1 GL_FALSE
(matrix->GLfloat*
(matrix:map exact->inexact
perspective-matrix)))
(glUniform1i (glGetUniformLocation shader-program "colorTexture") texture-unit)
(glUseProgram 0)
;; Sampler
(glGenSamplers 1 sampler-id*)
(let ((sampler-id (*->GLuint sampler-id*)))
(glSamplerParameteri sampler-id GL_TEXTURE_WRAP_S GL_CLAMP_TO_EDGE)
(glSamplerParameteri sampler-id GL_TEXTURE_WRAP_T GL_CLAMP_TO_EDGE)
(glSamplerParameteri sampler-id GL_TEXTURE_MAG_FILTER GL_NEAREST)
(glSamplerParameteri sampler-id GL_TEXTURE_MIN_FILTER GL_NEAREST))
;; Vertex Array Object
(glGenBuffers 1 position-buffer-object-id*)
(let ((position-buffer-object-id (*->GLuint position-buffer-object-id*)))
;; Upload buffer
(glBindBuffer GL_ARRAY_BUFFER position-buffer-object-id)
(glBufferData GL_ARRAY_BUFFER
(* (f32vector-length vertex-data-vector) GLfloat-size)
vertex-data
GL_DYNAMIC_DRAW)
;; Create VAO
(glGenVertexArrays 1 main-vao-id*)
(glBindVertexArray (*->GLuint main-vao-id*))
(glBindBuffer GL_ARRAY_BUFFER position-buffer-object-id)
(let ((position-attr (glGetAttribLocation shader-program "position"))
(texture-coordinates-attr (glGetAttribLocation shader-program "texCoord")))
(glEnableVertexAttribArray position-attr)
(glVertexAttribPointer position-attr 2 GL_FLOAT GL_FALSE (* 4 GLfloat-size) #f)
(glEnableVertexAttribArray texture-coordinates-attr)
(glVertexAttribPointer texture-coordinates-attr 2
GL_FLOAT GL_FALSE
(* 4 GLfloat-size) (integer->void* (* 2 GLfloat-size))))
(glBindBuffer GL_ARRAY_BUFFER 0)
(glBindVertexArray 0)
;; Game loop
(let ((event* (alloc-SDL_Event)))
(call/cc
(lambda (quit)
(let main-loop ()
(let event-loop ()
(when (= 1 (SDL_PollEvent event*))
(let ((event-type (SDL_Event-type event*)))
(cond
((= event-type SDL_KEYDOWN)
(SDL_LogVerbose SDL_LOG_CATEGORY_APPLICATION "Key down")
(let* ((kevt* (SDL_Event-key event*))
(key (SDL_Keysym-sym
(SDL_KeyboardEvent-keysym kevt*))))
(cond ((= key SDLK_ESCAPE)
(quit))
(else
(SDL_LogVerbose SDL_LOG_CATEGORY_APPLICATION (string-append "Key: " (number->string key)))))))
(else #f)))
(event-loop)))
;; -- Game logic --
(let ((GLfloat*-increment
(lambda (n x) (GLfloat*-set! vertex-data n (+ (GLfloat*-ref vertex-data n) x)))))
(GLfloat*-increment 0 1.0)
(GLfloat*-increment 1 1.0)
(GLfloat*-increment 4 1.0)
(GLfloat*-increment 5 1.0)
(GLfloat*-increment 8 1.0)
(GLfloat*-increment 9 1.0)
(GLfloat*-increment 12 1.0)
(GLfloat*-increment 13 1.0))
;; -- Draw --
(glClearColor 1.0 0.2 0.0 0.0)
(glClear GL_COLOR_BUFFER_BIT)
(glActiveTexture (+ GL_TEXTURE0 texture-unit))
(glBindTexture GL_TEXTURE_2D (*->GLuint texture-id*))
(glBindSampler texture-unit (*->GLuint sampler-id*))
;; Begin VAO
(glBindVertexArray (*->GLuint main-vao-id*))
;; Update vertex data buffer
(glBindBuffer GL_ARRAY_BUFFER position-buffer-object-id)
(glBufferSubData GL_ARRAY_BUFFER
0
(* (f32vector-length vertex-data-vector) GLfloat-size)
vertex-data)
(glUseProgram shader-program)
(glDrawArrays GL_QUADS 0 (/ (f32vector-length vertex-data-vector) 4))
(glUseProgram 0)
(glBindVertexArray 0)
;; End VAO
(SDL_GL_SwapWindow win)
(main-loop))))
(SDL_LogInfo SDL_LOG_CATEGORY_APPLICATION "Bye.")
(SDL_GL_DeleteContext ctx)
(SDL_DestroyWindow win)
(SDL_Quit)))))))
(##gc))
(main)
| false |
c9d1eb3ea2bdd50458aa26debec8426795df4de9 | 804e0b7ef83b4fd12899ba472efc823a286ca52d | /old/FeedReader/serf/widgets/clock.scm | 6c42445c7429ea3b6642996013759d9855580380 | [
"Apache-2.0"
]
| permissive | cha63506/CRESTaceans | 6ec436d1bcb0256e17499ea9eccd5c034e9158bf | a0d24fd3e93fc39eaf25a0b5df90ce1c4a96ec9b | refs/heads/master | 2017-05-06T16:59:57.189426 | 2013-10-17T15:22:35 | 2013-10-17T15:22:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 488 | scm | clock.scm | (define (thunk/clock)
(define :tick: 3000) ; Period between ticks in milliseconds.
(let ((links '())
(n 0))
(let loop ((m (? (this-mailbox :tick: 'tick))))
(match
(message/path+body m)
(#(link/create ,mailbox)
(set! links (cons mailbox links))
(! mailbox (@ mailbox 'clock/tick) n))
(tick
(for-each
(lambda (link) (! (@ link 'clock/tick) n))
links)
(set! n (+ n 1)))
(,_ignore #f))
(loop (? (this-mailbox :tick: 'tick))))))
| false |
cbaab7c64c481ecc3dceba685c59d8b6f6b28109 | 0bd832b9b372ee7d4877e99b68536c15a7f7c9c9 | /continuations2.scm | b9d5ead46417a276dc4c2cd8651fe24d308c51e9 | []
| no_license | jwilliamson1/schemer | eff9c10bcbcdea9110a44c80769a0334119b3da4 | c2f9743392652664f1ff5687819f040e724c8436 | refs/heads/master | 2022-01-06T14:52:10.638822 | 2021-12-31T21:32:22 | 2021-12-31T21:32:22 | 75,143,723 | 0 | 0 | null | 2020-11-11T13:11:47 | 2016-11-30T02:37:55 | Racket | UTF-8 | Scheme | false | false | 1,637 | scm | continuations2.scm |
(picking)
(cherry picking daddies)
(a-friend)
(defin 1st-rec
(lambda (newlat seen)
(a-friend)(cons (cherry) newlat) seen))
(define 2nd-rec
lambda (newlat seen)
1st-rec newlat (cons picking seen))
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies newlat) seen))
(define final-rec
col() ())
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies newlat) seen)))(quote())(quote())
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies (quote()) (quote())))
2nd-rec (daddies)(quote)
define 2nd-rec
lambda (newlat seen)
1st-rec newlat (cons picking seen))(daddies)(quote)
1st-rec daddies picking
(defin 1st-rec
(lambda (newlat seen)
(cons (cherry) newlat) seen))(daddies) (picking)
cons(cherry daddies ) (picking)
#f
(picking)
(cherry derp daddies)
(a-friend)
(defin 1st-rec
(lambda (newlat seen)
(a-friend)(cons (cherry) newlat) seen))
(define 2nd-rec
lambda (newlat seen)
1st-rec (cons (derp) newlat) seen))
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies newlat) seen))
(define final-rec
col() ())
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies newlat) seen)))(quote())(quote())
(define 3rd-rec
lambda(newlat seen)
2nd-rec (cons daddies (quote()) (quote())))
;sub
2nd-rec (daddies)(quote)
define 2nd-rec
lambda (newlat seen)
1st-rec (cons derp newlat ) seen )(daddies)(quote)
1st-rec (derp picking)(quote())
(defin 1st-rec
(lambda (newlat seen)
(cons (cherry) newlat) seen))(derp picking)(quote())
(a-friend(cons(cherry derp picking ) (quote())))
#f | false |
4bc19525cd5ea9a49c12b53783817e49ad5523a3 | f59b3ca0463fed14792de2445de7eaaf66138946 | /section-2/2_32.scm | c64946ece3155500cb7dff701603583060d69d59 | []
| no_license | uryu1994/sicp | f903db275f6f8c2da0a6c0d9a90c0c1cf8b1e718 | b14c728bc3351814ff99ace3b8312a651f788e6c | refs/heads/master | 2020-04-12T01:34:28.289074 | 2018-06-26T15:17:06 | 2018-06-26T15:17:06 | 58,478,460 | 0 | 1 | null | 2018-06-20T11:32:33 | 2016-05-10T16:53:00 | Scheme | UTF-8 | Scheme | false | false | 592 | scm | 2_32.scm | (use slib)
(require 'trace)
(define (subsets s)
(if (null? s)
(list nil)
(let ((rest (subsets (cdr s))))
(append rest (map (lambda (x) (cons (car s) x)) rest)))))
(trace subsets)
(define nil '())
(define x (list 1 2 3))
(subsets x)
;;(subsets (1 2 3))
;;(append rest (map (lambda (x) (cons 1 x)) rest)) rest <= (subsets (2 3))
;;
;;(subsets (2 3))
;;(append rest (map (lambda (x) (cons 2 x)) rest)) rest <= (subsets (3))
;;
;;(subsets (3))
;;(append rest (map (lambda (x) (cons 3 x)) rest)) rest <= (subsets '())
;;=> ( '() (3))
;;
;;(subsets (2 3))
;;=> ( '() (3) )
| false |
4bffb635413c9ff0c1dcb010fc92f5c46fc3f4c6 | a5cff5beae635b13a1d67cb707856212fbbe32a5 | /chapter5.scm | b386e3cfe9319f841909c5089680357b205488d3 | []
| no_license | abelard2008/plai | f6c1b2fa17d224579e8ec6e08d74e5f6fa80d5ed | b7de61a647a555f0355fc1d9617e80d6af27907d | refs/heads/master | 2020-12-10T21:26:24.032181 | 2020-01-16T10:47:20 | 2020-01-16T10:47:20 | 233,715,673 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 2,178 | scm | chapter5.scm | #lang plai
(define-type F1WAE
[num (n number?)]
[add (lhs F1WAE?)(rhs F1WAE?)]
[with (name symbol?) (named-expr F1WAE?)(body F1WAE?)]
[id (name symbol?)]
[app (fun-name symbol?)(arg F1WAE?)])
(define-type FunDef
[fundef (fun-name symbol?)
(arg-name symbol?)
(body F1WAE?)])
(define-type DefrdSub
[mtSub]
[aSub (name symbol?)(value number?)(ds DefrdSub?)])
(define (lookup name ds)
(type-case DefrdSub ds
[mtSub () (error 'lookup "no binding for identifier")]
[aSub (bound-name bound-value rest-ds)
(if (symbol=? bound-name name)
bound-value
(lookup name rest-ds))]))
(define (lookup-fundef fun-name fundefs)
(cond
[(empty? fundefs)(error fun-name "function not found")]
[else (if (symbol=? fun-name (fundef-fun-name (first fundefs)))
(first fundefs)
(lookup-fundef fun-name (rest fundefs)))]))
(define (interp expr fun-defs ds)
(type-case F1WAE expr
[num (n) n]
[add (l r) (+ (interp l fun-defs ds)(interp r fun-defs ds))]
[with (bound-id named-expr bound-body)
(interp bound-body
fun-defs
(aSub bound-id
(interp named-expr
fun-defs
ds)
ds)
)]
[id (v) (lookup v ds)]
[app (fun-name arg-expr)
(local ([define the-fun-def (lookup-fundef fun-name fun-defs)])
(interp (fundef-body the-fun-def)
fun-defs
(aSub (fundef-arg-name the-fun-def)
(interp arg-expr fun-defs ds)
ds)))]))
(define parse
(lambda (sexp)
(cond
[(number? sexp) (num sexp)]
[(symbol? sexp) (id sexp)]
[(list? sexp)
(case (first sexp)
[(+)(add (parse (second sexp))
(parse (third sexp)))]
[(with) (with (first (second sexp))
(parse (second (second sexp)))
(parse (third sexp)))]
[else (app (first sexp)
(parse (second sexp)))]
)]))) | false |
ab90e7bae8b87eec462deac2eb473327aa0fd809 | 84c9e7520891b609bff23c6fa3267a0f7f2b6c2e | /2.69.scm | 495a1e7733017390e22cb6ad3aa96eaf97529df8 | []
| no_license | masaedw/sicp | 047a4577cd137ec973dd9a7bb0d4f58d29ef9cb0 | 11a8adf49897465c4d8bddb7e1afef04876a805d | refs/heads/master | 2020-12-24T18:04:01.909864 | 2014-01-23T11:10:11 | 2014-01-23T11:17:38 | 6,839,863 | 1 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 464 | scm | 2.69.scm | (load "./2.68.scm")
(define (generate-huffman-tree pairs)
(successive-merge (make-leaf-set pairs)))
(define (successive-merge pairs)
(if (null? (cdr pairs))
(car pairs)
(let ((pri (car pairs))
(sec (cadr pairs)))
(successive-merge (adjoin-set (make-code-tree pri sec) (cddr pairs))))))
(define sample-pairs
'((A 8) (B 3) (C 1) (D 1) (E 1) (F 1) (G 1) (H 1)))
(define (main args)
(p (generate-huffman-tree sample-pairs))) | false |
84f52f542c5e3d0380cb95feaad57e2f97a8349c | f848bf700fa92fd97e10b65159f79a7b46565824 | /hdt/hdt.scm | 5b9837c3b8cd8fb94bc651029e76a561cf3aff24 | [
"MIT"
]
| permissive | her01n/hdt | 75e1158dda6e6f846b50ac0f72f5f9dd40d0eecb | 8d65000180ddddde94485e4a50c1c2e36a539e5f | refs/heads/master | 2023-02-13T05:40:38.668744 | 2023-01-27T15:21:27 | 2023-01-27T15:21:27 | 132,890,317 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 6,640 | scm | hdt.scm | (define-module (hdt hdt)
#:export (execute-tests)
#:export-syntax (assert test hook throws-exception))
(use-modules (ice-9 ftw) (ice-9 getopt-long) (ice-9 match)
((srfi srfi-1) #:prefix srfi1-))
(define* (execute-tests thunk #:key show)
(run-tests (collect-tests thunk) #:show show))
(define (collect-tests thunk)
(set! tests (cons '() tests))
(with-fluid* test-name '() thunk)
(let ((collected (car tests)))
(set! tests (cdr tests))
(reverse collected)))
(define tests '(() ()))
(define (register-test test-name proc)
(define name-string
(if (srfi1-every not test-name)
#f
(string-join (map (lambda (name) (or name "")) (reverse test-name)) "/")))
(define (the-test arg)
(cond
((equal? arg 'name) name-string)
((equal? arg 'execute) (proc))))
(set! tests (cons (cons the-test (car tests)) (cdr tests))))
(define test-proc (make-fluid (lambda () #f)))
(define test-name (make-fluid '()))
(define-syntax test'
(syntax-rules (define test)
((test' (define (proc-name args ...) proc-expr ...) test-expr ...)
(let ((proc-name #f)
(proc-proc (lambda (args ...) proc-expr ...)))
(test' (set! proc-name proc-proc) test-expr ...)))
((test' (define var-name var-expr) expr ...)
(let ((var-name #f)
(evaluate (lambda () var-expr)))
(test' (set! var-name (evaluate)) expr ...)))
((test')
(register-test (fluid-ref test-name) (fluid-ref test-proc)))
((test' (test inner-expr ...) outer-expr ...)
(begin
(test inner-expr ...)
(test' outer-expr ...)))
((test' expr tail ...)
(let ((parent-proc (fluid-ref test-proc)))
(with-fluid* test-proc (lambda () (parent-proc) expr)
(lambda () (test' tail ...)))))))
(define (datum->name expr)
(cond
((string? expr) expr)
((symbol? expr) (symbol->string expr))
(else #f)))
(define-syntax test
(lambda (x)
(syntax-case x ()
((test expr tail ...)
(let ((name (datum->name (syntax->datum (syntax expr)))))
(if name
#`(with-fluid* test-name (cons #,name (fluid-ref test-name))
(lambda () (test' tail ...)))
#`(with-fluid* test-name (cons #f (fluid-ref test-name))
(lambda () (test' expr tail ...)))))))))
(define-syntax hook
(syntax-rules ()
((hook expr ...)
(register-hook (lambda () expr ...)))))
(define (n-tests n)
(if (equal? n 1)
"1 test"
(format #f "~a tests" n)))
(define hooks (make-fluid '()))
(define (register-hook hook)
(fluid-set! hooks (cons hook (fluid-ref hooks))))
(define (report failure)
(match failure
((backtrace 'assertion-failed (message filename line exprs))
(format #t "assertion~a failed:\n" (if message (string-append " \"" message "\"") ""))
(for-each (lambda (expr) (format #t " ~s\n" expr)) exprs)
(format #t "~a:~a\n" filename line)
(display "\n"))
((backtrace key args)
(format #t "error: ~a ~a\n" key args)
(format #t "backtrace:\n~a\n" backtrace)
(display "\n"))))
; run a single test, including hooks and return the errors
(define* (run-test test #:key show)
(define (run)
(define test-error (catch-error (lambda () (test 'execute))))
(define hook-errors (map catch-error (fluid-ref hooks)))
(define errors (filter identity (cons test-error hook-errors)))
errors)
(define (hide-output)
(define output (open-output-string))
(define errors (with-output-to-port output run))
(if (not (null? errors)) (display (get-output-string output)))
; XXX Under some conditions (multi thread),
; standard function may write to a port that is no longer the current output port.
; We rely on garbage collection to close the port.
errors)
(if show
(run)
(hide-output)))
(define* (run-tests tests #:key show)
(define failures
(map
(lambda (test)
(with-fluid* hooks '()
(lambda ()
(define errors (run-test test #:show show))
(if (null? errors) (display ".") (display "F"))
errors)))
tests))
(define hook-failures (filter identity (map catch-error (fluid-ref hooks))))
(fluid-set! hooks '())
(display "\n")
(if (and (srfi1-every null? failures) (null? hook-failures))
(begin
(format #t "~a ok\n" (n-tests (length tests)))
#t)
(begin
(for-each
(lambda (test failures)
(if (not (null? failures))
(begin
(format #t "Test ~a failed.\n" (test 'name))
(for-each report failures))))
tests failures)
(for-each
(lambda (failure)
(format #t "Error in hook.\n")
(report failure))
hook-failures)
(format #t "~a failed.\n" (n-tests (srfi1-count (compose not null?) failures)))
#f)))
(define (catch-error thunk)
(call/cc
(lambda (return-error)
(define outer (stack-length (make-stack #t)))
(with-throw-handler #t
(lambda () (thunk) #f)
(lambda (key . args)
(define stack (make-stack #t 1 (+ outer 1)))
(define backtrace
(call-with-output-string (lambda (output) (display-backtrace stack output))))
(return-error (list backtrace key args))))
#f)))
(define (execute-check message filename line thunk description)
(if (not (thunk))
(throw 'assertion-failed message filename line description)))
(define-syntax lambdas
(syntax-rules ()
((lambdas form values) form)
((lambdas (form* ...) values arg arg* ...)
(lambdas
(form* ... ((lambda () (define value arg) (list-set! values 0 value) value)))
(cdr values)
arg* ...))))
(define-syntax assert
(lambda (x)
(define source (syntax-source x))
(define filename (assoc-ref source 'filename))
(define line (+ 1 (assoc-ref source 'line)))
(syntax-case x ()
((assert (proc arg* ...) message)
#`((lambda ()
(define values (map (const '*not-evaluated) '(arg* ...)))
(execute-check
message #,filename #,line
(lambda () (lambdas (proc) values arg* ...))
(list (quote (proc arg* ...)) (cons (quote proc) values))))))
((assert check message)
#`(execute-check
message #,filename #,line
(lambda () check)
(list (quote check))))
((assert check) #`(assert check #f)))))
(define-syntax throws-exception
(syntax-rules ()
((throws-exception expr)
(catch #t
(lambda () expr #f)
(lambda (key . args) #t)))))
| true |
8ebc8e5826f7dfa753a940a087b6cf483098062c | a2d8b4843847507b02085bb8adabd818f57dd09f | /scheme/sicp/ch_3/tst-streams.scm | 97f7f5911f27673b9553256b3f69343b91100543 | []
| no_license | tcharding/self_learning | df911b018fc86bd5f918394b79d2456bf51f35a8 | f6bb5c6f74092177aa1b71da2ce87ca1bfc5ef3c | refs/heads/master | 2022-05-13T05:09:32.284093 | 2022-05-02T08:25:18 | 2022-05-02T08:25:18 | 41,029,057 | 13 | 2 | null | null | null | null | UTF-8 | Scheme | false | false | 496 | scm | tst-streams.scm | ;;;; tests for streams.scm
(load-from-path "test-framework.scm")
(load-from-path "streams.scm")
(load-from-path "lib.scm")
(use-modules (ice-9 streams))
(define odds (make-stream (lambda (state)
(cons state (+ state 2)))
1))
(define (square n) (* n n))
(define oddsquares (stream-map square odds))
;(stream-car odds)
;(stream-car (stream-cdr odds))
#!
(display-stream (stream-map (lambda (x) x) (stream-enumerate-interval 1 10)))
;
!#
| false |
588d807a98e9c9f56c084a511e190c1c814a6e4e | 9b2eb10c34176f47f7f490a4ce8412b7dd42cce7 | /lib-r6rs/r7b-util/time.sls | 80509c463f3fb6ef8cceccc54e6f23522c95eace | [
"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 | 457 | sls | time.sls | (library (r7b-util time)
(export current-jiffy current-second jiffies-per-second)
(import (rnrs)
(r7b-compat i19))
(define scale 1000000000.0)
(define (jiffies-per-second) (exact scale))
(define (current-jiffy) (exact (return-sec time-monotonic)))
(define (current-second) (return-sec time-tai))
(define (return-sec sym)
(let ((t (current-time sym)))
(+ (* scale (time-second t))
(time-nanosecond t))))
)
| false |
b7ea743ee417b4c3e3fe6c5ba437aca87be019be | 0fb87930229b3bec24d7d6ad3dae79c715fd4c58 | /src/scheme/src/coroutine.scm | f9e0239f621a61058fa8358ef325d921b0a31b35 | [
"BSD-2-Clause"
]
| permissive | klose911/klose911.github.io | 76beb22570b8e483532e8f2521b2b6334b4f856e | 7d2407ff201af38d6c6178f93793b7d6cf59fbd8 | refs/heads/main | 2023-09-01T18:04:45.858325 | 2023-08-29T09:35:25 | 2023-08-29T09:35:25 | 73,625,857 | 3 | 2 | Apache-2.0 | 2020-09-17T08:27:56 | 2016-11-13T15:52:32 | HTML | UTF-8 | Scheme | false | false | 10,709 | scm | coroutine.scm | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; tree-traverse problem ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define call/cc call-with-current-continuation)
;;; native algorithm
(define flatten
(lambda (tree)
(cond ((null? tree) '())
((pair? (car tree))
(append (flatten (car tree))
(flatten (cdr tree))))
(else
(cons (car tree)
(flatten (cdr tree)))))))
;; (flatten '(1 (2 3))) ; => (1 2 3)
;; (flatten '((1 2) 3)) ; => (1 2 3)
(define same-fringe?
(lambda (tree1 tree2)
(let loop ((ftree1 (flatten tree1))
(ftree2 (flatten tree2)))
(cond ((and (null? ftree1) (null? ftree2)) #t)
((or (null? ftree1) (null? ftree2)) #f)
((eqv? (car ftree1) (car ftree2))
(loop (cdr ftree1) (cdr ftree2)))
(else #f)))))
;; (same-fringe? '(1 (2 3)) '((1 2) 3)) ; => #t
;; (same-fringe? '(a (b c) d) '(a b (d e))) ; => #f
;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; continuation solution ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; named-let example
;; (define (fact-let n)
;; (let loop((n1 n) (p n))
;; (if (= n1 1)
;; p
;; (let ((m (- n1 1)))
;; (loop m (* p m))))))
;; (fact-let 10) ; => 3628800
(define (tree->generator tree) ; 续延 0，返回给外层的比较函数
(let ((caller '*)) ;; 初始化续延变量
(letrec
((generate-leaves ; 内部定义的函数 generate-leaves // 续延 1，返回给 续延 0
(lambda ()
(let loop ((node tree)) ; named-let: 初始化 node 为 整课树 tree, 然后做遍历
(cond ((null? node) 'skip) ; 到达底部，返回 'skip
((pair? node) ; 节点还是二叉树，顺序遍历 car, cdr
(loop (car node))
(loop (cdr node)))
(else ; 节点是叶子
(call/cc ; 返回该叶节点作为生成器的结果，但是它会记住后续的循环并保存到 generate-leaves 变量
(lambda (rest-of-tree) ; 把续延 1 作为参数 rest-of-tree 传入
(set! generate-leaves ; 重新设置 generate-leaves 过程
(lambda ()
(rest-of-tree 'resume))) ; 记住续延1, ，下次调用 generate-leaves 时候，用来返回下一个访问到的节点
(caller node)))))) ; 返回当前节点
(caller '())))) ; => 循环结束才会被调用，返回一个空列表给caller。由于空列表不是一个合法的叶节点，用它来告诉生成器没有叶节点需要生成了
(lambda ()
(call/cc
(lambda (k) ; 调用 tree->generator 的 续延0 被作为参数 k 传入
(set! caller k) ; 局部变量 caller 被初始化为 续延0
(generate-leaves))))))) ; 初次调用 generate-leaves 过程
;; (define generator (tree-generator '(a (b c) d))) ;
;; (generator) ; => a
;; (generator) ; => b
;; (generator) ; => c
;; (generator) ; => d
;; (generator) ; => ()
;; (generator) ; => ()
(define same-fringe?
(lambda (tree1 tree2)
(let ((gen1 (tree->generator tree1))
(gen2 (tree->generator tree2)))
(let loop ()
(let ((leaf1 (gen1))
(leaf2 (gen2)))
(if (eqv? leaf1 leaf2)
(if (null? leaf1) #t (loop))
#f))))))
;; (define tree1 '(((a b) (y z)) (3 4)))
;; (define tree2 '(((a b) (t z)) (3 4)))
;; (define tree3 '(((a (b y) z)) (3 4)))
;; (same-fringe? tree1 tree2) ; => #f
;; (same-fringe? tree1 tree3) ; => #t
;;;;;;;;;;;;;;;;;;;;;;
;; 用函数实现协程序 ;;
;;;;;;;;;;;;;;;;;;;;;;
;;; queue(FIFO)
(define (make-queue)
(cons '() '()))
;;; 把一个元素加入到队列最后
(define (enqueue! queue obj)
(let ((lobj (list obj)))
(if (null? (car queue))
(begin
(set-car! queue lobj)
(set-cdr! queue lobj))
(begin
(set-cdr! (cdr queue) lobj)
(set-cdr! queue lobj)))
(car queue)))
;;; 从队列最前面取出一个元素
(define (dequeue! queue)
(let ((obj (car (car queue))))
(set-car! queue (cdr (car queue)))
obj))
;; (define test-queue (make-queue))
;; test-queue ;=> (())
;; (enqueue! test-queue 'a)
;; test-queue ;=> ((a) a)
;; enqueue! test-queue 'b)
;; test-queue ;=> ((a b) b)
;; (enqueue! test-queue 'c)
;; test-queue ;=> ((a b c) c)
;; (dequeue! test-queue) ; => a
;; test-queue ; => ((b c) c)
;; (dequeue! test-queue) ; => b
;; test-queue ; => ((c) c)
;; (dequeue! test-queue) ; => a
;; test-queue ; => (() c)
;;; coroutine
(define process-queue (make-queue)) ; 协程队列
;;; 把一个协程添加到队列最后
(define (coroutine thunk)
(enqueue! process-queue thunk))
;;; 获得队列中的第一个元素，并执行它
(define (start)
((dequeue! process-queue)))
(define (pause)
(call/cc
(lambda (k) ; 当前续延作为参数 k 传入
(coroutine (lambda () (k #f))) ; 添加当前续延到最后
(start)))) ; 执行当前队列第一个元素
;;; example
;; (coroutine (lambda ()
;; (let loop ((i 0))
;; (if (< i 10)
;; (begin
;; (display (1+ i))
;; (display " ")
;; (pause)
;; (loop (1+ i)))))))
;; (coroutine (lambda ()
;; (let loop ((i 0))
;; (if (< i 10)
;; (begin
;; (display (integer->char (+ i 97)))
;; (display " ")
;; (pause)
;; (loop (1+ i)))))))
;; (newline)
;; (start)
;; 1 a 2 b 3 c 4 d 5 e 6 f 7 g 8 h 9 i 10 j
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 创建协程宏：返回一个函数，一个变量名作为协程函数的初始参数，内容作为协程函数的内容 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (require compatibility/defmacro)
;; (define-macro coroutine
;; (lambda (x . body) ; x ：协程A的初始参数，body：协程A的内容
;; `(letrec ((+local-control-state (lambda (,x) ,@body)) ; 运行协程
;; (resume ; 两个参数的函数，保存协程A的续延，转而执行协程B
;; (lambda (c v) ; c: 另外一个协程B，v：执行用的参数
;; (call/cc
;; (lambda (k) ; 当前续延作为参数传入
;; (set! +local-control-state k) ; 把当前续延保存到 +local-control-state
;; (c v)))))) ; 执行协程 B
;; (lambda (v)
;; (+local-control-state v))))) ; 协程A恢复后，会从local-control-state变量里存放的续延开始
;; ;;; tree->generator 协程: tree遍历的树，matcher-cor 比较叶子节点的协程
;; (define (make-leaf-gen-coroutine tree matcher-cor)
;; (coroutine dont-need-an-init-arg ; 任意参数
;; (let loop ((node tree))
;; (cond ((null? node) 'skip)
;; ((pair? node)
;; (loop (car node))
;; (loop (cdr node)))
;; (else
;; (resume matcher-cor node)))) ; 转而执行 matcher-cor 协程做比较，传递给 matcher-cor 的参数是当前的叶子节点 node
;; (resume matcher-cor '()))) ; 转而执行 matcher-cor 协程，传递给 matcher-cor 的参数是空列表，通知 macher-cor 协程遍历完毕
;; ;;; 比较叶子节点的协程：tree-cor-1 遍历树1的协程， tree-cor-2 遍历树2的协程
;; (define (make-matcher-coroutine tree-cor-1 tree-cor-2)
;; (coroutine dont-need-an-init-arg ; 任意参数
;; (let loop ()
;; (let ((leaf1 (resume tree-cor-1 'get-1-a-leaf)) ; 转而执行 tree-cor-1 协程， 获取第一颗树的当前叶子节点，传递的参数可以任意
;; (leaf2 (resume tree-cor-2 'get-2-a-leaf))) ; 转而执行 tree-cor-2 协程， 获取第二颗树的当前叶子节点，传递的参数可以任意
;; (if (eqv? leaf1 leaf2)
;; (if (null? leaf1) #t (loop))
;; #f)))))
;; (define (same-fringe? tree1 tree2)
;; (letrec ((tree-cor-1 ; 创建 遍历第一颗树 协程
;; (make-leaf-gen-coroutine
;; tree1
;; (lambda (v) (matcher-cor v))))
;; (tree-cor-2 ; 创建 遍历第二颗树 协程
;; (make-leaf-gen-coroutine
;; tree2
;; (lambda (v) (matcher-cor v))))
;; (matcher-cor ; 创建 比较叶子节点 协程
;; (make-matcher-coroutine
;; (lambda (v) (tree-cor-1 v))
;; (lambda (v) (tree-cor-2 v)))))
;; (matcher-cor 'start-ball-rolling)))
;; (define tree1 '(((a b) (y z)) (3 4)))
;; (define tree2 '(((a b) (t z)) (3 4)))
;; (define tree3 '(((a (b y) z)) (3 4)))
;; (same-fringe? tree1 tree2) ; => #f
;; (same-fringe? tree1 tree3) ; => #t
;;;;;;;;;;;;
;; 卫生宏 ;;
;;;;;;;;;;;;
(define-syntax coroutine
(syntax-rules ()
((coroutine arg resume body ...) ; 故意把 resume 放到了 coroutine 宏的参数列表中。创建协程时候，必须使用一个符号作为局部函数resume的名字
(letrec ((local-control-state
(lambda (arg) body ...))
(resume
(lambda (c v)
(call/cc
(lambda (k)
(set! local-control-state k)
(c v))))))
(lambda (v)
(local-control-state v))))))
(define (make-leaf-gen-coroutine tree matcher-cor)
(coroutine dont-need-an-init-arg
go-on ; 任意给定一个名字， 但下面必须使用这个名字来执行宏中resume的
(let loop ((node tree))
(cond ((null? node) 'skip)
((pair? node)
(loop (car node))
(loop (cdr node)))
(else
(go-on matcher-cor node))))
(go-on matcher-cor '())))
(define (make-matcher-coroutine tree-cor-1 tree-cor-2)
(coroutine dont-need-an-init-arg
go-on ; 任意给定一个名字, 但下面必须使用这个名字来执行宏中resume的
(let loop ()
(let ((leaf1 (go-on tree-cor-1 'get-1-a-leaf))
(leaf2 (go-on tree-cor-2 'get-2-a-leaf)))
(if (eqv? leaf1 leaf2)
(if (null? leaf1) #t (loop))
#f)))))
(define (same-fringe? tree1 tree2)
(letrec ((tree-cor-1
(make-leaf-gen-coroutine
tree1
(lambda (v) (matcher-cor v))))
(tree-cor-2
(make-leaf-gen-coroutine
tree2
(lambda (v) (matcher-cor v))))
(matcher-cor
(make-matcher-coroutine
(lambda (v) (tree-cor-1 v))
(lambda (v) (tree-cor-2 v)))))
(matcher-cor 'start-ball-rolling)))
;; (define tree1 '(((a b) (y z)) (3 4)))
;; (define tree2 '(((a b) (t z)) (3 4)))
;; (define tree3 '(((a (b y) z)) (3 4)))
;; (same-fringe? tree1 tree2) ; => #f
;; (same-fringe? tree1 tree3) ; => #t
| true |
b3638cbf4dd6a28dde355c3ca358028537892095 | 0011048749c119b688ec878ec47dad7cd8dd00ec | /src/091/solution.scm | e6364e6e8b345bd5443d27373071fd1161267140 | [
"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 | 337 | scm | solution.scm | (define (solve n)
(do ((a 1 (+ a 1))
(s 0 (do ((b 1 (+ b 1))
(s s (+ s (* 2 (min (quotient (* (- b 0) (gcd a b)) a)
(quotient (* (- n a) (gcd a b)) b))))))
((> b n) s))))
((> a n) (+ (* 3 n n) s))))
(let ((_ (solve 50)))
(print _) (assert (= _ 14234)))
| false |
7bf5540861711c5507747e0a2adc8535192467fe | d9cb7af1bdc28925fd749260d5d643925185b084 | /2e/1.37.scm | c158464d3702270ca8f0b40f1b1b6e499543f778 | []
| no_license | akerber47/sicp | 19e0629df360e40fd2ea9ba34bf7bd92be562c3e | 9e3d72b3923777e2a66091d4d3f3bfa96f1536e0 | refs/heads/master | 2021-07-16T19:36:31.635537 | 2020-07-19T21:10:54 | 2020-07-19T21:10:54 | 14,405,303 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 886 | scm | 1.37.scm | ; (a)
(define (cont-frac n d k)
(define (cont-frac-starting-at i n d k)
(if (> i k)
0
(/ (n i) (+ (d i) (cont-frac-starting-at (+ i 1) n d k)))))
(cont-frac-starting-at 1 n d k))
(define (phi-approx k)
(cont-frac (lambda (i) 1.0) (lambda (i) 1.0) k))
; (b)
(define (cont-frac-iter n d k)
(define (cont-frac-acc n d k acc)
(if (< k 1)
acc
(cont-frac-acc n d (- k 1) (/ (n k) (+ (d k) acc)))))
(cont-frac-acc n d k 0))
; > (phi-approx 2)
; 0.5
; > (phi-approx 3)
; 0.6666666666666666
; > (phi-approx 4)
; 0.6000000000000001
; > (phi-approx 5)
; 0.625
; > (phi-approx 6)
; 0.6153846153846154
; > (phi-approx 7)
; 0.6190476190476191
; > (phi-approx 8)
; 0.6176470588235294
; > (phi-approx 9)
; 0.6181818181818182
; > (phi-approx 10)
; 0.6179775280898876
; > (phi-approx 11)
; 0.6180555555555556
; > (phi-approx 12)
; 0.6180257510729613
| false |
57f43ec78c740c8a050ea08e16c89ac47486a518 | c63772c43d0cda82479d8feec60123ee673cc070 | /ch1/40.scm | 7d211bf3fae474481311dd2f610633221d21c488 | [
"Apache-2.0"
]
| permissive | liuyang1/sicp-ans | 26150c9a9a9c2aaf23be00ced91add50b84c72ba | c3072fc65baa725d252201b603259efbccce990d | refs/heads/master | 2021-01-21T05:02:54.508419 | 2017-09-04T02:48:46 | 2017-09-04T02:48:52 | 14,819,541 | 2 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 404 | scm | 40.scm | #lang racket
(require "fixed.scm")
(define (cubic a b c)
(lambda (x) (+ (* x (+ (* x (+ x a)) b)) c)))
(define (newtons func guess)
(define dx 0.0001)
(define (deriv g)
(lambda (x)
(/ (- (g (+ x dx)) (g x))
dx)))
(define (newton-trans g)
(lambda (x)
(- x (/ (g x) ((deriv g) x)))))
(fixed (newton-trans func) guess))
; should return -1
(newtons (cubic 1 1 1) 1)
| false |
5443a6cba1246217cedef340748017ce9451c241 | c74dcb1facbd920d762017345171f47f8e41d0c5 | /chapter_2/2.32.scm | 83e1e187ecd8c8b0b6138a0653289a5f4fc8eaed | []
| no_license | akash-akya/sicp-exercises | 5125c1118c7f0e4400cb823508797fb67c745592 | c28f73719740c2c495b7bc38ee8b790219482b67 | refs/heads/master | 2021-06-15T19:12:47.679967 | 2019-08-03T14:03:20 | 2019-08-03T14:03:20 | 136,158,517 | 0 | 0 | null | null | null | null | UTF-8 | Scheme | false | false | 1,171 | scm | 2.32.scm | #lang sicp
;; Exercise 2.32: We can represent a set as a list of distinct elements,
;; and we can represent the set of all subsets of the set as a list of
;; lists. For example, if the set is (1 2 3), then the set of all subsets
;; is (() (3) (2) (2 3) (1) (1 3) (1 2) (1 2 3)). Complete the following
;; definition of a procedure that generates the set of subsets of a set
;; and give a clear explanation of why it works:
;; (define (subsets s)
;; (if (null? s)
;; (list nil)
;; (let ((rest (subsets (cdr s))))
;; (append rest (map ⟨??⟩ rest)))))
(define (subsets s)
(if (null? s)
(list nil)
(let ((rest (subsets (cdr s))))
(display "rest: ")
(display rest)
(newline)
(append rest
(map (lambda (sub) (cons (car s) sub))
rest)))))
;; let A: (list of subsets for (cdr s))
;; list of subsets = A + (new subsets created by prepending (car s) to A)
;; test
(define (test)
(cond ((equal? (subsets (list 1 2 3))
'(() (3) (2) (2 3) (1) (1 3) (1 2) (1 2 3)))
(display "Test passed"))
(else (display "Test failed")))
(newline))
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.