https://github.com/bl0ckeduser/wannabe-lisp

babby's first lisp (scheme) interpreter
https://github.com/bl0ckeduser/wannabe-lisp

Last synced: about 2 months ago
JSON representation

babby's first lisp (scheme) interpreter

• Host: GitHub
• URL: https://github.com/bl0ckeduser/wannabe-lisp
• Owner: bl0ckeduser
• License: other
• Created: 2013-07-10T22:31:16.000Z (over 11 years ago)
• Default Branch: master
• Last Pushed: 2016-03-16T13:47:29.000Z (almost 9 years ago)
• Last Synced: 2024-10-16T01:44:27.089Z (3 months ago)
• Language: C
• Homepage:
• Size: 170 KB
• Stars: 2
• Watchers: 3
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README
  • License: LICENSE

Awesome Lists containing this project

• AwesomeInterpreter - wannabe-lisp

README

        
Babby's first toy lisp (scheme) interpreter

===========================================

Based on the examples given in the SICP videos

(http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures/)

and also on the SICP text's examples

(http://mitpress.mit.edu/sicp/)

Currently supported Scheme procedures and special forms are:

<, <=, =, >, >=, -, *, +, and, append, apply, begin, car, cdr, caar,

cdar, ..., caaaaar, cond, cons, cons-stream, define, delay, display,

eq?, even?, filter, fold-right, force, if, lambda, length, let, list,

list-ref, list-tail, map, newline, not, null?, number?, odd?, or, pair?,

remainder, reverse, set!, stream-car, stream-cdr, stream-null?, symbol?,

the-empty-stream.

(Some more obscure variations of some special forms may not yet be supported)

Features include: tail-recursion optimization, noobish mark-sweep garbage 

collection, support for quotation (but not yet quasiquotation), ...

To build the code, do:

$ make

To run interactive REPL mode, do:

$ ./lisp -i

To run a code file, do:

$ ./lisp  6.

- (max-space exp) evaluates exp in the local scope, returning a number

  indicating the peak number of stack frames used in the evaluation.

  See tco-test.txt for example code. TCO'd iterative processes will 

  return a constant space count; recursive ones will return a growing

  space count. max-space cannot be used recursively.

- (save-to 'file-name.txt) logs to a file.

- (load 'file.txt) loads code from a file.

				~~~~~~~~

II. Parenthesis autocomplete:

you type a big expression in the REPL, then hit return with 

an empty line and the missing parentheses will be automatically

added

]=> (define (bob x)

...    (cond ((= x 0) 123

...          ((= x 1) 456

...             

... ))))

				~~~~~~~~

III. Auto-indent

The REPL auto-indents

				~~~~~~~~

IV. Debugging facilities

When user code crashes, it is possible to be presented, upon request,

with a useful printout showing a trace of recently evaluated list 

structures as well as the values of the symbols involved in these.

The trace printout grows downwards from outermost, least-recently-evaluated

list, up until the list structure that caused the error.

[ The constant BUFLEN (by default 5) in stacktrace.c sets the maximum number of 

  evaluation steps memorized by the debug-tracer, and the constant SYMLEN,

  by default 8, sets the maximum number of symbols memorized. ]

Below is an example session.

	]=> (define (derp l n)

	...    (if (= n 0)

	...       (cadr l)

	...       (derp l (- n 1))))

	#

	

	]=> (derp 123 10)

	Error: `cdr' expects a linked-list

	A debug log has been prepared. Type (debuglog) to see it.

	]=> (debuglog)

	

	===== DEBUGGING INFO  =====

	Evaluation trace:

	(if (= n 0) (cadr l) (derp l (- n 1)))

	(= n 0)

	(cadr l)

	(car (cdr x))

	(cdr x)

	

	Symbols: 

	derp: #

	n: 0

	=: (PRIM-OP =)

	l: 123

	-: (PRIM-OP -)

	cadr: #

	x: 123

	===========================