upscheme/tests/torture.scm

(define ones (map (lambda (x) 1) (iota 1000000)))

(write (apply + ones))
(newline)

(define (big n)
  (if (<= n 0)
      0
      `(+ 1 1 1 1 1 1 1 1 1 1 ,(big (- n 1)))))

(define nst (big 100000))

(write (eval nst))
(newline)

(define longg (cons '+ ones))
(write (eval longg))
(newline)

(define (f x)
  (begin (write x)
	 (newline)
	 (f (+ x 1))
	 0))
optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define ones (map (lambda (x) 1) (iota 1000000)))`

adding offset and count arguments to io.write making io.write output chars as utf8; suddenly switching to UTF32 was not intuitive adding stream argument to newline (R6RS) adding several more scheme compatibility procedures 2009-08-09 00:04:31 -04:00			`(write (apply + ones))`
optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(newline)`

adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(define (big n)`
			`(if (<= n 0)`
			`0`
			`(+ 1 1 1 1 1 1 1 1 1 1 ,(big (- n 1)))))

optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define nst (big 100000))`
adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00
adding offset and count arguments to io.write making io.write output chars as utf8; suddenly switching to UTF32 was not intuitive adding stream argument to newline (R6RS) adding several more scheme compatibility procedures 2009-08-09 00:04:31 -04:00			`(write (eval nst))`
adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(newline)`

optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define longg (cons '+ ones))`
adding offset and count arguments to io.write making io.write output chars as utf8; suddenly switching to UTF32 was not intuitive adding stream argument to newline (R6RS) adding several more scheme compatibility procedures 2009-08-09 00:04:31 -04:00			`(write (eval longg))`
optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(newline)`

adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(define (f x)`
adding offset and count arguments to io.write making io.write output chars as utf8; suddenly switching to UTF32 was not intuitive adding stream argument to newline (R6RS) adding several more scheme compatibility procedures 2009-08-09 00:04:31 -04:00			`(begin (write x)`
adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(newline)`
			`(f (+ x 1))`
			`0))`