Debian Codegraph @

regina_t.h

raw
1 /*
2 * The Regina Rexx Interpreter
3 * Copyright (C) 1992-1994 Anders Christensen <[email protected]>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library 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 GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the Free
17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 #ifndef REGINA_TYPES_H_INCLUDED
20 #define REGINA_TYPES_H_INCLUDED
21
22 typedef struct varbox *variableptr ;
23 typedef const struct varbox *cvariableptr ;
24
25 /*
26 * var_hashtable is a table with size entries. The entries are added according
27 * to their hash value.
28 * r is the number of read accesses.
29 * w is the number of write accesses.
30 * c is the number of collisions on access or while creating/copying the table.
31 * e is the number of true elements in the tbl, hashed to size buckets.
32 * Note that tbl contains one more hidden element used for variable
33 * maintenance if size > 0.
34 */
35 typedef struct {
36 variableptr *tbl;
37 unsigned reads;
38 unsigned writes;
39 unsigned collisions;
40 unsigned elements;
41 unsigned size;
42 } var_hashtable;
43
44 typedef struct varbox {
45 var_hashtable *index;
46 variableptr next, prev, realbox ;
47 struct strengtype *name, *value ;
48 int guard ;
49 num_descr *num ;
50 int flag ;
51 unsigned hash ;
52 long hwired, valid ; /* FGC: at least valid may be too small for many
53 recursions with short instead of long.
54 27.09.98 (09/27/98). */
55 variableptr stem ;
56 } variable ;
57
58 /* typedef int bool ; */
59
60 typedef struct {
61 unsigned int lnum:1 ; /* left side of comparison is a number or string constant */
62 unsigned int rnum:1 ; /* right side of comparison is a number or string constant */
63 unsigned int lsvar:1 ; /* left side of comparison is a simple variable */
64 unsigned int rsvar:1 ; /* right side of comparison is a simple variable */
65 unsigned int lcvar:1 ; /* left side of comparison is a compound variable */
66 unsigned int rcvar:1 ; /* right side of comparison is a compound variable */
67 } compflags ;
68
69 typedef enum {
70 awtUNKNOWN = 0,
71 awtSTREAM = 1,
72 awtSTEM = 2,
73 awtLIFO = 3,
74 awtFIFO = 4
75 } AddressWithType;
76
77 typedef enum {
78 antUNKNOWN = 0,
79 antSTRING = 1,
80 antSIMSYMBOL = 2
81 } AddressNameType;
82
83 typedef enum {
84 fpdRETAIN = 0,
85 fpdCLEAR = 1
86 } FilePtrDisposition;
87
88 typedef struct {
89 unsigned int append:1;
90 unsigned int isinput:1;
91 unsigned int iserror:1;
92 unsigned int awt:3; /* overlay with AddressWithType */
93 unsigned int ant:2; /* overlay with AddressNameType */
94 unsigned int noeol:1; /* for INPUT NOEOL */
95 } outputflags; /* used by ADDRESS WITH resourceo */
96
97 typedef enum {
98 PROTECTED_DelayedScriptExit,
99 PROTECTED_DelayedInterpreterExit,
100 PROTECTED_DelayedRexxSignal
101 } delayed_error_type_t;
102
103 typedef enum {
104 QisUnused,
105 QisSESSION,
106 QisInternal,
107 QisExternal,
108 QisTemp
109 } queue_type_t ;
110
111 typedef struct {
112 time_t sec ;
113 time_t usec ;
114 } rexx_time;
115
116 struct _tsd_t; /* If this won't work change "struct _tsd_t *" to "void *"
117 * below. This will require more changes. Let your compiler
118 * choose the places.
119 */
120
121 typedef struct pparambox *paramboxptr ;
122 typedef const struct pparambox *cparamboxptr ;
123 typedef struct pparambox {
124 paramboxptr next ;
125 int dealloc ;
126 struct strengtype *value ;
127 } parambox ;
128
129 typedef struct tnode {
130 unsigned int type ;
131 int charnr, lineno ;
132 union { /* saves memory which is really needed */
133 int called; /* used during execution *and* don't need init */
134 struct tnode *last; /* used during parsing */
135 } o ;
136 struct strengtype *name ;
137 rexx_time *now ;
138 struct tnode *p[4] ;
139 union {
140 /*
141 * WARNING: When changing check whether to modify dumptree and the
142 * whole instore stuff. Seek for X_CEXPRLIST.
143 */
144 streng *(*func)(struct _tsd_t *,cparamboxptr) ;
145 streng *strng ;
146 struct tnode *node ;
147 num_descr *number ;
148 compflags flags ;
149 variable *varbx ;
150 outputflags of ;
151 int parseflags ;
152 int nonansi ;
153 int trace_only ; /* For labels */
154 } u ;
155 struct tnode *next ;
156 unsigned long nodeindex ; /* for an effectiv relocation, never change! */
157 } treenode ;
158 typedef struct tnode *nodeptr ;
159 typedef const struct tnode *cnodeptr ;
160
161 typedef struct lineboxx *lineboxptr ;
162 typedef const struct lineboxx *clineboxptr ;
163 typedef struct lineboxx {
164 lineboxptr next, prev ;
165 struct strengtype *line ;
166 int lineno ;
167 } linebox ;
168
169 typedef struct labelboxx *labelboxptr ;
170 typedef const struct labelboxx *clabelboxptr ;
171 typedef struct labelboxx {
172 labelboxptr next ;
173 unsigned long hash ;
174 nodeptr entry ;
175 } labelbox ;
176
177 typedef struct trap_type /* index is type of signal */
178 {
179 unsigned int on_off:1 ; /* true if trap is active/on */
180 /* unsigned int trapped:1 ; */ /* true if condition has been raised */
181 unsigned int def_act:1 ; /* true if default action is to ignore */
182 unsigned int delayed:1 ; /* true if trap is in delay mode */
183 unsigned int ignored:1 ; /* true if ignored when in delayed mode */
184 unsigned int invoked:1 ; /* true if invoked by SIGNAL */
185 streng *name ; /* label to transfer control to */
186 } trap ;
187
188 typedef struct sig_type
189 {
190 int type ;
191 streng *info ;
192 streng *descr ;
193 int invoke ; /* is true if invoked with SIGNAL */
194 int rc, subrc, lineno ;
195 } sigtype ;
196
197 typedef void (*signal_handler)(int);
198
199 typedef struct __regina_option
200 {
201 char *name ;
202 int offset ;
203 char *contains ;
204 } option_type ;
205
206 typedef struct _StackLine {
207 /* A stack line is a double linked list element of a streng. The streng
208 * never contains a line end and is never NULL.
209 * A read operations will happen at the top end, as well as a LIFO
210 * operation.
211 * A FIFO operation will happen at the bottom end.
212 */
213 struct _StackLine *higher ;
214 struct _StackLine *lower ;
215 streng *contents ;
216 } StackLine ;
217
218 typedef struct _Buffer {
219 /* A buffer is a double linked list of stack line bundles.
220 * MAKEBUF() adds a new buffer at the newest end.
221 */
222 struct _Buffer *higher ;
223 struct _Buffer *lower ;
224
225 /* The "content" of the buffer. See StackLine for a description.
226 * For a faster response of QUEUED(), we count the elements of lines.
227 */
228 StackLine *top ;
229 StackLine *bottom ;
230 unsigned elements ;
231 } Buffer ;
232
233 typedef struct {
234 /* A queue is one of different implementations of queue types.
235 * See the picture and the description at the beginning of stack.c.
236 */
237 queue_type_t type;
238 union {
239 struct { /* internal or SESSION: i */
240 /* name is the uppercased name of the queue. In rare cases this
241 * may be NULL for QisSESSION after initialisation.
242 */
243 streng *name ;
244 /*
245 * Indicates if the queue is a "real" queue
246 * or a false queue as a result of a rxqueue('set', 'qname')
247 * on a queue that doesn't exist. This is crap behaviour!
248 * but that's how Object Rexx works :-(
249 */
250 int isReal ;
251 /*
252 * Content: We have a double linked list of buffers. See Buffer
253 * for a description.
254 */
255 Buffer *top ;
256 Buffer *bottom ;
257
258 /* This is the count of buffers including the zeroth buffer */
259 unsigned buffers ;
260
261 /* This is the overall count of elements in all buffers */
262 unsigned elements ;
263 } i ;
264 struct { /* external: e */
265 /*
266 * The port number for the current connection to an external rxstack
267 * Valid values: 1..0xFFFF, unused: 0
268 */
269 int portno;
270 /*
271 * The socket fd for the current connection to an external rxstack
272 * Valid values: not -1, unused/error: -1
273 */
274 int socket;
275 /*
276 * The server address of the current connection. Used to determine if
277 * we need to disconnect from one rxstack server and connect to
278 * another.
279 * The true data type is a 32 bit system depending type.
280 * Valid values: not 0, unused: 0
281 */
282 int address;
283 /*
284 * A boolean value which indicates if the external queue has had a timeout
285 * set on it via RXQUEUE( 'Timeout' )
286 * Valid values: 0 or 1
287 */
288 int timeoutSet;
289 streng *name;
290 } e ;
291 Buffer t ; /* temp: t */
292 } u ;
293 } Queue ;
294
295 typedef struct { /* one for each redirection in environment */
296 streng *name; /* name if any, but not expanded */
297 outputflags flags;
298 streng *base; /* "number" if name is a stem */
299 streng *currname; /* expanded name + ".number" if name */
300 /* is a stem */
301 int currnamelen; /* len(currname) without ".number"*/
302 int currnum; /* current number for a stem position */
303 /* or -1 if unknown */
304 int maxnum; /* maximum number for a stem position */
305 /* or -1 if unknown */
306 void *file; /* fileboxptr of the file with the */
307 /* above name or NULL. */
308 Queue *queue; /* queue with the above name or NULL. */
309 Queue *tmp_queue;/* temporary queue for the redirection*/
310 /* or NULL without this helper. */
311 unsigned int SameAsOutput:2; /* locally used in shell.c */
312 unsigned int FileRedirected:1; /* locally used in shell.c */
313 char *tempname; /* locally used filename in shell.c */
314 int type; /* locally used source in shell.c */
315 int hdls[3]; /* locally used connection in shell.c */
316 } environpart;
317
318 typedef struct {
319 struct strengtype *name; /* stemname or streamname if any */
320 int subtype; /* SUBENVIR_... */
321 int subcomed; /* has this environment been redirected to an API program via RexxRegistreSubcom???() */
322 environpart input;
323 environpart output;
324 environpart error;
325 } environment;
326
327 typedef struct proclevelbox *proclevel ;
328 typedef const struct proclevelbox *cproclevel ;
329 typedef struct proclevelbox {
330 int numfuzz, currnumsize, numform ;
331 int mathtype ;
332 rexx_time rx_time ;
333 proclevel prev, next ;
334 var_hashtable *vars ;
335 paramboxptr args ;
336 struct strengtype *environment, *prev_env ;
337 char tracestat, traceint, varflag ; /* MDW 30012002 */
338 sigtype *sig ;
339 trap *traps ;
340 jmp_buf *signal_continue; /* see jump_rexx_signal() */
341 unsigned long options;
342 int pool;
343 } proclevbox ;
344
345 typedef struct _ttree { /* bucket list of treenodes which allows ultra fast
346 * loading of instore macros.
347 */
348 struct _ttree *next;
349 unsigned long max; /* maximum number of elements in the bucket */
350 unsigned long num; /* current number of elements in the bucket */
351 unsigned long sum; /* sum of indices until element 0 */
352 treenode * elems;
353 } ttree; /* treenode type */
354
355 typedef struct { /* offsrcline: offset based source lines */
356 unsigned long length;
357 unsigned long offset;
358 /* That's all. You need the source string of the incore macro to create
359 * a real sourceline using this information.
360 */
361 } offsrcline;
362
363 typedef struct _otree { /* bucket list of offscrlines which allows ultra fast
364 * loading of instore macros.
365 */
366 struct _otree *next;
367 unsigned long max; /* maximum number of elements in the bucket */
368 unsigned long num; /* current number of elements in the bucket */
369 unsigned long sum; /* sum of indices until element 0 */
370 offsrcline * elems;
371 } otree; /* offsrcline type */
372
373 typedef struct { /* internal_parser_type is a structure containing data from a
374 * parsing operation.
375 */
376 lineboxptr first_source_line; /* Either this two values */
377 lineboxptr last_source_line ; /* exist or srclines below */
378 int tline; /* line number where error occurred */
379 int tstart; /* column number where error occurred */
380 int if_linenr; /* line number of last IF keyword */
381 int when_linenr; /* line number of last WHEN keyword */
382 int select_linenr; /* line number of last SELECT keyword */
383 labelboxptr first_label;
384 labelboxptr last_label;
385 unsigned long numlabels;
386 labelboxptr sort_labels ;
387 int result;
388 nodeptr root;
389 ttree * nodes;
390 otree * srclines; /* Either this two values exist */
391 const char * incore_source; /* or the two values above */
392 streng * kill; /* Probably the true source of incore_source in case
393 * of an "INTERPRET" instruction or other not user
394 * generated but interpreted strings; else NULL.
395 */
396 struct _tsd_t *TSD; /* needed during the parsing step */
397 } internal_parser_type;
398
399 typedef struct { /* extstring: external (instore) string */
400 unsigned long length;
401 /* and directly following the string's content */
402 } extstring;
403
404 typedef struct { /* external_parser_type: the instore macro in user space */
405 /* Never change from here until source including since it allows the
406 * reconstruction of the source if the machine type or Regina version
407 * doesn't match.
408 */
409 char Magic[32]; /* "Regina's Internal Format\r\n" filled with 0 */
410 #define MAGIC "Regina's Internal Format\r\n"
411 char ReginaVersion[64]; /* PARSE_VERSION_STRING */
412
413 /* The following structure allows the detection of different
414 * architectures. We don't want to try to decode something from
415 * a 64 bit big endian encoded parsing tree on an i586 for
416 * example.
417 */
418 union {
419 char ignore[4 * 256/8]; /* Allow 256 bit machines */
420 struct {
421 unsigned long one; /* value one */
422 unsigned long two; /* value two */
423 void * ptr3; /* value (void*)3, size may be different to unsigned */
424 void * ptr4; /* value (void*)4 */
425 } s;
426 } arch_detector;
427
428 unsigned long OverallSize; /* in byte of this structure and all dependencies */
429
430 unsigned long version; /* INSTORE_VERSION */
431
432 /* We describe the sourcelines first */
433 unsigned long NumberOfSourceLines;
434 unsigned long source;
435 /* Offset to table of source lines. Imagine a value of 1000 and
436 * 5 source lines (previous value). This structure has an address
437 * of 500 in the memory (what you get from malloc or something else).
438 * Then: The table has 5 entries at position 1500 in memory.
439 * Each table entry is an offsrcline structure. The source string is the
440 * instore[0] string of RexxStart or another source string.
441 */
442
443 unsigned long NumberOfTreeElements;
444 unsigned long TreeStart; /* Within 0 .. (NumberOfTreeElements-1) */
445 unsigned long tree;
446 /* Offset to table of nodes. Imagine a value of 2000 and
447 * 6 elements (NumberIfTreeElements). This structure has an address
448 * of 500 in the memory (what you get from malloc or something else).
449 * Then: The table has 6 treenodes at position 2500 in memory.
450 * Each table entry (treenode) must be relocated. Every nodeptr within a
451 * element is just an index within this table. If node->p[2] of one picked
452 * table entry is ((nodeptr) 4) then the address is calculated as follows:
453 * 500 + tree + (4*sizeof(treenode))
454 * This value should be assigned to node->p[2] to use the value in its
455 * normal manner.
456 * A NULL value is represented by (nodeptr) (unsigned) -1.
457 * Every string within a treenode is relocated by adding 500. Imagine a
458 * value of 3000 for node->name. Then an extstring structure is located
459 * at 3500 in memory which represents the string's content.
460 */
461 } external_parser_type;
462
463 typedef struct systeminfobox *sysinfo ;
464 typedef const struct systeminfobox *csysinfo ;
465 typedef struct systeminfobox {
466 struct strengtype *input_file ; /* must be 0-terminated without counting of the '\0' */
467 streng *environment ;
468 FILE *input_fp;
469 int tracing ;
470 int interactive ;
471 jmp_buf *script_exit; /* see jump_script_exit() */
472 streng *result ;
473 proclevbox *currlevel0 ;
474 struct systeminfobox *previous ;
475 nodeptr *callstack ;
476 int cstackcnt, cstackmax ;
477 int hooks ;
478 int invoked ;
479 int trace_override;
480 internal_parser_type tree;
481 int ctrlcounter;
482 } sysinfobox ;
483
484 #ifndef DONT_TYPEDEF_PFN
485 typedef unsigned long (*PFN)() ;
486 #endif
487
488
489 struct library {
490 streng *name;
491 void *handle;
492 unsigned long used;
493
494 struct library *next, *prev;
495 };
496
497
498 struct entry_point {
499 streng *name;
500 PFN addr;
501 union {
502 void *gci_info; /* for function handlers */
503 unsigned char user_area[8]; /* for suncommand and exit handlers */
504 } special;
505
506 unsigned long hash;
507 struct library *lib;
508 struct entry_point *next, *prev;
509 };
510
511 /*
512 * Every major OS has some functionality that isn't shared with others.
513 * Most functions relate to the command execution/redirection stuff.
514 * The global function collection *OS_Dep will point to this structure.
515 * Some systems, Win9x and OS/2-EMX, even use the DOS entry table because
516 * they can't take advantage of the performance functions the system
517 * usually provides.
518 * init() may map some "stupid" function on advanced function, as for
519 * instance Win9x doesn't support redirection correctly.
520 */
521 struct _tsd_t;
522 struct regina_utsname;
523 typedef struct _OS_Dep_funcs {
524 void (*init) (void);
525 int (*setenv_exec) (const char *name, const char *value);
526 int (*fork_exec) (struct _tsd_t *TSD, environment *env, const char *cmdline, int *rc);
527 int (*wait_exec) (int process);
528 int (*open_subprocess_connection) (const struct _tsd_t *TSD, environpart *ep);
529 void (*unblock_handle) (int *handle, void *async_info);
530 void (*restart_file) (int hdl);
531 int (*close_exec) (int handle, void *async_info);
532 void (*close_special) (int handle);
533 int (*read_exec) (int hdl, void *buf, unsigned size, void *async_info) ;
534 int (*write_exec) (int hdl, const void *buf, unsigned size, void *async_info);
535 void* (*create_async_info) (const struct _tsd_t *TSD);
536 void (*delete_async_info) (void *async_info);
537 void (*reset_async_info) (void *async_info);
538 void (*add_async_waiter) (void *async_info, int handle, int add_as_read_handle);
539 void (*wait_async_info) (void *async_info);
540 int (*uname_exec) (struct regina_utsname *name);
541 } OS_Dep_funcs;
542
543 #include "regina64.h"
544
545
546 #endif /* REGINA_TYPES_H_INCLUDED */