testers wanted: scheme interpreter for play/hack/test 
Author Message
 testers wanted: scheme interpreter for play/hack/test

I am looking for a few interested language hackers to play with and
comment on a scheme interpreter. I would prefer those who have been
hacking portable [non-scheme] interpreters for many years, who have
the time to look at other code, and especially interested in scheme
implementations. Those who may be interested in such a system for a
high-level academic project are also encouraged to contact.

The interpreter is PSI, a portable scheme interpreter that includes
a simple dag compiler and a virtual machine. It is R^4RS compatible
with a number of useful extensions. It can be used as an integrated
extension interpreter in other systems, allows for easy addition of
new primitives, and it embodies some other interesting ideas. There
are some unique[2] code debug/trace facilities, as well, acceptable
performance resulting from a fairly straight-forward implementation.
Continuations are fully and portably supported, and perform well.

PSI is designed and implemented by Ozan S. Yigit, David Keldsen and
Pontus Hedman.

PSI is based on the simple compilers/vm in Kent Dbyvig's thesis[1].

Those interested in looking/hacking at PSI, please note:

After this play period intended for getting some initial reactions,
PSI will be distributed as PUBLIC DOMAIN source, so that anyone can
copy it, and use it in every possible way, including for commercial
means, without requiring permissions, acknowledgements, licenses or
anything else. [discussion unnecessary, I know what I am doing. :-]

Also note that what I will send out isn't a "release" per-se. It is
not packaged beautifully. It does come with some documentation.

please send after-hours e-mail if you are really interested.


anything run slowly.       -- Tom Duff | ph: [416] 736 2100 x 33976
[1] R. Kent Dybvig.
    Three Implementation Models for Scheme.
    Department of Computer Science TR #87-011 [Ph.D. Dissertation]
    University of North Carolina at Chapel Hill,
    North Carolina, April 1987.

[2] an example using apropos, find-error, global-trace...
    [margin bars are for presentation purposes]

|   $ cat ../test/sample.scm
    (define (cor a . b)
      "this function adds its arguments together"
      (+ a b))
|   $ ./psi
|   > (include-source-code #t)
|   > (include-comment-strings #t)
|   > (load "../test/sample.scm")
|   > (apropos "c.r")
    code->car                       procedure of 1 argument
    code->cdr                       procedure of 1 argument
    car                             procedure of 1 argument
    cdr                             procedure of 1 argument
    current-error-port              procedure of 0 arguments
    cor                             (lambda (a . b) ...)
       defined in:  ../test/sample.scm
      "this function adds its arguments together"
    circular-safe-write             procedure of 2 arguments
       defined in:  /scheme/psi/scm/psidebug.scm
    call-with-current-continuation  procedure of 1 argument
    set-car!                        procedure of 2 arguments
    set-cdr!                        procedure of 2 arguments
    set-current-output-port!        procedure of 1 argument
    set-current-input-port!         procedure of 1 argument
    current-environment             procedure of N arguments
    circular-safe-display           procedure of 2 arguments
       defined in:  /scheme/psi/scm/psidebug.scm
    current-input-port              procedure of 0 arguments
    current-output-port             procedure of 0 arguments
    circular-safe                   procedure of 3 arguments
       defined in:  /scheme/psi/scm/psidebug.scm
    set-current-error-port!         procedure of 1 argument
|   > (define (foo) (cor 1 (cor 3 5)))
    #<procedure foo>
|   > (foo)
    Error  - +: invalid argument: (5)
    in expression:
    (+ a b)
|   > (find-error)
    return stack:
    top: #<procedure +>
    Error found in procedure:  cor
    on or before line 3 in file "../test/sample.scm"
    #<procedure +>
|   > (global-trace)
    usage: (global-trace type switch)
    or:    (global-trace type)
    type is all, compile, macros, opcodes, calls, source, reassign or shadow
    switch is #t or #f
    or defaults to #t if omitted
    Error  - global-trace: invalid argument: ()
|   > (global-trace 'source)
|   > (foo)
    [src: (foo)]
    [src: (lambda () (cor 1 (cor 3 5)))]
    [src: (cor 1 (cor 3 5))]
    [src: (cor 3 5)]
    [src: (lambda (a . b) "this function adds its arguments together" (+ a b))]
    [src: (+ a b)]
    Using error procedure...
    Error  - +: invalid argument: (5)
    in expression:
    (+ a b)
|   > (status)
    25753 cells in use 2919 free.
    288957 cells allocated (total)
    cell memory: 7 segments (28672 cells) 458808 bytes.
    5589 bytes string space in use
    collection invoked at 8192 bytes
    6927 bytes string space allocated (total)
    16520 bytes vector space in use
    collection invoked at 32768 bytes
    28400 bytes vector space allocated (total)
    67239 frames, 512 allocations, 99% reuse, 4231 kept.
    12 collections.
    almost worthless atoms: 321.
    compiler: 26809 code cells
    1868 reference cells, 1621 cached
    34 test 0 constant removals
    272 closure application optimizations
    1609 integrated primitive optimizations
|   > (exit)

Tue, 08 Aug 1995 13:53:07 GMT  
 testers wanted: scheme interpreter for play/hack/test

What timing!  God is a comedian.


Wed, 09 Aug 1995 05:01:56 GMT  
 [ 2 post ] 

 Relevant Pages 

1. testers wanted: scheme interpreter for play/hack/test

2. Scheme->C on Windows NT, beta testers wanted

3. BETA TESTERS WANTED to test new Java Applet

4. BETA TESTERS WANTED to test new Java Applet

5. BETA TEST version of Berkeley Logo, testers wanted.

6. small scheme interpreter pointers wanted

7. Scheme Interpreter in Scheme

8. Writing a Scheme Interpreter in Scheme

9. UMB Scheme -- Free Scheme Interpreter

10. Do you hack scheme for fun?

11. Hacking scheme-mode in emacs?

12. COBOL Hack Wants to Know about ST


Powered by phpBB® Forum Software