Add LISP interpreter in C.
mes.c: New file.
This commit is contained in:
Jan Nieuwenhuizen
parent
b99afdbbb7
commit
22ba3f6869
645
mes.c
Normal file
645
mes.c
Normal file
|
|
@ -0,0 +1,645 @@
|
||||||
|
/*
|
||||||
|
* Mes --- Maxwell Equations of Software
|
||||||
|
* Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
|
||||||
|
*
|
||||||
|
* This file is part of Mes.
|
||||||
|
*
|
||||||
|
* Mes is free software; you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Mes is distributed in the hope that it will be useful, but
|
||||||
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with Mes. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
// (setq comment-start "//")
|
||||||
|
// (setq comment-end "")
|
||||||
|
/*
|
||||||
|
* The Maxwell Equations of Software -- John McCarthy page 13
|
||||||
|
* http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define _GNU_SOURCE
|
||||||
|
#include <assert.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <stdbool.h>
|
||||||
|
|
||||||
|
#ifndef QUOTE_SUGAR
|
||||||
|
#define QUOTE_SUGAR 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
enum type {NIL, F, T, ATOM, NUMBER, PAIR, UNSPECIFIED, FUNCTION0, FUNCTION1, FUNCTION2, FUNCTION3, LAMBDA, LABEL};
|
||||||
|
|
||||||
|
struct scm_t;
|
||||||
|
typedef struct scm_t* (*function0_t) (void);
|
||||||
|
typedef struct scm_t* (*function1_t) (struct scm_t*);
|
||||||
|
typedef struct scm_t* (*function2_t) (struct scm_t*, struct scm_t*);
|
||||||
|
typedef struct scm_t* (*function3_t) (struct scm_t*, struct scm_t*, struct scm_t*);
|
||||||
|
|
||||||
|
typedef struct scm_t {
|
||||||
|
enum type type;
|
||||||
|
union {
|
||||||
|
char *name;
|
||||||
|
struct scm_t* car;
|
||||||
|
};
|
||||||
|
union {
|
||||||
|
int value;
|
||||||
|
function0_t function0;
|
||||||
|
function1_t function1;
|
||||||
|
function2_t function2;
|
||||||
|
function3_t function3;
|
||||||
|
struct scm_t* cdr;
|
||||||
|
};
|
||||||
|
} scm;
|
||||||
|
|
||||||
|
scm scm_nil = {NIL, "()"};
|
||||||
|
scm scm_t = {T, "#t"};
|
||||||
|
scm scm_f = {F, "#f"};
|
||||||
|
scm scm_lambda = {LAMBDA, "lambda"};
|
||||||
|
scm scm_label = {LABEL, "label"};
|
||||||
|
scm scm_unspecified = {UNSPECIFIED, "#<unspecified>"};
|
||||||
|
|
||||||
|
// PRIMITIVES
|
||||||
|
scm *
|
||||||
|
car (scm *x)
|
||||||
|
{
|
||||||
|
assert (x->type == PAIR);
|
||||||
|
return x->car;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
cdr (scm *x)
|
||||||
|
{
|
||||||
|
assert (x->type == PAIR);
|
||||||
|
return x->cdr;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
cons (scm *x, scm *y)
|
||||||
|
{
|
||||||
|
scm *p = malloc (sizeof (scm));
|
||||||
|
p->type = PAIR;
|
||||||
|
p->car = x;
|
||||||
|
p->cdr = y;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
eq_p (scm *x, scm *y)
|
||||||
|
{
|
||||||
|
return (x == y
|
||||||
|
// FIXME: alist lookup symbols
|
||||||
|
|| (x->type == ATOM && y->type == ATOM
|
||||||
|
&& !strcmp (x->name, y->name))
|
||||||
|
|| (x->type == NUMBER && y->type == NUMBER
|
||||||
|
&& x->value == y->value))
|
||||||
|
? &scm_t : &scm_f;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
null_p (scm *x)
|
||||||
|
{
|
||||||
|
return eq_p (x, &scm_nil);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
pair_p (scm *x)
|
||||||
|
{
|
||||||
|
return x->type == PAIR ? &scm_t : &scm_f;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *eval (scm*, scm*);
|
||||||
|
|
||||||
|
scm *
|
||||||
|
cond (scm *x, scm *a)
|
||||||
|
{
|
||||||
|
if (x == &scm_nil) return &scm_unspecified;
|
||||||
|
assert (x->type == PAIR);
|
||||||
|
scm *clause = car (x);
|
||||||
|
assert (clause->type == PAIR);
|
||||||
|
scm *expr = eval (car (clause), a);
|
||||||
|
if (expr != &scm_f) {
|
||||||
|
if (clause->type != PAIR)
|
||||||
|
return expr;
|
||||||
|
return eval (car (cdr (clause)), a);
|
||||||
|
}
|
||||||
|
return cond (cdr (x), a);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm scm_quote;
|
||||||
|
scm *
|
||||||
|
quote (scm *x)
|
||||||
|
{
|
||||||
|
return cons (&scm_quote, x);
|
||||||
|
}
|
||||||
|
|
||||||
|
//PRIMITIVES
|
||||||
|
scm scm_car = {FUNCTION1, .function1 = &car};
|
||||||
|
scm scm_cdr = {FUNCTION1, .function1 = &cdr};
|
||||||
|
scm scm_cons = {FUNCTION2, .function2 = &cons};
|
||||||
|
scm scm_cond = {FUNCTION2, .function2 = &cond};
|
||||||
|
scm scm_eq_p = {FUNCTION2, .function2 = &eq_p};
|
||||||
|
scm scm_null_p = {FUNCTION1, .function1 = &null_p};
|
||||||
|
scm scm_pair_p = {FUNCTION1, .function1 = &pair_p};
|
||||||
|
scm scm_quote = {FUNCTION1, .function1 = "e};
|
||||||
|
|
||||||
|
//LIBRARY FUNCTIONS
|
||||||
|
scm scm_read;
|
||||||
|
|
||||||
|
|
||||||
|
// NEXT
|
||||||
|
scm *caar (scm *x) {return (car (car (x)));}
|
||||||
|
scm *cadr (scm *x) {return (car (cdr (x)));}
|
||||||
|
scm *cdar (scm *x) {return (cdr (car (x)));}
|
||||||
|
scm *caddr (scm *x) {return car (cdr (cdr (x)));}
|
||||||
|
scm *cadar (scm *x) {return car (cdr (car (x)));}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
list (scm *x, ...)
|
||||||
|
{
|
||||||
|
va_list args;
|
||||||
|
scm *lst = &scm_nil;
|
||||||
|
|
||||||
|
va_start (args, x);
|
||||||
|
while (x != &scm_unspecified)
|
||||||
|
{
|
||||||
|
lst = cons (x, lst);
|
||||||
|
x = va_arg (args, scm*);
|
||||||
|
}
|
||||||
|
va_end (args);
|
||||||
|
return lst;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
atom (scm *x)
|
||||||
|
{
|
||||||
|
#if EVAL_COND
|
||||||
|
return cond
|
||||||
|
(list (cons (pair_p (x), &scm_f),
|
||||||
|
cons (null_p (x), &scm_f),
|
||||||
|
cons (&scm_t, x),
|
||||||
|
&scm_unspecified),
|
||||||
|
&scm_nil);
|
||||||
|
#else
|
||||||
|
if (pair_p (x) == &scm_t)
|
||||||
|
return &scm_f;
|
||||||
|
else if (null_p (x) == &scm_t)
|
||||||
|
return &scm_f;
|
||||||
|
return &scm_t;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
// Page 12
|
||||||
|
scm *
|
||||||
|
pairlis (scm *x, scm *y, scm *a)
|
||||||
|
{
|
||||||
|
#if EVAL_COND
|
||||||
|
return cond
|
||||||
|
(list (cons (null_p (x), a),
|
||||||
|
cons (&scm_t, cons (cons (car (x), car (y)),
|
||||||
|
pairlis (cdr (x), cdr (y), a))),
|
||||||
|
&scm_unspecified),
|
||||||
|
a);
|
||||||
|
#else
|
||||||
|
if (x == &scm_nil)
|
||||||
|
return a;
|
||||||
|
return cons (cons (car (x), car (y)),
|
||||||
|
pairlis (cdr (x), cdr (y), a));
|
||||||
|
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
assoc (scm *x, scm *a)
|
||||||
|
{
|
||||||
|
#if EVAL_COND
|
||||||
|
return cond
|
||||||
|
(list (cons (eq_p (caar (a), x), car (a)),
|
||||||
|
cons (&scm_t, assoc (x, cdr (a))),
|
||||||
|
&scm_unspecified),
|
||||||
|
a);
|
||||||
|
#else
|
||||||
|
// not Page 12:
|
||||||
|
if (a == &scm_nil) return &scm_f;
|
||||||
|
//
|
||||||
|
if (eq_p (caar (a), x) == &scm_t)
|
||||||
|
return car (a);
|
||||||
|
return assoc (x, cdr (a));
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
// Page 13
|
||||||
|
scm *apply (scm*, scm*, scm*);
|
||||||
|
|
||||||
|
scm *
|
||||||
|
eval_quote (scm *fn, scm *x)
|
||||||
|
{
|
||||||
|
return apply (fn, x, &scm_nil);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *procedure_p (scm*);
|
||||||
|
scm *call (scm *, scm*);
|
||||||
|
scm *display (scm*);
|
||||||
|
|
||||||
|
// .. continued Page 13
|
||||||
|
scm *
|
||||||
|
apply (scm *fn, scm *x, scm *a)
|
||||||
|
{
|
||||||
|
#if EVAL_COND
|
||||||
|
return cond
|
||||||
|
(list (cons (atom (fn),
|
||||||
|
cond (list (
|
||||||
|
&scm_unspecified),
|
||||||
|
a)),
|
||||||
|
cons (eq_p (car (fn), &scm_lambda),
|
||||||
|
eval (caddr (fn), pairlis (cadr (fn), x, a))),
|
||||||
|
&scm_unspecified), a);
|
||||||
|
#else
|
||||||
|
#if 0
|
||||||
|
printf ("apply fn=");
|
||||||
|
display (fn);
|
||||||
|
printf (" x=");
|
||||||
|
display (x);
|
||||||
|
puts ("");
|
||||||
|
#endif
|
||||||
|
if (atom (fn) != &scm_f)
|
||||||
|
{
|
||||||
|
if (fn == &scm_car)
|
||||||
|
return caar (x);
|
||||||
|
else if (fn == &scm_cdr)
|
||||||
|
return cdar (x);
|
||||||
|
else if (fn == &scm_cdr)
|
||||||
|
return cdar (x);
|
||||||
|
else if (fn == &scm_cons)
|
||||||
|
return cons (car (x), cadr (x));
|
||||||
|
else if (fn == &scm_eq_p)
|
||||||
|
return eq_p (car (x), cadr (x));
|
||||||
|
else if (procedure_p (fn) != &scm_f)
|
||||||
|
return call (fn, x);
|
||||||
|
else
|
||||||
|
return apply (eval (fn, a), x, a);
|
||||||
|
}
|
||||||
|
else if (car (fn) == &scm_lambda)
|
||||||
|
return eval (caddr (fn), pairlis (cadr (fn), x, a));
|
||||||
|
else if (car (fn) == &scm_label)
|
||||||
|
return apply (caddr (fn), x, cons (cons (cadr (fn),
|
||||||
|
caddr (fn)),
|
||||||
|
a));
|
||||||
|
return &scm_unspecified;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *evcon (scm*, scm*);
|
||||||
|
scm *evlis (scm*, scm*);
|
||||||
|
|
||||||
|
scm *
|
||||||
|
eval (scm *e, scm *a)
|
||||||
|
{
|
||||||
|
#if EVAL_COND
|
||||||
|
#error no eval cond here
|
||||||
|
#else
|
||||||
|
// not Page 12
|
||||||
|
if (e->type == NUMBER
|
||||||
|
|| e == &scm_t
|
||||||
|
|| e== &scm_f)
|
||||||
|
return e;
|
||||||
|
//
|
||||||
|
else if (atom (e) == &scm_t)
|
||||||
|
return cdr (assoc (e, a));
|
||||||
|
else if (atom (car (e)) == &scm_t)
|
||||||
|
{
|
||||||
|
if (car (e) == &scm_quote)
|
||||||
|
return cadr (e);
|
||||||
|
else if (car (e) == &scm_cond)
|
||||||
|
return evcon (cdr (e), a);
|
||||||
|
else
|
||||||
|
return apply (car (e), evlis (cdr (e), a), a);
|
||||||
|
}
|
||||||
|
return apply (car (e), evlis (cdr (e), a), a);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
evcon (scm *c, scm *a)
|
||||||
|
{
|
||||||
|
if (eval (caar (c), a) != &scm_f)
|
||||||
|
return eval (cadar (c), a);
|
||||||
|
return evcon (cdr (c), a);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
evlis (scm *m, scm *a)
|
||||||
|
{
|
||||||
|
if (m == &scm_nil)
|
||||||
|
return &scm_nil;
|
||||||
|
return cons (eval (car (m), a), evlis (cdr (m), a));
|
||||||
|
}
|
||||||
|
|
||||||
|
// EXTRAS
|
||||||
|
scm scm_eval = {FUNCTION2, .function2 = &eval};
|
||||||
|
scm scm_apply = {FUNCTION3, .function3 = &apply};
|
||||||
|
|
||||||
|
scm *
|
||||||
|
procedure_p (scm *x)
|
||||||
|
{
|
||||||
|
return (x->type == FUNCTION0
|
||||||
|
|| x->type == FUNCTION1
|
||||||
|
|| x->type == FUNCTION2
|
||||||
|
|| x->type == FUNCTION3)
|
||||||
|
? &scm_t : &scm_f;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
call (scm *fn, scm *x)
|
||||||
|
{
|
||||||
|
if (fn->type == FUNCTION0)
|
||||||
|
return fn->function0 ();
|
||||||
|
else if (fn->type == FUNCTION1)
|
||||||
|
return fn->function1 (car (x));
|
||||||
|
if (fn->type == FUNCTION2)
|
||||||
|
return fn->function2 (car (x), cadr (x));
|
||||||
|
if (fn->type == FUNCTION3)
|
||||||
|
return fn->function3 (car (x), cadr (x), caddr (x));
|
||||||
|
return &scm_unspecified;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
append (scm *x, scm *y)
|
||||||
|
{
|
||||||
|
if (x == &scm_nil) return y;
|
||||||
|
assert (x->type == PAIR);
|
||||||
|
return cons (car (x), append (cdr (x), y));
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
make_atom (char const *s)
|
||||||
|
{
|
||||||
|
// TODO: alist lookup symbols
|
||||||
|
scm *p = malloc (sizeof (scm));
|
||||||
|
p->type = ATOM;
|
||||||
|
p->name = strdup (s);
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
make_number (int x)
|
||||||
|
{
|
||||||
|
scm *p = malloc (sizeof (scm));
|
||||||
|
p->type = NUMBER;
|
||||||
|
p->value = x;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *environment = &scm_nil;
|
||||||
|
|
||||||
|
scm *
|
||||||
|
lookup (char *x)
|
||||||
|
{
|
||||||
|
if (!strcmp (x, " ()")) return &scm_nil;
|
||||||
|
if (!strcmp (x, "#t")) return &scm_t;
|
||||||
|
if (!strcmp (x, "#f")) return &scm_f;
|
||||||
|
if (!strcmp (x, "'")) return &scm_quote; // assert !quote?
|
||||||
|
if (isdigit (*x) || (*x == '-' && isdigit (*(x+1))))
|
||||||
|
return make_number (atoi (x));
|
||||||
|
|
||||||
|
// TODO: alist lookup symbols
|
||||||
|
if (!strcmp (x, "label")) return &scm_label;
|
||||||
|
if (!strcmp (x, "lambda")) return &scm_lambda;
|
||||||
|
|
||||||
|
if (!strcmp (x, "car")) return &scm_car;
|
||||||
|
if (!strcmp (x, "cdr")) return &scm_cdr;
|
||||||
|
if (!strcmp (x, "cons")) return &scm_cons;
|
||||||
|
if (!strcmp (x, "eq")) return &scm_eq_p;
|
||||||
|
if (!strcmp (x, "quote")) return &scm_quote;
|
||||||
|
if (!strcmp (x, "cond")) return &scm_cond;
|
||||||
|
|
||||||
|
if (x) {
|
||||||
|
scm *y = make_atom (x);
|
||||||
|
scm *r = assoc (y, environment);
|
||||||
|
if (r != &scm_f) return cdr (r);
|
||||||
|
return y;
|
||||||
|
}
|
||||||
|
|
||||||
|
return &scm_unspecified;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
cossa (scm *x, scm *a)
|
||||||
|
{
|
||||||
|
if (a == &scm_nil) return &scm_f;
|
||||||
|
if (eq_p (cdar (a), x) == &scm_t)
|
||||||
|
return car (a);
|
||||||
|
return cossa (x, cdr (a));
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *display_helper (scm*, bool, char*);
|
||||||
|
|
||||||
|
scm *
|
||||||
|
display (scm *x)
|
||||||
|
{
|
||||||
|
return display_helper (x, false, "");
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
display_helper (scm *x, bool cont, char *sep)
|
||||||
|
{
|
||||||
|
scm *r;
|
||||||
|
printf (sep);
|
||||||
|
if (x == &scm_nil) printf ("()");
|
||||||
|
else if (x == &scm_t) printf ("#t");
|
||||||
|
else if (x == &scm_f) printf ("#f");
|
||||||
|
else if (x == &scm_unspecified) printf ("#<unspecified>");
|
||||||
|
else if (x == &scm_quote) printf ("quote");
|
||||||
|
|
||||||
|
else if (x == &scm_label) printf ("label");
|
||||||
|
else if (x == &scm_lambda) printf ("lambda");
|
||||||
|
|
||||||
|
else if (x == &scm_car) printf ("car");
|
||||||
|
else if (x == &scm_cdr) printf ("cdr");
|
||||||
|
else if (x == &scm_cons) printf ("cons");
|
||||||
|
else if (x == &scm_cond) printf ("cond");
|
||||||
|
else if (x == &scm_eq_p) printf ("eq");
|
||||||
|
else if (x == &scm_null_p) printf ("null");
|
||||||
|
else if (x == &scm_pair_p) printf ("pair");
|
||||||
|
else if (x == &scm_quote) printf ("quote");
|
||||||
|
|
||||||
|
else if (x->type == NUMBER) printf ("%d", x->value);
|
||||||
|
else if (x->type == NUMBER) printf ("0");
|
||||||
|
else if (x->type == ATOM) printf (x->name);
|
||||||
|
else if (x->type == PAIR) {
|
||||||
|
#if QUOTE_SUGAR
|
||||||
|
if (car (x) == &scm_quote) {
|
||||||
|
printf ("'");
|
||||||
|
return display_helper (car (cdr (x)), cont, "");
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
if (!cont) printf ("(");
|
||||||
|
display (car (x));
|
||||||
|
if (cdr (x)->type == PAIR)
|
||||||
|
display_helper (cdr (x), true, " ");
|
||||||
|
else if (cdr (x) != &scm_nil) {
|
||||||
|
printf (" . ");
|
||||||
|
display (cdr (x));
|
||||||
|
}
|
||||||
|
if (!cont) printf (")");
|
||||||
|
}
|
||||||
|
else if ((r = cossa (x, environment)) != &scm_f)
|
||||||
|
printf (car (r)->name);
|
||||||
|
|
||||||
|
return &scm_unspecified;
|
||||||
|
}
|
||||||
|
|
||||||
|
// READ
|
||||||
|
int
|
||||||
|
ungetchar (int c)
|
||||||
|
{
|
||||||
|
return ungetc (c, stdin);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
peekchar ()
|
||||||
|
{
|
||||||
|
int c = getchar ();
|
||||||
|
ungetchar (c);
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm*
|
||||||
|
builtin_getchar ()
|
||||||
|
{
|
||||||
|
return make_number (getchar ());
|
||||||
|
}
|
||||||
|
scm scm_getchar = {FUNCTION0, .name="getchar", .function0 = &builtin_getchar};
|
||||||
|
|
||||||
|
scm*
|
||||||
|
builtin_peekchar ()
|
||||||
|
{
|
||||||
|
return make_number (peekchar ());
|
||||||
|
}
|
||||||
|
scm scm_peekchar = {FUNCTION0, .name="peekchar", .function0 = &builtin_peekchar};
|
||||||
|
|
||||||
|
scm*
|
||||||
|
builtin_ungetchar (scm* c)
|
||||||
|
{
|
||||||
|
assert (c->type == NUMBER);
|
||||||
|
ungetchar (c->value);
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
scm scm_ungetchar = {FUNCTION1, .name="ungetchar", .function1 = &builtin_ungetchar};
|
||||||
|
|
||||||
|
int
|
||||||
|
readcomment (int c)
|
||||||
|
{
|
||||||
|
if (c == '\n') return c;
|
||||||
|
return readcomment (getchar ());
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
readblock (int c)
|
||||||
|
{
|
||||||
|
if (c == '!' && peekchar () == '#') return getchar ();
|
||||||
|
return readblock (getchar ());
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *readlis (scm *a);
|
||||||
|
|
||||||
|
scm *
|
||||||
|
readword (int c, char* w, scm *a)
|
||||||
|
{
|
||||||
|
if (c == EOF && !w) return &scm_nil;
|
||||||
|
if (c == '\n' && !w) return readword (getchar (), w, a);
|
||||||
|
if (c == EOF || c == '\n') return lookup (w);
|
||||||
|
if (c == ' ') return readword ('\n', w, a);
|
||||||
|
if (c == '(' && !w) return readlis (a);
|
||||||
|
if (c == '(') {ungetchar (c); return lookup (w);}
|
||||||
|
if (c == ')' && !w) {ungetchar (c); return &scm_nil;}
|
||||||
|
if (c == ')') {ungetchar (c); return lookup (w);}
|
||||||
|
if (c == '\'' && !w) {return cons (lookup ("'"),
|
||||||
|
cons (readword (getchar (), w, a),
|
||||||
|
&scm_nil));}
|
||||||
|
if (c == ';') {readcomment (c); return readword ('\n', w, a);}
|
||||||
|
if (c == '#' && peekchar () == '!') {getchar (); readblock (getchar ()); return readword (getchar (), w, a);}
|
||||||
|
char s[2];
|
||||||
|
s[0] = c;
|
||||||
|
s[1] = 0;
|
||||||
|
char buf[256] = "";
|
||||||
|
return readword (getchar (), strcat (w ? w : buf, s), a);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
readlis (scm *a)
|
||||||
|
{
|
||||||
|
int c = getchar ();
|
||||||
|
if (c == ')') return &scm_nil;
|
||||||
|
scm *w = readword (c, 0, a);
|
||||||
|
return cons (w, readlis (a));
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
read ()
|
||||||
|
{
|
||||||
|
return readword (getchar (), 0, environment);
|
||||||
|
}
|
||||||
|
scm scm_read = {FUNCTION0, .function0 = &read};
|
||||||
|
|
||||||
|
scm *
|
||||||
|
add_environment (scm *a, char *name, scm* x)
|
||||||
|
{
|
||||||
|
return cons (cons (make_atom (name), x), a);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
less_p (scm *a, scm *b)
|
||||||
|
{
|
||||||
|
assert (a->type == NUMBER);
|
||||||
|
assert (b->type == NUMBER);
|
||||||
|
return a->value < b->value ? &scm_t : &scm_f;
|
||||||
|
}
|
||||||
|
|
||||||
|
scm *
|
||||||
|
minus (scm *a, scm *b)
|
||||||
|
{
|
||||||
|
assert (a->type == NUMBER);
|
||||||
|
assert (b->type == NUMBER);
|
||||||
|
return make_number (a->value - b->value);
|
||||||
|
}
|
||||||
|
|
||||||
|
scm scm_less_p = {FUNCTION2, .function2 = &less_p};
|
||||||
|
scm scm_minus = {FUNCTION2, .function2 = &minus};
|
||||||
|
|
||||||
|
scm *
|
||||||
|
fill_environment ()
|
||||||
|
{
|
||||||
|
scm *a = &scm_nil;
|
||||||
|
a = add_environment (a, "<", &scm_less_p);
|
||||||
|
a = add_environment (a, "-", &scm_minus);
|
||||||
|
return a;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
main (int argc, char *argv[])
|
||||||
|
{
|
||||||
|
environment = fill_environment ();
|
||||||
|
|
||||||
|
scm *program = read ();
|
||||||
|
#if DEBUG
|
||||||
|
puts ("");
|
||||||
|
display (program);
|
||||||
|
puts ("\n =>");
|
||||||
|
#endif
|
||||||
|
scm *result;
|
||||||
|
result = eval (program, environment);
|
||||||
|
display (result);
|
||||||
|
puts ("");
|
||||||
|
exit (0);
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue