diff --git a/tests/experimental/fac-test.c b/tests/experimental/fac-test.c new file mode 100644 index 00000000..a9612229 --- /dev/null +++ b/tests/experimental/fac-test.c @@ -0,0 +1,3170 @@ +/** + ** 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) + (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) + "" + (size hash compare associate entries)) + #(20 + #[procedure] + #[procedure] + #[procedure] + #(((r$10 . + #((record-marker) + #((record-marker) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (id args body has-cont)) + #(4 + (k$5 n$1$2) + ((#((record-marker) + #((record-marker) + "" + (id args body has-cont)) + #(3 + (r$6) + ((if r$6 + (k$5 1) + (#((record-marker) + #((record-marker) + "" + (id args body has-cont)) + #(2 + (r$8) + ((fac #((record-marker) + #((record-marker) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (size hash compare associate entries)) + #(13 + #[procedure] + #[procedure] + #[procedure] + #(((r$10 . + #((record-marker) + #((record-marker) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (size hash compare associate entries)) + #(13 + #[procedure] + #[procedure] + #[procedure] + #(((r$10 . + #((record-marker) + #((record-marker) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (size hash compare associate entries)) + #(13 + #[procedure] + #[procedure] + #[procedure] + #(((r$10 . + #((record-marker) + #((record-marker) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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) + "" + (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 { \ + ((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 { \ + ((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 __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)__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)__lambda_3);c_7332.num_args = 1; +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;}