#define DBG_MEM 0
#define DBG_EVAL 0
+#define DBG_READ 0
+#define DBG_FREE_CONS 0
+#define NDEBUG 1
#include <stdint.h>
#include <string.h>
#include <ao_lisp_os.h>
+#ifndef __BYTE_ORDER
+#include <endian.h>
+#endif
typedef uint16_t ao_poly;
typedef int16_t ao_signed_poly;
#define ao_lisp_pool ao_lisp_const
#define AO_LISP_POOL AO_LISP_POOL_CONST
-#define _atom(n) ao_lisp_atom_poly(ao_lisp_atom_intern(#n))
+#define _atom(n) ao_lisp_atom_poly(ao_lisp_atom_intern(n))
#define _bool(v) ao_lisp_bool_poly(ao_lisp_bool_get(v))
#define _ao_lisp_bool_true _bool(1)
#define _ao_lisp_bool_false _bool(0)
-#define _ao_lisp_atom_quote _atom(quote)
-#define _ao_lisp_atom_set _atom(set)
-#define _ao_lisp_atom_setq _atom(setq)
-#define _ao_lisp_atom_car _atom(car)
-#define _ao_lisp_atom_cdr _atom(cdr)
-#define _ao_lisp_atom_cons _atom(cons)
-#define _ao_lisp_atom_last _atom(last)
-#define _ao_lisp_atom_length _atom(length)
-#define _ao_lisp_atom_cond _atom(cond)
-#define _ao_lisp_atom_else _atom(else)
-#define _ao_lisp_atom_lambda _atom(lambda)
-#define _ao_lisp_atom_led _atom(led)
-#define _ao_lisp_atom_delay _atom(delay)
-#define _ao_lisp_atom_pack _atom(pack)
-#define _ao_lisp_atom_unpack _atom(unpack)
-#define _ao_lisp_atom_flush _atom(flush)
-#define _ao_lisp_atom_eval _atom(eval)
-#define _ao_lisp_atom_read _atom(read)
-#define _ao_lisp_atom_eof _atom(eof)
-#define _ao_lisp_atom_save _atom(save)
-#define _ao_lisp_atom_restore _atom(restore)
-#define _ao_lisp_atom_call2fcc _atom(call/cc)
-#define _ao_lisp_atom_collect _atom(collect)
-#define _ao_lisp_atom_symbolp _atom(symbol?)
-#define _ao_lisp_atom_builtin _atom(builtin?)
-#define _ao_lisp_atom_symbolp _atom(symbol?)
-#define _ao_lisp_atom_symbolp _atom(symbol?)
+
+#define _ao_lisp_atom_eof _atom("eof")
+#define _ao_lisp_atom_else _atom("else")
+
+#define AO_LISP_BUILTIN_ATOMS
+#include "ao_lisp_builtin.h"
+
#else
#include "ao_lisp_const.h"
#ifndef AO_LISP_POOL
#define AO_LISP_ATOM 4
#define AO_LISP_BUILTIN 5
#define AO_LISP_FRAME 6
-#define AO_LISP_LAMBDA 7
-#define AO_LISP_STACK 8
-#define AO_LISP_BOOL 9
-#define AO_LISP_NUM_TYPE 10
+#define AO_LISP_FRAME_VALS 7
+#define AO_LISP_LAMBDA 8
+#define AO_LISP_STACK 9
+#define AO_LISP_BOOL 10
+#define AO_LISP_BIGINT 11
+#define AO_LISP_FLOAT 12
+#define AO_LISP_NUM_TYPE 13
/* Leave two bits for types to use as they please */
#define AO_LISP_OTHER_TYPE_MASK 0x3f
#define AO_LISP_DIVIDE_BY_ZERO 0x02
#define AO_LISP_INVALID 0x04
#define AO_LISP_UNDEFINED 0x08
-#define AO_LISP_EOF 0x10
+#define AO_LISP_REDEFINED 0x10
+#define AO_LISP_EOF 0x20
+#define AO_LISP_EXIT 0x40
extern uint8_t ao_lisp_exception;
#define AO_LISP_IS_CONST(a) (ao_lisp_const <= ((uint8_t *) (a)) && ((uint8_t *) (a)) < ao_lisp_const + AO_LISP_POOL_CONST)
#define AO_LISP_IS_POOL(a) (ao_lisp_pool <= ((uint8_t *) (a)) && ((uint8_t *) (a)) < ao_lisp_pool + AO_LISP_POOL)
-#define AO_LISP_IS_INT(p) (ao_lisp_base_type(p) == AO_LISP_INT);
+#define AO_LISP_IS_INT(p) (ao_lisp_poly_base_type(p) == AO_LISP_INT)
void *
ao_lisp_ref(ao_poly poly);
ao_poly val;
};
+struct ao_lisp_frame_vals {
+ uint8_t type;
+ uint8_t size;
+ struct ao_lisp_val vals[];
+};
+
struct ao_lisp_frame {
uint8_t type;
uint8_t num;
ao_poly prev;
- struct ao_lisp_val vals[];
+ ao_poly vals;
};
struct ao_lisp_bool {
uint16_t pad;
};
+struct ao_lisp_bigint {
+ uint32_t value;
+};
+
+struct ao_lisp_float {
+ uint8_t type;
+ uint8_t pad1;
+ uint16_t pad2;
+ float value;
+};
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+static inline uint32_t
+ao_lisp_int_bigint(int32_t i) {
+ return AO_LISP_BIGINT | (i << 8);
+}
+static inline int32_t
+ao_lisp_bigint_int(uint32_t bi) {
+ return (int32_t) bi >> 8;
+}
+#else
+static inline uint32_t
+ao_lisp_int_bigint(int32_t i) {
+ return (uint32_t) (i & 0xffffff) | (AO_LISP_BIGINT << 24);
+}
+static inlint int32_t
+ao_lisp_bigint_int(uint32_t bi) {
+ return (int32_t) (bi << 8) >> 8;
+}
+#endif
+
+#define AO_LISP_MIN_INT (-(1 << (15 - AO_LISP_TYPE_SHIFT)))
+#define AO_LISP_MAX_INT ((1 << (15 - AO_LISP_TYPE_SHIFT)) - 1)
+#define AO_LISP_MIN_BIGINT (-(1 << 24))
+#define AO_LISP_MAX_BIGINT ((1 << 24) - 1)
+
+#define AO_LISP_NOT_INTEGER 0x7fffffff
+
/* Set on type when the frame escapes the lambda */
#define AO_LISP_FRAME_MARK 0x80
#define AO_LISP_FRAME_PRINT 0x40
return ao_lisp_poly(frame, AO_LISP_OTHER);
}
+static inline struct ao_lisp_frame_vals *
+ao_lisp_poly_frame_vals(ao_poly poly) {
+ return ao_lisp_ref(poly);
+}
+
+static inline ao_poly
+ao_lisp_frame_vals_poly(struct ao_lisp_frame_vals *vals) {
+ return ao_lisp_poly(vals, AO_LISP_OTHER);
+}
+
enum eval_state {
eval_sexpr, /* Evaluate an sexpr */
eval_val, /* Value computed */
eval_formal, /* Formal computed */
eval_exec, /* Start a lambda evaluation */
+ eval_apply, /* Execute apply */
eval_cond, /* Start next cond clause */
eval_cond_test, /* Check cond condition */
- eval_progn, /* Start next progn entry */
+ eval_begin, /* Start next begin entry */
eval_while, /* Start while condition */
eval_while_test, /* Check while condition */
eval_macro, /* Finished with macro generation */
return type;
}
+static inline int
+ao_lisp_is_cons(ao_poly poly) {
+ return (ao_lisp_poly_base_type(poly) == AO_LISP_CONS);
+}
+
+static inline int
+ao_lisp_is_pair(ao_poly poly) {
+ return poly != AO_LISP_NIL && (ao_lisp_poly_base_type(poly) == AO_LISP_CONS);
+}
+
static inline struct ao_lisp_cons *
ao_lisp_poly_cons(ao_poly poly)
{
return ao_lisp_poly(cons, AO_LISP_CONS);
}
-static inline int
+static inline int32_t
ao_lisp_poly_int(ao_poly poly)
{
- return (int) ((ao_signed_poly) poly >> AO_LISP_TYPE_SHIFT);
+ return (int32_t) ((ao_signed_poly) poly >> AO_LISP_TYPE_SHIFT);
}
static inline ao_poly
-ao_lisp_int_poly(int i)
+ao_lisp_int_poly(int32_t i)
{
return ((ao_poly) i << 2) | AO_LISP_INT;
}
+static inline struct ao_lisp_bigint *
+ao_lisp_poly_bigint(ao_poly poly)
+{
+ return ao_lisp_ref(poly);
+}
+
+static inline ao_poly
+ao_lisp_bigint_poly(struct ao_lisp_bigint *bi)
+{
+ return ao_lisp_poly(bi, AO_LISP_OTHER);
+}
+
static inline char *
ao_lisp_poly_string(ao_poly poly)
{
{
return ao_lisp_ref(poly);
}
+
+static inline ao_poly
+ao_lisp_float_poly(struct ao_lisp_float *f)
+{
+ return ao_lisp_poly(f, AO_LISP_OTHER);
+}
+
+static inline struct ao_lisp_float *
+ao_lisp_poly_float(ao_poly poly)
+{
+ return ao_lisp_ref(poly);
+}
+
+float
+ao_lisp_poly_number(ao_poly p);
+
/* memory functions */
extern int ao_lisp_collects[2];
int
ao_lisp_collect(uint8_t style);
+#if DBG_FREE_CONS
+void
+ao_lisp_cons_check(struct ao_lisp_cons *cons);
+#endif
+
void
ao_lisp_cons_stash(int id, struct ao_lisp_cons *cons);
return ao_lisp_poly_stack(ao_lisp_poly_fetch(id));
}
+void
+ao_lisp_frame_stash(int id, struct ao_lisp_frame *frame);
+
+struct ao_lisp_frame *
+ao_lisp_frame_fetch(int id);
+
/* bool */
extern const struct ao_lisp_type ao_lisp_bool_type;
void
-ao_lisp_bool_print(ao_poly v);
+ao_lisp_bool_write(ao_poly v);
#ifdef AO_LISP_MAKE_CONST
struct ao_lisp_bool *ao_lisp_true, *ao_lisp_false;
struct ao_lisp_cons *
ao_lisp_cons_cons(ao_poly car, ao_poly cdr);
+/* Return a cons or NULL for a proper list, else error */
+struct ao_lisp_cons *
+ao_lisp_cons_cdr(struct ao_lisp_cons *cons);
+
ao_poly
ao_lisp__cons(ao_poly car, ao_poly cdr);
ao_lisp_cons_free(struct ao_lisp_cons *cons);
void
-ao_lisp_cons_print(ao_poly);
+ao_lisp_cons_write(ao_poly);
void
-ao_lisp_cons_patom(ao_poly);
+ao_lisp_cons_display(ao_poly);
int
ao_lisp_cons_length(struct ao_lisp_cons *cons);
ao_lisp_string_unpack(char *a);
void
-ao_lisp_string_print(ao_poly s);
+ao_lisp_string_write(ao_poly s);
void
-ao_lisp_string_patom(ao_poly s);
+ao_lisp_string_display(ao_poly s);
/* atom */
extern const struct ao_lisp_type ao_lisp_atom_type;
extern struct ao_lisp_frame *ao_lisp_frame_current;
void
-ao_lisp_atom_print(ao_poly a);
+ao_lisp_atom_write(ao_poly a);
struct ao_lisp_atom *
ao_lisp_atom_intern(char *name);
ao_poly *
-ao_lisp_atom_ref(struct ao_lisp_frame *frame, ao_poly atom);
+ao_lisp_atom_ref(ao_poly atom);
ao_poly
ao_lisp_atom_get(ao_poly atom);
ao_poly
ao_lisp_atom_set(ao_poly atom, ao_poly val);
+ao_poly
+ao_lisp_atom_def(ao_poly atom, ao_poly val);
+
/* int */
void
-ao_lisp_int_print(ao_poly i);
+ao_lisp_int_write(ao_poly i);
+
+int32_t
+ao_lisp_poly_integer(ao_poly p);
+
+ao_poly
+ao_lisp_integer_poly(int32_t i);
+
+static inline int
+ao_lisp_integer_typep(uint8_t t)
+{
+ return (t == AO_LISP_INT) || (t == AO_LISP_BIGINT);
+}
+
+void
+ao_lisp_bigint_write(ao_poly i);
+extern const struct ao_lisp_type ao_lisp_bigint_type;
/* prim */
void
-ao_lisp_poly_print(ao_poly p);
+ao_lisp_poly_write(ao_poly p);
void
-ao_lisp_poly_patom(ao_poly p);
+ao_lisp_poly_display(ao_poly p);
int
ao_lisp_poly_mark(ao_poly p, uint8_t note_cons);
ao_poly
ao_lisp_set_cond(struct ao_lisp_cons *cons);
+/* float */
+extern const struct ao_lisp_type ao_lisp_float_type;
+
+void
+ao_lisp_float_write(ao_poly p);
+
+ao_poly
+ao_lisp_float_get(float value);
+
+static inline uint8_t
+ao_lisp_number_typep(uint8_t t)
+{
+ return ao_lisp_integer_typep(t) || (t == AO_LISP_FLOAT);
+}
+
+float
+ao_lisp_poly_number(ao_poly p);
+
/* builtin */
void
-ao_lisp_builtin_print(ao_poly b);
+ao_lisp_builtin_write(ao_poly b);
extern const struct ao_lisp_type ao_lisp_builtin_type;
/* frame */
extern const struct ao_lisp_type ao_lisp_frame_type;
+extern const struct ao_lisp_type ao_lisp_frame_vals_type;
#define AO_LISP_FRAME_FREE 6
void
ao_lisp_frame_bind(struct ao_lisp_frame *frame, int num, ao_poly atom, ao_poly val);
-int
-ao_lisp_frame_add(struct ao_lisp_frame **frame, ao_poly atom, ao_poly val);
+ao_poly
+ao_lisp_frame_add(struct ao_lisp_frame *frame, ao_poly atom, ao_poly val);
void
-ao_lisp_frame_print(ao_poly p);
+ao_lisp_frame_write(ao_poly p);
+
+void
+ao_lisp_frame_init(void);
/* lambda */
extern const struct ao_lisp_type ao_lisp_lambda_type;
ao_lisp_lambda_new(ao_poly cons);
void
-ao_lisp_lambda_print(ao_poly lambda);
+ao_lisp_lambda_write(ao_poly lambda);
ao_poly
ao_lisp_lambda_eval(void);
ao_lisp_stack_clear(void);
void
-ao_lisp_stack_print(ao_poly stack);
+ao_lisp_stack_write(ao_poly stack);
ao_poly
ao_lisp_stack_eval(void);
/* error */
+void
+ao_lisp_vprintf(char *format, va_list args);
+
+void
+ao_lisp_printf(char *format, ...);
+
void
ao_lisp_error_poly(char *name, ao_poly poly, ao_poly last);
/* debugging macros */
-#if DBG_EVAL
+#if DBG_EVAL || DBG_READ || DBG_MEM
#define DBG_CODE 1
int ao_lisp_stack_depth;
#define DBG_DO(a) a
#define DBG_IN() (++ao_lisp_stack_depth)
#define DBG_OUT() (--ao_lisp_stack_depth)
#define DBG_RESET() (ao_lisp_stack_depth = 0)
-#define DBG(...) printf(__VA_ARGS__)
-#define DBGI(...) do { DBG("%4d: ", __LINE__); DBG_INDENT(); DBG(__VA_ARGS__); } while (0)
-#define DBG_CONS(a) ao_lisp_cons_print(ao_lisp_cons_poly(a))
-#define DBG_POLY(a) ao_lisp_poly_print(a)
+#define DBG(...) ao_lisp_printf(__VA_ARGS__)
+#define DBGI(...) do { printf("%4d: ", __LINE__); DBG_INDENT(); DBG(__VA_ARGS__); } while (0)
+#define DBG_CONS(a) ao_lisp_cons_write(ao_lisp_cons_poly(a))
+#define DBG_POLY(a) ao_lisp_poly_write(a)
#define OFFSET(a) ((a) ? (int) ((uint8_t *) a - ao_lisp_pool) : -1)
-#define DBG_STACK() ao_lisp_stack_print(ao_lisp_stack_poly(ao_lisp_stack))
+#define DBG_STACK() ao_lisp_stack_write(ao_lisp_stack_poly(ao_lisp_stack))
static inline void
ao_lisp_frames_dump(void)
{
#define DBG_FRAMES()
#endif
+#if DBG_READ
+#define RDBGI(...) DBGI(__VA_ARGS__)
+#define RDBG_IN() DBG_IN()
+#define RDBG_OUT() DBG_OUT()
+#else
+#define RDBGI(...)
+#define RDBG_IN()
+#define RDBG_OUT()
+#endif
+
#define DBG_MEM_START 1
#if DBG_MEM
#include <assert.h>
extern int dbg_move_depth;
#define MDBG_DUMP 1
-#define MDBG_OFFSET(a) ((int) ((uint8_t *) (a) - ao_lisp_pool))
+#define MDBG_OFFSET(a) ((a) ? (int) ((uint8_t *) (a) - ao_lisp_pool) : -1)
extern int dbg_mem;
-#define MDBG_DO(a) a
+#define MDBG_DO(a) DBG_DO(a)
#define MDBG_MOVE(...) do { if (dbg_mem) { int d; for (d = 0; d < dbg_move_depth; d++) printf (" "); printf(__VA_ARGS__); } } while (0)
#define MDBG_MORE(...) do { if (dbg_mem) printf(__VA_ARGS__); } while (0)
#define MDBG_MOVE_IN() (dbg_move_depth++)
projects / fw / altos / blobdiff