cvs/stack/stack.h

/*
    stack - an interactive interpreter for a stack-based language
    Copyright (C) 2002  Mats Alritzson and Teddy Hogeborn

    This program 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 2 of the License, or
    (at your option) any later version.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Authors: Mats Alritzson <masse@fukt.bth.se>
             Teddy Hogeborn <teddy@fukt.bth.se>
*/

#define HASHTBLSIZE 2048

/* First, define some types. */

struct cons_struct;

/* A value of some type */
typedef struct {
  enum {
    integer,
    tfloat,
    string,
    func,                       /* Function pointer */
    symb, 
    tcons
  } type:4;                     /* Type of stack element */

  union {
    struct {
      unsigned int mark:1;
      unsigned int protect:1;
    } flag;
    unsigned int no_gc:2;
  } gc;

  union {
    struct cons_struct *c;
    void *ptr;                  /* Pointer to the content */
    int i;                      /* ...or an integer */
    float f;
  } content;                    /* Stores a pointer or an integer */

} value;

/* An item (value) on a stack */
typedef struct stackitem_struct
{
  value *item;                 /* The value on the stack */
                               /* (This is never NULL) */
  struct stackitem_struct *next; /* Next item */
} stackitem;

typedef struct cons_struct {
  value *car;
  value *cdr;
} cons;

/* A symbol with a name and possible value */
/* (These do not need reference counters, they are kept unique by
   hashing.) */
typedef struct symbol_struct {
  char *id;                     /* Symbol name */
  value *val;                   /* The value (if any) bound to it */
  struct symbol_struct *next;   /* In case of hashing conflicts, a */
} symbol;                       /* symbol is a kind of stack item. */

/* A type for a hash table for symbols */
typedef symbol *hashtbl[HASHTBLSIZE]; /* Hash table declaration */

/* An environment; gives access to the stack and a hash table of
   defined symbols */
typedef struct {
  stackitem *gc_ref;
  int gc_limit, gc_count;

  cons *head;           /* Head of the stack */
  hashtbl symbols;              /* Hash table of all variable bindings */
  int err;                      /* Error flag */
  char *in_string;              /* Input pending to be read */
  char *free_string;            /* Free this string when all input is
                                   read from in_string */
  FILE *inputstream;            /* stdin or a file, most likely */
  int interactive;              /* print prompts, stack, etc */
} environment;

/* A type for pointers to external functions */
typedef void (*funcp)(environment*); /* funcp is a pointer to a void
                                         function (environment *) */

