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