mirror of
https://github.com/justinethier/cyclone.git
synced 2025-05-24 04:25:06 +02:00
3274 lines
84 KiB
C
3274 lines
84 KiB
C
/**
|
|
** This file was automatically generated by the Cyclone scheme compiler
|
|
** http://justinethier.github.io/cyclone/
|
|
**
|
|
** (c) 2014-2018 Justin Ethier
|
|
** Version 0.9.4
|
|
**
|
|
**/
|
|
|
|
/*
|
|
"---------------- input program:"
|
|
*/
|
|
/*
|
|
((import (scheme base) (scheme write))
|
|
(define (fac n)
|
|
(if (= n 0) 1 (* n (fac (- n 1)))))
|
|
(write (fac 10)))
|
|
*/
|
|
/*
|
|
"inline candidates:"
|
|
*/
|
|
/*
|
|
()
|
|
*/
|
|
/*
|
|
"imports:"
|
|
*/
|
|
/*
|
|
((scheme base) (scheme write))
|
|
*/
|
|
/*
|
|
"resolved imports:"
|
|
*/
|
|
/*
|
|
((member scheme base)
|
|
(assoc scheme base)
|
|
(cons-source scheme base)
|
|
(syntax-rules scheme base)
|
|
(letrec* scheme base)
|
|
(guard scheme base)
|
|
(guard-aux scheme base)
|
|
(define-record-type scheme base)
|
|
(record? scheme base)
|
|
(is-a? scheme base)
|
|
(register-simple-type scheme base)
|
|
(make-type-predicate scheme base)
|
|
(make-constructor scheme base)
|
|
(make-getter scheme base)
|
|
(make-setter scheme base)
|
|
(slot-ref scheme base)
|
|
(slot-set! scheme base)
|
|
(type-slot-offset scheme base)
|
|
(receive scheme base)
|
|
(abs scheme base)
|
|
(max scheme base)
|
|
(min scheme base)
|
|
(modulo scheme base)
|
|
(floor-remainder scheme base)
|
|
(even? scheme base)
|
|
(exact-integer? scheme base)
|
|
(exact-integer-sqrt scheme base)
|
|
(exact? scheme base)
|
|
(inexact? scheme base)
|
|
(odd? scheme base)
|
|
(complex? scheme base)
|
|
(rational? scheme base)
|
|
(bignum? scheme base)
|
|
(gcd scheme base)
|
|
(lcm scheme base)
|
|
(quotient scheme base)
|
|
(remainder scheme base)
|
|
(truncate-quotient scheme base)
|
|
(truncate-remainder scheme base)
|
|
(truncate/ scheme base)
|
|
(floor-quotient scheme base)
|
|
(floor-remainder scheme base)
|
|
(floor/ scheme base)
|
|
(square scheme base)
|
|
(expt scheme base)
|
|
(call-with-current-continuation scheme base)
|
|
(call/cc scheme base)
|
|
(call-with-values scheme base)
|
|
(dynamic-wind scheme base)
|
|
(values scheme base)
|
|
(char=? scheme base)
|
|
(char<? scheme base)
|
|
(char>? scheme base)
|
|
(char<=? scheme base)
|
|
(char>=? scheme base)
|
|
(string=? scheme base)
|
|
(string<? scheme base)
|
|
(string<=? scheme base)
|
|
(string>? scheme base)
|
|
(string>=? scheme base)
|
|
(foldl scheme base)
|
|
(foldr scheme base)
|
|
(not scheme base)
|
|
(list? scheme base)
|
|
(zero? scheme base)
|
|
(positive? scheme base)
|
|
(negative? scheme base)
|
|
(append scheme base)
|
|
(list scheme base)
|
|
(make-list scheme base)
|
|
(list-copy scheme base)
|
|
(map scheme base)
|
|
(Cyc-map-loop-1 scheme base)
|
|
(Cyc-for-each-loop-1 scheme base)
|
|
(for-each scheme base)
|
|
(list-tail scheme base)
|
|
(list-ref scheme base)
|
|
(list-set! scheme base)
|
|
(reverse scheme base)
|
|
(boolean=? scheme base)
|
|
(symbol=? scheme base)
|
|
(Cyc-obj=? scheme base)
|
|
(vector scheme base)
|
|
(vector-append scheme base)
|
|
(vector-copy scheme base)
|
|
(vector-copy! scheme base)
|
|
(vector-fill! scheme base)
|
|
(vector->list scheme base)
|
|
(vector->string scheme base)
|
|
(vector-map scheme base)
|
|
(vector-for-each scheme base)
|
|
(make-string scheme base)
|
|
(string scheme base)
|
|
(string-copy scheme base)
|
|
(string-copy! scheme base)
|
|
(string-fill! scheme base)
|
|
(string->list scheme base)
|
|
(string->vector scheme base)
|
|
(string-map scheme base)
|
|
(string-for-each scheme base)
|
|
(make-parameter scheme base)
|
|
(current-output-port scheme base)
|
|
(current-input-port scheme base)
|
|
(current-error-port scheme base)
|
|
(call-with-port scheme base)
|
|
(error-object? scheme base)
|
|
(error-object-message scheme base)
|
|
(error-object-irritants scheme base)
|
|
(error scheme base)
|
|
(raise scheme base)
|
|
(raise-continuable scheme base)
|
|
(with-handler scheme base)
|
|
(with-exception-handler scheme base)
|
|
(Cyc-add-exception-handler scheme base)
|
|
(Cyc-remove-exception-handler scheme base)
|
|
(newline scheme base)
|
|
(write-char scheme base)
|
|
(write-string scheme base)
|
|
(flush-output-port scheme base)
|
|
(peek-char scheme base)
|
|
(read-char scheme base)
|
|
(read-line scheme base)
|
|
(read-string scheme base)
|
|
(input-port? scheme base)
|
|
(output-port? scheme base)
|
|
(input-port-open? scheme base)
|
|
(output-port-open? scheme base)
|
|
(get-output-string scheme base)
|
|
(open-output-string scheme base)
|
|
(open-input-string scheme base)
|
|
(get-output-bytevector scheme base)
|
|
(open-input-bytevector scheme base)
|
|
(open-output-bytevector scheme base)
|
|
(features scheme base)
|
|
(Cyc-version scheme base)
|
|
(any scheme base)
|
|
(every scheme base)
|
|
(and scheme base)
|
|
(or scheme base)
|
|
(let scheme base)
|
|
(let* scheme base)
|
|
(letrec scheme base)
|
|
(let*-values scheme base)
|
|
(let-values scheme base)
|
|
(begin scheme base)
|
|
(case scheme base)
|
|
(cond scheme base)
|
|
(cond-expand scheme base)
|
|
(do scheme base)
|
|
(when scheme base)
|
|
(unless scheme base)
|
|
(quasiquote scheme base)
|
|
(floor scheme base)
|
|
(ceiling scheme base)
|
|
(truncate scheme base)
|
|
(round scheme base)
|
|
(exact scheme base)
|
|
(inexact scheme base)
|
|
(eof-object scheme base)
|
|
(syntax-error scheme base)
|
|
(bytevector-copy scheme base)
|
|
(bytevector-copy! scheme base)
|
|
(utf8->string scheme base)
|
|
(string->utf8 scheme base)
|
|
(denominator scheme base)
|
|
(numerator scheme base)
|
|
(parameterize scheme base)
|
|
(peek-u8 scheme base)
|
|
(read-u8 scheme base)
|
|
(write-u8 scheme base)
|
|
(display scheme write)
|
|
(write scheme write)
|
|
(write-shared scheme write)
|
|
(write-simple scheme write))
|
|
*/
|
|
/*
|
|
"resolved macros:"
|
|
*/
|
|
/*
|
|
()
|
|
*/
|
|
/*
|
|
"---------------- after macro expansion:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda (n$1)
|
|
(if (= n$1 0) 1 (* n$1 (fac (- n$1 1))))))
|
|
(write (fac 10)))
|
|
*/
|
|
/*
|
|
"---------------- after macro expansion cleanup:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda (n$1)
|
|
(if (= n$1 0) 1 (* n$1 (fac (- n$1 1))))))
|
|
(write (fac 10)))
|
|
*/
|
|
/*
|
|
"---------------- after processing globals"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda (n$1)
|
|
(if (= n$1 0) 1 (* n$1 (fac (- n$1 1))))))
|
|
((lambda () 0 (write (fac 10)))))
|
|
*/
|
|
/*
|
|
"pass thru exports:"
|
|
*/
|
|
/*
|
|
()
|
|
*/
|
|
/*
|
|
"---------------- after alpha conversion:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda (n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
1
|
|
(Cyc-fast-mul n$1$2 (fac (Cyc-fast-sub n$1$2 1))))))
|
|
((lambda () 0 (write (fac 10)))))
|
|
*/
|
|
/*
|
|
"---------------- after func->primitive conversion:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda (n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
1
|
|
(Cyc-fast-mul n$1$2 (fac (Cyc-fast-sub n$1$2 1))))))
|
|
((lambda () 0 (write (fac 10)))))
|
|
*/
|
|
/*
|
|
"---------------- results of inlinable-top-level-lambda analysis: "
|
|
*/
|
|
/*
|
|
()
|
|
*/
|
|
/*
|
|
"---------------- after CPS:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-4-cont
|
|
(k$5 n$1$2)
|
|
((lambda-3
|
|
(r$6)
|
|
(if r$6
|
|
(k$5 1)
|
|
((lambda-2
|
|
(r$8)
|
|
(fac (lambda-1 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
r$8))
|
|
(Cyc-fast-sub n$1$2 1))))
|
|
(Cyc-fast-eq n$1$2 0))))
|
|
((lambda-7
|
|
()
|
|
((lambda-6
|
|
(r$9)
|
|
(fac (lambda-5 (r$10) (write %halt r$10)) 10))
|
|
0))))
|
|
*/
|
|
/*
|
|
"---------------- cps analysis db:"
|
|
*/
|
|
/*
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<srfi-hash-table>"
|
|
(size hash compare associate entries))
|
|
#(20
|
|
#[procedure]
|
|
#[procedure]
|
|
#[procedure]
|
|
#(((r$10 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
5
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$9 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
6
|
|
#f
|
|
#t
|
|
0
|
|
0
|
|
()
|
|
#f
|
|
0
|
|
0
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$7 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
1
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$8 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
2
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(2)
|
|
#f
|
|
(Cyc-fast-sub n$1$2 1)
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$6 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
3
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(3)
|
|
#f
|
|
(Cyc-fast-eq n$1$2 0)
|
|
0
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
((1
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((2
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((3
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((4
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((5
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((6
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((7
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((%halt .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-eq
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(4)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-sub
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(3)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-mul
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((n$1$2 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
3
|
|
(4 3 1)
|
|
#f
|
|
#f
|
|
0
|
|
3
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(k$5 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
2
|
|
(1 3)
|
|
#f
|
|
#f
|
|
2
|
|
0
|
|
#t
|
|
()
|
|
#t
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(fac .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
-1
|
|
4
|
|
#f
|
|
#f
|
|
3
|
|
(6 2 -1)
|
|
#f
|
|
(#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(4
|
|
(k$5 n$1$2)
|
|
((#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(3
|
|
(r$6)
|
|
((if r$6
|
|
(k$5 1)
|
|
(#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(2
|
|
(r$8)
|
|
((fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1
|
|
(r$7)
|
|
((k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
#f))
|
|
r$8))
|
|
#f))
|
|
(Cyc-fast-sub n$1$2 1))))
|
|
#f))
|
|
(Cyc-fast-eq n$1$2 0)))
|
|
#t)))
|
|
2
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((write .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
())))
|
|
*/
|
|
/*
|
|
"---------------- after cps optimizations (1):"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-4-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac (lambda-1 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
(fac (lambda-5 (r$10) (write %halt r$10)) 10))
|
|
*/
|
|
/*
|
|
("not a direct recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
("recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
"---------------- cps analysis db:"
|
|
*/
|
|
/*
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<srfi-hash-table>"
|
|
(size hash compare associate entries))
|
|
#(13
|
|
#[procedure]
|
|
#[procedure]
|
|
#[procedure]
|
|
#(((r$10 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
5
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$7 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
1
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
((1
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
()
|
|
()
|
|
((4
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((5
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((%halt .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-sub
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(4)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-mul
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-eq
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(4)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((n$1$2 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
3
|
|
(4 1 4)
|
|
#f
|
|
#f
|
|
0
|
|
3
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(k$5 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
2
|
|
(1 4)
|
|
#f
|
|
#f
|
|
2
|
|
0
|
|
#t
|
|
()
|
|
#t
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(fac .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
-1
|
|
4
|
|
#f
|
|
#f
|
|
3
|
|
(-1 4 -1)
|
|
#f
|
|
(#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(4
|
|
(k$5 n$1$2)
|
|
((if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1))))
|
|
#t)))
|
|
2
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#t))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((write .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
())))
|
|
*/
|
|
/*
|
|
"---------------- after cps optimizations (2):"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-4-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac (lambda-1 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
(fac (lambda-5 (r$10) (write %halt r$10)) 10))
|
|
*/
|
|
/*
|
|
("not a direct recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
("recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
"---------------- cps analysis db:"
|
|
*/
|
|
/*
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<srfi-hash-table>"
|
|
(size hash compare associate entries))
|
|
#(13
|
|
#[procedure]
|
|
#[procedure]
|
|
#[procedure]
|
|
#(((r$10 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
5
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$7 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
1
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
((1
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
()
|
|
()
|
|
((4
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((5
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((%halt .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-sub
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(4)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-mul
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-eq
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(4)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((n$1$2 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
3
|
|
(4 1 4)
|
|
#f
|
|
#f
|
|
0
|
|
3
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(k$5 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
4
|
|
#f
|
|
#f
|
|
#f
|
|
2
|
|
(1 4)
|
|
#f
|
|
#f
|
|
2
|
|
0
|
|
#t
|
|
()
|
|
#t
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(fac .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
-1
|
|
4
|
|
#f
|
|
#f
|
|
3
|
|
(-1 4 -1)
|
|
#f
|
|
(#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(4
|
|
(k$5 n$1$2)
|
|
((if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1))))
|
|
#t)))
|
|
2
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#t))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((write .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(5)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
())))
|
|
*/
|
|
/*
|
|
"---------------- after cps optimizations (3):"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-4-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac (lambda-1 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
(fac (lambda-5 (r$10) (write %halt r$10)) 10))
|
|
*/
|
|
/*
|
|
("not a direct recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(2 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
("recursive call"
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(2 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1)))
|
|
*/
|
|
/*
|
|
"---------------- after renumber lambdas"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-1-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac (lambda-2 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
(fac (lambda-3 (r$10) (write %halt r$10)) 10))
|
|
*/
|
|
/*
|
|
"---------------- after wrap-mutables:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-1-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac (lambda-2 (r$7) (k$5 (Cyc-fast-mul n$1$2 r$7)))
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
(fac (lambda-3 (r$10) (write %halt r$10)) 10))
|
|
*/
|
|
/*
|
|
"---------------- after closure-convert:"
|
|
*/
|
|
/*
|
|
((define fac
|
|
(lambda-1-cont
|
|
(k$5 n$1$2)
|
|
(if (Cyc-fast-eq n$1$2 0)
|
|
((%closure-ref k$5 0) k$5 1)
|
|
((%closure-ref fac 0)
|
|
fac
|
|
(%closure
|
|
(lambda-2
|
|
(self$11 r$7)
|
|
((%closure-ref (%closure-ref self$11 1) 0)
|
|
(%closure-ref self$11 1)
|
|
(Cyc-fast-mul (%closure-ref self$11 2) r$7)))
|
|
k$5
|
|
n$1$2)
|
|
(Cyc-fast-sub n$1$2 1)))))
|
|
((%closure-ref fac 0)
|
|
fac
|
|
(%closure
|
|
(lambda-3
|
|
(self$12 r$10)
|
|
((%closure-ref write 0) write %halt r$10)))
|
|
10))
|
|
*/
|
|
/*
|
|
"---------------- analysis db: "
|
|
*/
|
|
/*
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<srfi-hash-table>"
|
|
(size hash compare associate entries))
|
|
#(13
|
|
#[procedure]
|
|
#[procedure]
|
|
#[procedure]
|
|
#(((r$10 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
3
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(3)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(r$7 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
2
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(2)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
((1
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f #f ? () #f #f #f #f))))
|
|
((2
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f (self$11 r$7) ? () #f #f #f 2))))
|
|
((3
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f (self$12 r$10) ? () #f #f #f 0))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((%halt .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(3)
|
|
#f
|
|
#f
|
|
0
|
|
1
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-sub
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-mul
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(2)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(Cyc-fast-eq
|
|
.
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(1)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((n$1$2 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
1
|
|
#f
|
|
#f
|
|
#f
|
|
3
|
|
(1 2 1)
|
|
#f
|
|
#f
|
|
0
|
|
3
|
|
#t
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(k$5 .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(#f
|
|
1
|
|
#f
|
|
#f
|
|
#f
|
|
2
|
|
(2 1)
|
|
#f
|
|
#f
|
|
2
|
|
0
|
|
#t
|
|
()
|
|
#t
|
|
#f
|
|
#f
|
|
#f
|
|
#f)))
|
|
(fac .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
-1
|
|
1
|
|
#f
|
|
#f
|
|
3
|
|
(-1 1 -1)
|
|
#f
|
|
(#((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(1
|
|
(k$5 n$1$2)
|
|
((if (Cyc-fast-eq n$1$2 0)
|
|
(k$5 1)
|
|
(fac #((record-marker)
|
|
#((record-marker)
|
|
"<lambda-ast>"
|
|
(id args body has-cont))
|
|
#(2 (r$7) ((k$5 (Cyc-fast-mul n$1$2 r$7))) #f))
|
|
(Cyc-fast-sub n$1$2 1))))
|
|
#t)))
|
|
2
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#t))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
((write .
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-variable>"
|
|
(global
|
|
defined-by
|
|
defines-lambda-id
|
|
const
|
|
const-value
|
|
ref-count
|
|
ref-by
|
|
reassigned
|
|
assigned-value
|
|
app-fnc-count
|
|
app-arg-count
|
|
inlinable
|
|
mutated-indirectly
|
|
cont
|
|
def-in-loop
|
|
ref-in-loop
|
|
direct-rec-call
|
|
self-rec-call))
|
|
#(?
|
|
?
|
|
#f
|
|
#f
|
|
#f
|
|
1
|
|
(3)
|
|
#f
|
|
#f
|
|
1
|
|
0
|
|
#f
|
|
()
|
|
#f
|
|
#f
|
|
#f
|
|
#f
|
|
#f))))
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
()
|
|
())))
|
|
*/
|
|
/*
|
|
"---------------- C headers: "
|
|
*/
|
|
/*
|
|
()
|
|
*/
|
|
/*
|
|
"---------------- module globals: "
|
|
*/
|
|
/*
|
|
(fac)
|
|
*/
|
|
/*
|
|
"---------------- C code:"
|
|
*/
|
|
/*
|
|
(c-compile-closure-element-ref
|
|
2
|
|
self$11
|
|
"0"
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f (self$11 r$7) ? () #f #f #f 2)))
|
|
*/
|
|
/*
|
|
(c-compile-closure-element-ref
|
|
2
|
|
self$11
|
|
"1"
|
|
#((record-marker)
|
|
#((record-marker)
|
|
"<analysis-db-function>"
|
|
(simple
|
|
all-params
|
|
unused-params
|
|
assigned-to-var
|
|
side-effects
|
|
well-known
|
|
cgen-id
|
|
closure-size))
|
|
#(#f (self$11 r$7) ? () #f #f #f 2)))
|
|
*/
|
|
#define closcall1(td, clo,a1) \
|
|
if (type_is_pair_prim(clo)) { \
|
|
Cyc_apply(td, 0, (closure)(a1), clo); \
|
|
} else if((clo)->pc) { \
|
|
object buf[1]; buf[0] = a1;\
|
|
((gc_thread_data *)td)->args = &buf; \
|
|
((gc_thread_data *)td)->pc = (clo)->pc; \
|
|
((clo)->fn)(td, 1);\
|
|
} else { \
|
|
((clo)->fn)(td, 1, clo,a1);\
|
|
}
|
|
#define return_closcall1(td, clo,a1) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[1]; buf[0] = a1;\
|
|
GC(td, clo, buf, 1); \
|
|
return; \
|
|
} else {\
|
|
closcall1(td, (closure) (clo),a1); \
|
|
return;\
|
|
} \
|
|
}
|
|
|
|
#define return_direct1(td, _fn,a1) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[1]; buf[0] = a1; \
|
|
mclosure0(c1, (function_type) _fn); \
|
|
GC(td, &c1, buf, 1); \
|
|
return; \
|
|
} else { \
|
|
(_fn)(td, 1, (closure)_fn,a1); \
|
|
}}
|
|
|
|
#define return_direct_with_clo1(td, clo, _fn,a1) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[1]; buf[0] = a1;\
|
|
GC(td, clo, buf, 1); \
|
|
return; \
|
|
} else { \
|
|
(_fn)(td, 1, (closure)(clo),a1); \
|
|
}}
|
|
|
|
#define closcall2(td, clo,a1,a2) \
|
|
if (type_is_pair_prim(clo)) { \
|
|
Cyc_apply(td, 1, (closure)(a1), clo,a2); \
|
|
} else if((clo)->pc) { \
|
|
object buf[2]; buf[0] = a1;buf[1] = a2; \
|
|
((gc_thread_data *)td)->args = &buf; \
|
|
((gc_thread_data *)td)->pc = (clo)->pc; \
|
|
((clo)->fn)(td, 2);\
|
|
} else { \
|
|
((clo)->fn)(td, 2, clo,a1,a2);\
|
|
}
|
|
#define return_closcall2(td, clo,a1,a2) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[2]; buf[0] = a1;buf[1] = a2;\
|
|
GC(td, clo, buf, 2); \
|
|
return; \
|
|
} else {\
|
|
closcall2(td, (closure) (clo),a1,a2); \
|
|
return;\
|
|
} \
|
|
}
|
|
|
|
#define return_direct2(td, _fn,a1,a2) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[2]; buf[0] = a1;buf[1] = a2; \
|
|
mclosure0(c1, (function_type) _fn); \
|
|
GC(td, &c1, buf, 2); \
|
|
return; \
|
|
} else { \
|
|
(_fn)(td, 2, (closure)_fn,a1,a2); \
|
|
}}
|
|
|
|
#define return_direct_with_clo2(td, clo, _fn,a1,a2) { \
|
|
char top; \
|
|
if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
|
|
object buf[2]; buf[0] = a1;buf[1] = a2;\
|
|
GC(td, clo, buf, 2); \
|
|
return; \
|
|
} else { \
|
|
(_fn)(td, 2, (closure)(clo),a1,a2); \
|
|
}}
|
|
|
|
#include "cyclone/types.h"
|
|
object __glo_fac = NULL;
|
|
extern object __glo_member_scheme_base;
|
|
extern object __glo_assoc_scheme_base;
|
|
extern object __glo_cons_91source_scheme_base;
|
|
extern object __glo_syntax_91rules_scheme_base;
|
|
extern object __glo_letrec_85_scheme_base;
|
|
extern object __glo_guard_scheme_base;
|
|
extern object __glo_guard_91aux_scheme_base;
|
|
extern object __glo_define_91record_91type_scheme_base;
|
|
extern object __glo_record_127_scheme_base;
|
|
extern object __glo_is_91a_127_scheme_base;
|
|
extern object __glo_register_91simple_91type_scheme_base;
|
|
extern object __glo_make_91type_91predicate_scheme_base;
|
|
extern object __glo_make_91constructor_scheme_base;
|
|
extern object __glo_make_91getter_scheme_base;
|
|
extern object __glo_make_91setter_scheme_base;
|
|
extern object __glo_slot_91ref_scheme_base;
|
|
extern object __glo_slot_91set_67_scheme_base;
|
|
extern object __glo_type_91slot_91offset_scheme_base;
|
|
extern object __glo_receive_scheme_base;
|
|
extern object __glo_abs_scheme_base;
|
|
extern object __glo_max_scheme_base;
|
|
extern object __glo_min_scheme_base;
|
|
extern object __glo_modulo_scheme_base;
|
|
extern object __glo_floor_91remainder_scheme_base;
|
|
extern object __glo_even_127_scheme_base;
|
|
extern object __glo_exact_91integer_127_scheme_base;
|
|
extern object __glo_exact_91integer_91sqrt_scheme_base;
|
|
extern object __glo_exact_127_scheme_base;
|
|
extern object __glo_inexact_127_scheme_base;
|
|
extern object __glo_odd_127_scheme_base;
|
|
extern object __glo_complex_127_scheme_base;
|
|
extern object __glo_rational_127_scheme_base;
|
|
extern object __glo_bignum_127_scheme_base;
|
|
extern object __glo_gcd_scheme_base;
|
|
extern object __glo_lcm_scheme_base;
|
|
extern object __glo_quotient_scheme_base;
|
|
extern object __glo_remainder_scheme_base;
|
|
extern object __glo_truncate_91quotient_scheme_base;
|
|
extern object __glo_truncate_91remainder_scheme_base;
|
|
extern object __glo_truncate_95_scheme_base;
|
|
extern object __glo_floor_91quotient_scheme_base;
|
|
extern object __glo_floor_91remainder_scheme_base;
|
|
extern object __glo_floor_95_scheme_base;
|
|
extern object __glo_square_scheme_base;
|
|
extern object __glo_expt_scheme_base;
|
|
extern object __glo_call_91with_91current_91continuation_scheme_base;
|
|
extern object __glo_call_95cc_scheme_base;
|
|
extern object __glo_call_91with_91values_scheme_base;
|
|
extern object __glo_dynamic_91wind_scheme_base;
|
|
extern object __glo_values_scheme_base;
|
|
extern object __glo_char_123_127_scheme_base;
|
|
extern object __glo_char_121_127_scheme_base;
|
|
extern object __glo_char_125_127_scheme_base;
|
|
extern object __glo_char_121_123_127_scheme_base;
|
|
extern object __glo_char_125_123_127_scheme_base;
|
|
extern object __glo_string_123_127_scheme_base;
|
|
extern object __glo_string_121_127_scheme_base;
|
|
extern object __glo_string_121_123_127_scheme_base;
|
|
extern object __glo_string_125_127_scheme_base;
|
|
extern object __glo_string_125_123_127_scheme_base;
|
|
extern object __glo_foldl_scheme_base;
|
|
extern object __glo_foldr_scheme_base;
|
|
extern object __glo_not_scheme_base;
|
|
extern object __glo_list_127_scheme_base;
|
|
extern object __glo_zero_127_scheme_base;
|
|
extern object __glo_positive_127_scheme_base;
|
|
extern object __glo_negative_127_scheme_base;
|
|
extern object __glo_append_scheme_base;
|
|
extern object __glo__list_scheme_base;
|
|
extern object __glo_make_91list_scheme_base;
|
|
extern object __glo_list_91copy_scheme_base;
|
|
extern object __glo_map_scheme_base;
|
|
extern object __glo_Cyc_91map_91loop_911_scheme_base;
|
|
extern object __glo_Cyc_91for_91each_91loop_911_scheme_base;
|
|
extern object __glo_for_91each_scheme_base;
|
|
extern object __glo_list_91tail_scheme_base;
|
|
extern object __glo_list_91ref_scheme_base;
|
|
extern object __glo_list_91set_67_scheme_base;
|
|
extern object __glo_reverse_scheme_base;
|
|
extern object __glo_boolean_123_127_scheme_base;
|
|
extern object __glo_symbol_123_127_scheme_base;
|
|
extern object __glo_Cyc_91obj_123_127_scheme_base;
|
|
extern object __glo_vector_scheme_base;
|
|
extern object __glo_vector_91append_scheme_base;
|
|
extern object __glo_vector_91copy_scheme_base;
|
|
extern object __glo_vector_91copy_67_scheme_base;
|
|
extern object __glo_vector_91fill_67_scheme_base;
|
|
extern object __glo_vector_91_125list_scheme_base;
|
|
extern object __glo_vector_91_125string_scheme_base;
|
|
extern object __glo_vector_91map_scheme_base;
|
|
extern object __glo_vector_91for_91each_scheme_base;
|
|
extern object __glo_make_91string_scheme_base;
|
|
extern object __glo_string_scheme_base;
|
|
extern object __glo_string_91copy_scheme_base;
|
|
extern object __glo_string_91copy_67_scheme_base;
|
|
extern object __glo_string_91fill_67_scheme_base;
|
|
extern object __glo_string_91_125list_scheme_base;
|
|
extern object __glo_string_91_125vector_scheme_base;
|
|
extern object __glo_string_91map_scheme_base;
|
|
extern object __glo_string_91for_91each_scheme_base;
|
|
extern object __glo_make_91parameter_scheme_base;
|
|
extern object __glo_current_91output_91port_scheme_base;
|
|
extern object __glo_current_91input_91port_scheme_base;
|
|
extern object __glo_current_91error_91port_scheme_base;
|
|
extern object __glo_call_91with_91port_scheme_base;
|
|
extern object __glo_error_91object_127_scheme_base;
|
|
extern object __glo_error_91object_91message_scheme_base;
|
|
extern object __glo_error_91object_91irritants_scheme_base;
|
|
extern object __glo_error_scheme_base;
|
|
extern object __glo_raise_scheme_base;
|
|
extern object __glo_raise_91continuable_scheme_base;
|
|
extern object __glo_with_91handler_scheme_base;
|
|
extern object __glo_with_91exception_91handler_scheme_base;
|
|
extern object __glo_Cyc_91add_91exception_91handler_scheme_base;
|
|
extern object __glo_Cyc_91remove_91exception_91handler_scheme_base;
|
|
extern object __glo_newline_scheme_base;
|
|
extern object __glo_write_91char_scheme_base;
|
|
extern object __glo_write_91string_scheme_base;
|
|
extern object __glo_flush_91output_91port_scheme_base;
|
|
extern object __glo_peek_91char_scheme_base;
|
|
extern object __glo_read_91char_scheme_base;
|
|
extern object __glo_read_91line_scheme_base;
|
|
extern object __glo_read_91string_scheme_base;
|
|
extern object __glo_input_91port_127_scheme_base;
|
|
extern object __glo_output_91port_127_scheme_base;
|
|
extern object __glo_input_91port_91open_127_scheme_base;
|
|
extern object __glo_output_91port_91open_127_scheme_base;
|
|
extern object __glo_get_91output_91string_scheme_base;
|
|
extern object __glo_open_91output_91string_scheme_base;
|
|
extern object __glo_open_91input_91string_scheme_base;
|
|
extern object __glo_get_91output_91bytevector_scheme_base;
|
|
extern object __glo_open_91input_91bytevector_scheme_base;
|
|
extern object __glo_open_91output_91bytevector_scheme_base;
|
|
extern object __glo_features_scheme_base;
|
|
extern object __glo_Cyc_91version_scheme_base;
|
|
extern object __glo_any_scheme_base;
|
|
extern object __glo_every_scheme_base;
|
|
extern object __glo_and_scheme_base;
|
|
extern object __glo_or_scheme_base;
|
|
extern object __glo_let_scheme_base;
|
|
extern object __glo_let_85_scheme_base;
|
|
extern object __glo_letrec_scheme_base;
|
|
extern object __glo_let_85_91values_scheme_base;
|
|
extern object __glo_let_91values_scheme_base;
|
|
extern object __glo_begin_scheme_base;
|
|
extern object __glo__case_scheme_base;
|
|
extern object __glo_cond_scheme_base;
|
|
extern object __glo_cond_91expand_scheme_base;
|
|
extern object __glo__do_scheme_base;
|
|
extern object __glo_when_scheme_base;
|
|
extern object __glo_unless_scheme_base;
|
|
extern object __glo_quasiquote_scheme_base;
|
|
extern object __glo_floor_scheme_base;
|
|
extern object __glo_ceiling_scheme_base;
|
|
extern object __glo_truncate_scheme_base;
|
|
extern object __glo_round_scheme_base;
|
|
extern object __glo_exact_scheme_base;
|
|
extern object __glo_inexact_scheme_base;
|
|
extern object __glo_eof_91object_scheme_base;
|
|
extern object __glo_syntax_91error_scheme_base;
|
|
extern object __glo_bytevector_91copy_scheme_base;
|
|
extern object __glo_bytevector_91copy_67_scheme_base;
|
|
extern object __glo_utf8_91_125string_scheme_base;
|
|
extern object __glo_string_91_125utf8_scheme_base;
|
|
extern object __glo_denominator_scheme_base;
|
|
extern object __glo_numerator_scheme_base;
|
|
extern object __glo_parameterize_scheme_base;
|
|
extern object __glo_peek_91u8_scheme_base;
|
|
extern object __glo_read_91u8_scheme_base;
|
|
extern object __glo_write_91u8_scheme_base;
|
|
extern object __glo_display_scheme_write;
|
|
extern object __glo_write_scheme_write;
|
|
extern object __glo_write_91shared_scheme_write;
|
|
extern object __glo_write_91simple_scheme_write;
|
|
extern object __glo_string_123_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_string_121_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_string_121_123_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_string_125_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_string_125_123_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_not_191_191inline_191_191_scheme_base;
|
|
extern object __glo_zero_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_positive_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_negative_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_floor_191_191inline_191_191_scheme_base;
|
|
extern object __glo_ceiling_191_191inline_191_191_scheme_base;
|
|
extern object __glo_truncate_191_191inline_191_191_scheme_base;
|
|
extern object __glo_round_191_191inline_191_191_scheme_base;
|
|
extern object __glo_inexact_191_191inline_191_191_scheme_base;
|
|
extern object __glo_sqrt_191_191inline_191_191_scheme_base;
|
|
extern object __glo_exact_91integer_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_exact_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_complex_127_191_191inline_191_191_scheme_base;
|
|
extern object __glo_denominator_191_191inline_191_191_scheme_base;
|
|
extern object __glo_numerator_191_191inline_191_191_scheme_base;
|
|
extern object __glo_quotient_191_191inline_191_191_scheme_base;
|
|
extern object __glo_square_191_191inline_191_191_scheme_base;
|
|
extern object __glo_eof_91object_191_191inline_191_191_scheme_base;
|
|
#include "cyclone/runtime.h"
|
|
#include "cyclone/runtime-main.h"
|
|
static void __host_lambda_1(void *data, int argc);
|
|
//static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
|
|
// ((gc_thread_data *)data)->pc = 2;
|
|
// ((gc_thread_data *)data)->args[0] = self_7311;
|
|
// ((gc_thread_data *)data)->args[1] = r_737;
|
|
// __host_lambda_1(data, argc);
|
|
//}
|
|
//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
|
|
// ((gc_thread_data *)data)->pc = 1;
|
|
// ((gc_thread_data *)data)->args[0] = k_735;
|
|
// ((gc_thread_data *)data)->args[1] = n_731_732;
|
|
// __host_lambda_1(data, argc);
|
|
//}
|
|
//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
|
|
// ((gc_thread_data *)data)->pc = 3;
|
|
// ((gc_thread_data *)data)->args[0] = self_7312;
|
|
// ((gc_thread_data *)data)->args[1] = r_7310;
|
|
// __host_lambda_1(data, argc);
|
|
//}
|
|
static void __host_lambda_1(void *data, int argc) {
|
|
object top;
|
|
object *stack = ((gc_thread_data *)data)->args; // TODO: do it inline for benchmarks/production code
|
|
// // initialize "stack" here, and unload arguments.
|
|
// // assumes the compile can compute the stack's max size, since it knows the number of args each function has
|
|
// memcpy(stack, args, sizeof(object) * argc);
|
|
|
|
while(1) {
|
|
top = alloca(sizeof(object)); // TODO: is there a more efficient way?
|
|
// TODO: if exceeded stack limit, initiate minor GC
|
|
// bundle up args, pc, and pass them along
|
|
|
|
switch(((gc_thread_data *)data)->pc) {
|
|
case 3: { // Lambda ID 3
|
|
//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
|
|
// return_closcall2(data, __glo_write_scheme_write, primitive__75halt, r_7310);;
|
|
return_closcall2(data, __glo_write_scheme_write, primitive__75halt, stack[1]);
|
|
break;
|
|
}
|
|
case 1: { // Lambda ID 1
|
|
//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
|
|
Cyc_st_add(data, "fac-test.scm:fac");
|
|
// TODO: how much smarter does our compiler need to be to compute local jumps for the below instead of C fnc calls?
|
|
object c_7316 = Cyc_num_fast_eq_op(data, stack[1], obj_int2obj(0));
|
|
if( (boolean_f != c_7316) ){
|
|
//TODO: apply reports an invalid obj type here, WTF?
|
|
return_closcall1(data, stack[0], obj_int2obj(1));
|
|
} else {
|
|
|
|
closureN_type* c_7319 = alloca(sizeof(closureN_type));
|
|
c_7319->hdr.mark = gc_color_red;
|
|
c_7319->hdr.grayed = 0;
|
|
c_7319->tag = closureN_tag;
|
|
//c_7319->fn = (function_type)__lambda_2;
|
|
c_7319->fn = (function_type)__host_lambda_1;
|
|
c_7319->pc = 2;
|
|
c_7319->num_args = 1;
|
|
c_7319->num_elements = 2;
|
|
c_7319->elements = (object *)alloca(sizeof(object) * 2);
|
|
c_7319->elements[0] = stack[0];
|
|
c_7319->elements[1] = stack[1];
|
|
|
|
object local_7329 = alloca(sizeof(complex_num_type));
|
|
object c_7330 = Cyc_fast_sub(data,local_7329, stack[1], obj_int2obj(1));
|
|
return_closcall2(data, __glo_fac, &c_7319, c_7330);
|
|
}
|
|
// TODO
|
|
break;
|
|
}
|
|
case 2: { // Lambda ID 2
|
|
//static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
|
|
//complex_num_type local_7324; object c_7325 = Cyc_fast_mul(data,&local_7324,((closureN)self_7311)->elements[1], r_737);
|
|
//return_closcall1(data, ((closureN)self_7311)->elements[0], c_7325);;
|
|
object local_7324 = alloca(sizeof(complex_num_type));
|
|
object c_7325 = Cyc_fast_mul(data,local_7324,((closureN)stack[0])->elements[1], stack[1]);
|
|
// TODO: can we be smart enough to call lambda directly, instead of via closure?
|
|
return_closcall1(data, ((closureN)stack[0])->elements[0], c_7325);
|
|
break;
|
|
}
|
|
default: {
|
|
// raise error
|
|
fprintf(stderr, "Unknown PC value %d\n", ((gc_thread_data *)data)->pc);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) ;
|
|
//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) ;
|
|
//static void __lambda_2(void *data, int argc, object self_7311, object r_737) ;
|
|
//
|
|
//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
|
|
// return_closcall2(data, __glo_write_scheme_write, primitive__75halt, r_7310);;
|
|
//}
|
|
//
|
|
//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
|
|
// Cyc_st_add(data, "fac-test.scm:fac");
|
|
// object c_7316 = Cyc_num_fast_eq_op(data,n_731_732, obj_int2obj(0));
|
|
//if( (boolean_f != c_7316) ){
|
|
// return_closcall1(data, k_735, obj_int2obj(1));
|
|
//} else {
|
|
//
|
|
//closureN_type c_7319;
|
|
//c_7319.hdr.mark = gc_color_red;
|
|
// c_7319.hdr.grayed = 0;
|
|
//c_7319.tag = closureN_tag;
|
|
// c_7319.fn = (function_type)__lambda_2;
|
|
//c_7319.num_args = 1;
|
|
//c_7319.num_elements = 2;
|
|
//c_7319.elements = (object *)alloca(sizeof(object) * 2);
|
|
//c_7319.elements[0] = k_735;
|
|
//c_7319.elements[1] = n_731_732;
|
|
//
|
|
//
|
|
//complex_num_type local_7329; object c_7330 = Cyc_fast_sub(data,&local_7329,n_731_732, obj_int2obj(1));
|
|
//return_closcall2(data, __glo_fac, &c_7319, c_7330);}
|
|
//;
|
|
//}
|
|
//
|
|
//static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
|
|
//
|
|
//complex_num_type local_7324; object c_7325 = Cyc_fast_mul(data,&local_7324,((closureN)self_7311)->elements[1], r_737);
|
|
//return_closcall1(data, ((closureN)self_7311)->elements[0], c_7325);;
|
|
//}
|
|
|
|
static void c_entry_pt_first_lambda(void *data, int argc, closure cont, object value);
|
|
extern void c_schemecyclonecommon_entry_pt(void *data, int argc, closure cont, object value);
|
|
extern void c_schemebase_entry_pt(void *data, int argc, closure cont, object value);
|
|
extern void c_schemewrite_entry_pt(void *data, int argc, closure cont, object value);
|
|
static void c_entry_pt(data, argc, env,cont) void *data; int argc; closure env,cont; {
|
|
Cyc_set_globals_changed((gc_thread_data *)data);
|
|
|
|
add_global((object *) &__glo_fac);
|
|
mclosure0(c_7313, (function_type)__host_lambda_1);c_7313.num_args = 1;
|
|
c_7313.pc = 1;
|
|
//mclosure0(c_7313, (function_type)__lambda_1);c_7313.num_args = 1;
|
|
__glo_fac = &c_7313;
|
|
|
|
make_cvar(cvar_7334, (object *)&__glo_fac);make_pair(pair_7335, find_or_add_symbol("fac"), &cvar_7334);
|
|
make_pair(c_7336, &pair_7335,Cyc_global_variables);
|
|
Cyc_global_variables = &c_7336;
|
|
mclosure1(c_done, c_entry_pt_first_lambda, &c_done);
|
|
mclosure1(c_7337, c_schemewrite_entry_pt, &c_done);
|
|
mclosure1(c_7338, c_schemebase_entry_pt, &c_7337);
|
|
mclosure1(c_7339, c_schemecyclonecommon_entry_pt, &c_7338);
|
|
(c_7339.fn)(data, 0, &c_7339, &c_7339);
|
|
}
|
|
static void c_entry_pt_first_lambda(void *data, int argc, closure cont, object value) {
|
|
|
|
|
|
mclosure0(c_7332, (function_type)__host_lambda_1);
|
|
c_7332.num_args = 1;
|
|
c_7332.pc = 3;
|
|
//mclosure0(c_7332, (function_type)__lambda_3);c_7332.num_args = 1;
|
|
//TODO: how do we know what calling convention to use for glo_fac? we could use a wrapper that accepts
|
|
//the current calling convention and then makes a call to the real function. this sucks in terms of
|
|
//performance (unless we can make it up later via a goto loop!) but may be a reasonable starting point
|
|
return_closcall2(data, __glo_fac, &c_7332, obj_int2obj(10));
|
|
;
|
|
}
|
|
int main(int argc, char **argv, char **envp)
|
|
{gc_thread_data *thd;
|
|
long stack_size = global_stack_size = STACK_SIZE;
|
|
long heap_size = global_heap_size = HEAP_SIZE;
|
|
mclosure0(clos_halt,&Cyc_halt); // Halt if final closure is reached
|
|
mclosure0(entry_pt,&c_entry_pt); // First function to execute
|
|
_cyc_argc = argc;
|
|
_cyc_argv = argv;
|
|
set_env_variables(envp);
|
|
gc_initialize();
|
|
thd = malloc(sizeof(gc_thread_data));
|
|
gc_thread_data_init(thd, 0, (char *) &stack_size, stack_size);
|
|
thd->gc_cont = &entry_pt;
|
|
thd->gc_args[0] = &clos_halt;
|
|
thd->gc_num_args = 1;
|
|
thd->thread_id = pthread_self();
|
|
gc_add_mutator(thd);
|
|
Cyc_heap_init(heap_size);
|
|
thd->thread_state = CYC_THREAD_STATE_RUNNABLE;
|
|
Cyc_start_trampoline(thd);
|
|
return 0;}
|