summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMike Blumenkrantz <zmike@osg.samsung.com>2016-02-22 12:16:16 -0500
committerMike Blumenkrantz <zmike@osg.samsung.com>2016-02-22 18:29:01 -0500
commit3af1a8af1e76701d2204a8b3307cd80abce47efc (patch)
treece512b1ac6e86afb66ebb15eb3a45b731ac423ed
parenta0ad57bb16545c2aa5b1a153c97e0ca1b675e6b9 (diff)
embryo: reformat the whole thing
so many tabs
-rw-r--r--src/lib/embryo/embryo_amx.c2564
-rw-r--r--src/lib/embryo/embryo_args.c29
-rw-r--r--src/lib/embryo/embryo_float.c95
-rw-r--r--src/lib/embryo/embryo_main.c3
-rw-r--r--src/lib/embryo/embryo_rand.c3
-rw-r--r--src/lib/embryo/embryo_str.c208
-rw-r--r--src/lib/embryo/embryo_time.c62
7 files changed, 1500 insertions, 1464 deletions
diff --git a/src/lib/embryo/embryo_amx.c b/src/lib/embryo/embryo_amx.c
index 6453d38523..e8df24dd97 100644
--- a/src/lib/embryo/embryo_amx.c
+++ b/src/lib/embryo/embryo_amx.c
@@ -20,7 +20,6 @@
20 * 3. This notice may not be removed or altered from any source distribution. 20 * 3. This notice may not be removed or altered from any source distribution.
21 */ 21 */
22 22
23
24#ifdef HAVE_CONFIG_H 23#ifdef HAVE_CONFIG_H
25# include "config.h" 24# include "config.h"
26#endif 25#endif
@@ -38,17 +37,16 @@
38#include "Embryo.h" 37#include "Embryo.h"
39#include "embryo_private.h" 38#include "embryo_private.h"
40 39
41 40#define JUMPABS(base, ip) ((Embryo_Cell *)(code + (*ip)))
42#define JUMPABS(base, ip) ((Embryo_Cell *)(code + (*ip)))
43 41
44#ifdef WORDS_BIGENDIAN 42#ifdef WORDS_BIGENDIAN
45static void _embryo_byte_swap_16 (unsigned short *v); 43static void _embryo_byte_swap_16(unsigned short *v);
46static void _embryo_byte_swap_32 (unsigned int *v); 44static void _embryo_byte_swap_32(unsigned int *v);
47#endif 45#endif
48static int _embryo_native_call (Embryo_Program *ep, Embryo_Cell idx, Embryo_Cell *result, Embryo_Cell *params); 46static int _embryo_native_call(Embryo_Program *ep, Embryo_Cell idx, Embryo_Cell *result, Embryo_Cell *params);
49static int _embryo_func_get (Embryo_Program *ep, int idx, char *funcname); 47static int _embryo_func_get(Embryo_Program *ep, int idx, char *funcname);
50static int _embryo_var_get (Embryo_Program *ep, int idx, char *varname, Embryo_Cell *ep_addr); 48static int _embryo_var_get(Embryo_Program *ep, int idx, char *varname, Embryo_Cell *ep_addr);
51static int _embryo_program_init (Embryo_Program *ep, void *code); 49static int _embryo_program_init(Embryo_Program *ep, void *code);
52 50
53#ifdef WORDS_BIGENDIAN 51#ifdef WORDS_BIGENDIAN
54static void 52static void
@@ -69,28 +67,29 @@ _embryo_byte_swap_32(unsigned int *v)
69 t = s[0]; s[0] = s[3]; s[3] = t; 67 t = s[0]; s[0] = s[3]; s[3] = t;
70 t = s[1]; s[1] = s[2]; s[2] = t; 68 t = s[1]; s[1] = s[2]; s[2] = t;
71} 69}
70
72#endif 71#endif
73 72
74static int 73static int
75_embryo_native_call(Embryo_Program *ep, Embryo_Cell idx, Embryo_Cell *result, Embryo_Cell *params) 74_embryo_native_call(Embryo_Program *ep, Embryo_Cell idx, Embryo_Cell *result, Embryo_Cell *params)
76{ 75{
77 Embryo_Header *hdr; 76 Embryo_Header *hdr;
78 Embryo_Func_Stub *func_entry; 77 Embryo_Func_Stub *func_entry;
79 Embryo_Native f; 78 Embryo_Native f;
80 79
81 hdr = (Embryo_Header *)ep->base; 80 hdr = (Embryo_Header *)ep->base;
82 func_entry = GETENTRY(hdr, natives, idx); 81 func_entry = GETENTRY(hdr, natives, idx);
83 if ((func_entry->address <= 0) || 82 if ((func_entry->address <= 0) ||
84 (func_entry->address > ep->native_calls_size)) 83 (func_entry->address > ep->native_calls_size))
85 { 84 {
86 ep->error = EMBRYO_ERROR_CALLBACK; 85 ep->error = EMBRYO_ERROR_CALLBACK;
87 return ep->error; 86 return ep->error;
88 } 87 }
89 f = ep->native_calls[func_entry->address - 1]; 88 f = ep->native_calls[func_entry->address - 1];
90 if (!f) 89 if (!f)
91 { 90 {
92 ep->error = EMBRYO_ERROR_CALLBACK; 91 ep->error = EMBRYO_ERROR_CALLBACK;
93 return ep->error; 92 return ep->error;
94 } 93 }
95 ep->error = EMBRYO_ERROR_NONE; 94 ep->error = EMBRYO_ERROR_NONE;
96 *result = f(ep, params); 95 *result = f(ep, params);
@@ -100,7 +99,7 @@ _embryo_native_call(Embryo_Program *ep, Embryo_Cell idx, Embryo_Cell *result, Em
100static int 99static int
101_embryo_func_get(Embryo_Program *ep, int idx, char *funcname) 100_embryo_func_get(Embryo_Program *ep, int idx, char *funcname)
102{ 101{
103 Embryo_Header *hdr; 102 Embryo_Header *hdr;
104 Embryo_Func_Stub *func; 103 Embryo_Func_Stub *func;
105 104
106 hdr = (Embryo_Header *)ep->code; 105 hdr = (Embryo_Header *)ep->code;
@@ -115,23 +114,23 @@ _embryo_func_get(Embryo_Program *ep, int idx, char *funcname)
115static int 114static int
116_embryo_var_get(Embryo_Program *ep, int idx, char *varname, Embryo_Cell *ep_addr) 115_embryo_var_get(Embryo_Program *ep, int idx, char *varname, Embryo_Cell *ep_addr)
117{ 116{
118 Embryo_Header *hdr; 117 Embryo_Header *hdr;
119 Embryo_Func_Stub *var; 118 Embryo_Func_Stub *var;
120 119
121 hdr=(Embryo_Header *)ep->base; 120 hdr = (Embryo_Header *)ep->base;
122 if (idx >= (Embryo_Cell)NUMENTRIES(hdr, pubvars, tags)) 121 if (idx >= (Embryo_Cell)NUMENTRIES(hdr, pubvars, tags))
123 return EMBRYO_ERROR_INDEX; 122 return EMBRYO_ERROR_INDEX;
124 123
125 var = GETENTRY(hdr, pubvars, idx); 124 var = GETENTRY(hdr, pubvars, idx);
126 strcpy(varname, GETENTRYNAME(hdr, var)); 125 strcpy(varname, GETENTRYNAME(hdr, var));
127 *ep_addr = var->address; 126 *ep_addr = var->address;
128 return EMBRYO_ERROR_NONE; 127 return EMBRYO_ERROR_NONE;
129} 128}
130 129
131static int 130static int
132_embryo_program_init(Embryo_Program *ep, void *code) 131_embryo_program_init(Embryo_Program *ep, void *code)
133{ 132{
134 Embryo_Header *hdr; 133 Embryo_Header *hdr;
135 134
136 if ((ep->flags & EMBRYO_FLAG_RELOC)) return 1; 135 if ((ep->flags & EMBRYO_FLAG_RELOC)) return 1;
137 ep->code = (unsigned char *)code; 136 ep->code = (unsigned char *)code;
@@ -156,77 +155,77 @@ _embryo_program_init(Embryo_Program *ep, void *code)
156 155
157 if (hdr->magic != EMBRYO_MAGIC) return 0; 156 if (hdr->magic != EMBRYO_MAGIC) return 0;
158 if ((hdr->file_version < MIN_FILE_VERSION) || 157 if ((hdr->file_version < MIN_FILE_VERSION) ||
159 (hdr->ep_version > CUR_FILE_VERSION)) return 0; 158 (hdr->ep_version > CUR_FILE_VERSION)) return 0;
160 if ((hdr->defsize != sizeof(Embryo_Func_Stub)) && 159 if ((hdr->defsize != sizeof(Embryo_Func_Stub)) &&
161 (hdr->defsize != (2 * sizeof(unsigned int)))) return 0; 160 (hdr->defsize != (2 * sizeof(unsigned int)))) return 0;
162 if (hdr->defsize == (2 * sizeof(unsigned int))) 161 if (hdr->defsize == (2 * sizeof(unsigned int)))
163 { 162 {
164 unsigned short *len; 163 unsigned short *len;
165 164
166 len = (unsigned short*)((unsigned char*)ep->code + hdr->nametable); 165 len = (unsigned short *)((unsigned char *)ep->code + hdr->nametable);
167#ifdef WORDS_BIGENDIAN 166#ifdef WORDS_BIGENDIAN
168 embryo_swap_16((unsigned short *)len); 167 embryo_swap_16((unsigned short *)len);
169#endif 168#endif
170 if (*len > sNAMEMAX) return 0; 169 if (*len > sNAMEMAX) return 0;
171 } 170 }
172 if (hdr->stp <= 0) return 0; 171 if (hdr->stp <= 0) return 0;
173 if ((hdr->flags & EMBRYO_FLAG_COMPACT)) return 0; 172 if ((hdr->flags & EMBRYO_FLAG_COMPACT)) return 0;
174 173
175#ifdef WORDS_BIGENDIAN 174#ifdef WORDS_BIGENDIAN
176 { 175 {
177 Embryo_Func_Stub *fs; 176 Embryo_Func_Stub *fs;
178 int i, num; 177 int i, num;
179 178
180 /* also align all addresses in the public function, public variable and */ 179 /* also align all addresses in the public function, public variable and */
181 /* public tag tables */ 180 /* public tag tables */
182 fs = GETENTRY(hdr, publics, 0); 181 fs = GETENTRY(hdr, publics, 0);
183 num = NUMENTRIES(hdr, publics, natives); 182 num = NUMENTRIES(hdr, publics, natives);
184 for (i = 0; i < num; i++) 183 for (i = 0; i < num; i++)
185 { 184 {
186 embryo_swap_32(&(fs->address)); 185 embryo_swap_32(&(fs->address));
187 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize); 186 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
188 } 187 }
189 188
190 fs = GETENTRY(hdr, pubvars, 0); 189 fs = GETENTRY(hdr, pubvars, 0);
191 num = NUMENTRIES(hdr, pubvars, tags); 190 num = NUMENTRIES(hdr, pubvars, tags);
192 for (i = 0; i < num; i++) 191 for (i = 0; i < num; i++)
193 { 192 {
194 embryo_swap_32(&(fs->address)); 193 embryo_swap_32(&(fs->address));
195 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize); 194 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
196 } 195 }
197 196
198 fs = GETENTRY(hdr, tags, 0); 197 fs = GETENTRY(hdr, tags, 0);
199 num = NUMENTRIES(hdr, tags, nametable); 198 num = NUMENTRIES(hdr, tags, nametable);
200 for (i = 0; i < num; i++) 199 for (i = 0; i < num; i++)
201 { 200 {
202 embryo_swap_32(&(fs->address)); 201 embryo_swap_32(&(fs->address));
203 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize); 202 fs = (Embryo_Func_Stub *)((unsigned char *)fs + hdr->defsize);
204 } 203 }
205 } 204 }
206#endif 205#endif
207 ep->flags = EMBRYO_FLAG_RELOC; 206 ep->flags = EMBRYO_FLAG_RELOC;
208 207
209#ifdef WORDS_BIGENDIAN 208#ifdef WORDS_BIGENDIAN
210/* until we do more... this is only used for bigendian */ 209/* until we do more... this is only used for bigendian */
211 { 210 {
212 Embryo_Cell cip, code_size, cip_end; 211 Embryo_Cell cip, code_size, cip_end;
213 Embryo_Cell *code; 212 Embryo_Cell *code;
214 213
215 code_size = hdr->dat - hdr->cod; 214 code_size = hdr->dat - hdr->cod;
216 code = (Embryo_Cell *)((unsigned char *)ep->code + (int)hdr->cod); 215 code = (Embryo_Cell *)((unsigned char *)ep->code + (int)hdr->cod);
217 cip_end = code_size / sizeof(Embryo_Cell); 216 cip_end = code_size / sizeof(Embryo_Cell);
218 for (cip = 0; cip < cip_end; cip++) 217 for (cip = 0; cip < cip_end; cip++)
219 { 218 {
220/* move this here - later we probably want something that verifies opcodes 219/* move this here - later we probably want something that verifies opcodes
221 * are valid and ok... 220 * are valid and ok...
222 */ 221 */
223#ifdef WORDS_BIGENDIAN 222#ifdef WORDS_BIGENDIAN
224 embryo_swap_32(&(code[cip])); 223 embryo_swap_32(&(code[cip]));
225#endif 224#endif
226 } 225 }
227 } 226 }
228#endif 227#endif
229 228
230 /* init native api for handling floating point - default in embryo */ 229 /* init native api for handling floating point - default in embryo */
231 _embryo_args_init(ep); 230 _embryo_args_init(ep);
232 _embryo_fp_init(ep); 231 _embryo_fp_init(ep);
@@ -252,8 +251,8 @@ embryo_program_new(void *data, int size)
252 code_data = malloc(size); 251 code_data = malloc(size);
253 if (!code_data) 252 if (!code_data)
254 { 253 {
255 free(ep); 254 free(ep);
256 return NULL; 255 return NULL;
257 } 256 }
258 memcpy(code_data, data, size); 257 memcpy(code_data, data, size);
259 if (_embryo_program_init(ep, code_data)) return ep; 258 if (_embryo_program_init(ep, code_data)) return ep;
@@ -274,8 +273,8 @@ embryo_program_const_new(void *data, int size)
274 273
275 if (_embryo_program_init(ep, data)) 274 if (_embryo_program_init(ep, data))
276 { 275 {
277 ep->dont_free_code = 1; 276 ep->dont_free_code = 1;
278 return ep; 277 return ep;
279 } 278 }
280 free(ep); 279 free(ep);
281 return NULL; 280 return NULL;
@@ -285,7 +284,7 @@ EAPI Embryo_Program *
285embryo_program_load(const char *file) 284embryo_program_load(const char *file)
286{ 285{
287 Embryo_Program *ep; 286 Embryo_Program *ep;
288 Embryo_Header hdr; 287 Embryo_Header hdr;
289 FILE *f; 288 FILE *f;
290 void *program = NULL; 289 void *program = NULL;
291 int program_size = 0; 290 int program_size = 0;
@@ -297,13 +296,13 @@ embryo_program_load(const char *file)
297 fseek(f, 0L, SEEK_SET); 296 fseek(f, 0L, SEEK_SET);
298 if (program_size < (int)sizeof(Embryo_Header)) 297 if (program_size < (int)sizeof(Embryo_Header))
299 { 298 {
300 fclose(f); 299 fclose(f);
301 return NULL; 300 return NULL;
302 } 301 }
303 if (fread(&hdr, sizeof(Embryo_Header), 1, f) != 1) 302 if (fread(&hdr, sizeof(Embryo_Header), 1, f) != 1)
304 { 303 {
305 fclose(f); 304 fclose(f);
306 return NULL; 305 return NULL;
307 } 306 }
308 fseek(f, 0L, SEEK_SET); 307 fseek(f, 0L, SEEK_SET);
309#ifdef WORDS_BIGENDIAN 308#ifdef WORDS_BIGENDIAN
@@ -313,14 +312,14 @@ embryo_program_load(const char *file)
313 program = malloc(program_size); 312 program = malloc(program_size);
314 if (!program) 313 if (!program)
315 { 314 {
316 fclose(f); 315 fclose(f);
317 return NULL; 316 return NULL;
318 } 317 }
319 if (fread(program, program_size, 1, f) != 1) 318 if (fread(program, program_size, 1, f) != 1)
320 { 319 {
321 free(program); 320 free(program);
322 fclose(f); 321 fclose(f);
323 return NULL; 322 return NULL;
324 } 323 }
325 ep = embryo_program_new(program, program_size); 324 ep = embryo_program_new(program, program_size);
326 free(program); 325 free(program);
@@ -338,22 +337,21 @@ embryo_program_free(Embryo_Program *ep)
338 if (ep->native_calls) free(ep->native_calls); 337 if (ep->native_calls) free(ep->native_calls);
339 for (i = 0; i < ep->params_size; i++) 338 for (i = 0; i < ep->params_size; i++)
340 { 339 {
341 if (ep->params[i].string) free(ep->params[i].string); 340 if (ep->params[i].string) free(ep->params[i].string);
342 if (ep->params[i].cell_array) free(ep->params[i].cell_array); 341 if (ep->params[i].cell_array) free(ep->params[i].cell_array);
343 } 342 }
344 if (ep->params) free(ep->params); 343 if (ep->params) free(ep->params);
345 free(ep); 344 free(ep);
346} 345}
347 346
348
349EAPI void 347EAPI void
350embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell (*func) (Embryo_Program *ep, Embryo_Cell *params)) 348embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell (*func)(Embryo_Program *ep, Embryo_Cell *params))
351{ 349{
352 Embryo_Func_Stub *func_entry; 350 Embryo_Func_Stub *func_entry;
353 Embryo_Header *hdr; 351 Embryo_Header *hdr;
354 int i, num; 352 int i, num;
355 353
356 if ((!ep ) || (!name) || (!func)) return; 354 if ((!ep) || (!name) || (!func)) return;
357 if (strlen(name) > sNAMEMAX) return; 355 if (strlen(name) > sNAMEMAX) return;
358 356
359 hdr = (Embryo_Header *)ep->code; 357 hdr = (Embryo_Header *)ep->code;
@@ -364,44 +362,43 @@ embryo_program_native_call_add(Embryo_Program *ep, const char *name, Embryo_Cell
364 ep->native_calls_size++; 362 ep->native_calls_size++;
365 if (ep->native_calls_size > ep->native_calls_alloc) 363 if (ep->native_calls_size > ep->native_calls_alloc)
366 { 364 {
367 Embryo_Native *calls; 365 Embryo_Native *calls;
368 366
369 ep->native_calls_alloc += 32; 367 ep->native_calls_alloc += 32;
370 calls = realloc(ep->native_calls, 368 calls = realloc(ep->native_calls,
371 ep->native_calls_alloc * sizeof(Embryo_Native)); 369 ep->native_calls_alloc * sizeof(Embryo_Native));
372 if (!calls) 370 if (!calls)
373 { 371 {
374 ep->native_calls_size--; 372 ep->native_calls_size--;
375 ep->native_calls_alloc -= 32; 373 ep->native_calls_alloc -= 32;
376 return; 374 return;
377 } 375 }
378 ep->native_calls = calls; 376 ep->native_calls = calls;
379 } 377 }
380 ep->native_calls[ep->native_calls_size - 1] = func; 378 ep->native_calls[ep->native_calls_size - 1] = func;
381 379
382 func_entry = GETENTRY(hdr, natives, 0); 380 func_entry = GETENTRY(hdr, natives, 0);
383 for (i = 0; i < num; i++) 381 for (i = 0; i < num; i++)
384 { 382 {
385 if (func_entry->address == 0) 383 if (func_entry->address == 0)
386 { 384 {
387 char *entry_name; 385 char *entry_name;
388 386
389 entry_name = GETENTRYNAME(hdr, func_entry); 387 entry_name = GETENTRYNAME(hdr, func_entry);
390 if ((entry_name) && (!strcmp(entry_name, name))) 388 if ((entry_name) && (!strcmp(entry_name, name)))
391 { 389 {
392 func_entry->address = ep->native_calls_size; 390 func_entry->address = ep->native_calls_size;
393 /* FIXME: embryo_cc is putting in multiple native */ 391 /* FIXME: embryo_cc is putting in multiple native */
394 /* function call entries - so we need to fill in all */ 392 /* function call entries - so we need to fill in all */
395 /* of them!!! */ 393 /* of them!!! */
396 /* return; */ 394 /* return; */
397 } 395 }
398 } 396 }
399 func_entry = 397 func_entry =
400 (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize); 398 (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr->defsize);
401 } 399 }
402} 400}
403 401
404
405EAPI void 402EAPI void
406embryo_program_vm_reset(Embryo_Program *ep) 403embryo_program_vm_reset(Embryo_Program *ep)
407{ 404{
@@ -427,15 +424,15 @@ embryo_program_vm_push(Embryo_Program *ep)
427 ep->pushes++; 424 ep->pushes++;
428 if (ep->pushes > 1) 425 if (ep->pushes > 1)
429 { 426 {
430 embryo_program_vm_reset(ep); 427 embryo_program_vm_reset(ep);
431 return; 428 return;
432 } 429 }
433 hdr = (Embryo_Header *)ep->code; 430 hdr = (Embryo_Header *)ep->code;
434 ep->base = calloc(1, hdr->stp); 431 ep->base = calloc(1, hdr->stp);
435 if (!ep->base) 432 if (!ep->base)
436 { 433 {
437 ep->pushes = 0; 434 ep->pushes = 0;
438 return; 435 return;
439 } 436 }
440 embryo_program_vm_reset(ep); 437 embryo_program_vm_reset(ep);
441} 438}
@@ -450,13 +447,12 @@ embryo_program_vm_pop(Embryo_Program *ep)
450 ep->base = NULL; 447 ep->base = NULL;
451} 448}
452 449
453
454EAPI void 450EAPI void
455embryo_swap_16(unsigned short *v 451embryo_swap_16(unsigned short *v
456#ifndef WORDS_BIGENDIAN 452#ifndef WORDS_BIGENDIAN
457 EINA_UNUSED 453 EINA_UNUSED
458#endif 454#endif
459 ) 455 )
460{ 456{
461#ifdef WORDS_BIGENDIAN 457#ifdef WORDS_BIGENDIAN
462 _embryo_byte_swap_16(v); 458 _embryo_byte_swap_16(v);
@@ -478,8 +474,8 @@ embryo_swap_32(unsigned int *v
478EAPI Embryo_Function 474EAPI Embryo_Function
479embryo_program_function_find(Embryo_Program *ep, const char *name) 475embryo_program_function_find(Embryo_Program *ep, const char *name)
480{ 476{
481 int first, last, mid, result; 477 int first, last, mid, result;
482 char pname[sNAMEMAX + 1]; 478 char pname[sNAMEMAX + 1];
483 Embryo_Header *hdr; 479 Embryo_Header *hdr;
484 480
485 if (!ep) return EMBRYO_FUNCTION_NONE; 481 if (!ep) return EMBRYO_FUNCTION_NONE;
@@ -489,26 +485,26 @@ embryo_program_function_find(Embryo_Program *ep, const char *name)
489 /* binary search */ 485 /* binary search */
490 while (first <= last) 486 while (first <= last)
491 { 487 {
492 mid = (first + last) / 2; 488 mid = (first + last) / 2;
493 if (_embryo_func_get(ep, mid, pname) == EMBRYO_ERROR_NONE) 489 if (_embryo_func_get(ep, mid, pname) == EMBRYO_ERROR_NONE)
494 result = strcmp(pname, name); 490 result = strcmp(pname, name);
495 else 491 else
496 return EMBRYO_FUNCTION_NONE; 492 return EMBRYO_FUNCTION_NONE;
497/* result = -1;*/ 493/* result = -1;*/
498 if (result > 0) last = mid - 1; 494 if (result > 0) last = mid - 1;
499 else if (result < 0) first = mid + 1; 495 else if (result < 0)
500 else return mid; 496 first = mid + 1;
497 else return mid;
501 } 498 }
502 return EMBRYO_FUNCTION_NONE; 499 return EMBRYO_FUNCTION_NONE;
503} 500}
504 501
505
506EAPI Embryo_Cell 502EAPI Embryo_Cell
507embryo_program_variable_find(Embryo_Program *ep, const char *name) 503embryo_program_variable_find(Embryo_Program *ep, const char *name)
508{ 504{
509 int first, last, mid, result; 505 int first, last, mid, result;
510 char pname[sNAMEMAX + 1]; 506 char pname[sNAMEMAX + 1];
511 Embryo_Cell paddr; 507 Embryo_Cell paddr;
512 Embryo_Header *hdr; 508 Embryo_Header *hdr;
513 509
514 if (!ep) return EMBRYO_CELL_NONE; 510 if (!ep) return EMBRYO_CELL_NONE;
@@ -519,15 +515,16 @@ embryo_program_variable_find(Embryo_Program *ep, const char *name)
519 /* binary search */ 515 /* binary search */
520 while (first <= last) 516 while (first <= last)
521 { 517 {
522 mid = (first + last) / 2; 518 mid = (first + last) / 2;
523 if (_embryo_var_get(ep, mid, pname, &paddr) == EMBRYO_ERROR_NONE) 519 if (_embryo_var_get(ep, mid, pname, &paddr) == EMBRYO_ERROR_NONE)
524 result = strcmp(pname, name); 520 result = strcmp(pname, name);
525 else 521 else
526 return EMBRYO_CELL_NONE; 522 return EMBRYO_CELL_NONE;
527/* result = -1;*/ 523/* result = -1;*/
528 if (result > 0) last = mid - 1; 524 if (result > 0) last = mid - 1;
529 else if (result < 0) first = mid + 1; 525 else if (result < 0)
530 else return paddr; 526 first = mid + 1;
527 else return paddr;
531 } 528 }
532 return EMBRYO_CELL_NONE; 529 return EMBRYO_CELL_NONE;
533} 530}
@@ -546,8 +543,8 @@ embryo_program_variable_count_get(Embryo_Program *ep)
546EAPI Embryo_Cell 543EAPI Embryo_Cell
547embryo_program_variable_get(Embryo_Program *ep, int num) 544embryo_program_variable_get(Embryo_Program *ep, int num)
548{ 545{
549 Embryo_Cell paddr; 546 Embryo_Cell paddr;
550 char pname[sNAMEMAX + 1]; 547 char pname[sNAMEMAX + 1];
551 548
552 if (!ep) return EMBRYO_CELL_NONE; 549 if (!ep) return EMBRYO_CELL_NONE;
553 if (!ep->base) return EMBRYO_CELL_NONE; 550 if (!ep->base) return EMBRYO_CELL_NONE;
@@ -556,7 +553,6 @@ embryo_program_variable_get(Embryo_Program *ep, int num)
556 return EMBRYO_CELL_NONE; 553 return EMBRYO_CELL_NONE;
557} 554}
558 555
559
560EAPI void 556EAPI void
561embryo_program_error_set(Embryo_Program *ep, Embryo_Error error) 557embryo_program_error_set(Embryo_Program *ep, Embryo_Error error)
562{ 558{
@@ -571,7 +567,6 @@ embryo_program_error_get(Embryo_Program *ep)
571 return ep->error; 567 return ep->error;
572} 568}
573 569
574
575EAPI void 570EAPI void
576embryo_program_data_set(Embryo_Program *ep, void *data) 571embryo_program_data_set(Embryo_Program *ep, void *data)
577{ 572{
@@ -590,45 +585,45 @@ EAPI const char *
590embryo_error_string_get(Embryo_Error error) 585embryo_error_string_get(Embryo_Error error)
591{ 586{
592 const char *messages[] = 587 const char *messages[] =
593 { 588 {
594 /* EMBRYO_ERROR_NONE */ "(none)", 589 /* EMBRYO_ERROR_NONE */
595 /* EMBRYO_ERROR_EXIT */ "Forced exit", 590 "(none)",
596 /* EMBRYO_ERROR_ASSERT */ "Assertion failed", 591 /* EMBRYO_ERROR_EXIT */ "Forced exit",
597 /* EMBRYO_ERROR_STACKERR */ "Stack/heap collision (insufficient stack size)", 592 /* EMBRYO_ERROR_ASSERT */ "Assertion failed",
598 /* EMBRYO_ERROR_BOUNDS */ "Array index out of bounds", 593 /* EMBRYO_ERROR_STACKERR */ "Stack/heap collision (insufficient stack size)",
599 /* EMBRYO_ERROR_MEMACCESS */ "Invalid memory access", 594 /* EMBRYO_ERROR_BOUNDS */ "Array index out of bounds",
600 /* EMBRYO_ERROR_INVINSTR */ "Invalid instruction", 595 /* EMBRYO_ERROR_MEMACCESS */ "Invalid memory access",
601 /* EMBRYO_ERROR_STACKLOW */ "Stack underflow", 596 /* EMBRYO_ERROR_INVINSTR */ "Invalid instruction",
602 /* EMBRYO_ERROR_HEAPLOW */ "Heap underflow", 597 /* EMBRYO_ERROR_STACKLOW */ "Stack underflow",
603 /* EMBRYO_ERROR_CALLBACK */ "No (valid) native function callback", 598 /* EMBRYO_ERROR_HEAPLOW */ "Heap underflow",
604 /* EMBRYO_ERROR_NATIVE */ "Native function failed", 599 /* EMBRYO_ERROR_CALLBACK */ "No (valid) native function callback",
605 /* EMBRYO_ERROR_DIVIDE */ "Divide by zero", 600 /* EMBRYO_ERROR_NATIVE */ "Native function failed",
606 /* EMBRYO_ERROR_SLEEP */ "(sleep mode)", 601 /* EMBRYO_ERROR_DIVIDE */ "Divide by zero",
607 /* 13 */ "(reserved)", 602 /* EMBRYO_ERROR_SLEEP */ "(sleep mode)",
608 /* 14 */ "(reserved)", 603 /* 13 */ "(reserved)",
609 /* 15 */ "(reserved)", 604 /* 14 */ "(reserved)",
610 /* EMBRYO_ERROR_MEMORY */ "Out of memory", 605 /* 15 */ "(reserved)",
611 /* EMBRYO_ERROR_FORMAT */ "Invalid/unsupported P-code file format", 606 /* EMBRYO_ERROR_MEMORY */ "Out of memory",
612 /* EMBRYO_ERROR_VERSION */ "File is for a newer version of the Embryo_Program", 607 /* EMBRYO_ERROR_FORMAT */ "Invalid/unsupported P-code file format",
613 /* EMBRYO_ERROR_NOTFOUND */ "Native/Public function is not found", 608 /* EMBRYO_ERROR_VERSION */ "File is for a newer version of the Embryo_Program",
614 /* EMBRYO_ERROR_INDEX */ "Invalid index parameter (bad entry point)", 609 /* EMBRYO_ERROR_NOTFOUND */ "Native/Public function is not found",
615 /* EMBRYO_ERROR_DEBUG */ "Debugger cannot run", 610 /* EMBRYO_ERROR_INDEX */ "Invalid index parameter (bad entry point)",
616 /* EMBRYO_ERROR_INIT */ "Embryo_Program not initialized (or doubly initialized)", 611 /* EMBRYO_ERROR_DEBUG */ "Debugger cannot run",
617 /* EMBRYO_ERROR_USERDATA */ "Unable to set user data field (table full)", 612 /* EMBRYO_ERROR_INIT */ "Embryo_Program not initialized (or doubly initialized)",
618 /* EMBRYO_ERROR_INIT_JIT */ "Cannot initialize the JIT", 613 /* EMBRYO_ERROR_USERDATA */ "Unable to set user data field (table full)",
619 /* EMBRYO_ERROR_PARAMS */ "Parameter error", 614 /* EMBRYO_ERROR_INIT_JIT */ "Cannot initialize the JIT",
620 }; 615 /* EMBRYO_ERROR_PARAMS */ "Parameter error",
621 if (((int)error < 0) || 616 };
617 if (((int)error < 0) ||
622 ((int)error >= (int)(sizeof(messages) / sizeof(messages[0])))) 618 ((int)error >= (int)(sizeof(messages) / sizeof(messages[0]))))
623 return (const char *)"(unknown)"; 619 return (const char *)"(unknown)";
624 return messages[error]; 620 return messages[error];
625} 621}
626 622
627
628EAPI int 623EAPI int
629embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell) 624embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell)
630{ 625{
631 int len; 626 int len;
632 Embryo_Header *hdr; 627 Embryo_Header *hdr;
633 628
634 if ((!ep) || (!ep->base)) return 0; 629 if ((!ep) || (!ep->base)) return 0;
@@ -637,42 +632,42 @@ embryo_data_string_length_get(Embryo_Program *ep, Embryo_Cell *str_cell)
637 ((void *)str_cell >= (void *)(ep->base + hdr->stp)) || 632 ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
638 ((void *)str_cell < (void *)ep->base)) 633 ((void *)str_cell < (void *)ep->base))
639 return 0; 634 return 0;
640 for (len = 0; str_cell[len] != 0; len++); 635 for (len = 0; str_cell[len] != 0; len++) ;
641 return len; 636 return len;
642} 637}
643 638
644EAPI void 639EAPI void
645embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst) 640embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst)
646{ 641{
647 int i; 642 int i;
648 Embryo_Header *hdr; 643 Embryo_Header *hdr;
649 644
650 if (!dst) return; 645 if (!dst) return;
651 if ((!ep) || (!ep->base)) 646 if ((!ep) || (!ep->base))
652 { 647 {
653 dst[0] = 0; 648 dst[0] = 0;
654 return; 649 return;
655 } 650 }
656 hdr = (Embryo_Header *)ep->base; 651 hdr = (Embryo_Header *)ep->base;
657 if ((!str_cell) || 652 if ((!str_cell) ||
658 ((void *)str_cell >= (void *)(ep->base + hdr->stp)) || 653 ((void *)str_cell >= (void *)(ep->base + hdr->stp)) ||
659 ((void *)str_cell < (void *)ep->base)) 654 ((void *)str_cell < (void *)ep->base))
660 { 655 {
661 dst[0] = 0; 656 dst[0] = 0;
662 return; 657 return;
663 } 658 }
664 for (i = 0; str_cell[i] != 0; i++) 659 for (i = 0; str_cell[i] != 0; i++)
665 { 660 {
666#ifdef WORDS_BIGENDIAN 661#ifdef WORDS_BIGENDIAN
667 { 662 {
668 Embryo_Cell tmp; 663 Embryo_Cell tmp;
669 664
670 tmp = str_cell[i]; 665 tmp = str_cell[i];
671 _embryo_byte_swap_32(&tmp); 666 _embryo_byte_swap_32(&tmp);
672 dst[i] = tmp; 667 dst[i] = tmp;
673 } 668 }
674#else 669#else
675 dst[i] = str_cell[i]; 670 dst[i] = str_cell[i];
676#endif 671#endif
677 } 672 }
678 dst[i] = 0; 673 dst[i] = 0;
@@ -681,7 +676,7 @@ embryo_data_string_get(Embryo_Program *ep, Embryo_Cell *str_cell, char *dst)
681EAPI void 676EAPI void
682embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cell) 677embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cell)
683{ 678{
684 int i; 679 int i;
685 Embryo_Header *hdr; 680 Embryo_Header *hdr;
686 681
687 if (!ep) return; 682 if (!ep) return;
@@ -693,27 +688,27 @@ embryo_data_string_set(Embryo_Program *ep, const char *src, Embryo_Cell *str_cel
693 return; 688 return;
694 if (!src) 689 if (!src)
695 { 690 {
696 str_cell[0] = 0; 691 str_cell[0] = 0;
697 return; 692 return;
698 } 693 }
699 for (i = 0; src[i] != 0; i++) 694 for (i = 0; src[i] != 0; i++)
700 { 695 {
701 if ((void *)(&(str_cell[i])) >= (void *)(ep->base + hdr->stp)) return; 696 if ((void *)(&(str_cell[i])) >= (void *)(ep->base + hdr->stp)) return;
702 else if ((void *)(&(str_cell[i])) == (void *)(ep->base + hdr->stp - 1)) 697 else if ((void *)(&(str_cell[i])) == (void *)(ep->base + hdr->stp - 1))
703 { 698 {
704 str_cell[i] = 0; 699 str_cell[i] = 0;
705 return; 700 return;
706 } 701 }
707#ifdef WORDS_BIGENDIAN 702#ifdef WORDS_BIGENDIAN
708 { 703 {
709 Embryo_Cell tmp; 704 Embryo_Cell tmp;
710 705
711 tmp = src[i]; 706 tmp = src[i];
712 _embryo_byte_swap_32(&tmp); 707 _embryo_byte_swap_32(&tmp);
713 str_cell[i] = tmp; 708 str_cell[i] = tmp;
714 } 709 }
715#else 710#else
716 str_cell[i] = src[i]; 711 str_cell[i] = src[i];
717#endif 712#endif
718 } 713 }
719 str_cell[i] = 0; 714 str_cell[i] = 0;
@@ -732,11 +727,10 @@ embryo_data_address_get(Embryo_Program *ep, Embryo_Cell addr)
732 return (Embryo_Cell *)(data + (int)addr); 727 return (Embryo_Cell *)(data + (int)addr);
733} 728}
734 729
735
736EAPI Embryo_Cell 730EAPI Embryo_Cell
737embryo_data_heap_push(Embryo_Program *ep, int cells) 731embryo_data_heap_push(Embryo_Program *ep, int cells)
738{ 732{
739 Embryo_Cell addr; 733 Embryo_Cell addr;
740 734
741 if ((!ep) || (!ep->base)) return EMBRYO_CELL_NONE; 735 if ((!ep) || (!ep->base)) return EMBRYO_CELL_NONE;
742 if (ep->stk - ep->hea - (cells * sizeof(Embryo_Cell)) < STKMARGIN) 736 if (ep->stk - ep->hea - (cells * sizeof(Embryo_Cell)) < STKMARGIN)
@@ -754,7 +748,6 @@ embryo_data_heap_pop(Embryo_Program *ep, Embryo_Cell down_to)
754 if (ep->hea > down_to) ep->hea = down_to; 748 if (ep->hea > down_to) ep->hea = down_to;
755} 749}
756 750
757
758EAPI int 751EAPI int
759embryo_program_recursion_get(Embryo_Program *ep) 752embryo_program_recursion_get(Embryo_Program *ep)
760{ 753{
@@ -771,30 +764,31 @@ embryo_program_recursion_get(Embryo_Program *ep)
771#ifdef EMBRYO_EXEC_JUMPTABLE 764#ifdef EMBRYO_EXEC_JUMPTABLE
772#define SWITCH(x) while (1) { goto *switchtable[x]; 765#define SWITCH(x) while (1) { goto *switchtable[x];
773#define SWITCHEND break; } 766#define SWITCHEND break; }
774#define CASE(x) SWITCHTABLE_##x: 767#define CASE(x) SWITCHTABLE_##x :
775#define BREAK break; 768#define BREAK break;
776#else 769#else
777#define SWITCH(x) switch (x) { 770#define SWITCH(x) switch (x) {
778#define SWITCHEND } 771#define SWITCHEND }
779#define CASE(x) case x: 772
780#define BREAK break 773#define CASE(x) case x:
774#define BREAK break
781#endif 775#endif
782 776
783EAPI Embryo_Status 777EAPI Embryo_Status
784embryo_program_run(Embryo_Program *ep, Embryo_Function fn) 778embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
785{ 779{
786 Embryo_Header *hdr; 780 Embryo_Header *hdr;
787 Embryo_Func_Stub *func; 781 Embryo_Func_Stub *func;
788 unsigned char *code, *data; 782 unsigned char *code, *data;
789 Embryo_Cell pri, alt, stk, frm, hea, hea_start; 783 Embryo_Cell pri, alt, stk, frm, hea, hea_start;
790 Embryo_Cell reset_stk, reset_hea, *cip; 784 Embryo_Cell reset_stk, reset_hea, *cip;
791 Embryo_UCell codesize; 785 Embryo_UCell codesize;
792 int i; 786 int i;
793 unsigned char op; 787 unsigned char op;
794 Embryo_Cell offs; 788 Embryo_Cell offs;
795 int num; 789 int num;
796 int max_run_cycles; 790 int max_run_cycles;
797 int cycle_count; 791 int cycle_count;
798#ifdef EMBRYO_EXEC_JUMPTABLE 792#ifdef EMBRYO_EXEC_JUMPTABLE
799 /* we limit the jumptable to 256 elements. why? above we forced "op" to be 793 /* we limit the jumptable to 256 elements. why? above we forced "op" to be
800 * a unsigned char - that means 256 max values. we limit opcode overflow 794 * a unsigned char - that means 256 max values. we limit opcode overflow
@@ -804,186 +798,186 @@ embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
804 * keep them innocuous. 798 * keep them innocuous.
805 */ 799 */
806 static const void *switchtable[256] = 800 static const void *switchtable[256] =
807 { 801 {
808 &&SWITCHTABLE_EMBRYO_OP_NONE, 802 && SWITCHTABLE_EMBRYO_OP_NONE,
809 &&SWITCHTABLE_EMBRYO_OP_LOAD_PRI, 803 && SWITCHTABLE_EMBRYO_OP_LOAD_PRI,
810 &&SWITCHTABLE_EMBRYO_OP_LOAD_ALT, 804 && SWITCHTABLE_EMBRYO_OP_LOAD_ALT,
811 &&SWITCHTABLE_EMBRYO_OP_LOAD_S_PRI, 805 && SWITCHTABLE_EMBRYO_OP_LOAD_S_PRI,
812 &&SWITCHTABLE_EMBRYO_OP_LOAD_S_ALT, 806 && SWITCHTABLE_EMBRYO_OP_LOAD_S_ALT,
813 &&SWITCHTABLE_EMBRYO_OP_LREF_PRI, 807 && SWITCHTABLE_EMBRYO_OP_LREF_PRI,
814 &&SWITCHTABLE_EMBRYO_OP_LREF_ALT, 808 && SWITCHTABLE_EMBRYO_OP_LREF_ALT,
815 &&SWITCHTABLE_EMBRYO_OP_LREF_S_PRI, 809 && SWITCHTABLE_EMBRYO_OP_LREF_S_PRI,
816 &&SWITCHTABLE_EMBRYO_OP_LREF_S_ALT, 810 && SWITCHTABLE_EMBRYO_OP_LREF_S_ALT,
817 &&SWITCHTABLE_EMBRYO_OP_LOAD_I, 811 && SWITCHTABLE_EMBRYO_OP_LOAD_I,
818 &&SWITCHTABLE_EMBRYO_OP_LODB_I, 812 && SWITCHTABLE_EMBRYO_OP_LODB_I,
819 &&SWITCHTABLE_EMBRYO_OP_CONST_PRI, 813 && SWITCHTABLE_EMBRYO_OP_CONST_PRI,
820 &&SWITCHTABLE_EMBRYO_OP_CONST_ALT, 814 && SWITCHTABLE_EMBRYO_OP_CONST_ALT,
821 &&SWITCHTABLE_EMBRYO_OP_ADDR_PRI, 815 && SWITCHTABLE_EMBRYO_OP_ADDR_PRI,
822 &&SWITCHTABLE_EMBRYO_OP_ADDR_ALT, 816 && SWITCHTABLE_EMBRYO_OP_ADDR_ALT,
823 &&SWITCHTABLE_EMBRYO_OP_STOR_PRI, 817 && SWITCHTABLE_EMBRYO_OP_STOR_PRI,
824 &&SWITCHTABLE_EMBRYO_OP_STOR_ALT, 818 && SWITCHTABLE_EMBRYO_OP_STOR_ALT,
825 &&SWITCHTABLE_EMBRYO_OP_STOR_S_PRI, 819 && SWITCHTABLE_EMBRYO_OP_STOR_S_PRI,
826 &&SWITCHTABLE_EMBRYO_OP_STOR_S_ALT, 820 && SWITCHTABLE_EMBRYO_OP_STOR_S_ALT,
827 &&SWITCHTABLE_EMBRYO_OP_SREF_PRI, 821 && SWITCHTABLE_EMBRYO_OP_SREF_PRI,
828 &&SWITCHTABLE_EMBRYO_OP_SREF_ALT, 822 && SWITCHTABLE_EMBRYO_OP_SREF_ALT,
829 &&SWITCHTABLE_EMBRYO_OP_SREF_S_PRI, 823 && SWITCHTABLE_EMBRYO_OP_SREF_S_PRI,
830 &&SWITCHTABLE_EMBRYO_OP_SREF_S_ALT, 824 && SWITCHTABLE_EMBRYO_OP_SREF_S_ALT,
831 &&SWITCHTABLE_EMBRYO_OP_STOR_I, 825 && SWITCHTABLE_EMBRYO_OP_STOR_I,
832 &&SWITCHTABLE_EMBRYO_OP_STRB_I, 826 && SWITCHTABLE_EMBRYO_OP_STRB_I,
833 &&SWITCHTABLE_EMBRYO_OP_LIDX, 827 && SWITCHTABLE_EMBRYO_OP_LIDX,
834 &&SWITCHTABLE_EMBRYO_OP_LIDX_B, 828 && SWITCHTABLE_EMBRYO_OP_LIDX_B,
835 &&SWITCHTABLE_EMBRYO_OP_IDXADDR, 829 && SWITCHTABLE_EMBRYO_OP_IDXADDR,
836 &&SWITCHTABLE_EMBRYO_OP_IDXADDR_B, 830 && SWITCHTABLE_EMBRYO_OP_IDXADDR_B,
837 &&SWITCHTABLE_EMBRYO_OP_ALIGN_PRI, 831 && SWITCHTABLE_EMBRYO_OP_ALIGN_PRI,
838 &&SWITCHTABLE_EMBRYO_OP_ALIGN_ALT, 832 && SWITCHTABLE_EMBRYO_OP_ALIGN_ALT,
839 &&SWITCHTABLE_EMBRYO_OP_LCTRL, 833 && SWITCHTABLE_EMBRYO_OP_LCTRL,
840 &&SWITCHTABLE_EMBRYO_OP_SCTRL, 834 && SWITCHTABLE_EMBRYO_OP_SCTRL,
841 &&SWITCHTABLE_EMBRYO_OP_MOVE_PRI, 835 && SWITCHTABLE_EMBRYO_OP_MOVE_PRI,
842 &&SWITCHTABLE_EMBRYO_OP_MOVE_ALT, 836 && SWITCHTABLE_EMBRYO_OP_MOVE_ALT,
843 &&SWITCHTABLE_EMBRYO_OP_XCHG, 837 && SWITCHTABLE_EMBRYO_OP_XCHG,
844 &&SWITCHTABLE_EMBRYO_OP_PUSH_PRI, 838 && SWITCHTABLE_EMBRYO_OP_PUSH_PRI,
845 &&SWITCHTABLE_EMBRYO_OP_PUSH_ALT, 839 && SWITCHTABLE_EMBRYO_OP_PUSH_ALT,
846 &&SWITCHTABLE_EMBRYO_OP_PUSH_R, 840 && SWITCHTABLE_EMBRYO_OP_PUSH_R,
847 &&SWITCHTABLE_EMBRYO_OP_PUSH_C, 841 && SWITCHTABLE_EMBRYO_OP_PUSH_C,
848 &&SWITCHTABLE_EMBRYO_OP_PUSH, 842 && SWITCHTABLE_EMBRYO_OP_PUSH,
849 &&SWITCHTABLE_EMBRYO_OP_PUSH_S, 843 && SWITCHTABLE_EMBRYO_OP_PUSH_S,
850 &&SWITCHTABLE_EMBRYO_OP_POP_PRI, 844 && SWITCHTABLE_EMBRYO_OP_POP_PRI,
851 &&SWITCHTABLE_EMBRYO_OP_POP_ALT, 845 && SWITCHTABLE_EMBRYO_OP_POP_ALT,
852 &&SWITCHTABLE_EMBRYO_OP_STACK, 846 && SWITCHTABLE_EMBRYO_OP_STACK,
853 &&SWITCHTABLE_EMBRYO_OP_HEAP, 847 && SWITCHTABLE_EMBRYO_OP_HEAP,
854 &&SWITCHTABLE_EMBRYO_OP_PROC, 848 && SWITCHTABLE_EMBRYO_OP_PROC,
855 &&SWITCHTABLE_EMBRYO_OP_RET, 849 && SWITCHTABLE_EMBRYO_OP_RET,
856 &&SWITCHTABLE_EMBRYO_OP_RETN, 850 && SWITCHTABLE_EMBRYO_OP_RETN,
857 &&SWITCHTABLE_EMBRYO_OP_CALL, 851 && SWITCHTABLE_EMBRYO_OP_CALL,
858 &&SWITCHTABLE_EMBRYO_OP_CALL_PRI, 852 && SWITCHTABLE_EMBRYO_OP_CALL_PRI,
859 &&SWITCHTABLE_EMBRYO_OP_JUMP, 853 && SWITCHTABLE_EMBRYO_OP_JUMP,
860 &&SWITCHTABLE_EMBRYO_OP_JREL, 854 && SWITCHTABLE_EMBRYO_OP_JREL,
861 &&SWITCHTABLE_EMBRYO_OP_JZER, 855 && SWITCHTABLE_EMBRYO_OP_JZER,
862 &&SWITCHTABLE_EMBRYO_OP_JNZ, 856 && SWITCHTABLE_EMBRYO_OP_JNZ,
863 &&SWITCHTABLE_EMBRYO_OP_JEQ, 857 && SWITCHTABLE_EMBRYO_OP_JEQ,
864 &&SWITCHTABLE_EMBRYO_OP_JNEQ, 858 && SWITCHTABLE_EMBRYO_OP_JNEQ,
865 &&SWITCHTABLE_EMBRYO_OP_JLESS, 859 && SWITCHTABLE_EMBRYO_OP_JLESS,
866 &&SWITCHTABLE_EMBRYO_OP_JLEQ, 860 && SWITCHTABLE_EMBRYO_OP_JLEQ,
867 &&SWITCHTABLE_EMBRYO_OP_JGRTR, 861 && SWITCHTABLE_EMBRYO_OP_JGRTR,
868 &&SWITCHTABLE_EMBRYO_OP_JGEQ, 862 && SWITCHTABLE_EMBRYO_OP_JGEQ,
869 &&SWITCHTABLE_EMBRYO_OP_JSLESS, 863 && SWITCHTABLE_EMBRYO_OP_JSLESS,
870 &&SWITCHTABLE_EMBRYO_OP_JSLEQ, 864 && SWITCHTABLE_EMBRYO_OP_JSLEQ,
871 &&SWITCHTABLE_EMBRYO_OP_JSGRTR, 865 && SWITCHTABLE_EMBRYO_OP_JSGRTR,
872 &&SWITCHTABLE_EMBRYO_OP_JSGEQ, 866 && SWITCHTABLE_EMBRYO_OP_JSGEQ,
873 &&SWITCHTABLE_EMBRYO_OP_SHL, 867 && SWITCHTABLE_EMBRYO_OP_SHL,
874 &&SWITCHTABLE_EMBRYO_OP_SHR, 868 && SWITCHTABLE_EMBRYO_OP_SHR,
875 &&SWITCHTABLE_EMBRYO_OP_SSHR, 869 && SWITCHTABLE_EMBRYO_OP_SSHR,
876 &&SWITCHTABLE_EMBRYO_OP_SHL_C_PRI, 870 && SWITCHTABLE_EMBRYO_OP_SHL_C_PRI,
877 &&SWITCHTABLE_EMBRYO_OP_SHL_C_ALT, 871 && SWITCHTABLE_EMBRYO_OP_SHL_C_ALT,
878 &&SWITCHTABLE_EMBRYO_OP_SHR_C_PRI, 872 && SWITCHTABLE_EMBRYO_OP_SHR_C_PRI,
879 &&SWITCHTABLE_EMBRYO_OP_SHR_C_ALT, 873 && SWITCHTABLE_EMBRYO_OP_SHR_C_ALT,
880 &&SWITCHTABLE_EMBRYO_OP_SMUL, 874 && SWITCHTABLE_EMBRYO_OP_SMUL,
881 &&SWITCHTABLE_EMBRYO_OP_SDIV, 875 && SWITCHTABLE_EMBRYO_OP_SDIV,
882 &&SWITCHTABLE_EMBRYO_OP_SDIV_ALT, 876 && SWITCHTABLE_EMBRYO_OP_SDIV_ALT,
883 &&SWITCHTABLE_EMBRYO_OP_UMUL, 877 && SWITCHTABLE_EMBRYO_OP_UMUL,
884 &&SWITCHTABLE_EMBRYO_OP_UDIV, 878 && SWITCHTABLE_EMBRYO_OP_UDIV,
885 &&SWITCHTABLE_EMBRYO_OP_UDIV_ALT, 879 && SWITCHTABLE_EMBRYO_OP_UDIV_ALT,
886 &&SWITCHTABLE_EMBRYO_OP_ADD, 880 && SWITCHTABLE_EMBRYO_OP_ADD,
887 &&SWITCHTABLE_EMBRYO_OP_SUB, 881 && SWITCHTABLE_EMBRYO_OP_SUB,
888 &&SWITCHTABLE_EMBRYO_OP_SUB_ALT, 882 && SWITCHTABLE_EMBRYO_OP_SUB_ALT,
889 &&SWITCHTABLE_EMBRYO_OP_AND, 883 && SWITCHTABLE_EMBRYO_OP_AND,
890 &&SWITCHTABLE_EMBRYO_OP_OR, 884 && SWITCHTABLE_EMBRYO_OP_OR,
891 &&SWITCHTABLE_EMBRYO_OP_XOR, 885 && SWITCHTABLE_EMBRYO_OP_XOR,
892 &&SWITCHTABLE_EMBRYO_OP_NOT, 886 && SWITCHTABLE_EMBRYO_OP_NOT,
893 &&SWITCHTABLE_EMBRYO_OP_NEG, 887 && SWITCHTABLE_EMBRYO_OP_NEG,
894 &&SWITCHTABLE_EMBRYO_OP_INVERT, 888 && SWITCHTABLE_EMBRYO_OP_INVERT,
895 &&SWITCHTABLE_EMBRYO_OP_ADD_C, 889 && SWITCHTABLE_EMBRYO_OP_ADD_C,
896 &&SWITCHTABLE_EMBRYO_OP_SMUL_C, 890 && SWITCHTABLE_EMBRYO_OP_SMUL_C,
897 &&SWITCHTABLE_EMBRYO_OP_ZERO_PRI, 891 && SWITCHTABLE_EMBRYO_OP_ZERO_PRI,
898 &&SWITCHTABLE_EMBRYO_OP_ZERO_ALT, 892 && SWITCHTABLE_EMBRYO_OP_ZERO_ALT,
899 &&SWITCHTABLE_EMBRYO_OP_ZERO, 893 && SWITCHTABLE_EMBRYO_OP_ZERO,
900 &&SWITCHTABLE_EMBRYO_OP_ZERO_S, 894 && SWITCHTABLE_EMBRYO_OP_ZERO_S,
901 &&SWITCHTABLE_EMBRYO_OP_SIGN_PRI, 895 && SWITCHTABLE_EMBRYO_OP_SIGN_PRI,
902 &&SWITCHTABLE_EMBRYO_OP_SIGN_ALT, 896 && SWITCHTABLE_EMBRYO_OP_SIGN_ALT,
903 &&SWITCHTABLE_EMBRYO_OP_EQ, 897 && SWITCHTABLE_EMBRYO_OP_EQ,
904 &&SWITCHTABLE_EMBRYO_OP_NEQ, 898 && SWITCHTABLE_EMBRYO_OP_NEQ,
905 &&SWITCHTABLE_EMBRYO_OP_LESS, 899 && SWITCHTABLE_EMBRYO_OP_LESS,
906 &&SWITCHTABLE_EMBRYO_OP_LEQ, 900 && SWITCHTABLE_EMBRYO_OP_LEQ,
907 &&SWITCHTABLE_EMBRYO_OP_GRTR, 901 && SWITCHTABLE_EMBRYO_OP_GRTR,
908 &&SWITCHTABLE_EMBRYO_OP_GEQ, 902 && SWITCHTABLE_EMBRYO_OP_GEQ,
909 &&SWITCHTABLE_EMBRYO_OP_SLESS, 903 && SWITCHTABLE_EMBRYO_OP_SLESS,
910 &&SWITCHTABLE_EMBRYO_OP_SLEQ, 904 && SWITCHTABLE_EMBRYO_OP_SLEQ,
911 &&SWITCHTABLE_EMBRYO_OP_SGRTR, 905 && SWITCHTABLE_EMBRYO_OP_SGRTR,
912 &&SWITCHTABLE_EMBRYO_OP_SGEQ, 906 && SWITCHTABLE_EMBRYO_OP_SGEQ,
913 &&SWITCHTABLE_EMBRYO_OP_EQ_C_PRI, 907 && SWITCHTABLE_EMBRYO_OP_EQ_C_PRI,
914 &&SWITCHTABLE_EMBRYO_OP_EQ_C_ALT, 908 && SWITCHTABLE_EMBRYO_OP_EQ_C_ALT,
915 &&SWITCHTABLE_EMBRYO_OP_INC_PRI, 909 && SWITCHTABLE_EMBRYO_OP_INC_PRI,
916 &&SWITCHTABLE_EMBRYO_OP_INC_ALT, 910 && SWITCHTABLE_EMBRYO_OP_INC_ALT,
917 &&SWITCHTABLE_EMBRYO_OP_INC, 911 && SWITCHTABLE_EMBRYO_OP_INC,
918 &&SWITCHTABLE_EMBRYO_OP_INC_S, 912 && SWITCHTABLE_EMBRYO_OP_INC_S,
919 &&SWITCHTABLE_EMBRYO_OP_INC_I, 913 && SWITCHTABLE_EMBRYO_OP_INC_I,
920 &&SWITCHTABLE_EMBRYO_OP_DEC_PRI, 914 && SWITCHTABLE_EMBRYO_OP_DEC_PRI,
921 &&SWITCHTABLE_EMBRYO_OP_DEC_ALT, 915 && SWITCHTABLE_EMBRYO_OP_DEC_ALT,
922 &&SWITCHTABLE_EMBRYO_OP_DEC, 916 && SWITCHTABLE_EMBRYO_OP_DEC,
923 &&SWITCHTABLE_EMBRYO_OP_DEC_S, 917 && SWITCHTABLE_EMBRYO_OP_DEC_S,
924 &&SWITCHTABLE_EMBRYO_OP_DEC_I, 918 && SWITCHTABLE_EMBRYO_OP_DEC_I,
925 &&SWITCHTABLE_EMBRYO_OP_MOVS, 919 && SWITCHTABLE_EMBRYO_OP_MOVS,
926 &&SWITCHTABLE_EMBRYO_OP_CMPS, 920 && SWITCHTABLE_EMBRYO_OP_CMPS,
927 &&SWITCHTABLE_EMBRYO_OP_FILL, 921 && SWITCHTABLE_EMBRYO_OP_FILL,
928 &&SWITCHTABLE_EMBRYO_OP_HALT, 922 && SWITCHTABLE_EMBRYO_OP_HALT,
929 &&SWITCHTABLE_EMBRYO_OP_BOUNDS, 923 && SWITCHTABLE_EMBRYO_OP_BOUNDS,
930 &&SWITCHTABLE_EMBRYO_OP_SYSREQ_PRI, 924 && SWITCHTABLE_EMBRYO_OP_SYSREQ_PRI,
931 &&SWITCHTABLE_EMBRYO_OP_SYSREQ_C, 925 && SWITCHTABLE_EMBRYO_OP_SYSREQ_C,
932 &&SWITCHTABLE_EMBRYO_OP_FILE, 926 && SWITCHTABLE_EMBRYO_OP_FILE,
933 &&SWITCHTABLE_EMBRYO_OP_LINE, 927 && SWITCHTABLE_EMBRYO_OP_LINE,
934 &&SWITCHTABLE_EMBRYO_OP_SYMBOL, 928 && SWITCHTABLE_EMBRYO_OP_SYMBOL,
935 &&SWITCHTABLE_EMBRYO_OP_SRANGE, 929 && SWITCHTABLE_EMBRYO_OP_SRANGE,
936 &&SWITCHTABLE_EMBRYO_OP_JUMP_PRI, 930 && SWITCHTABLE_EMBRYO_OP_JUMP_PRI,
937 &&SWITCHTABLE_EMBRYO_OP_SWITCH, 931 && SWITCHTABLE_EMBRYO_OP_SWITCH,
938 &&SWITCHTABLE_EMBRYO_OP_CASETBL, 932 && SWITCHTABLE_EMBRYO_OP_CASETBL,
939 &&SWITCHTABLE_EMBRYO_OP_SWAP_PRI, 933 && SWITCHTABLE_EMBRYO_OP_SWAP_PRI,
940 &&SWITCHTABLE_EMBRYO_OP_SWAP_ALT, 934 && SWITCHTABLE_EMBRYO_OP_SWAP_ALT,
941 &&SWITCHTABLE_EMBRYO_OP_PUSHADDR, 935 && SWITCHTABLE_EMBRYO_OP_PUSHADDR,
942 &&SWITCHTABLE_EMBRYO_OP_NOP, 936 && SWITCHTABLE_EMBRYO_OP_NOP,
943 &&SWITCHTABLE_EMBRYO_OP_SYSREQ_D, 937 && SWITCHTABLE_EMBRYO_OP_SYSREQ_D,
944 &&SWITCHTABLE_EMBRYO_OP_SYMTAG, 938 && SWITCHTABLE_EMBRYO_OP_SYMTAG,
945 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 939 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
946 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 940 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
947 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 941 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
948 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 942 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
949 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 943 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
950 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 944 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
951 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 945 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
952 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 946 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
953 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 947 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
954 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 948 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
955 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 949 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
956 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 950 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
957 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 951 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
958 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 952 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
959 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 953 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
960 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 954 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
961 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 955 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
962 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 956 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
963 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 957 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
964 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 958 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
965 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 959 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
966 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 960 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
967 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, 961 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE,
968 &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE, &&SWITCHTABLE_EMBRYO_OP_NONE 962 && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE, && SWITCHTABLE_EMBRYO_OP_NONE
969 }; 963 };
970#endif 964#endif
971 if (!ep) return EMBRYO_PROGRAM_FAIL; 965 if (!ep) return EMBRYO_PROGRAM_FAIL;
972 if (!(ep->flags & EMBRYO_FLAG_RELOC)) 966 if (!(ep->flags & EMBRYO_FLAG_RELOC))
973 { 967 {
974 ep->error = EMBRYO_ERROR_INIT; 968 ep->error = EMBRYO_ERROR_INIT;
975 return EMBRYO_PROGRAM_FAIL; 969 return EMBRYO_PROGRAM_FAIL;
976 } 970 }
977 if (!ep->base) 971 if (!ep->base)
978 { 972 {
979 ep->error = EMBRYO_ERROR_INIT; 973 ep->error = EMBRYO_ERROR_INIT;
980 return EMBRYO_PROGRAM_FAIL; 974 return EMBRYO_PROGRAM_FAIL;
981 } 975 }
982 if (ep->run_count > 0) 976 if (ep->run_count > 0)
983 { 977 {
984 /* return EMBRYO_PROGRAM_BUSY; */ 978 /* return EMBRYO_PROGRAM_BUSY; */
985 /* FIXME: test C->vm->C->vm recursion more fully */ 979 /* FIXME: test C->vm->C->vm recursion more fully */
986 /* it seems to work... just fine!!! - strange! */ 980 /* it seems to work... just fine!!! - strange! */
987 } 981 }
988 982
989 /* set up the registers */ 983 /* set up the registers */
@@ -1000,39 +994,39 @@ embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
1000 /* get the start address */ 994 /* get the start address */
1001 if (fn == EMBRYO_FUNCTION_MAIN) 995 if (fn == EMBRYO_FUNCTION_MAIN)
1002 { 996 {
1003 if (hdr->cip < 0) 997 if (hdr->cip < 0)
1004 { 998 {
1005 ep->error = EMBRYO_ERROR_INDEX; 999 ep->error = EMBRYO_ERROR_INDEX;
1006 return EMBRYO_PROGRAM_FAIL; 1000 return EMBRYO_PROGRAM_FAIL;
1007 } 1001 }
1008 cip = (Embryo_Cell *)(code + (int)hdr->cip); 1002 cip = (Embryo_Cell *)(code + (int)hdr->cip);
1009 } 1003 }
1010 else if (fn == EMBRYO_FUNCTION_CONT) 1004 else if (fn == EMBRYO_FUNCTION_CONT)
1011 { 1005 {
1012 /* all registers: pri, alt, frm, cip, hea, stk, reset_stk, reset_hea */ 1006 /* all registers: pri, alt, frm, cip, hea, stk, reset_stk, reset_hea */
1013 frm = ep->frm; 1007 frm = ep->frm;
1014 stk = ep->stk; 1008 stk = ep->stk;
1015 hea = ep->hea; 1009 hea = ep->hea;
1016 pri = ep->pri; 1010 pri = ep->pri;
1017 alt = ep->alt; 1011 alt = ep->alt;
1018 reset_stk = ep->reset_stk; 1012 reset_stk = ep->reset_stk;
1019 reset_hea = ep->reset_hea; 1013 reset_hea = ep->reset_hea;
1020 cip = (Embryo_Cell *)(code + (int)ep->cip); 1014 cip = (Embryo_Cell *)(code + (int)ep->cip);
1021 } 1015 }
1022 else if (fn < 0) 1016 else if (fn < 0)
1023 { 1017 {
1024 ep->error = EMBRYO_ERROR_INDEX; 1018 ep->error = EMBRYO_ERROR_INDEX;
1025 return EMBRYO_PROGRAM_FAIL; 1019 return EMBRYO_PROGRAM_FAIL;
1026 } 1020 }
1027 else 1021 else
1028 { 1022 {
1029 if (fn >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives)) 1023 if (fn >= (Embryo_Cell)NUMENTRIES(hdr, publics, natives))
1030 { 1024 {
1031 ep->error = EMBRYO_ERROR_INDEX; 1025 ep->error = EMBRYO_ERROR_INDEX;
1032 return EMBRYO_PROGRAM_FAIL; 1026 return EMBRYO_PROGRAM_FAIL;
1033 } 1027 }
1034 func = GETENTRY(hdr, publics, fn); 1028 func = GETENTRY(hdr, publics, fn);
1035 cip = (Embryo_Cell *)(code + (int)func->address); 1029 cip = (Embryo_Cell *)(code + (int)func->address);
1036 } 1030 }
1037 /* check values just copied */ 1031 /* check values just copied */
1038 CHKSTACK(); 1032 CHKSTACK();
@@ -1040,73 +1034,73 @@ embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
1040 1034
1041 if (fn != EMBRYO_FUNCTION_CONT) 1035 if (fn != EMBRYO_FUNCTION_CONT)
1042 { 1036 {
1043 int j; 1037 int j;
1044 1038
1045 for (j = ep->params_size - 1; j >= 0; j--) 1039 for (j = ep->params_size - 1; j >= 0; j--)
1046 { 1040 {
1047 Embryo_Param *pr; 1041 Embryo_Param *pr;
1048 1042
1049 pr = &(ep->params[j]); 1043 pr = &(ep->params[j]);
1050 if (pr->string) 1044 if (pr->string)
1051 { 1045 {
1052 int len; 1046 int len;
1053 Embryo_Cell ep_addr, *addr; 1047 Embryo_Cell ep_addr, *addr;
1054 1048
1055 len = strlen(pr->string); 1049 len = strlen(pr->string);
1056 ep_addr = embryo_data_heap_push(ep, len + 1); 1050 ep_addr = embryo_data_heap_push(ep, len + 1);
1057 if (ep_addr == EMBRYO_CELL_NONE) 1051 if (ep_addr == EMBRYO_CELL_NONE)
1058 { 1052 {
1059 ep->error = EMBRYO_ERROR_HEAPLOW; 1053 ep->error = EMBRYO_ERROR_HEAPLOW;
1060 return EMBRYO_PROGRAM_FAIL; 1054 return EMBRYO_PROGRAM_FAIL;
1061 } 1055 }
1062 addr = embryo_data_address_get(ep, ep_addr); 1056 addr = embryo_data_address_get(ep, ep_addr);
1063 if (addr) 1057 if (addr)
1064 embryo_data_string_set(ep, pr->string, addr); 1058 embryo_data_string_set(ep, pr->string, addr);
1065 else 1059 else
1066 { 1060 {
1067 ep->error = EMBRYO_ERROR_HEAPLOW; 1061 ep->error = EMBRYO_ERROR_HEAPLOW;
1068 return EMBRYO_PROGRAM_FAIL; 1062 return EMBRYO_PROGRAM_FAIL;
1069 } 1063 }
1070 PUSH(ep_addr); 1064 PUSH(ep_addr);
1071 free(pr->string); 1065 free(pr->string);
1072 } 1066 }
1073 else if (pr->cell_array) 1067 else if (pr->cell_array)
1074 { 1068 {
1075 int len; 1069 int len;
1076 Embryo_Cell ep_addr, *addr; 1070 Embryo_Cell ep_addr, *addr;
1077 1071
1078 len = pr->cell_array_size; 1072 len = pr->cell_array_size;
1079 ep_addr = embryo_data_heap_push(ep, len + 1); 1073 ep_addr = embryo_data_heap_push(ep, len + 1);
1080 if (ep_addr == EMBRYO_CELL_NONE) 1074 if (ep_addr == EMBRYO_CELL_NONE)
1081 { 1075 {
1082 ep->error = EMBRYO_ERROR_HEAPLOW; 1076 ep->error = EMBRYO_ERROR_HEAPLOW;
1083 return EMBRYO_PROGRAM_FAIL; 1077 return EMBRYO_PROGRAM_FAIL;
1084 } 1078 }
1085 addr = embryo_data_address_get(ep, ep_addr); 1079 addr = embryo_data_address_get(ep, ep_addr);
1086 if (addr) 1080 if (addr)
1087 memcpy(addr, pr->cell_array, 1081 memcpy(addr, pr->cell_array,
1088 pr->cell_array_size * sizeof(Embryo_Cell)); 1082 pr->cell_array_size * sizeof(Embryo_Cell));
1089 else 1083 else
1090 { 1084 {
1091 ep->error = EMBRYO_ERROR_HEAPLOW; 1085 ep->error = EMBRYO_ERROR_HEAPLOW;
1092 return EMBRYO_PROGRAM_FAIL; 1086 return EMBRYO_PROGRAM_FAIL;
1093 } 1087 }
1094 PUSH(ep_addr); 1088 PUSH(ep_addr);
1095 free(pr->cell_array); 1089 free(pr->cell_array);
1096 } 1090 }
1097 else 1091 else
1098 { 1092 {
1099 PUSH(pr->cell); 1093 PUSH(pr->cell);
1100 } 1094 }
1101 } 1095 }
1102 PUSH(ep->params_size * sizeof(Embryo_Cell)); 1096 PUSH(ep->params_size * sizeof(Embryo_Cell));
1103 PUSH(0); 1097 PUSH(0);
1104 if (ep->params) 1098 if (ep->params)
1105 { 1099 {
1106 free(ep->params); 1100 free(ep->params);
1107 ep->params = NULL; 1101 ep->params = NULL;
1108 } 1102 }
1109 ep->params_size = ep->params_alloc = 0; 1103 ep->params_size = ep->params_alloc = 0;
1110 } 1104 }
1111 /* check stack/heap before starting to run */ 1105 /* check stack/heap before starting to run */
1112 CHKMARGIN(); 1106 CHKMARGIN();
@@ -1116,771 +1110,791 @@ embryo_program_run(Embryo_Program *ep, Embryo_Function fn)
1116 1110
1117 max_run_cycles = ep->max_run_cycles; 1111 max_run_cycles = ep->max_run_cycles;
1118 /* start running */ 1112 /* start running */
1119 for (cycle_count = 0;;) 1113 for (cycle_count = 0;; )
1120 { 1114 {
1121 if (max_run_cycles > 0) 1115 if (max_run_cycles > 0)
1122 { 1116 {
1123 if (cycle_count >= max_run_cycles) 1117 if (cycle_count >= max_run_cycles)
1124 { 1118 {
1125 TOOLONG(ep); 1119 TOOLONG(ep);
1126 } 1120 }
1127 cycle_count++; 1121 cycle_count++;
1128 } 1122 }
1129 op = (Embryo_Opcode)*cip++; 1123 op = (Embryo_Opcode) * cip++;
1130 SWITCH(op); 1124 SWITCH(op);
1131 CASE(EMBRYO_OP_LOAD_PRI); 1125 CASE(EMBRYO_OP_LOAD_PRI);
1132 GETPARAM(offs); 1126 GETPARAM(offs);
1133 pri = *(Embryo_Cell *)(data + (int)offs); 1127 pri = *(Embryo_Cell *)(data + (int)offs);
1134 BREAK; 1128 BREAK;
1135 CASE(EMBRYO_OP_LOAD_ALT); 1129 CASE(EMBRYO_OP_LOAD_ALT);
1136 GETPARAM(offs); 1130 GETPARAM(offs);
1137 alt = *(Embryo_Cell *)(data + (int)offs); 1131 alt = *(Embryo_Cell *)(data + (int)offs);
1138 BREAK; 1132 BREAK;
1139 CASE(EMBRYO_OP_LOAD_S_PRI); 1133 CASE(EMBRYO_OP_LOAD_S_PRI);
1140 GETPARAM(offs); 1134 GETPARAM(offs);
1141 pri = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1135 pri = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1142 BREAK; 1136 BREAK;
1143 CASE(EMBRYO_OP_LOAD_S_ALT); 1137 CASE(EMBRYO_OP_LOAD_S_ALT);
1144 GETPARAM(offs); 1138 GETPARAM(offs);
1145 alt = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1139 alt = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1146 BREAK; 1140 BREAK;
1147 CASE(EMBRYO_OP_LREF_PRI); 1141 CASE(EMBRYO_OP_LREF_PRI);
1148 GETPARAM(offs); 1142 GETPARAM(offs);
1149 offs = *(Embryo_Cell *)(data + (int)offs); 1143 offs = *(Embryo_Cell *)(data + (int)offs);
1150 pri = *(Embryo_Cell *)(data + (int)offs); 1144 pri = *(Embryo_Cell *)(data + (int)offs);
1151 BREAK; 1145 BREAK;
1152 CASE(EMBRYO_OP_LREF_ALT); 1146 CASE(EMBRYO_OP_LREF_ALT);
1153 GETPARAM(offs); 1147 GETPARAM(offs);
1154 offs = *(Embryo_Cell *)(data + (int)offs); 1148 offs = *(Embryo_Cell *)(data + (int)offs);
1155 alt = *(Embryo_Cell *)(data + (int)offs); 1149 alt = *(Embryo_Cell *)(data + (int)offs);
1156 BREAK; 1150 BREAK;
1157 CASE(EMBRYO_OP_LREF_S_PRI); 1151 CASE(EMBRYO_OP_LREF_S_PRI);
1158 GETPARAM(offs); 1152 GETPARAM(offs);
1159 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1153 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1160 pri = *(Embryo_Cell *)(data + (int)offs); 1154 pri = *(Embryo_Cell *)(data + (int)offs);
1161 BREAK; 1155 BREAK;
1162 CASE(EMBRYO_OP_LREF_S_ALT); 1156 CASE(EMBRYO_OP_LREF_S_ALT);
1163 GETPARAM(offs); 1157 GETPARAM(offs);
1164 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1158 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1165 alt = *(Embryo_Cell *)(data + (int)offs); 1159 alt = *(Embryo_Cell *)(data + (int)offs);
1166 BREAK; 1160 BREAK;
1167 CASE(EMBRYO_OP_LOAD_I); 1161 CASE(EMBRYO_OP_LOAD_I);
1168 CHKMEM(pri); 1162 CHKMEM(pri);
1169 pri = *(Embryo_Cell *)(data + (int)pri); 1163 pri = *(Embryo_Cell *)(data + (int)pri);
1170 BREAK; 1164 BREAK;
1171 CASE(EMBRYO_OP_LODB_I); 1165 CASE(EMBRYO_OP_LODB_I);
1172 GETPARAM(offs); 1166 GETPARAM(offs);
1173 CHKMEM(pri); 1167 CHKMEM(pri);
1174 switch (offs) 1168 switch (offs)
1175 { 1169 {
1176 case 1: 1170 case 1:
1177 pri = *(data + (int)pri); 1171 pri = *(data + (int)pri);
1178 break; 1172 break;
1179 case 2: 1173
1180 pri = *(unsigned short *)(data + (int)pri); 1174 case 2:
1181 break; 1175 pri = *(unsigned short *)(data + (int)pri);
1182 case 4: 1176 break;
1183 pri = *(unsigned int *)(data + (int)pri); 1177
1184 break; 1178 case 4:
1185 default: 1179 pri = *(unsigned int *)(data + (int)pri);
1186 ABORT(ep, EMBRYO_ERROR_INVINSTR); 1180 break;
1187 break; 1181
1188 } 1182 default:
1189 BREAK; 1183 ABORT(ep, EMBRYO_ERROR_INVINSTR);
1190 CASE(EMBRYO_OP_CONST_PRI); 1184 break;
1191 GETPARAM(pri); 1185 }
1192 BREAK; 1186 BREAK;
1193 CASE(EMBRYO_OP_CONST_ALT); 1187 CASE(EMBRYO_OP_CONST_PRI);
1194 GETPARAM(alt); 1188 GETPARAM(pri);
1195 BREAK; 1189 BREAK;
1196 CASE(EMBRYO_OP_ADDR_PRI); 1190 CASE(EMBRYO_OP_CONST_ALT);
1197 GETPARAM(pri); 1191 GETPARAM(alt);
1198 pri += frm; 1192 BREAK;
1199 BREAK; 1193 CASE(EMBRYO_OP_ADDR_PRI);
1200 CASE(EMBRYO_OP_ADDR_ALT); 1194 GETPARAM(pri);
1201 GETPARAM(alt); 1195 pri += frm;
1202 alt += frm; 1196 BREAK;
1203 BREAK; 1197 CASE(EMBRYO_OP_ADDR_ALT);
1204 CASE(EMBRYO_OP_STOR_PRI); 1198 GETPARAM(alt);
1205 GETPARAM(offs); 1199 alt += frm;
1206 *(Embryo_Cell *)(data + (int)offs) = pri; 1200 BREAK;
1207 BREAK; 1201 CASE(EMBRYO_OP_STOR_PRI);
1208 CASE(EMBRYO_OP_STOR_ALT); 1202 GETPARAM(offs);
1209 GETPARAM(offs); 1203 *(Embryo_Cell *)(data + (int)offs) = pri;
1210 *(Embryo_Cell *)(data + (int)offs) = alt; 1204 BREAK;
1211 BREAK; 1205 CASE(EMBRYO_OP_STOR_ALT);
1212 CASE(EMBRYO_OP_STOR_S_PRI); 1206 GETPARAM(offs);
1213 GETPARAM(offs); 1207 *(Embryo_Cell *)(data + (int)offs) = alt;
1214 *(Embryo_Cell *)(data + (int)frm + (int)offs) = pri; 1208 BREAK;
1215 BREAK; 1209 CASE(EMBRYO_OP_STOR_S_PRI);
1216 CASE(EMBRYO_OP_STOR_S_ALT); 1210 GETPARAM(offs);
1217 GETPARAM(offs); 1211 *(Embryo_Cell *)(data + (int)frm + (int)offs) = pri;
1218 *(Embryo_Cell *)(data + (int)frm + (int)offs) = alt; 1212 BREAK;
1219 BREAK; 1213 CASE(EMBRYO_OP_STOR_S_ALT);
1220 CASE(EMBRYO_OP_SREF_PRI); 1214 GETPARAM(offs);
1221 GETPARAM(offs); 1215 *(Embryo_Cell *)(data + (int)frm + (int)offs) = alt;
1222 offs = *(Embryo_Cell *)(data + (int)offs); 1216 BREAK;
1223 *(Embryo_Cell *)(data + (int)offs) = pri; 1217 CASE(EMBRYO_OP_SREF_PRI);
1224 BREAK; 1218 GETPARAM(offs);
1225 CASE(EMBRYO_OP_SREF_ALT); 1219 offs = *(Embryo_Cell *)(data + (int)offs);
1226 GETPARAM(offs); 1220 *(Embryo_Cell *)(data + (int)offs) = pri;
1227 offs = *(Embryo_Cell *)(data + (int)offs); 1221 BREAK;
1228 *(Embryo_Cell *)(data + (int)offs) = alt; 1222 CASE(EMBRYO_OP_SREF_ALT);
1229 BREAK; 1223 GETPARAM(offs);
1230 CASE(EMBRYO_OP_SREF_S_PRI); 1224 offs = *(Embryo_Cell *)(data + (int)offs);
1231 GETPARAM(offs); 1225 *(Embryo_Cell *)(data + (int)offs) = alt;
1232 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1226 BREAK;
1233 *(Embryo_Cell *)(data + (int)offs) = pri; 1227 CASE(EMBRYO_OP_SREF_S_PRI);
1234 BREAK; 1228 GETPARAM(offs);
1235 CASE(EMBRYO_OP_SREF_S_ALT); 1229 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1236 GETPARAM(offs); 1230 *(Embryo_Cell *)(data + (int)offs) = pri;
1237 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs); 1231 BREAK;
1238 *(Embryo_Cell *)(data + (int)offs) = alt; 1232 CASE(EMBRYO_OP_SREF_S_ALT);
1239 BREAK; 1233 GETPARAM(offs);
1240 CASE(EMBRYO_OP_STOR_I); 1234 offs = *(Embryo_Cell *)(data + (int)frm + (int)offs);
1241 CHKMEM(alt); 1235 *(Embryo_Cell *)(data + (int)offs) = alt;
1242 *(Embryo_Cell *)(data + (int)alt) = pri; 1236 BREAK;
1243 BREAK; 1237 CASE(EMBRYO_OP_STOR_I);
1244 CASE(EMBRYO_OP_STRB_I); 1238 CHKMEM(alt);
1245 GETPARAM(offs); 1239 *(Embryo_Cell *)(data + (int)alt) = pri;
1246 CHKMEM(alt); 1240 BREAK;
1247 switch (offs) 1241 CASE(EMBRYO_OP_STRB_I);
1248 { 1242 GETPARAM(offs);
1249 case 1: 1243 CHKMEM(alt);
1250 *(data + (int)alt) = (unsigned char)pri; 1244 switch (offs)
1251 break; 1245 {
1252 case 2: 1246 case 1:
1253 *(unsigned short *)(data + (int)alt) = (unsigned short)pri; 1247 *(data + (int)alt) = (unsigned char)pri;
1254 break; 1248 break;
1255 case 4: 1249
1256 *(unsigned int *)(data + (int)alt) = (unsigned int)pri; 1250 case 2:
1257 break; 1251 *(unsigned short *)(data + (int)alt) = (unsigned short)pri;
1258 default: 1252 break;
1259 ABORT(ep, EMBRYO_ERROR_INVINSTR); 1253
1260 break; 1254 case 4:
1261 } 1255 *(unsigned int *)(data + (int)alt) = (unsigned int)pri;
1262 BREAK; 1256 break;
1263 CASE(EMBRYO_OP_LIDX); 1257
1264 offs = (pri * sizeof(Embryo_Cell)) + alt; 1258 default:
1265 CHKMEM(offs); 1259 ABORT(ep, EMBRYO_ERROR_INVINSTR);
1266 pri = *(Embryo_Cell *)(data + (int)offs); 1260 break;
1267 BREAK; 1261 }
1268 CASE(EMBRYO_OP_LIDX_B); 1262 BREAK;
1269 GETPARAM(offs); 1263 CASE(EMBRYO_OP_LIDX);
1270 offs = (pri << (int)offs) + alt; 1264 offs = (pri * sizeof(Embryo_Cell)) + alt;
1271 CHKMEM(offs); 1265 CHKMEM(offs);
1272 pri = *(Embryo_Cell *)(data + (int)offs); 1266 pri = *(Embryo_Cell *)(data + (int)offs);
1273 BREAK; 1267 BREAK;
1274 CASE(EMBRYO_OP_IDXADDR); 1268 CASE(EMBRYO_OP_LIDX_B);
1275 pri = (pri * sizeof(Embryo_Cell)) + alt; 1269 GETPARAM(offs);
1276 BREAK; 1270 offs = (pri << (int)offs) + alt;
1277 CASE(EMBRYO_OP_IDXADDR_B); 1271 CHKMEM(offs);
1278 GETPARAM(offs); 1272 pri = *(Embryo_Cell *)(data + (int)offs);
1279 pri = (pri << (int)offs) + alt; 1273 BREAK;
1280 BREAK; 1274 CASE(EMBRYO_OP_IDXADDR);
1281 CASE(EMBRYO_OP_ALIGN_PRI); 1275 pri = (pri * sizeof(Embryo_Cell)) + alt;
1282 GETPARAM(offs); 1276 BREAK;
1277 CASE(EMBRYO_OP_IDXADDR_B);
1278 GETPARAM(offs);
1279 pri = (pri << (int)offs) + alt;
1280 BREAK;
1281 CASE(EMBRYO_OP_ALIGN_PRI);
1282 GETPARAM(offs);
1283#ifdef WORDS_BIGENDIAN 1283#ifdef WORDS_BIGENDIAN
1284 if ((size_t)offs < sizeof(Embryo_Cell)) 1284 if ((size_t)offs < sizeof(Embryo_Cell))
1285 pri ^= sizeof(Embryo_Cell) - offs; 1285 pri ^= sizeof(Embryo_Cell) - offs;
1286#endif 1286#endif
1287 BREAK; 1287 BREAK;
1288 CASE(EMBRYO_OP_ALIGN_ALT); 1288 CASE(EMBRYO_OP_ALIGN_ALT);
1289 GETPARAM(offs); 1289 GETPARAM(offs);
1290#ifdef WORDS_BIGENDIAN 1290#ifdef WORDS_BIGENDIAN
1291 if ((size_t)offs < sizeof(Embryo_Cell)) 1291 if ((size_t)offs < sizeof(Embryo_Cell))
1292 alt ^= sizeof(Embryo_Cell) - offs; 1292 alt ^= sizeof(Embryo_Cell) - offs;
1293#endif 1293#endif
1294 BREAK; 1294 BREAK;
1295 CASE(EMBRYO_OP_LCTRL); 1295 CASE(EMBRYO_OP_LCTRL);
1296 GETPARAM(offs); 1296 GETPARAM(offs);
1297 switch (offs) 1297 switch (offs)
1298 { 1298 {
1299 case 0: 1299 case 0:
1300 pri = hdr->cod; 1300 pri = hdr->cod;
1301 break; 1301 break;
1302 case 1: 1302
1303 pri = hdr->dat; 1303 case 1:
1304 break; 1304 pri = hdr->dat;
1305 case 2: 1305 break;
1306 pri = hea; 1306
1307 break; 1307 case 2:
1308 case 3: 1308 pri = hea;
1309 pri = ep->stp; 1309 break;
1310 break; 1310
1311 case 4: 1311 case 3:
1312 pri = stk; 1312 pri = ep->stp;
1313 break; 1313 break;
1314 case 5: 1314
1315 pri = frm; 1315 case 4:
1316 break; 1316 pri = stk;
1317 case 6: 1317 break;
1318 pri = (Embryo_Cell)((unsigned char *)cip - code); 1318
1319 break; 1319 case 5:
1320 default: 1320 pri = frm;
1321 ABORT(ep, EMBRYO_ERROR_INVINSTR); 1321 break;
1322 break; 1322
1323 } 1323 case 6:
1324 BREAK; 1324 pri = (Embryo_Cell)((unsigned char *)cip - code);
1325 CASE(EMBRYO_OP_SCTRL); 1325 break;
1326 GETPARAM(offs); 1326
1327 switch (offs) 1327 default:
1328 { 1328 ABORT(ep, EMBRYO_ERROR_INVINSTR);
1329 case 0: 1329 break;
1330 case 1: 1330 }
1331 case 2: 1331 BREAK;
1332 hea = pri; 1332 CASE(EMBRYO_OP_SCTRL);
1333 break; 1333 GETPARAM(offs);
1334 case 3: 1334 switch (offs)
1335 /* cannot change these parameters */ 1335 {
1336 break; 1336 case 0:
1337 case 4: 1337 case 1:
1338 stk = pri; 1338 case 2:
1339 break; 1339 hea = pri;
1340 case 5: 1340 break;
1341 frm = pri; 1341
1342 break; 1342 case 3:
1343 case 6: 1343 /* cannot change these parameters */
1344 cip = (Embryo_Cell *)(code + (int)pri); 1344 break;
1345 break; 1345
1346 default: 1346 case 4:
1347 ABORT(ep, EMBRYO_ERROR_INVINSTR); 1347 stk = pri;
1348 break; 1348 break;
1349 } 1349
1350 BREAK; 1350 case 5:
1351 CASE(EMBRYO_OP_MOVE_PRI); 1351 frm = pri;
1352 pri = alt; 1352 break;
1353 BREAK; 1353
1354 CASE(EMBRYO_OP_MOVE_ALT); 1354 case 6:
1355 alt = pri; 1355 cip = (Embryo_Cell *)(code + (int)pri);
1356 BREAK; 1356 break;
1357 CASE(EMBRYO_OP_XCHG); 1357
1358 offs = pri; /* offs is a temporary variable */ 1358 default:
1359 pri = alt; 1359 ABORT(ep, EMBRYO_ERROR_INVINSTR);
1360 alt = offs; 1360 break;
1361 BREAK; 1361 }
1362 CASE(EMBRYO_OP_PUSH_PRI); 1362 BREAK;
1363 PUSH(pri); 1363 CASE(EMBRYO_OP_MOVE_PRI);
1364 BREAK; 1364 pri = alt;
1365 CASE(EMBRYO_OP_PUSH_ALT); 1365 BREAK;
1366 PUSH(alt); 1366 CASE(EMBRYO_OP_MOVE_ALT);
1367 BREAK; 1367 alt = pri;
1368 CASE(EMBRYO_OP_PUSH_C); 1368 BREAK;
1369 GETPARAM(offs); 1369 CASE(EMBRYO_OP_XCHG);
1370 PUSH(offs); 1370 offs = pri; /* offs is a temporary variable */
1371 BREAK; 1371 pri = alt;
1372 CASE(EMBRYO_OP_PUSH_R); 1372 alt = offs;
1373 GETPARAM(offs); 1373 BREAK;
1374 while (offs--) PUSH(pri); 1374 CASE(EMBRYO_OP_PUSH_PRI);
1375 BREAK; 1375 PUSH(pri);
1376 CASE(EMBRYO_OP_PUSH); 1376 BREAK;
1377 GETPARAM(offs); 1377 CASE(EMBRYO_OP_PUSH_ALT);
1378 PUSH(*(Embryo_Cell *)(data + (int)offs)); 1378 PUSH(alt);
1379 BREAK; 1379 BREAK;
1380 CASE(EMBRYO_OP_PUSH_S); 1380 CASE(EMBRYO_OP_PUSH_C);
1381 GETPARAM(offs); 1381 GETPARAM(offs);
1382 PUSH(*(Embryo_Cell *)(data + (int)frm + (int)offs)); 1382 PUSH(offs);
1383 BREAK; 1383 BREAK;
1384 CASE(EMBRYO_OP_POP_PRI); 1384 CASE(EMBRYO_OP_PUSH_R);
1385 POP(pri); 1385 GETPARAM(offs);
1386 BREAK; 1386 while (offs--)
1387 CASE(EMBRYO_OP_POP_ALT); 1387 PUSH(pri);
1388 POP(alt); 1388 BREAK;
1389 BREAK; 1389 CASE(EMBRYO_OP_PUSH);
1390 CASE(EMBRYO_OP_STACK); 1390 GETPARAM(offs);
1391 GETPARAM(offs); 1391 PUSH(*(Embryo_Cell *)(data + (int)offs));
1392 alt = stk; 1392 BREAK;
1393 stk += offs; 1393 CASE(EMBRYO_OP_PUSH_S);
1394 CHKMARGIN(); 1394 GETPARAM(offs);
1395 CHKSTACK(); 1395 PUSH(*(Embryo_Cell *)(data + (int)frm + (int)offs));
1396 BREAK; 1396 BREAK;
1397 CASE(EMBRYO_OP_HEAP); 1397 CASE(EMBRYO_OP_POP_PRI);
1398 GETPARAM(offs); 1398 POP(pri);
1399 alt = hea; 1399 BREAK;
1400 hea += offs; 1400 CASE(EMBRYO_OP_POP_ALT);
1401 CHKMARGIN(); 1401 POP(alt);
1402 CHKHEAP(); 1402 BREAK;
1403 BREAK; 1403 CASE(EMBRYO_OP_STACK);
1404 CASE(EMBRYO_OP_PROC); 1404 GETPARAM(offs);
1405 PUSH(frm); 1405 alt = stk;
1406 frm = stk; 1406 stk += offs;
1407 CHKMARGIN(); 1407 CHKMARGIN();
1408 BREAK; 1408 CHKSTACK();
1409 CASE(EMBRYO_OP_RET); 1409 BREAK;
1410 POP(frm); 1410 CASE(EMBRYO_OP_HEAP);
1411 POP(offs); 1411 GETPARAM(offs);
1412 if ((Embryo_UCell)offs >= codesize) 1412 alt = hea;
1413 ABORT(ep, EMBRYO_ERROR_MEMACCESS); 1413 hea += offs;
1414 cip = (Embryo_Cell *)(code + (int)offs); 1414 CHKMARGIN();
1415 BREAK; 1415 CHKHEAP();
1416 CASE(EMBRYO_OP_RETN); 1416 BREAK;
1417 POP(frm); 1417 CASE(EMBRYO_OP_PROC);
1418 POP(offs); 1418 PUSH(frm);
1419 if ((Embryo_UCell)offs >= codesize) 1419 frm = stk;
1420 ABORT(ep, EMBRYO_ERROR_MEMACCESS); 1420 CHKMARGIN();
1421 cip = (Embryo_Cell *)(code + (int)offs); 1421 BREAK;
1422 stk += *(Embryo_Cell *)(data + (int)stk) + sizeof(Embryo_Cell); /* remove parameters from the stack */ 1422 CASE(EMBRYO_OP_RET);
1423 ep->stk = stk; 1423 POP(frm);
1424 BREAK; 1424 POP(offs);
1425 CASE(EMBRYO_OP_CALL); 1425 if ((Embryo_UCell)offs >= codesize)
1426 PUSH(((unsigned char *)cip - code) + sizeof(Embryo_Cell));/* skip address */ 1426 ABORT(ep, EMBRYO_ERROR_MEMACCESS);
1427 cip = JUMPABS(code, cip); /* jump to the address */ 1427 cip = (Embryo_Cell *)(code + (int)offs);
1428 BREAK; 1428 BREAK;
1429 CASE(EMBRYO_OP_CALL_PRI); 1429 CASE(EMBRYO_OP_RETN);
1430 PUSH((unsigned char *)cip - code); 1430 POP(frm);
1431 cip = (Embryo_Cell *)(code + (int)pri); 1431 POP(offs);
1432 BREAK; 1432 if ((Embryo_UCell)offs >= codesize)
1433 CASE(EMBRYO_OP_JUMP); 1433 ABORT(ep, EMBRYO_ERROR_MEMACCESS);
1434 /* since the GETPARAM() macro modifies cip, you cannot 1434 cip = (Embryo_Cell *)(code + (int)offs);
1435 * do GETPARAM(cip) directly */ 1435 stk += *(Embryo_Cell *)(data + (int)stk) + sizeof(Embryo_Cell); /* remove parameters from the stack */
1436 cip = JUMPABS(code, cip); 1436 ep->stk = stk;
1437 BREAK; 1437 BREAK;
1438 CASE(EMBRYO_OP_JREL); 1438 CASE(EMBRYO_OP_CALL);
1439 offs = *cip; 1439 PUSH(((unsigned char *)cip - code) + sizeof(Embryo_Cell)); /* skip address */
1440 cip = (Embryo_Cell *)((unsigned char *)cip + (int)offs + sizeof(Embryo_Cell)); 1440 cip = JUMPABS(code, cip); /* jump to the address */
1441 BREAK; 1441 BREAK;
1442 CASE(EMBRYO_OP_JZER); 1442 CASE(EMBRYO_OP_CALL_PRI);
1443 if (pri == 0) 1443 PUSH((unsigned char *)cip - code);
1444 cip = JUMPABS(code, cip); 1444 cip = (Embryo_Cell *)(code + (int)pri);
1445 else 1445 BREAK;
1446 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1446 CASE(EMBRYO_OP_JUMP);
1447 BREAK; 1447 /* since the GETPARAM() macro modifies cip, you cannot
1448 CASE(EMBRYO_OP_JNZ); 1448 * do GETPARAM(cip) directly */
1449 if (pri != 0) 1449 cip = JUMPABS(code, cip);
1450 cip = JUMPABS(code, cip); 1450 BREAK;
1451 else 1451 CASE(EMBRYO_OP_JREL);
1452 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1452 offs = *cip;
1453 BREAK; 1453 cip = (Embryo_Cell *)((unsigned char *)cip + (int)offs + sizeof(Embryo_Cell));
1454 CASE(EMBRYO_OP_JEQ); 1454 BREAK;
1455 if (pri==alt) 1455 CASE(EMBRYO_OP_JZER);
1456 cip = JUMPABS(code, cip); 1456 if (pri == 0)
1457 else 1457 cip = JUMPABS(code, cip);
1458 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1458 else
1459 BREAK; 1459 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1460 CASE(EMBRYO_OP_JNEQ); 1460 BREAK;
1461 if (pri != alt) 1461 CASE(EMBRYO_OP_JNZ);
1462 cip = JUMPABS(code, cip); 1462 if (pri != 0)
1463 else 1463 cip = JUMPABS(code, cip);
1464 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1464 else
1465 BREAK; 1465 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1466 CASE(EMBRYO_OP_JLESS); 1466 BREAK;
1467 if ((Embryo_UCell)pri < (Embryo_UCell)alt) 1467 CASE(EMBRYO_OP_JEQ);
1468 cip = JUMPABS(code, cip); 1468 if (pri == alt)
1469 else 1469 cip = JUMPABS(code, cip);
1470 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1470 else
1471 BREAK; 1471 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1472 CASE(EMBRYO_OP_JLEQ); 1472 BREAK;
1473 if ((Embryo_UCell)pri <= (Embryo_UCell)alt) 1473 CASE(EMBRYO_OP_JNEQ);
1474 cip = JUMPABS(code, cip); 1474 if (pri != alt)
1475 else 1475 cip = JUMPABS(code, cip);
1476 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1476 else
1477 BREAK; 1477 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1478 CASE(EMBRYO_OP_JGRTR); 1478 BREAK;
1479 if ((Embryo_UCell)pri > (Embryo_UCell)alt) 1479 CASE(EMBRYO_OP_JLESS);
1480 cip = JUMPABS(code, cip); 1480 if ((Embryo_UCell)pri < (Embryo_UCell)alt)
1481 else 1481 cip = JUMPABS(code, cip);
1482 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1482 else
1483 BREAK; 1483 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1484 CASE(EMBRYO_OP_JGEQ); 1484 BREAK;
1485 if ((Embryo_UCell)pri >= (Embryo_UCell)alt) 1485 CASE(EMBRYO_OP_JLEQ);
1486 cip = JUMPABS(code, cip); 1486 if ((Embryo_UCell)pri <= (Embryo_UCell)alt)
1487 else 1487 cip = JUMPABS(code, cip);
1488 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1488 else
1489 BREAK; 1489 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1490 CASE(EMBRYO_OP_JSLESS); 1490 BREAK;
1491 if (pri < alt) 1491 CASE(EMBRYO_OP_JGRTR);
1492 cip = JUMPABS(code, cip); 1492 if ((Embryo_UCell)pri > (Embryo_UCell)alt)
1493 else 1493 cip = JUMPABS(code, cip);
1494 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1494 else
1495 BREAK; 1495 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1496 CASE(EMBRYO_OP_JSLEQ); 1496 BREAK;
1497 if (pri <= alt) 1497 CASE(EMBRYO_OP_JGEQ);
1498 cip = JUMPABS(code, cip); 1498 if ((Embryo_UCell)pri >= (Embryo_UCell)alt)
1499 else 1499 cip = JUMPABS(code, cip);
1500 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1500 else
1501 BREAK; 1501 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1502 CASE(EMBRYO_OP_JSGRTR); 1502 BREAK;
1503 if (pri > alt) 1503 CASE(EMBRYO_OP_JSLESS);
1504 cip = JUMPABS(code, cip); 1504 if (pri < alt)
1505 else 1505 cip = JUMPABS(code, cip);
1506 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1506 else
1507 BREAK; 1507 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1508 CASE(EMBRYO_OP_JSGEQ); 1508 BREAK;
1509 if (pri >= alt) 1509 CASE(EMBRYO_OP_JSLEQ);
1510 cip = JUMPABS(code, cip); 1510 if (pri <= alt)
1511 else 1511 cip = JUMPABS(code, cip);
1512 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell)); 1512 else
1513 BREAK; 1513 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1514 CASE(EMBRYO_OP_SHL); 1514 BREAK;
1515 pri <<= alt; 1515 CASE(EMBRYO_OP_JSGRTR);
1516 BREAK; 1516 if (pri > alt)
1517 CASE(EMBRYO_OP_SHR); 1517 cip = JUMPABS(code, cip);
1518 pri = (Embryo_UCell)pri >> (int)alt; 1518 else
1519 BREAK; 1519 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1520 CASE(EMBRYO_OP_SSHR); 1520 BREAK;
1521 pri >>= alt; 1521 CASE(EMBRYO_OP_JSGEQ);
1522 BREAK; 1522 if (pri >= alt)
1523 CASE(EMBRYO_OP_SHL_C_PRI); 1523 cip = JUMPABS(code, cip);
1524 GETPARAM(offs); 1524 else
1525 pri <<= offs; 1525 cip = (Embryo_Cell *)((unsigned char *)cip + sizeof(Embryo_Cell));
1526 BREAK; 1526 BREAK;
1527 CASE(EMBRYO_OP_SHL_C_ALT); 1527 CASE(EMBRYO_OP_SHL);
1528 GETPARAM(offs); 1528 pri <<= alt;
1529 alt <<= offs; 1529 BREAK;
1530 BREAK; 1530 CASE(EMBRYO_OP_SHR);
1531 CASE(EMBRYO_OP_SHR_C_PRI); 1531 pri = (Embryo_UCell)pri >> (int)alt;
1532 GETPARAM(offs); 1532 BREAK;
1533 pri = (Embryo_UCell)pri >> (int)offs; 1533 CASE(EMBRYO_OP_SSHR);
1534 BREAK; 1534 pri >>= alt;
1535 CASE(EMBRYO_OP_SHR_C_ALT); 1535 BREAK;
1536 GETPARAM(offs); 1536 CASE(EMBRYO_OP_SHL_C_PRI);
1537 alt = (Embryo_UCell)alt >> (int)offs; 1537 GETPARAM(offs);
1538 BREAK; 1538 pri <<= offs;
1539 CASE(EMBRYO_OP_SMUL); 1539 BREAK;
1540 pri *= alt; 1540 CASE(EMBRYO_OP_SHL_C_ALT);
1541 BREAK; 1541 GETPARAM(offs);
1542 CASE(EMBRYO_OP_SDIV); 1542 alt <<= offs;
1543 if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE); 1543 BREAK;
1544 /* divide must always round down; this is a bit 1544 CASE(EMBRYO_OP_SHR_C_PRI);
1545 * involved to do in a machine-independent way. 1545 GETPARAM(offs);
1546 */ 1546 pri = (Embryo_UCell)pri >> (int)offs;
1547 offs = ((pri % alt) + alt) % alt; /* true modulus */ 1547 BREAK;
1548 pri = (pri - offs) / alt; /* division result */ 1548 CASE(EMBRYO_OP_SHR_C_ALT);
1549 alt = offs; 1549 GETPARAM(offs);
1550 BREAK; 1550 alt = (Embryo_UCell)alt >> (int)offs;
1551 CASE(EMBRYO_OP_SDIV_ALT); 1551 BREAK;
1552 if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE); 1552 CASE(EMBRYO_OP_SMUL);
1553 /* divide must always round down; this is a bit 1553 pri *= alt;
1554 * involved to do in a machine-independent way. 1554 BREAK;
1555 */ 1555 CASE(EMBRYO_OP_SDIV);
1556 offs = ((alt % pri) + pri) % pri; /* true modulus */ 1556 if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1557 pri = (alt - offs) / pri; /* division result */ 1557 /* divide must always round down; this is a bit
1558 alt = offs; 1558 * involved to do in a machine-independent way.
1559 BREAK; 1559 */
1560 CASE(EMBRYO_OP_UMUL); 1560 offs = ((pri % alt) + alt) % alt; /* true modulus */
1561 pri = (Embryo_UCell)pri * (Embryo_UCell)alt; 1561 pri = (pri - offs) / alt; /* division result */
1562 BREAK; 1562 alt = offs;
1563 CASE(EMBRYO_OP_UDIV); 1563 BREAK;
1564 if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE); 1564 CASE(EMBRYO_OP_SDIV_ALT);
1565 offs = (Embryo_UCell)pri % (Embryo_UCell)alt; /* temporary storage */ 1565 if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1566 pri = (Embryo_UCell)pri / (Embryo_UCell)alt; 1566 /* divide must always round down; this is a bit
1567 alt = offs; 1567 * involved to do in a machine-independent way.
1568 BREAK; 1568 */
1569 CASE(EMBRYO_OP_UDIV_ALT); 1569 offs = ((alt % pri) + pri) % pri; /* true modulus */
1570 if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE); 1570 pri = (alt - offs) / pri; /* division result */
1571 offs = (Embryo_UCell)alt % (Embryo_UCell)pri; /* temporary storage */ 1571 alt = offs;
1572 pri = (Embryo_UCell)alt / (Embryo_UCell)pri; 1572 BREAK;
1573 alt = offs; 1573 CASE(EMBRYO_OP_UMUL);
1574 BREAK; 1574 pri = (Embryo_UCell)pri * (Embryo_UCell)alt;
1575 CASE(EMBRYO_OP_ADD); 1575 BREAK;
1576 pri += alt; 1576 CASE(EMBRYO_OP_UDIV);
1577 BREAK; 1577 if (alt == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1578 CASE(EMBRYO_OP_SUB); 1578 offs = (Embryo_UCell)pri % (Embryo_UCell)alt; /* temporary storage */
1579 pri -= alt; 1579 pri = (Embryo_UCell)pri / (Embryo_UCell)alt;
1580 BREAK; 1580 alt = offs;
1581 CASE(EMBRYO_OP_SUB_ALT); 1581 BREAK;
1582 pri = alt - pri; 1582 CASE(EMBRYO_OP_UDIV_ALT);
1583 BREAK; 1583 if (pri == 0) ABORT(ep, EMBRYO_ERROR_DIVIDE);
1584 CASE(EMBRYO_OP_AND); 1584 offs = (Embryo_UCell)alt % (Embryo_UCell)pri; /* temporary storage */
1585 pri &= alt; 1585 pri = (Embryo_UCell)alt / (Embryo_UCell)pri;
1586 BREAK; 1586 alt = offs;
1587 CASE(EMBRYO_OP_OR); 1587 BREAK;
1588 pri |= alt; 1588 CASE(EMBRYO_OP_ADD);
1589 BREAK; 1589 pri += alt;
1590 CASE(EMBRYO_OP_XOR); 1590 BREAK;
1591 pri ^= alt; 1591 CASE(EMBRYO_OP_SUB);
1592 BREAK; 1592 pri -= alt;
1593 CASE(EMBRYO_OP_NOT); 1593 BREAK;
1594 pri = !pri; 1594 CASE(EMBRYO_OP_SUB_ALT);
1595 BREAK; 1595 pri = alt - pri;
1596 CASE(EMBRYO_OP_NEG); 1596 BREAK;
1597 pri = -pri; 1597 CASE(EMBRYO_OP_AND);
1598 BREAK; 1598 pri &= alt;
1599 CASE(EMBRYO_OP_INVERT); 1599 BREAK;
1600 pri = ~pri; 1600 CASE(EMBRYO_OP_OR);
1601 BREAK; 1601 pri |= alt;
1602 CASE(EMBRYO_OP_ADD_C); 1602 BREAK;
1603 GETPARAM(offs); 1603 CASE(EMBRYO_OP_XOR);
1604 pri += offs; 1604 pri ^= alt;
1605 BREAK; 1605 BREAK;
1606 CASE(EMBRYO_OP_SMUL_C); 1606 CASE(EMBRYO_OP_NOT);
1607 GETPARAM(offs); 1607 pri = !pri;
1608 pri *= offs; 1608 BREAK;
1609 BREAK; 1609 CASE(EMBRYO_OP_NEG);
1610 CASE(EMBRYO_OP_ZERO_PRI); 1610 pri = -pri;
1611 pri = 0; 1611 BREAK;
1612 BREAK; 1612 CASE(EMBRYO_OP_INVERT);
1613 CASE(EMBRYO_OP_ZERO_ALT); 1613 pri = ~pri;
1614 alt = 0; 1614 BREAK;
1615 BREAK; 1615 CASE(EMBRYO_OP_ADD_C);
1616 CASE(EMBRYO_OP_ZERO); 1616 GETPARAM(offs);
1617 GETPARAM(offs); 1617 pri += offs;
1618 *(Embryo_Cell *)(data + (int)offs) = 0; 1618 BREAK;
1619 BREAK; 1619 CASE(EMBRYO_OP_SMUL_C);
1620 CASE(EMBRYO_OP_ZERO_S); 1620 GETPARAM(offs);
1621 GETPARAM(offs); 1621 pri *= offs;
1622 *(Embryo_Cell *)(data + (int)frm + (int)offs) = 0; 1622 BREAK;
1623 BREAK; 1623 CASE(EMBRYO_OP_ZERO_PRI);
1624 CASE(EMBRYO_OP_SIGN_PRI); 1624 pri = 0;
1625 if ((pri & 0xff) >= 0x80) pri |= ~(Embryo_UCell)0xff; 1625 BREAK;
1626 BREAK; 1626 CASE(EMBRYO_OP_ZERO_ALT);
1627 CASE(EMBRYO_OP_SIGN_ALT); 1627 alt = 0;
1628 if ((alt & 0xff) >= 0x80) alt |= ~(Embryo_UCell)0xff; 1628 BREAK;
1629 BREAK; 1629 CASE(EMBRYO_OP_ZERO);
1630 CASE(EMBRYO_OP_EQ); 1630 GETPARAM(offs);
1631 pri = (pri == alt) ? 1 : 0; 1631 *(Embryo_Cell *)(data + (int)offs) = 0;
1632 BREAK; 1632 BREAK;
1633 CASE(EMBRYO_OP_NEQ); 1633 CASE(EMBRYO_OP_ZERO_S);
1634 pri = (pri != alt) ? 1 : 0; 1634 GETPARAM(offs);
1635 BREAK; 1635 *(Embryo_Cell *)(data + (int)frm + (int)offs) = 0;
1636 CASE(EMBRYO_OP_LESS); 1636 BREAK;
1637 pri = ((Embryo_UCell)pri < (Embryo_UCell)alt) ? 1 : 0; 1637 CASE(EMBRYO_OP_SIGN_PRI);
1638 BREAK; 1638 if ((pri & 0xff) >= 0x80) pri |= ~(Embryo_UCell)0xff;
1639 CASE(EMBRYO_OP_LEQ); 1639 BREAK;
1640 pri = ((Embryo_UCell)pri <= (Embryo_UCell)alt) ? 1 : 0; 1640 CASE(EMBRYO_OP_SIGN_ALT);
1641 BREAK; 1641 if ((alt & 0xff) >= 0x80) alt |= ~(Embryo_UCell)0xff;
1642 CASE(EMBRYO_OP_GRTR); 1642 BREAK;
1643 pri = ((Embryo_UCell)pri > (Embryo_UCell)alt) ? 1 : 0; 1643 CASE(EMBRYO_OP_EQ);
1644 BREAK; 1644 pri = (pri == alt) ? 1 : 0;
1645 CASE(EMBRYO_OP_GEQ); 1645 BREAK;
1646 pri = ((Embryo_UCell)pri >= (Embryo_UCell)alt) ? 1 : 0; 1646 CASE(EMBRYO_OP_NEQ);
1647 BREAK; 1647 pri = (pri != alt) ? 1 : 0;
1648 CASE(EMBRYO_OP_SLESS); 1648 BREAK;
1649 pri = (pri < alt) ? 1 : 0; 1649 CASE(EMBRYO_OP_LESS);
1650 BREAK; 1650 pri = ((Embryo_UCell)pri < (Embryo_UCell)alt) ? 1 : 0;
1651 CASE(EMBRYO_OP_SLEQ); 1651 BREAK;
1652 pri = (pri <= alt) ? 1 : 0; 1652 CASE(EMBRYO_OP_LEQ);
1653 BREAK; 1653 pri = ((Embryo_UCell)pri <= (Embryo_UCell)alt) ? 1 : 0;
1654 CASE(EMBRYO_OP_SGRTR); 1654 BREAK;
1655 pri = (pri > alt) ? 1 : 0; 1655 CASE(EMBRYO_OP_GRTR);
1656 BREAK; 1656 pri = ((Embryo_UCell)pri > (Embryo_UCell)alt) ? 1 : 0;
1657 CASE(EMBRYO_OP_SGEQ); 1657 BREAK;
1658 pri = (pri >= alt) ? 1 : 0; 1658 CASE(EMBRYO_OP_GEQ);
1659 BREAK; 1659 pri = ((Embryo_UCell)pri >= (Embryo_UCell)alt) ? 1 : 0;
1660 CASE(EMBRYO_OP_EQ_C_PRI); 1660 BREAK;
1661 GETPARAM(offs); 1661 CASE(EMBRYO_OP_SLESS);
1662 pri = (pri == offs) ? 1 : 0; 1662 pri = (pri < alt) ? 1 : 0;
1663 BREAK; 1663 BREAK;
1664 CASE(EMBRYO_OP_EQ_C_ALT); 1664 CASE(EMBRYO_OP_SLEQ);
1665 GETPARAM(offs); 1665 pri = (pri <= alt) ? 1 : 0;
1666 pri = (alt == offs) ? 1 : 0; 1666 BREAK;
1667 BREAK; 1667 CASE(EMBRYO_OP_SGRTR);
1668 CASE(EMBRYO_OP_INC_PRI); 1668 pri = (pri > alt) ? 1 : 0;
1669 pri++; 1669 BREAK;
1670 BREAK; 1670 CASE(EMBRYO_OP_SGEQ);
1671 CASE(EMBRYO_OP_INC_ALT); 1671 pri = (pri >= alt) ? 1 : 0;
1672 alt++; 1672 BREAK;
1673 BREAK; 1673 CASE(EMBRYO_OP_EQ_C_PRI);
1674 CASE(EMBRYO_OP_INC); 1674 GETPARAM(offs);
1675 GETPARAM(offs); 1675 pri = (pri == offs) ? 1 : 0;
1676 *(Embryo_Cell *)(data + (int)offs) += 1; 1676 BREAK;
1677 BREAK; 1677 CASE(EMBRYO_OP_EQ_C_ALT);
1678 CASE(EMBRYO_OP_INC_S); 1678 GETPARAM(offs);
1679 GETPARAM(offs); 1679 pri = (alt == offs) ? 1 : 0;
1680 *(Embryo_Cell *)(data + (int)frm + (int)offs) += 1; 1680 BREAK;
1681 BREAK; 1681 CASE(EMBRYO_OP_INC_PRI);
1682 CASE(EMBRYO_OP_INC_I); 1682 pri++;
1683 *(Embryo_Cell *)(data + (int)pri) += 1; 1683 BREAK;
1684 BREAK; 1684 CASE(EMBRYO_OP_INC_ALT);
1685 CASE(EMBRYO_OP_DEC_PRI); 1685 alt++;
1686 pri--; 1686 BREAK;
1687 BREAK; 1687 CASE(EMBRYO_OP_INC);
1688 CASE(EMBRYO_OP_DEC_ALT); 1688 GETPARAM(offs);
1689 alt--; 1689 *(Embryo_Cell *)(data + (int)offs) += 1;
1690 BREAK; 1690 BREAK;
1691 CASE(EMBRYO_OP_DEC); 1691 CASE(EMBRYO_OP_INC_S);
1692 GETPARAM(offs); 1692 GETPARAM(offs);
1693 *(Embryo_Cell *)(data + (int)offs) -= 1; 1693 *(Embryo_Cell *)(data + (int)frm + (int)offs) += 1;
1694 BREAK; 1694 BREAK;
1695 CASE(EMBRYO_OP_DEC_S); 1695 CASE(EMBRYO_OP_INC_I);
1696 GETPARAM(offs); 1696 *(Embryo_Cell *)(data + (int)pri) += 1;
1697 *(Embryo_Cell *)(data + (int)frm + (int)offs) -= 1; 1697 BREAK;
1698 BREAK; 1698 CASE(EMBRYO_OP_DEC_PRI);
1699 CASE(EMBRYO_OP_DEC_I); 1699 pri--;
1700 *(Embryo_Cell *)(data + (int)pri) -= 1; 1700 BREAK;
1701 BREAK; 1701 CASE(EMBRYO_OP_DEC_ALT);
1702 CASE(EMBRYO_OP_MOVS); 1702 alt--;
1703 GETPARAM(offs); 1703 BREAK;
1704 CHKMEM(pri); 1704 CASE(EMBRYO_OP_DEC);
1705 CHKMEM(pri + offs); 1705 GETPARAM(offs);
1706 CHKMEM(alt); 1706 *(Embryo_Cell *)(data + (int)offs) -= 1;
1707 CHKMEM(alt + offs); 1707 BREAK;
1708 memcpy(data+(int)alt, data+(int)pri, (int)offs); 1708 CASE(EMBRYO_OP_DEC_S);
1709 BREAK; 1709 GETPARAM(offs);
1710 CASE(EMBRYO_OP_CMPS); 1710 *(Embryo_Cell *)(data + (int)frm + (int)offs) -= 1;
1711 GETPARAM(offs); 1711 BREAK;
1712 CHKMEM(pri); 1712 CASE(EMBRYO_OP_DEC_I);
1713 CHKMEM(pri + offs); 1713 *(Embryo_Cell *)(data + (int)pri) -= 1;
1714 CHKMEM(alt); 1714 BREAK;
1715 CHKMEM(alt + offs); 1715 CASE(EMBRYO_OP_MOVS);
1716 pri = memcmp(data + (int)alt, data + (int)pri, (int)offs); 1716 GETPARAM(offs);
1717 BREAK; 1717 CHKMEM(pri);
1718 CASE(EMBRYO_OP_FILL); 1718 CHKMEM(pri + offs);
1719 GETPARAM(offs); 1719 CHKMEM(alt);
1720 CHKMEM(alt); 1720 CHKMEM(alt + offs);
1721 CHKMEM(alt + offs); 1721 memcpy(data + (int)alt, data + (int)pri, (int)offs);
1722 for (i = (int)alt; 1722 BREAK;
1723 (size_t)offs >= sizeof(Embryo_Cell); 1723 CASE(EMBRYO_OP_CMPS);
1724 i += sizeof(Embryo_Cell), offs -= sizeof(Embryo_Cell)) 1724 GETPARAM(offs);
1725 *(Embryo_Cell *)(data + i) = pri; 1725 CHKMEM(pri);
1726 BREAK; 1726 CHKMEM(pri + offs);
1727 CASE(EMBRYO_OP_HALT); 1727 CHKMEM(alt);
1728 GETPARAM(offs); 1728 CHKMEM(alt + offs);
1729 ep->retval = pri; 1729 pri = memcmp(data + (int)alt, data + (int)pri, (int)offs);
1730 /* store complete status */ 1730 BREAK;
1731 ep->frm = frm; 1731 CASE(EMBRYO_OP_FILL);
1732 ep->stk = stk; 1732 GETPARAM(offs);
1733 ep->hea = hea; 1733 CHKMEM(alt);
1734 ep->pri = pri; 1734 CHKMEM(alt + offs);
1735 ep->alt = alt; 1735 for (i = (int)alt;
1736 ep->cip = (Embryo_Cell)((unsigned char*)cip - code); 1736 (size_t)offs >= sizeof(Embryo_Cell);
1737 if (offs == EMBRYO_ERROR_SLEEP) 1737 i += sizeof(Embryo_Cell), offs -= sizeof(Embryo_Cell))
1738 { 1738 *(Embryo_Cell *)(data + i) = pri;
1739 ep->reset_stk = reset_stk; 1739 BREAK;
1740 ep->reset_hea = reset_hea; 1740 CASE(EMBRYO_OP_HALT);
1741 ep->run_count--; 1741 GETPARAM(offs);
1742 return EMBRYO_PROGRAM_SLEEP; 1742 ep->retval = pri;
1743 } 1743 /* store complete status */
1744 OK(ep, (int)offs); 1744 ep->frm = frm;
1745 CASE(EMBRYO_OP_BOUNDS); 1745 ep->stk = stk;
1746 GETPARAM(offs); 1746 ep->hea = hea;
1747 if ((Embryo_UCell)pri > (Embryo_UCell)offs) 1747 ep->pri = pri;
1748 ABORT(ep, EMBRYO_ERROR_BOUNDS); 1748 ep->alt = alt;
1749 BREAK; 1749 ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
1750 CASE(EMBRYO_OP_SYSREQ_PRI); 1750 if (offs == EMBRYO_ERROR_SLEEP)
1751 /* save a few registers */ 1751 {
1752 ep->cip = (Embryo_Cell)((unsigned char *)cip - code); 1752 ep->reset_stk = reset_stk;
1753 ep->hea = hea; 1753 ep->reset_hea = reset_hea;
1754 ep->frm = frm; 1754 ep->run_count--;
1755 ep->stk = stk; 1755 return EMBRYO_PROGRAM_SLEEP;
1756 num = _embryo_native_call(ep, pri, &pri, (Embryo_Cell *)(data + (int)stk)); 1756 }
1757 if (num != EMBRYO_ERROR_NONE) 1757 OK(ep, (int)offs);
1758 { 1758 CASE(EMBRYO_OP_BOUNDS);
1759 if (num == EMBRYO_ERROR_SLEEP) 1759 GETPARAM(offs);
1760 { 1760 if ((Embryo_UCell)pri > (Embryo_UCell)offs)
1761 ep->pri = pri; 1761 ABORT(ep, EMBRYO_ERROR_BOUNDS);
1762 ep->alt = alt; 1762 BREAK;
1763 ep->reset_stk = reset_stk; 1763 CASE(EMBRYO_OP_SYSREQ_PRI);
1764 ep->reset_hea = reset_hea; 1764 /* save a few registers */
1765 ep->run_count--; 1765 ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
1766 return EMBRYO_PROGRAM_SLEEP; 1766 ep->hea = hea;
1767 } 1767 ep->frm = frm;
1768 ABORT(ep, num); 1768 ep->stk = stk;
1769 } 1769 num = _embryo_native_call(ep, pri, &pri, (Embryo_Cell *)(data + (int)stk));
1770 BREAK; 1770 if (num != EMBRYO_ERROR_NONE)
1771 CASE(EMBRYO_OP_SYSREQ_C); 1771 {
1772 GETPARAM(offs); 1772 if (num == EMBRYO_ERROR_SLEEP)
1773 /* save a few registers */ 1773 {
1774 ep->cip = (Embryo_Cell)((unsigned char *)cip - code); 1774 ep->pri = pri;
1775 ep->hea = hea; 1775 ep->alt = alt;
1776 ep->frm = frm; 1776 ep->reset_stk = reset_stk;
1777 ep->stk = stk; 1777 ep->reset_hea = reset_hea;
1778 num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk)); 1778 ep->run_count--;
1779 if (num != EMBRYO_ERROR_NONE) 1779 return EMBRYO_PROGRAM_SLEEP;
1780 { 1780 }
1781 if (num == EMBRYO_ERROR_SLEEP) 1781 ABORT(ep, num);
1782 { 1782 }
1783 ep->pri = pri; 1783 BREAK;
1784 ep->alt = alt; 1784 CASE(EMBRYO_OP_SYSREQ_C);
1785 ep->reset_stk = reset_stk; 1785 GETPARAM(offs);
1786 ep->reset_hea = reset_hea; 1786 /* save a few registers */
1787 ep->run_count--; 1787 ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
1788 return EMBRYO_PROGRAM_SLEEP; 1788 ep->hea = hea;
1789 } 1789 ep->frm = frm;
1790 { 1790 ep->stk = stk;
1791 Embryo_Header *hdr2; 1791 num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
1792 int j, num2; 1792 if (num != EMBRYO_ERROR_NONE)
1793 Embryo_Func_Stub *func_entry; 1793 {
1794 1794 if (num == EMBRYO_ERROR_SLEEP)
1795 hdr2 = (Embryo_Header *)ep->code; 1795 {
1796 num2 = NUMENTRIES(hdr2, natives, libraries); 1796 ep->pri = pri;
1797 func_entry = GETENTRY(hdr2, natives, 0); 1797 ep->alt = alt;
1798 for (j = 0; j < num2; j++) 1798 ep->reset_stk = reset_stk;
1799 { 1799 ep->reset_hea = reset_hea;
1800 char *entry_name; 1800 ep->run_count--;
1801 1801 return EMBRYO_PROGRAM_SLEEP;
1802 entry_name = GETENTRYNAME(hdr2, func_entry); 1802 }
1803 if (j == offs) 1803 {
1804 printf("EMBRYO: CALL [%i] %s() non-existent!\n", j, entry_name); 1804 Embryo_Header *hdr2;
1805 func_entry = 1805 int j, num2;
1806 (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr2->defsize); 1806 Embryo_Func_Stub *func_entry;
1807 } 1807
1808 } 1808 hdr2 = (Embryo_Header *)ep->code;
1809 ABORT(ep, num); 1809 num2 = NUMENTRIES(hdr2, natives, libraries);
1810 } 1810 func_entry = GETENTRY(hdr2, natives, 0);
1811 BREAK; 1811 for (j = 0; j < num2; j++)
1812 CASE(EMBRYO_OP_SYSREQ_D); 1812 {
1813 GETPARAM(offs); 1813 char *entry_name;
1814 /* save a few registers */ 1814
1815 ep->cip = (Embryo_Cell)((unsigned char *)cip - code); 1815 entry_name = GETENTRYNAME(hdr2, func_entry);
1816 ep->hea = hea; 1816 if (j == offs)
1817 ep->frm = frm; 1817 printf("EMBRYO: CALL [%i] %s() non-existent!\n", j, entry_name);
1818 ep->stk = stk; 1818 func_entry =
1819 num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk)); 1819 (Embryo_Func_Stub *)((unsigned char *)func_entry + hdr2->defsize);
1820 if (num != EMBRYO_ERROR_NONE) 1820 }
1821 { 1821 }
1822 if (num == EMBRYO_ERROR_SLEEP) 1822 ABORT(ep, num);
1823 { 1823 }
1824 ep->pri = pri; 1824 BREAK;
1825 ep->alt = alt; 1825 CASE(EMBRYO_OP_SYSREQ_D);
1826 ep->reset_stk = reset_stk; 1826 GETPARAM(offs);
1827 ep->reset_hea = reset_hea; 1827 /* save a few registers */
1828 ep->run_count--; 1828 ep->cip = (Embryo_Cell)((unsigned char *)cip - code);
1829 return EMBRYO_PROGRAM_SLEEP; 1829 ep->hea = hea;
1830 } 1830 ep->frm = frm;
1831 ABORT(ep, ep->error); 1831 ep->stk = stk;
1832 } 1832 num = _embryo_native_call(ep, offs, &pri, (Embryo_Cell *)(data + (int)stk));
1833 BREAK; 1833 if (num != EMBRYO_ERROR_NONE)
1834 CASE(EMBRYO_OP_JUMP_PRI); 1834 {
1835 cip = (Embryo_Cell *)(code + (int)pri); 1835 if (num == EMBRYO_ERROR_SLEEP)
1836 BREAK; 1836 {
1837 CASE(EMBRYO_OP_SWITCH); 1837 ep->pri = pri;
1838 { 1838 ep->alt = alt;
1839 Embryo_Cell *cptr; 1839 ep->reset_stk = reset_stk;
1840 1840 ep->reset_hea = reset_hea;
1841 /* +1, to skip the "casetbl" opcode */ 1841 ep->run_count--;
1842 cptr = (Embryo_Cell *)(code + (*cip)) + 1; 1842 return EMBRYO_PROGRAM_SLEEP;
1843 /* number of records in the case table */ 1843 }
1844 num = (int)(*cptr); 1844 ABORT(ep, ep->error);
1845 /* preset to "none-matched" case */ 1845 }
1846 cip = (Embryo_Cell *)(code + *(cptr + 1)); 1846 BREAK;
1847 for (cptr += 2; 1847 CASE(EMBRYO_OP_JUMP_PRI);
1848 (num > 0) && (*cptr != pri); 1848 cip = (Embryo_Cell *)(code + (int)pri);
1849 num--, cptr += 2); 1849 BREAK;
1850 /* case found */ 1850 CASE(EMBRYO_OP_SWITCH);
1851 if (num > 0) 1851 {
1852 cip = (Embryo_Cell *)(code + *(cptr + 1)); 1852 Embryo_Cell *cptr;
1853 } 1853
1854 BREAK; 1854 /* +1, to skip the "casetbl" opcode */
1855 CASE(EMBRYO_OP_SWAP_PRI); 1855 cptr = (Embryo_Cell *)(code + (*cip)) + 1;
1856 offs = *(Embryo_Cell *)(data + (int)stk); 1856 /* number of records in the case table */
1857 *(Embryo_Cell *)(data + (int)stk) = pri; 1857 num = (int)(*cptr);
1858 pri = offs; 1858 /* preset to "none-matched" case */
1859 BREAK; 1859 cip = (Embryo_Cell *)(code + *(cptr + 1));
1860 CASE(EMBRYO_OP_SWAP_ALT); 1860 for (cptr += 2;
1861 offs = *(Embryo_Cell *)(data + (int)stk); 1861 (num > 0) && (*cptr != pri);
1862 *(Embryo_Cell *)(data + (int)stk) = alt; 1862 num--, cptr += 2) ;
1863 alt = offs; 1863 /* case found */
1864 BREAK; 1864 if (num > 0)
1865 CASE(EMBRYO_OP_PUSHADDR); 1865 cip = (Embryo_Cell *)(code + *(cptr + 1));
1866 GETPARAM(offs); 1866 }
1867 PUSH(frm + offs); 1867 BREAK;
1868 BREAK; 1868 CASE(EMBRYO_OP_SWAP_PRI);
1869 CASE(EMBRYO_OP_NOP); 1869 offs = *(Embryo_Cell *)(data + (int)stk);
1870 BREAK; 1870 *(Embryo_Cell *)(data + (int)stk) = pri;
1871 CASE(EMBRYO_OP_NONE); 1871 pri = offs;
1872 CASE(EMBRYO_OP_FILE); 1872 BREAK;
1873 CASE(EMBRYO_OP_LINE); 1873 CASE(EMBRYO_OP_SWAP_ALT);
1874 CASE(EMBRYO_OP_SYMBOL); 1874 offs = *(Embryo_Cell *)(data + (int)stk);
1875 CASE(EMBRYO_OP_SRANGE); 1875 *(Embryo_Cell *)(data + (int)stk) = alt;
1876 CASE(EMBRYO_OP_CASETBL); 1876 alt = offs;
1877 CASE(EMBRYO_OP_SYMTAG); 1877 BREAK;
1878 BREAK; 1878 CASE(EMBRYO_OP_PUSHADDR);
1879 GETPARAM(offs);
1880 PUSH(frm + offs);
1881 BREAK;
1882 CASE(EMBRYO_OP_NOP);
1883 BREAK;
1884 CASE(EMBRYO_OP_NONE);
1885 CASE(EMBRYO_OP_FILE);
1886 CASE(EMBRYO_OP_LINE);
1887 CASE(EMBRYO_OP_SYMBOL);
1888 CASE(EMBRYO_OP_SRANGE);
1889 CASE(EMBRYO_OP_CASETBL);
1890 CASE(EMBRYO_OP_SYMTAG);
1891 BREAK;
1892
1879#ifndef EMBRYO_EXEC_JUMPTABLE 1893#ifndef EMBRYO_EXEC_JUMPTABLE
1880 default: 1894 default:
1881 ABORT(ep, EMBRYO_ERROR_INVINSTR); 1895 ABORT(ep, EMBRYO_ERROR_INVINSTR);
1882#endif 1896#endif
1883 SWITCHEND; 1897 SWITCHEND;
1884 } 1898 }
1885 ep->max_run_cycles = max_run_cycles; 1899 ep->max_run_cycles = max_run_cycles;
1886 ep->run_count--; 1900 ep->run_count--;
@@ -1910,7 +1924,6 @@ embryo_program_max_cycle_run_get(Embryo_Program *ep)
1910 return ep->max_run_cycles; 1924 return ep->max_run_cycles;
1911} 1925}
1912 1926
1913
1914EAPI int 1927EAPI int
1915embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell) 1928embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell)
1916{ 1929{
@@ -1919,10 +1932,10 @@ embryo_parameter_cell_push(Embryo_Program *ep, Embryo_Cell cell)
1919 ep->params_size++; 1932 ep->params_size++;
1920 if (ep->params_size > ep->params_alloc) 1933 if (ep->params_size > ep->params_alloc)
1921 { 1934 {
1922 ep->params_alloc += 8; 1935 ep->params_alloc += 8;
1923 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param)); 1936 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
1924 if (!pr) return 0; 1937 if (!pr) return 0;
1925 ep->params = pr; 1938 ep->params = pr;
1926 } 1939 }
1927 pr = &(ep->params[ep->params_size - 1]); 1940 pr = &(ep->params[ep->params_size - 1]);
1928 pr->string = NULL; 1941 pr->string = NULL;
@@ -1945,14 +1958,14 @@ embryo_parameter_string_push(Embryo_Program *ep, const char *str)
1945 ep->params_size++; 1958 ep->params_size++;
1946 if (ep->params_size > ep->params_alloc) 1959 if (ep->params_size > ep->params_alloc)
1947 { 1960 {
1948 ep->params_alloc += 8; 1961 ep->params_alloc += 8;
1949 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param)); 1962 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
1950 if (!pr) 1963 if (!pr)
1951 { 1964 {
1952 free(str_dup); 1965 free(str_dup);
1953 return 0; 1966 return 0;
1954 } 1967 }
1955 ep->params = pr; 1968 ep->params = pr;
1956 } 1969 }
1957 pr = &(ep->params[ep->params_size - 1]); 1970 pr = &(ep->params[ep->params_size - 1]);
1958 pr->string = str_dup; 1971 pr->string = str_dup;
@@ -1974,14 +1987,14 @@ embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num
1974 ep->params_size++; 1987 ep->params_size++;
1975 if (ep->params_size > ep->params_alloc) 1988 if (ep->params_size > ep->params_alloc)
1976 { 1989 {
1977 ep->params_alloc += 8; 1990 ep->params_alloc += 8;
1978 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param)); 1991 pr = realloc(ep->params, ep->params_alloc * sizeof(Embryo_Param));
1979 if (!pr) 1992 if (!pr)
1980 { 1993 {
1981 free(cell_array); 1994 free(cell_array);
1982 return 0; 1995 return 0;
1983 } 1996 }
1984 ep->params = pr; 1997 ep->params = pr;
1985 } 1998 }
1986 pr = &(ep->params[ep->params_size - 1]); 1999 pr = &(ep->params[ep->params_size - 1]);
1987 pr->string = NULL; 2000 pr->string = NULL;
@@ -1991,3 +2004,4 @@ embryo_parameter_cell_array_push(Embryo_Program *ep, Embryo_Cell *cells, int num
1991 memcpy(pr->cell_array, cells, num * sizeof(Embryo_Cell)); 2004 memcpy(pr->cell_array, cells, num * sizeof(Embryo_Cell));
1992 return 1; 2005 return 1;
1993} 2006}
2007
diff --git a/src/lib/embryo/embryo_args.c b/src/lib/embryo/embryo_args.c
index c0682e6353..e741d8a32a 100644
--- a/src/lib/embryo/embryo_args.c
+++ b/src/lib/embryo/embryo_args.c
@@ -7,11 +7,11 @@
7#include "Embryo.h" 7#include "Embryo.h"
8#include "embryo_private.h" 8#include "embryo_private.h"
9 9
10#define STRSET(ep, par, str) { \ 10#define STRSET(ep, par, str) { \
11 Embryo_Cell *___cptr; \ 11 Embryo_Cell *___cptr; \
12 if ((___cptr = embryo_data_address_get(ep, par))) { \ 12 if ((___cptr = embryo_data_address_get(ep, par))) { \
13 embryo_data_string_set(ep, str, ___cptr); \ 13 embryo_data_string_set(ep, str, ___cptr); \
14 } } 14 } }
15 15
16/* exported args api */ 16/* exported args api */
17 17
@@ -25,7 +25,7 @@ _embryo_args_numargs(Embryo_Program *ep, Embryo_Cell *params EINA_UNUSED)
25 hdr = (Embryo_Header *)ep->base; 25 hdr = (Embryo_Header *)ep->base;
26 data = ep->base + (int)hdr->dat; 26 data = ep->base + (int)hdr->dat;
27 bytes = *(Embryo_Cell *)(data + (int)ep->frm + 27 bytes = *(Embryo_Cell *)(data + (int)ep->frm +
28 (2 * sizeof(Embryo_Cell))); 28 (2 * sizeof(Embryo_Cell)));
29 return bytes / sizeof(Embryo_Cell); 29 return bytes / sizeof(Embryo_Cell);
30} 30}
31 31
@@ -40,7 +40,7 @@ _embryo_args_getarg(Embryo_Program *ep, Embryo_Cell *params)
40 hdr = (Embryo_Header *)ep->base; 40 hdr = (Embryo_Header *)ep->base;
41 data = ep->base + (int)hdr->dat; 41 data = ep->base + (int)hdr->dat;
42 val = *(Embryo_Cell *)(data + (int)ep->frm + 42 val = *(Embryo_Cell *)(data + (int)ep->frm +
43 (((int)params[1] + 3) * sizeof(Embryo_Cell))); 43 (((int)params[1] + 3) * sizeof(Embryo_Cell)));
44 val += params[2] * sizeof(Embryo_Cell); 44 val += params[2] * sizeof(Embryo_Cell);
45 val = *(Embryo_Cell *)(data + (int)val); 45 val = *(Embryo_Cell *)(data + (int)val);
46 return val; 46 return val;
@@ -57,7 +57,7 @@ _embryo_args_setarg(Embryo_Program *ep, Embryo_Cell *params)
57 hdr = (Embryo_Header *)ep->base; 57 hdr = (Embryo_Header *)ep->base;
58 data = ep->base + (int)hdr->dat; 58 data = ep->base + (int)hdr->dat;
59 val = *(Embryo_Cell *)(data + (int)ep->frm + 59 val = *(Embryo_Cell *)(data + (int)ep->frm +
60 (((int)params[1] + 3) * sizeof(Embryo_Cell))); 60 (((int)params[1] + 3) * sizeof(Embryo_Cell)));
61 val += params[2] * sizeof(Embryo_Cell); 61 val += params[2] * sizeof(Embryo_Cell);
62 if ((val < 0) || ((val >= ep->hea) && (val < ep->stk))) return 0; 62 if ((val < 0) || ((val >= ep->hea) && (val < ep->stk))) return 0;
63 *(Embryo_Cell *)(data + (int)val) = params[3]; 63 *(Embryo_Cell *)(data + (int)val) = params[3];
@@ -77,20 +77,20 @@ _embryo_args_getsarg(Embryo_Program *ep, Embryo_Cell *params)
77 /* params[2] = buf */ 77 /* params[2] = buf */
78 /* params[3] = buflen */ 78 /* params[3] = buflen */
79 if (params[0] != (3 * sizeof(Embryo_Cell))) return 0; 79 if (params[0] != (3 * sizeof(Embryo_Cell))) return 0;
80 if (params[3] <= 0) return 0; /* buflen must be > 0 */ 80 if (params[3] <= 0) return 0; /* buflen must be > 0 */
81 hdr = (Embryo_Header *)ep->base; 81 hdr = (Embryo_Header *)ep->base;
82 data = ep->base + (int)hdr->dat; 82 data = ep->base + (int)hdr->dat;
83 base_cell = *(Embryo_Cell *)(data + (int)ep->frm + 83 base_cell = *(Embryo_Cell *)(data + (int)ep->frm +
84 (((int)params[1] + 3) * sizeof(Embryo_Cell))); 84 (((int)params[1] + 3) * sizeof(Embryo_Cell)));
85 85
86 s = alloca(params[3]); 86 s = alloca(params[3]);
87 87
88 while (i < params[3]) 88 while (i < params[3])
89 { 89 {
90 int offset = base_cell + (i * sizeof(Embryo_Cell)); 90 int offset = base_cell + (i * sizeof(Embryo_Cell));
91 91
92 s[i] = *(Embryo_Cell *)(data + offset); 92 s[i] = *(Embryo_Cell *)(data + offset);
93 if (!s[i++]) break; 93 if (!s[i++]) break;
94 } 94 }
95 95
96 s[i - 1] = 0; 96 s[i - 1] = 0;
@@ -104,10 +104,11 @@ _embryo_args_getsarg(Embryo_Program *ep, Embryo_Cell *params)
104void 104void
105_embryo_args_init(Embryo_Program *ep) 105_embryo_args_init(Embryo_Program *ep)
106{ 106{
107 embryo_program_native_call_add(ep, "numargs", _embryo_args_numargs); 107 embryo_program_native_call_add(ep, "numargs", _embryo_args_numargs);
108 embryo_program_native_call_add(ep, "getarg", _embryo_args_getarg); 108 embryo_program_native_call_add(ep, "getarg", _embryo_args_getarg);
109 embryo_program_native_call_add(ep, "setarg", _embryo_args_setarg); 109 embryo_program_native_call_add(ep, "setarg", _embryo_args_setarg);
110 embryo_program_native_call_add(ep, "getfarg", _embryo_args_getarg); 110 embryo_program_native_call_add(ep, "getfarg", _embryo_args_getarg);
111 embryo_program_native_call_add(ep, "setfarg", _embryo_args_setarg); 111 embryo_program_native_call_add(ep, "setfarg", _embryo_args_setarg);
112 embryo_program_native_call_add(ep, "getsarg", _embryo_args_getsarg); 112 embryo_program_native_call_add(ep, "getsarg", _embryo_args_getsarg);
113} 113}
114
diff --git a/src/lib/embryo/embryo_float.c b/src/lib/embryo/embryo_float.c
index 84914774cf..23c6a5c89e 100644
--- a/src/lib/embryo/embryo_float.c
+++ b/src/lib/embryo/embryo_float.c
@@ -36,7 +36,6 @@
36 * Carsten Haitzler, <raster@rasterman.com> 36 * Carsten Haitzler, <raster@rasterman.com>
37 */ 37 */
38 38
39
40#ifdef HAVE_CONFIG_H 39#ifdef HAVE_CONFIG_H
41# include "config.h" 40# include "config.h"
42#endif 41#endif
@@ -49,7 +48,7 @@
49#include "Embryo.h" 48#include "Embryo.h"
50#include "embryo_private.h" 49#include "embryo_private.h"
51 50
52#define PI 3.1415926535897932384626433832795f 51#define PI 3.1415926535897932384626433832795f
53#ifndef MAXFLOAT 52#ifndef MAXFLOAT
54#define MAXFLOAT 3.40282347e+38f 53#define MAXFLOAT 3.40282347e+38f
55#endif 54#endif
@@ -62,11 +61,13 @@ _embryo_fp_degrees_to_radians(float angle, int radix)
62 switch (radix) 61 switch (radix)
63 { 62 {
64 case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */ 63 case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */
65 return (angle * PI / 180.0f); 64 return angle * PI / 180.0f;
65
66 case 2: /* grades, centesimal system */ 66 case 2: /* grades, centesimal system */
67 return (angle * PI / 200.0f); 67 return angle * PI / 200.0f;
68
68 default: /* assume already radian */ 69 default: /* assume already radian */
69 break; 70 break;
70 } 71 }
71 return angle; 72 return angle;
72} 73}
@@ -187,20 +188,23 @@ _embryo_fp_round(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params)
187 switch (params[2]) 188 switch (params[2])
188 { 189 {
189 case 1: /* round downwards (truncate) */ 190 case 1: /* round downwards (truncate) */
190 f = (floorf(f)); 191 f = (floorf(f));
191 break; 192 break;
193
192 case 2: /* round upwards */ 194 case 2: /* round upwards */
193 f = (ceilf(f)); 195 f = (ceilf(f));
194 break; 196 break;
197
195 case 3: /* round towards zero */ 198 case 3: /* round towards zero */
196 if (f >= 0.0) f = (floorf(f)); 199 if (f >= 0.0) f = (floorf(f));
197 else f = (ceilf(f)); 200 else f = (ceilf(f));
198 break; 201 break;
202
199 default: /* standard, round to nearest */ 203 default: /* standard, round to nearest */
200 f = (floorf(f + 0.5)); 204 f = (floorf(f + 0.5));
201 break; 205 break;
202 } 206 }
203 return (Embryo_Cell)f; 207 return (Embryo_Cell)f;
204} 208}
205 209
206static Embryo_Cell 210static Embryo_Cell
@@ -214,7 +218,8 @@ _embryo_fp_cmp(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params)
214 f = EMBRYO_CELL_TO_FLOAT(params[1]); 218 f = EMBRYO_CELL_TO_FLOAT(params[1]);
215 ff = EMBRYO_CELL_TO_FLOAT(params[2]); 219 ff = EMBRYO_CELL_TO_FLOAT(params[2]);
216 if (f == ff) return 0; 220 if (f == ff) return 0;
217 else if (f > ff) return 1; 221 else if (f > ff)
222 return 1;
218 return -1; 223 return -1;
219} 224}
220 225
@@ -229,8 +234,8 @@ _embryo_fp_sqroot(Embryo_Program *ep, Embryo_Cell *params)
229 f = sqrtf(f); 234 f = sqrtf(f);
230 if (f < 0) 235 if (f < 0)
231 { 236 {
232 embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN); 237 embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN);
233 return 0; 238 return 0;
234 } 239 }
235 return EMBRYO_FLOAT_TO_CELL(f); 240 return EMBRYO_FLOAT_TO_CELL(f);
236} 241}
@@ -261,18 +266,19 @@ _embryo_fp_log(Embryo_Program *ep, Embryo_Cell *params)
261 ff = EMBRYO_CELL_TO_FLOAT(params[2]); 266 ff = EMBRYO_CELL_TO_FLOAT(params[2]);
262 if ((f <= 0.0) || (ff <= 0.0)) 267 if ((f <= 0.0) || (ff <= 0.0))
263 { 268 {
264 embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN); 269 embryo_program_error_set(ep, EMBRYO_ERROR_DOMAIN);
265 return 0; 270 return 0;
266 } 271 }
267 if (ff == 10.0) f = log10f(f); 272 if (ff == 10.0) f = log10f(f);
268 else if (ff == 2.0) f = log2f(f); 273 else if (ff == 2.0)
269 else 274 f = log2f(f);
275 else
270 { 276 {
271 tf = logf(ff); 277 tf = logf(ff);
272 if (tf == 0.0) f = 0.0; 278 if (tf == 0.0) f = 0.0;
273 else f = (logf(f) / tf); 279 else f = (logf(f) / tf);
274 } 280 }
275 return EMBRYO_FLOAT_TO_CELL(f); 281 return EMBRYO_FLOAT_TO_CELL(f);
276} 282}
277 283
278static Embryo_Cell 284static Embryo_Cell
@@ -453,30 +459,31 @@ _embryo_fp_hypot(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params)
453void 459void
454_embryo_fp_init(Embryo_Program *ep) 460_embryo_fp_init(Embryo_Program *ep)
455{ 461{
456 embryo_program_native_call_add(ep, "float", _embryo_fp); 462 embryo_program_native_call_add(ep, "float", _embryo_fp);
457 embryo_program_native_call_add(ep, "atof", _embryo_fp_str); 463 embryo_program_native_call_add(ep, "atof", _embryo_fp_str);
458 embryo_program_native_call_add(ep, "float_mul", _embryo_fp_mul); 464 embryo_program_native_call_add(ep, "float_mul", _embryo_fp_mul);
459 embryo_program_native_call_add(ep, "float_div", _embryo_fp_div); 465 embryo_program_native_call_add(ep, "float_div", _embryo_fp_div);
460 embryo_program_native_call_add(ep, "float_add", _embryo_fp_add); 466 embryo_program_native_call_add(ep, "float_add", _embryo_fp_add);
461 embryo_program_native_call_add(ep, "float_sub", _embryo_fp_sub); 467 embryo_program_native_call_add(ep, "float_sub", _embryo_fp_sub);
462 embryo_program_native_call_add(ep, "fract", _embryo_fp_fract); 468 embryo_program_native_call_add(ep, "fract", _embryo_fp_fract);
463 embryo_program_native_call_add(ep, "round", _embryo_fp_round); 469 embryo_program_native_call_add(ep, "round", _embryo_fp_round);
464 embryo_program_native_call_add(ep, "float_cmp", _embryo_fp_cmp); 470 embryo_program_native_call_add(ep, "float_cmp", _embryo_fp_cmp);
465 embryo_program_native_call_add(ep, "sqrt", _embryo_fp_sqroot); 471 embryo_program_native_call_add(ep, "sqrt", _embryo_fp_sqroot);
466 embryo_program_native_call_add(ep, "pow", _embryo_fp_power); 472 embryo_program_native_call_add(ep, "pow", _embryo_fp_power);
467 embryo_program_native_call_add(ep, "log", _embryo_fp_log); 473 embryo_program_native_call_add(ep, "log", _embryo_fp_log);
468 embryo_program_native_call_add(ep, "sin", _embryo_fp_sin); 474 embryo_program_native_call_add(ep, "sin", _embryo_fp_sin);
469 embryo_program_native_call_add(ep, "cos", _embryo_fp_cos); 475 embryo_program_native_call_add(ep, "cos", _embryo_fp_cos);
470 embryo_program_native_call_add(ep, "tan", _embryo_fp_tan); 476 embryo_program_native_call_add(ep, "tan", _embryo_fp_tan);
471 embryo_program_native_call_add(ep, "abs", _embryo_fp_abs); 477 embryo_program_native_call_add(ep, "abs", _embryo_fp_abs);
472 /* Added in embryo 1.2 */ 478 /* Added in embryo 1.2 */
473 embryo_program_native_call_add(ep, "asin", _embryo_fp_asin); 479 embryo_program_native_call_add(ep, "asin", _embryo_fp_asin);
474 embryo_program_native_call_add(ep, "acos", _embryo_fp_acos); 480 embryo_program_native_call_add(ep, "acos", _embryo_fp_acos);
475 embryo_program_native_call_add(ep, "atan", _embryo_fp_atan); 481 embryo_program_native_call_add(ep, "atan", _embryo_fp_atan);
476 embryo_program_native_call_add(ep, "atan2", _embryo_fp_atan2); 482 embryo_program_native_call_add(ep, "atan2", _embryo_fp_atan2);
477 embryo_program_native_call_add(ep, "log1p", _embryo_fp_log1p); 483 embryo_program_native_call_add(ep, "log1p", _embryo_fp_log1p);
478 embryo_program_native_call_add(ep, "cbrt", _embryo_fp_cbrt); 484 embryo_program_native_call_add(ep, "cbrt", _embryo_fp_cbrt);
479 embryo_program_native_call_add(ep, "exp", _embryo_fp_exp); 485 embryo_program_native_call_add(ep, "exp", _embryo_fp_exp);
480 embryo_program_native_call_add(ep, "exp2", _embryo_fp_exp2); 486 embryo_program_native_call_add(ep, "exp2", _embryo_fp_exp2);
481 embryo_program_native_call_add(ep, "hypot", _embryo_fp_hypot); 487 embryo_program_native_call_add(ep, "hypot", _embryo_fp_hypot);
482} 488}
489
diff --git a/src/lib/embryo/embryo_main.c b/src/lib/embryo/embryo_main.c
index e80834c8f9..37fc811b6e 100644
--- a/src/lib/embryo/embryo_main.c
+++ b/src/lib/embryo/embryo_main.c
@@ -10,7 +10,7 @@
10#include "embryo_private.h" 10#include "embryo_private.h"
11 11
12static Embryo_Version _version = { VMAJ, VMIN, VMIC, VREV }; 12static Embryo_Version _version = { VMAJ, VMIN, VMIC, VREV };
13EAPI Embryo_Version *embryo_version = &_version; 13EAPI Embryo_Version * embryo_version = &_version;
14 14
15static int _embryo_init_count = 0; 15static int _embryo_init_count = 0;
16int _embryo_default_log_dom = -1; 16int _embryo_default_log_dom = -1;
@@ -67,3 +67,4 @@ embryo_shutdown(void)
67 67
68 return _embryo_init_count; 68 return _embryo_init_count;
69} 69}
70
diff --git a/src/lib/embryo/embryo_rand.c b/src/lib/embryo/embryo_rand.c
index 0f13d87127..a21d43767f 100644
--- a/src/lib/embryo/embryo_rand.c
+++ b/src/lib/embryo/embryo_rand.c
@@ -33,6 +33,7 @@ _embryo_rand_randf(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params EINA_UNUS
33void 33void
34_embryo_rand_init(Embryo_Program *ep) 34_embryo_rand_init(Embryo_Program *ep)
35{ 35{
36 embryo_program_native_call_add(ep, "rand", _embryo_rand_rand); 36 embryo_program_native_call_add(ep, "rand", _embryo_rand_rand);
37 embryo_program_native_call_add(ep, "randf", _embryo_rand_randf); 37 embryo_program_native_call_add(ep, "randf", _embryo_rand_randf);
38} 38}
39
diff --git a/src/lib/embryo/embryo_str.c b/src/lib/embryo/embryo_str.c
index 649bd49f8f..de39437058 100644
--- a/src/lib/embryo/embryo_str.c
+++ b/src/lib/embryo/embryo_str.c
@@ -23,20 +23,20 @@
23#include "Embryo.h" 23#include "Embryo.h"
24#include "embryo_private.h" 24#include "embryo_private.h"
25 25
26#define STRGET(ep, str, par) { \ 26#define STRGET(ep, str, par) { \
27 Embryo_Cell *___cptr; \ 27 Embryo_Cell *___cptr; \
28 str = NULL; \ 28 str = NULL; \
29 if ((___cptr = embryo_data_address_get(ep, par))) { \ 29 if ((___cptr = embryo_data_address_get(ep, par))) { \
30 int ___l; \ 30 int ___l; \
31 ___l = embryo_data_string_length_get(ep, ___cptr); \ 31 ___l = embryo_data_string_length_get(ep, ___cptr); \
32 (str) = alloca(___l + 1); \ 32 (str) = alloca(___l + 1); \
33 if (str) embryo_data_string_get(ep, ___cptr, str); \ 33 if (str) embryo_data_string_get(ep, ___cptr, str); \
34 } } 34 } }
35#define STRSET(ep, par, str) { \ 35#define STRSET(ep, par, str) { \
36 Embryo_Cell *___cptr; \ 36 Embryo_Cell *___cptr; \
37 if ((___cptr = embryo_data_address_get(ep, par))) { \ 37 if ((___cptr = embryo_data_address_get(ep, par))) { \
38 embryo_data_string_set(ep, str, ___cptr); \ 38 embryo_data_string_set(ep, str, ___cptr); \
39 } } 39 } }
40 40
41/* exported string api */ 41/* exported string api */
42 42
@@ -249,8 +249,8 @@ _embryo_str_strcut(Embryo_Program *ep, Embryo_Cell *params)
249 if (params[4] >= l1) params[4] = l1; 249 if (params[4] >= l1) params[4] = l1;
250 if (params[4] == params[3]) 250 if (params[4] == params[3])
251 { 251 {
252 STRSET(ep, params[1], ""); 252 STRSET(ep, params[1], "");
253 return 0; 253 return 0;
254 } 254 }
255 s2 = alloca(params[4] - params[3] + 1); 255 s2 = alloca(params[4] - params[3] + 1);
256 strncpy(s2, s1 + params[3], params[4] - params[3]); 256 strncpy(s2, s1 + params[3], params[4] - params[3]);
@@ -270,8 +270,9 @@ _str_snprintf(Embryo_Program *ep, char *s1, char *s2, int max_len, int pnum, Emb
270 { 270 {
271 if ((!inesc) && (!insub)) 271 if ((!inesc) && (!insub))
272 { 272 {
273 if (s1[i] == '\\') inesc = 1; 273 if (s1[i] == '\\') inesc = 1;
274 else if (s1[i] == '%') insub = 1; 274 else if (s1[i] == '%')
275 insub = 1;
275 if ((!inesc) && (!insub)) 276 if ((!inesc) && (!insub))
276 { 277 {
277 s2[o] = s1[i]; 278 s2[o] = s1[i];
@@ -287,17 +288,19 @@ _str_snprintf(Embryo_Program *ep, char *s1, char *s2, int max_len, int pnum, Emb
287 switch (s1[i]) 288 switch (s1[i])
288 { 289 {
289 case 't': 290 case 't':
290 s2[o] = '\t'; 291 s2[o] = '\t';
291 o++; 292 o++;
292 break; 293 break;
294
293 case 'n': 295 case 'n':
294 s2[o] = '\n'; 296 s2[o] = '\n';
295 o++; 297 o++;
296 break; 298 break;
299
297 default: 300 default:
298 s2[o] = s1[i]; 301 s2[o] = s1[i];
299 o++; 302 o++;
300 break; 303 break;
301 } 304 }
302 inesc = 0; 305 inesc = 0;
303 } 306 }
@@ -307,49 +310,76 @@ _str_snprintf(Embryo_Program *ep, char *s1, char *s2, int max_len, int pnum, Emb
307 switch (s1[i]) 310 switch (s1[i])
308 { 311 {
309 case '%': 312 case '%':
310 s2[o] = '%'; 313 s2[o] = '%';
311 o++; 314 o++;
312 break; 315 break;
316
313 case 'c': 317 case 'c':
314 cptr = embryo_data_address_get(ep, params[p]); 318 cptr = embryo_data_address_get(ep, params[p]);
315 if (cptr) s2[o] = (char)(*cptr); 319 if (cptr) s2[o] = (char)(*cptr);
316 p++; 320 p++;
317 o++; 321 o++;
318 break; 322 break;
323
319 case 'i': 324 case 'i':
320 case 'd': 325 case 'd':
321 case 'x': 326 case 'x':
322 case 'X': 327 case 'X':
328 {
329 char fmt[10] = "";
330 char tmp[256] = "";
331 int l;
332
333 if (s1[i] == 'i') strcpy(fmt, "%i");
334 else if (s1[i] == 'd')
335 strcpy(fmt, "%d");
336 else if (s1[i] == 'x')
337 strcpy(fmt, "%x");
338 else if (s1[i] == 'X')
339 strcpy(fmt, "%08x");
340 cptr = embryo_data_address_get(ep, params[p]);
341 if (cptr) snprintf(tmp, sizeof(tmp), fmt, (int)(*cptr));
342 l = strlen(tmp);
343 if ((o + l) > max_len)
323 { 344 {
324 char fmt[10] = ""; 345 l = max_len - o;
325 char tmp[256] = ""; 346 if (l < 0) l = 0;
326 int l; 347 tmp[l] = 0;
327
328 if (s1[i] == 'i') strcpy(fmt, "%i");
329 else if (s1[i] == 'd') strcpy(fmt, "%d");
330 else if (s1[i] == 'x') strcpy(fmt, "%x");
331 else if (s1[i] == 'X') strcpy(fmt, "%08x");
332 cptr = embryo_data_address_get(ep, params[p]);
333 if (cptr) snprintf(tmp, sizeof(tmp), fmt, (int)(*cptr));
334 l = strlen(tmp);
335 if ((o + l) > max_len)
336 {
337 l = max_len - o;
338 if (l < 0) l = 0;
339 tmp[l] = 0;
340 }
341 strcpy(s2 + o, tmp);
342 o += l;
343 p++;
344 } 348 }
345 break; 349 strcpy(s2 + o, tmp);
350 o += l;
351 p++;
352 }
353 break;
354
346 case 'f': 355 case 'f':
356 {
357 char tmp[256] = "";
358 int l;
359
360 cptr = embryo_data_address_get(ep, params[p]);
361 if (cptr) snprintf(tmp, sizeof(tmp), "%f", (double)EMBRYO_CELL_TO_FLOAT(*cptr));
362 l = strlen(tmp);
363 if ((o + l) > max_len)
347 { 364 {
348 char tmp[256] = ""; 365 l = max_len - o;
349 int l; 366 if (l < 0) l = 0;
367 tmp[l] = 0;
368 }
369 strcpy(s2 + o, tmp);
370 o += l;
371 p++;
372 }
373 break;
374
375 case 's':
376 {
377 char *tmp;
378 int l;
350 379
351 cptr = embryo_data_address_get(ep, params[p]); 380 STRGET(ep, tmp, params[p]);
352 if (cptr) snprintf(tmp, sizeof(tmp), "%f", (double)EMBRYO_CELL_TO_FLOAT(*cptr)); 381 if (tmp)
382 {
353 l = strlen(tmp); 383 l = strlen(tmp);
354 if ((o + l) > max_len) 384 if ((o + l) > max_len)
355 { 385 {
@@ -359,32 +389,13 @@ _str_snprintf(Embryo_Program *ep, char *s1, char *s2, int max_len, int pnum, Emb
359 } 389 }
360 strcpy(s2 + o, tmp); 390 strcpy(s2 + o, tmp);
361 o += l; 391 o += l;
362 p++;
363 } 392 }
364 break; 393 p++;
365 case 's': 394 }
366 { 395 break;
367 char *tmp;
368 int l;
369 396
370 STRGET(ep, tmp, params[p]);
371 if (tmp)
372 {
373 l = strlen(tmp);
374 if ((o + l) > max_len)
375 {
376 l = max_len - o;
377 if (l < 0) l = 0;
378 tmp[l] = 0;
379 }
380 strcpy(s2 + o, tmp);
381 o += l;
382 }
383 p++;
384 }
385 break;
386 default: 397 default:
387 break; 398 break;
388 } 399 }
389 insub = 0; 400 insub = 0;
390 } 401 }
@@ -503,21 +514,22 @@ _embryo_str_strrchr(Embryo_Program *ep, Embryo_Cell *params)
503void 514void
504_embryo_str_init(Embryo_Program *ep) 515_embryo_str_init(Embryo_Program *ep)
505{ 516{
506 embryo_program_native_call_add(ep, "atoi", _embryo_str_atoi); 517 embryo_program_native_call_add(ep, "atoi", _embryo_str_atoi);
507 embryo_program_native_call_add(ep, "fnmatch", _embryo_str_fnmatch); 518 embryo_program_native_call_add(ep, "fnmatch", _embryo_str_fnmatch);
508 embryo_program_native_call_add(ep, "strcmp", _embryo_str_strcmp); 519 embryo_program_native_call_add(ep, "strcmp", _embryo_str_strcmp);
509 embryo_program_native_call_add(ep, "strncmp", _embryo_str_strncmp); 520 embryo_program_native_call_add(ep, "strncmp", _embryo_str_strncmp);
510 embryo_program_native_call_add(ep, "strcpy", _embryo_str_strcpy); 521 embryo_program_native_call_add(ep, "strcpy", _embryo_str_strcpy);
511 embryo_program_native_call_add(ep, "strncpy", _embryo_str_strncpy); 522 embryo_program_native_call_add(ep, "strncpy", _embryo_str_strncpy);
512 embryo_program_native_call_add(ep, "strlen", _embryo_str_strlen); 523 embryo_program_native_call_add(ep, "strlen", _embryo_str_strlen);
513 embryo_program_native_call_add(ep, "strcat", _embryo_str_strcat); 524 embryo_program_native_call_add(ep, "strcat", _embryo_str_strcat);
514 embryo_program_native_call_add(ep, "strncat", _embryo_str_strncat); 525 embryo_program_native_call_add(ep, "strncat", _embryo_str_strncat);
515 embryo_program_native_call_add(ep, "strprep", _embryo_str_strprep); 526 embryo_program_native_call_add(ep, "strprep", _embryo_str_strprep);
516 embryo_program_native_call_add(ep, "strnprep", _embryo_str_strnprep); 527 embryo_program_native_call_add(ep, "strnprep", _embryo_str_strnprep);
517 embryo_program_native_call_add(ep, "strcut", _embryo_str_strcut); 528 embryo_program_native_call_add(ep, "strcut", _embryo_str_strcut);
518 embryo_program_native_call_add(ep, "snprintf", _embryo_str_snprintf); 529 embryo_program_native_call_add(ep, "snprintf", _embryo_str_snprintf);
519 embryo_program_native_call_add(ep, "strstr", _embryo_str_strstr); 530 embryo_program_native_call_add(ep, "strstr", _embryo_str_strstr);
520 embryo_program_native_call_add(ep, "strchr", _embryo_str_strchr); 531 embryo_program_native_call_add(ep, "strchr", _embryo_str_strchr);
521 embryo_program_native_call_add(ep, "strrchr", _embryo_str_strrchr); 532 embryo_program_native_call_add(ep, "strrchr", _embryo_str_strrchr);
522 embryo_program_native_call_add(ep, "printf", _embryo_str_printf); 533 embryo_program_native_call_add(ep, "printf", _embryo_str_printf);
523} 534}
535
diff --git a/src/lib/embryo/embryo_time.c b/src/lib/embryo/embryo_time.c
index 8725377b0c..2caab43290 100644
--- a/src/lib/embryo/embryo_time.c
+++ b/src/lib/embryo/embryo_time.c
@@ -27,9 +27,9 @@
27static Embryo_Cell 27static Embryo_Cell
28_embryo_time_seconds(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params EINA_UNUSED) 28_embryo_time_seconds(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params EINA_UNUSED)
29{ 29{
30 struct timeval timev; 30 struct timeval timev;
31 double t; 31 double t;
32 float f; 32 float f;
33 33
34 gettimeofday(&timev, NULL); 34 gettimeofday(&timev, NULL);
35 t = (double)(timev.tv_sec - ((timev.tv_sec / (60 * 60 * 24)) * (60 * 60 * 24))) 35 t = (double)(timev.tv_sec - ((timev.tv_sec / (60 * 60 * 24)) * (60 * 60 * 24)))
@@ -41,10 +41,10 @@ _embryo_time_seconds(Embryo_Program *ep EINA_UNUSED, Embryo_Cell *params EINA_UN
41static Embryo_Cell 41static Embryo_Cell
42_embryo_time_date(Embryo_Program *ep, Embryo_Cell *params) 42_embryo_time_date(Embryo_Program *ep, Embryo_Cell *params)
43{ 43{
44 static time_t last_tzset = 0; 44 static time_t last_tzset = 0;
45 struct timeval timev; 45 struct timeval timev;
46 struct tm *tm; 46 struct tm *tm;
47 time_t tt; 47 time_t tt;
48 48
49 if (params[0] != (8 * sizeof(Embryo_Cell))) return 0; 49 if (params[0] != (8 * sizeof(Embryo_Cell))) return 0;
50 gettimeofday(&timev, NULL); 50 gettimeofday(&timev, NULL);
@@ -52,35 +52,34 @@ _embryo_time_date(Embryo_Program *ep, Embryo_Cell *params)
52 if ((tt > (last_tzset + 1)) || 52 if ((tt > (last_tzset + 1)) ||
53 (tt < (last_tzset - 1))) 53 (tt < (last_tzset - 1)))
54 { 54 {
55 last_tzset = tt; 55 last_tzset = tt;
56 tzset(); 56 tzset();
57 } 57 }
58 tm = localtime(&tt); 58 tm = localtime(&tt);
59 if (tm) 59 if (tm)
60 { 60 {
61 Embryo_Cell *cptr; 61 Embryo_Cell *cptr;
62 double t; 62 double t;
63 float f; 63 float f;
64
65 cptr = embryo_data_address_get(ep, params[1]);
66 if (cptr) *cptr = tm->tm_year + 1900;
67 cptr = embryo_data_address_get(ep, params[2]);
68 if (cptr) *cptr = tm->tm_mon + 1;
69 cptr = embryo_data_address_get(ep, params[3]);
70 if (cptr) *cptr = tm->tm_mday;
71 cptr = embryo_data_address_get(ep, params[4]);
72 if (cptr) *cptr = tm->tm_yday;
73 cptr = embryo_data_address_get(ep, params[5]);
74 if (cptr) *cptr = (tm->tm_wday + 6) % 7;
75 cptr = embryo_data_address_get(ep, params[6]);
76 if (cptr) *cptr = tm->tm_hour;
77 cptr = embryo_data_address_get(ep, params[7]);
78 if (cptr) *cptr = tm->tm_min;
79 cptr = embryo_data_address_get(ep, params[8]);
80 t = (double)tm->tm_sec + (((double)timev.tv_usec) / 1000000);
81 f = (float)t;
82 if (cptr) *cptr = EMBRYO_FLOAT_TO_CELL(f);
83 64
65 cptr = embryo_data_address_get(ep, params[1]);
66 if (cptr) *cptr = tm->tm_year + 1900;
67 cptr = embryo_data_address_get(ep, params[2]);
68 if (cptr) *cptr = tm->tm_mon + 1;
69 cptr = embryo_data_address_get(ep, params[3]);
70 if (cptr) *cptr = tm->tm_mday;
71 cptr = embryo_data_address_get(ep, params[4]);
72 if (cptr) *cptr = tm->tm_yday;
73 cptr = embryo_data_address_get(ep, params[5]);
74 if (cptr) *cptr = (tm->tm_wday + 6) % 7;
75 cptr = embryo_data_address_get(ep, params[6]);
76 if (cptr) *cptr = tm->tm_hour;
77 cptr = embryo_data_address_get(ep, params[7]);
78 if (cptr) *cptr = tm->tm_min;
79 cptr = embryo_data_address_get(ep, params[8]);
80 t = (double)tm->tm_sec + (((double)timev.tv_usec) / 1000000);
81 f = (float)t;
82 if (cptr) *cptr = EMBRYO_FLOAT_TO_CELL(f);
84 } 83 }
85 return 0; 84 return 0;
86} 85}
@@ -91,5 +90,6 @@ void
91_embryo_time_init(Embryo_Program *ep) 90_embryo_time_init(Embryo_Program *ep)
92{ 91{
93 embryo_program_native_call_add(ep, "seconds", _embryo_time_seconds); 92 embryo_program_native_call_add(ep, "seconds", _embryo_time_seconds);
94 embryo_program_native_call_add(ep, "date", _embryo_time_date); 93 embryo_program_native_call_add(ep, "date", _embryo_time_date);
95} 94}
95