void init_env(environment*);
void printerr(const char*);
extern void toss(environment*);
symbol **hash(hashtbl, const char*);
value* new_val(environment*);
void gc_mark(value*);
void gc_maybe(environment *env);
extern void gc_init(environment*);
void push_val(environment*, value*);
void push_int(environment*, int);
void push_float(environment*, float);
void push_cstring(environment*, const char*);
char *mangle_str(const char*);
extern void mangle(environment*);
void push_sym(environment*, const char*);
extern void nl();
extern void type(environment*);
void print_h(cons*, int);
extern void print_(environment*);
extern void print(environment*);
extern void princ_(environment*);
extern void princ(environment*);
void print_st(cons*, long);
extern void printstack(environment*);
extern void swap(environment*);
extern void rot(environment*);
extern void rcl(environment*);
extern void eval(environment*);
extern void rev(environment*);
extern void pack(environment*);
extern void expand(environment*);
extern void eq(environment*);
extern void not(environment*);
extern void neq(environment*);
extern void def(environment*);
extern void quit(environment*);
extern void clear(environment*);
extern void words(environment*);
void forget_sym(symbol**);
extern void forget(environment*);
extern void errn(environment*);
extern void sx_2b(environment*);
extern void sx_2d(environment*);
extern void sx_3e(environment*);
value *copy_val(environment*, value*);
extern void sx_647570(environment*);
extern void sx_6966(environment*);
extern void ifelse(environment*);
extern void sx_7768696c65(environment*);
extern void sx_666f72(environment*);
extern void to(environment*);
extern void readline(environment*);
extern void sx_72656164(environment*);
extern void foreach(environment*);
void protect(value*);
void unprotect(value*);
extern void copying(environment*);
extern void warranty(environment*);
extern void sx_2a(environment*);
extern void sx_2f(environment*);
extern void mod(environment*);
extern void sx_3c(environment*);
extern void sx_3c3d(environment*);
extern void sx_3e3d(environment*);
extern void sx_646976(environment*);
1	teddy	1.4	/*
2			stack - an interactive interpreter for a stack-based language
3			Copyright (C) 2002 Mats Alritzson and Teddy Hogeborn
4
5			This program is free software; you can redistribute it and/or modify
6			it under the terms of the GNU General Public License as published by
7			the Free Software Foundation; either version 2 of the License, or
8			(at your option) any later version.
9
10			This program is distributed in the hope that it will be useful,
11			but WITHOUT ANY WARRANTY; without even the implied warranty of
12			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			GNU General Public License for more details.
14
15			You should have received a copy of the GNU General Public License
16			along with this program; if not, write to the Free Software
17			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19			Authors: Mats Alritzson <masse@fukt.bth.se>
20			Teddy Hogeborn <teddy@fukt.bth.se>
21			*/
22	teddy	1.1
23			#define HASHTBLSIZE 2048
24
25			/* First, define some types. */
26
27	masse	1.10	struct cons_struct;
28
29	teddy	1.1	/* A value of some type */
30			typedef struct {
31			enum {
32			integer,
33	masse	1.5	tfloat,
34	teddy	1.1	string,
35			func, /* Function pointer */
36			symb,
37	masse	1.10	tcons
38	masse	1.5	} type:4; /* Type of stack element */
39	masse	1.2
40	teddy	1.9	union {
41			struct {
42			unsigned int mark:1;
43			unsigned int protect:1;
44			} flag;
45			unsigned int no_gc:2;
46			} gc;
47	teddy	1.1
48			union {
49	masse	1.10	struct cons_struct *c;
50	teddy	1.1	void ptr; / Pointer to the content */
51	masse	1.5	int i; /* ...or an integer */
52			float f;
53	teddy	1.1	} content; /* Stores a pointer or an integer */
54
55			} value;
56
57	masse	1.10	/* An item (value) on a stack */
58			typedef struct stackitem_struct
59			{
60			value item; / The value on the stack */
61			/* (This is never NULL) */
62			struct stackitem_struct next; / Next item */
63			} stackitem;
64
65			typedef struct cons_struct {
66			value *car;
67			value *cdr;
68			} cons;
69
70	teddy	1.1	/* A symbol with a name and possible value */
71			/* (These do not need reference counters, they are kept unique by
72			hashing.) */
73			typedef struct symbol_struct {
74			char id; / Symbol name */
75			value val; / The value (if any) bound to it */
76			struct symbol_struct next; / In case of hashing conflicts, a */
77			} symbol; /* symbol is a kind of stack item. */
78
79			/* A type for a hash table for symbols */
80			typedef symbol hashtbl[HASHTBLSIZE]; / Hash table declaration */
81
82			/* An environment; gives access to the stack and a hash table of
83			defined symbols */
84			typedef struct {
85			stackitem *gc_ref;
86			int gc_limit, gc_count;
87
88	masse	1.10	cons head; / Head of the stack */
89	teddy	1.1	hashtbl symbols; /* Hash table of all variable bindings */
90			int err; /* Error flag */
91			char in_string; / Input pending to be read */
92			char free_string; / Free this string when all input is
93	teddy	1.4	read from in_string */
94	teddy	1.1	FILE inputstream; / stdin or a file, most likely */
95			int interactive; /* print prompts, stack, etc */
96			} environment;
97
98			/* A type for pointers to external functions */
99	masse	1.2	typedef void (funcp)(environment); /* funcp is a pointer to a void
100	teddy	1.1	function (environment ) /
101
102	masse	1.2	void init_env(environment*);
103			void printerr(const char*);
104			extern void toss(environment*);
105			symbol *hash(hashtbl, const char);
106			value* new_val(environment*);
107			void gc_mark(value*);
108	teddy	1.7	void gc_maybe(environment *env);
109	masse	1.2	extern void gc_init(environment*);
110			void push_val(environment, value);
111			void push_int(environment*, int);
112	masse	1.5	void push_float(environment*, float);
113	masse	1.2	void push_cstring(environment, const char);
114			char mangle_str(const char);
115			extern void mangle(environment*);
116			void push_sym(environment, const char);
117	teddy	1.1	extern void nl();
118	masse	1.2	extern void type(environment*);
119	masse	1.10	void print_h(cons*, int);
120	masse	1.2	extern void print_(environment*);
121			extern void print(environment*);
122			extern void princ_(environment*);
123			extern void princ(environment*);
124	masse	1.10	void print_st(cons*, long);
125	masse	1.2	extern void printstack(environment*);
126			extern void swap(environment*);
127			extern void rot(environment*);
128			extern void rcl(environment*);
129			extern void eval(environment*);
130			extern void rev(environment*);
131			extern void pack(environment*);
132			extern void expand(environment*);
133			extern void eq(environment*);
134			extern void not(environment*);
135			extern void neq(environment*);
136			extern void def(environment*);
137			extern void quit(environment*);
138			extern void clear(environment*);
139			extern void words(environment*);
140			void forget_sym(symbol**);
141			extern void forget(environment*);
142			extern void errn(environment*);
143			extern void sx_2b(environment*);
144			extern void sx_2d(environment*);
145			extern void sx_3e(environment*);
146			value copy_val(environment, value*);
147			extern void sx_647570(environment*);
148			extern void sx_6966(environment*);
149			extern void ifelse(environment*);
150			extern void sx_7768696c65(environment*);
151			extern void sx_666f72(environment*);
152			extern void to(environment*);
153			extern void readline(environment*);
154			extern void sx_72656164(environment*);
155			extern void foreach(environment*);
156	masse	1.8	void protect(value*);
157			void unprotect(value*);
158	masse	1.5	extern void copying(environment*);
159			extern void warranty(environment*);
160			extern void sx_2a(environment*);
161			extern void sx_2f(environment*);
162			extern void mod(environment*);
163			extern void sx_3c(environment*);
164			extern void sx_3c3d(environment*);
165			extern void sx_3e3d(environment*);
166	masse	1.6	extern void sx_646976(environment*);