gpgscm: Fix compact vector encoding.
[gnupg.git] / tests / gpgscm / scheme-private.h
1 /* scheme-private.h */
2
3 #ifndef _SCHEME_PRIVATE_H
4 #define _SCHEME_PRIVATE_H
5
6 #include <stdint.h>
7 #include "scheme.h"
8 /*------------------ Ugly internals -----------------------------------*/
9 /*------------------ Of interest only to FFI users --------------------*/
10
11 #ifdef __cplusplus
12 extern "C" {
13 #endif
14
15 enum scheme_port_kind {
16   port_free=0,
17   port_file=1,
18   port_string=2,
19   port_srfi6=4,
20   port_input=16,
21   port_output=32,
22   port_saw_EOF=64
23 };
24
25 typedef struct port {
26   unsigned char kind;
27   union {
28     struct {
29       FILE *file;
30       int closeit;
31     } stdio;
32     struct {
33       char *start;
34       char *past_the_end;
35       char *curr;
36     } string;
37   } rep;
38 #if SHOW_ERROR_LINE
39   pointer curr_line;
40   pointer filename;
41 #endif
42 } port;
43
44 /* cell structure */
45 struct cell {
46   uintptr_t _flag;
47   union {
48     struct {
49       char   *_svalue;
50       int   _length;
51     } _string;
52     num _number;
53     port *_port;
54     foreign_func _ff;
55     struct {
56       struct cell *_car;
57       struct cell *_cdr;
58     } _cons;
59     struct {
60       size_t _length;
61       pointer _elements[0];
62     } _vector;
63     struct {
64          char *_data;
65          const foreign_object_vtable *_vtable;
66     } _foreign_object;
67   } _object;
68 };
69
70 #if USE_HISTORY
71 /* The history is a two-dimensional ring buffer.  A donut-shaped data
72  * structure.  This data structure is inspired by MIT/GNU Scheme.  */
73 struct history {
74   /* Number of calls to store.  Must be a power of two.  */
75   size_t N;
76
77   /* Number of tail-calls to store in each call frame.  Must be a
78    * power of two.  */
79   size_t M;
80
81   /* Masks for fast index calculations.  */
82   size_t mask_N;
83   size_t mask_M;
84
85   /* A vector of size N containing calls.  */
86   pointer callstack;
87
88   /* A vector of size N containing vectors of size M containing tail
89    * calls.  */
90   pointer tailstacks;
91
92   /* Our current position.  */
93   size_t n;
94   size_t *m;
95 };
96 #endif
97
98 struct scheme {
99 /* arrays for segments */
100 func_alloc malloc;
101 func_dealloc free;
102
103 /* return code */
104 int retcode;
105 int tracing;
106
107
108 #ifndef CELL_SEGSIZE
109 #define CELL_SEGSIZE    5000  /* # of cells in one segment */
110 #endif
111 #ifndef CELL_NSEGMENT
112 #define CELL_NSEGMENT   10    /* # of segments for cells */
113 #endif
114 void *alloc_seg[CELL_NSEGMENT];
115 pointer cell_seg[CELL_NSEGMENT];
116 int     last_cell_seg;
117
118 /* We use 4 registers. */
119 pointer args;            /* register for arguments of function */
120 pointer envir;           /* stack register for current environment */
121 pointer code;            /* register for current code */
122 pointer dump;            /* stack register for next evaluation */
123
124 #if USE_HISTORY
125 struct history history;  /* we keep track of the call history for
126                           * error messages */
127 #endif
128
129 int interactive_repl;    /* are we in an interactive REPL? */
130
131 struct cell _sink;
132 pointer sink;            /* when mem. alloc. fails */
133 struct cell _NIL;
134 pointer NIL;             /* special cell representing empty cell */
135 struct cell _HASHT;
136 pointer T;               /* special cell representing #t */
137 struct cell _HASHF;
138 pointer F;               /* special cell representing #f */
139 struct cell _EOF_OBJ;
140 pointer EOF_OBJ;         /* special cell representing end-of-file object */
141 pointer oblist;          /* pointer to symbol table */
142 pointer global_env;      /* pointer to global environment */
143 pointer c_nest;          /* stack for nested calls from C */
144
145 /* global pointers to special symbols */
146 pointer LAMBDA;               /* pointer to syntax lambda */
147 pointer QUOTE;           /* pointer to syntax quote */
148
149 pointer QQUOTE;               /* pointer to symbol quasiquote */
150 pointer UNQUOTE;         /* pointer to symbol unquote */
151 pointer UNQUOTESP;       /* pointer to symbol unquote-splicing */
152 pointer FEED_TO;         /* => */
153 pointer COLON_HOOK;      /* *colon-hook* */
154 pointer ERROR_HOOK;      /* *error-hook* */
155 pointer SHARP_HOOK;  /* *sharp-hook* */
156 #if USE_COMPILE_HOOK
157 pointer COMPILE_HOOK;  /* *compile-hook* */
158 #endif
159
160 #if USE_SMALL_INTEGERS
161 /* A fixed allocation of small integers.  */
162 void *integer_alloc;
163 pointer integer_cells;
164 #endif
165
166 pointer free_cell;       /* pointer to top of free cells */
167 long    fcells;          /* # of free cells */
168 size_t  inhibit_gc;      /* nesting of gc_disable */
169 size_t  reserved_cells;  /* # of reserved cells */
170 #ifndef NDEBUG
171 int     reserved_lineno;   /* location of last reservation */
172 #endif
173
174 pointer inport;
175 pointer outport;
176 pointer save_inport;
177 pointer loadport;
178
179 #ifndef MAXFIL
180 #define MAXFIL 64
181 #endif
182 port load_stack[MAXFIL];     /* Stack of open files for port -1 (LOADing) */
183 int nesting_stack[MAXFIL];
184 int file_i;
185 int nesting;
186
187 char    gc_verbose;      /* if gc_verbose is not zero, print gc status */
188 char    no_memory;       /* Whether mem. alloc. has failed */
189
190 #ifndef LINESIZE
191 #define LINESIZE 1024
192 #endif
193 char    linebuff[LINESIZE];
194 #ifndef STRBUFFSIZE
195 #define STRBUFFSIZE 256
196 #endif
197 char    *strbuff;
198 size_t strbuff_size;
199 FILE *tmpfp;
200 int tok;
201 int print_flag;
202 pointer value;
203 int op;
204 unsigned int flags;
205
206 void *ext_data;     /* For the benefit of foreign functions */
207 long gensym_cnt;
208
209 struct scheme_interface *vptr;
210 };
211
212 /* operator code */
213 enum scheme_opcodes {
214 #define _OP_DEF(A,B,C,D,E,OP) OP,
215 #include "opdefines.h"
216   OP_MAXDEFINED
217 };
218
219
220 #define cons(sc,a,b) _cons(sc,a,b,0)
221 #define immutable_cons(sc,a,b) _cons(sc,a,b,1)
222
223 int is_string(pointer p);
224 char *string_value(pointer p);
225 int is_number(pointer p);
226 num nvalue(pointer p);
227 long ivalue(pointer p);
228 double rvalue(pointer p);
229 int is_integer(pointer p);
230 int is_real(pointer p);
231 int is_character(pointer p);
232 long charvalue(pointer p);
233 int is_vector(pointer p);
234
235 int is_port(pointer p);
236
237 int is_pair(pointer p);
238 pointer pair_car(pointer p);
239 pointer pair_cdr(pointer p);
240 pointer set_car(pointer p, pointer q);
241 pointer set_cdr(pointer p, pointer q);
242
243 int is_symbol(pointer p);
244 char *symname(pointer p);
245 int hasprop(pointer p);
246
247 int is_syntax(pointer p);
248 int is_proc(pointer p);
249 int is_foreign(pointer p);
250 char *syntaxname(pointer p);
251 int is_closure(pointer p);
252 #ifdef USE_MACRO
253 int is_macro(pointer p);
254 #endif
255 pointer closure_code(pointer p);
256 pointer closure_env(pointer p);
257
258 int is_continuation(pointer p);
259 int is_promise(pointer p);
260 int is_environment(pointer p);
261 int is_immutable(pointer p);
262 void setimmutable(pointer p);
263
264 int is_foreign_object(pointer p);
265 const foreign_object_vtable *get_foreign_object_vtable(pointer p);
266 void *get_foreign_object_data(pointer p);
267
268 #ifdef __cplusplus
269 }
270 #endif
271
272 #endif
273
274 /*
275 Local variables:
276 c-file-style: "k&r"
277 End:
278 */