src/vm.c

   1 /*
   2  * This program is free software: you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation, either version 3 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  */
  15 #include <stdarg.h>
  16 #include <stdint.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include "vm.h"
  22
  23
  24 //#define VM_DEBUG
  25
  26 #define SECRET  (42)
  27
  28
  29 // should be enough for everyone!
  30 #define MAX_INST_COUNT  (1000000)
  31
  32 //extern int goobers;
  33
  34
  35 //extern void fatal (const char *fmt, ...) __attribute__((__noreturn__)) __attribute__((format(printf, 1, 2)));
  36 static __attribute__((__noreturn__)) __attribute__((format(printf, 1, 2))) void fatalis (const char *fmt, ...) {
  37   va_list ap;
  38   //
  39   fprintf(stderr, "AWISH FATAL: ");
  40   va_start(ap, fmt);
  41   vfprintf(stderr, fmt, ap);
  42   va_end(ap);
  43   fprintf(stderr, "\n");
  44   exit(1);
  45 }
  46
  47
  48 #ifndef VM_FATAL_DEFINED
  49 static __attribute__((__noreturn__)) __attribute__((format(printf, 3, 4))) void vmfatal (int tid, int pc, const char *fmt, ...) {
  50   va_list ap;
  51   //
  52   fprintf(stderr, "VM FATAL (thread #%d, pc=%04x): ", tid, (unsigned int)pc);
  53   va_start(ap, fmt);
  54   vfprintf(stderr, fmt, ap);
  55   va_end(ap);
  56   fprintf(stderr, "\n");
  57   exit(1);
  58 }
  59 #endif
  60
  61
  62 const char *vmOpNames[] = {
  63   "add",
  64   "sub",
  65   "mul",
  66   "div",
  67   "mod",
  68   "bor",
  69   "xor",
  70   "and",
  71
  72   "jeq",
  73   "jne",
  74   "jlt",
  75   "jle",
  76   "jgt",
  77   "jge",
  78
  79   "jmp",
  80
  81   "bsr",
  82
  83   "brk",
  84   "end",
  85   "new",
  86
  87   "set",
  88   "get",
  89
  90   "psh",
  91   "pop",
  92   "swp",
  93   "pck",
  94   "rol",
  95   "dpt",
  96
  97   "tid",
  98   "kil",
  99   "sus",
 100   "res",
 101   "sta",
 102
 103   "rxc",
 104   "wxc",
 105
 106   "ret",
 107
 108   "rst",
 109
 110   "mgf",
 111   "mgb",
 112   "msf",
 113   "msb",
 114
 115   NULL
 116 };
 117
 118
 119 VMRSTCB vmRSTCB = NULL;
 120 VMMapGetCB vmMapGetCB = NULL;
 121 VMMapSetCB vmMapSetCB = NULL;
 122
 123
 124 typedef struct {
 125   int pc;
 126   int suspended;
 127   int sp;
 128   int *stack; // internal
 129   int *tvars; // internal
 130 } VMThread;
 131
 132
 133 int vmDebugTrace = 0;
 134 FILE *vmDebugOutput = NULL;
 135
 136
 137 static VMThread vmThreads[VM_MAX_THREADS];
 138 static int vmExecuted[VM_MAX_THREADS];
 139 static int vmLastThreadId = 0;
 140
 141 unsigned char vmCode[65536];
 142 int vmCodeSize = 0;
 143 int vmGVars[VM_VARS_SIZE];
 144
 145 int vmMaxGVar = 0;
 146 int vmMaxTVar = 0;
 147
 148
 149 static void fixLastThreadId (void) {
 150   for (; vmLastThreadId > 0; --vmLastThreadId) if (vmThreads[vmLastThreadId].stack) break;
 151 }
 152
 153
 154 static int vmFindFreeThread (void) {
 155   for (int f = 0; f < VM_MAX_THREADS; ++f) if (vmThreads[f].stack == NULL) return f;
 156   return -1;
 157 }
 158
 159
 160 static int vmInitThread (VMThread *trd) {
 161   trd->pc = 0;
 162   trd->sp = 0;
 163   trd->suspended = 0;
 164   trd->stack = calloc(VM_STACK_SIZE, sizeof(int));
 165   if (trd->stack == NULL) return -1;
 166   trd->tvars = calloc(VM_VARS_SIZE, sizeof(int));
 167   if (trd->tvars == NULL) { free(trd->stack); return -1; }
 168   return 0;
 169 }
 170
 171
 172 static void vmFreeThread (VMThread *trd) {
 173   if (trd->stack) free(trd->stack);
 174   if (trd->tvars) free(trd->tvars);
 175   trd->stack = NULL;
 176   trd->tvars = NULL;
 177   trd->pc = 0;
 178   trd->sp = 0;
 179   trd->suspended = 0;
 180 }
 181
 182
 183 int vmInitialize (void) {
 184   vmFreeLabels();
 185   memset(vmThreads, 0, sizeof(vmThreads));
 186   // setup main thread
 187   vmLastThreadId = 0;
 188   if (vmInitThread(vmThreads)) return -1; // alas
 189   return 0;
 190 }
 191
 192
 193 void vmDeinitialize (void) {
 194   for (int f = 0; f < VM_MAX_THREADS; ++f) {
 195     if (vmThreads[f].stack) free(vmThreads[f].stack);
 196     if (vmThreads[f].tvars) free(vmThreads[f].tvars);
 197   }
 198   memset(vmThreads, 0, sizeof(vmThreads));
 199   vmLastThreadId = 0;
 200   vmFreeLabels();
 201 }
 202
 203
 204 static inline int vmGetByte (int tid, int opc, VMThread *trd) {
 205   if (trd->pc < 0 || trd->pc >= vmCodeSize) vmfatal(tid, opc, "out of code");
 206   return vmCode[trd->pc++];
 207 }
 208
 209
 210 #define STACK_WANT(n)  do { if (trd->sp < (n)) vmfatal(tid, opc, "stack underflow"); } while (0)
 211 #define STACK_FSPC(n)  do { if (trd->sp+(n) > VM_STACK_SIZE) vmfatal(tid, opc, "stack overflow"); } while (0)
 212
 213 #define STACK_TOP()    (trd->stack[trd->sp-1])
 214 #define STACK_POP()    (trd->stack[--(trd->sp)])
 215 #define STACK_PUSH(n)  trd->stack[(trd->sp)++] = (n)
 216
 217
 218 #define MATH(op) do { \
 219   switch (argc) { \
 220     case 0: \
 221       STACK_WANT(2); \
 222       trd->stack[trd->sp-2] = (trd->stack[trd->sp-2]) op (trd->stack[trd->sp-1]); \
 223       --(trd->sp); \
 224       break; \
 225     case 1: \
 226       STACK_WANT(1); \
 227       trd->stack[trd->sp-1] = (trd->stack[trd->sp-1]) op (argv[0]); \
 228       break; \
 229     case 2: if (argp[0] != NULL) *(argp[0]) = (argv[0]) op (argv[1]); break; \
 230     case 3: if (argp[2] != NULL) *(argp[2]) = (argv[0]) op (argv[1]); break; \
 231   } \
 232 } while(0)
 233
 234
 235 #define CHECK_DIV_ZERO \
 236   switch (argc) { \
 237     case 0: \
 238       if (trd->sp > 0 && trd->stack[trd->sp-1] == 0) { fprintf(stderr, "VM FATAL: division by zero!\n"); exit(1); } \
 239       break; \
 240     case 1: \
 241       if (argv[0] == 0) { fprintf(stderr, "VM FATAL: division by zero!\n"); exit(1); } \
 242       break; \
 243     default: \
 244       if (argv[1] == 0) { fprintf(stderr, "VM FATAL: division by zero!\n"); exit(1); } \
 245       break; \
 246   }
 247
 248
 249 #define JXX(op) do { \
 250   switch (argc) { \
 251     case 0: \
 252       STACK_WANT(3); \
 253       argv[0] = STACK_POP(); \
 254     case 1: \
 255       STACK_WANT(2); \
 256       argv[2] = STACK_POP(); \
 257       argv[1] = STACK_POP(); \
 258       break; \
 259     case 2: \
 260       STACK_WANT(1); \
 261       argv[2] = argv[1]; \
 262       argv[1] = STACK_POP(); \
 263       break; \
 264   } \
 265   if (argv[1] op argv[2]) trd->pc = argv[0]; \
 266 } while (0)
 267
 268
 269 static inline int isBranch (int opcode) {
 270   return
 271     opcode == VM_JMP  ||
 272     opcode == VM_BSR  ||
 273     opcode == VM_JEQ  ||
 274     opcode == VM_JNE  ||
 275     opcode == VM_JLT  ||
 276     opcode == VM_JLE  ||
 277     opcode == VM_JGT  ||
 278     opcode == VM_JGE;
 279 }
 280
 281
 282 // <0: BRK; >0: END
 283 int vmExecuteOne (int tid) {
 284   VMThread *trd = &vmThreads[tid];
 285   int opcode;
 286   int argc;
 287   int argv[3]; // argument values
 288   int *argp[3]; // pointer to vars for each arg
 289   int opc = trd->pc;
 290   //
 291   // decode instruction
 292   opcode = vmGetByte(tid, opc, trd);
 293   argc = (opcode>>6)&0x03;
 294   opcode &= 0x3f;
 295   argv[0] = argv[1] = argv[2] = 0;
 296   argp[0] = argp[1] = argp[2] = NULL;
 297   // read operands
 298   if (tid > vmLastThreadId) vmLastThreadId = tid;
 299   for (int f = 0; f < argc; ++f) {
 300     int vn = vmGetByte(tid, opc, trd);
 301     //
 302     if (vn == 255) {
 303       // immediate
 304       argv[f] = vmGetByte(tid, opc, trd);
 305       argv[f] |= vmGetByte(tid, opc, trd)<<8;
 306       if (argv[f] >= 32768 && (f != 0 || !isBranch(opcode))) argv[f] -= 65536;
 307     } else {
 308       if (vn == 127) {
 309         // stack var; <0: from stack top
 310         argv[f] = vmGetByte(tid, opc, trd);
 311         argv[f] |= (vmGetByte(tid, opc, trd)<<8);
 312         if (argv[f] >= 32768) argv[f] -= 65536;
 313         if (argv[f] < 0) argv[f] += trd->sp;
 314         if (argv[f] < 0 || argv[f] >= VM_STACK_SIZE) vmfatal(tid, opc, "invalid stack offset");
 315         argp[f] = trd->stack+argv[f];
 316       } else {
 317         // variable
 318         argp[f] = vn&0x80 ? vmGVars : trd->tvars;
 319         argp[f] += vn&0x7f;
 320       }
 321       argv[f] = *(argp[f]);
 322     }
 323   }
 324   //
 325 //#ifdef VM_DEBUG
 326   if (vmDebugTrace) {
 327     if (vmDebugOutput == NULL) vmDebugOutput = stderr;
 328     //
 329     fprintf(vmDebugOutput, "(%04d) %04x: ", tid, (unsigned int)opc);
 330     if (opcode < sizeof(vmOpNames)/sizeof(char *)-1) fprintf(vmDebugOutput, "%s", vmOpNames[opcode]); else fprintf(vmDebugOutput, "BAD");
 331     for (int f = 0; f < argc; ++f) {
 332       fputc(' ', vmDebugOutput);
 333       if (argp[f]) {
 334         unsigned int ofs = 0;
 335         //
 336         fputc('[', vmDebugOutput);
 337         if (argp[f] >= trd->tvars && argp[f] < trd->tvars+VM_VARS_SIZE) {
 338           ofs = (unsigned int)(argp[f]-trd->tvars);
 339         } else if (argp[f] >= trd->stack && argp[f] < trd->stack+VM_VARS_SIZE) {
 340           ofs = (unsigned int)(argp[f]-trd->stack);
 341           fputc('.', vmDebugOutput);
 342         } else if (argp[f] >= vmGVars && argp[f] < vmGVars+VM_VARS_SIZE) {
 343           ofs = (unsigned int)(argp[f]-vmGVars);
 344           fputc('@', vmDebugOutput);
 345         }
 346         fprintf(vmDebugOutput, "%u]", ofs);
 347       }
 348       if (f == 0 && isBranch(opcode)) {
 349         fprintf(vmDebugOutput, "(0x%04x)", argv[f]);
 350       } else {
 351         fprintf(vmDebugOutput, "(%d)", argv[f]);
 352       }
 353     }
 354     fputc('\n', vmDebugOutput);
 355     if (vmDebugOutput != stderr && vmDebugOutput != stdout) fflush(vmDebugOutput);
 356   }
 357 //#endif
 358   //
 359   switch (opcode) {
 360     case VM_ADD: MATH(+); break;
 361     case VM_SUB: MATH(-); break;
 362     case VM_MUL: MATH(*); break;
 363     case VM_DIV:
 364       CHECK_DIV_ZERO
 365       MATH(/);
 366       break;
 367     case VM_MOD:
 368       CHECK_DIV_ZERO
 369       MATH(%);
 370       break;
 371     case VM_BOR: MATH(|); break;
 372     case VM_XOR: MATH(^); break;
 373     case VM_AND: MATH(&); break;
 374
 375     case VM_JEQ: JXX(==); break;
 376     case VM_JNE: JXX(!=); break;
 377     case VM_JLT: JXX(<); break;
 378     case VM_JLE: JXX(<=); break;
 379     case VM_JGT: JXX(>); break;
 380     case VM_JGE: JXX(>=); break;
 381
 382     case VM_JMP:
 383       if (argc == 0) {
 384         STACK_WANT(1);
 385         argv[0] = STACK_POP();
 386       }
 387       trd->pc = argv[0];
 388       break;
 389
 390     case VM_BSR:
 391       switch (argc) {
 392         case 0:
 393           STACK_WANT(1);
 394           argv[0] = STACK_POP();
 395           break;
 396         case 1:
 397           break;
 398         case 2:
 399           STACK_FSPC(1);
 400           STACK_PUSH(argv[1]);
 401           break;
 402         case 3:
 403           STACK_FSPC(2);
 404           STACK_PUSH(argv[1]);
 405           STACK_PUSH(argv[2]);
 406           break;
 407       }
 408       STACK_FSPC(1);
 409       STACK_PUSH(trd->pc);
 410       trd->pc = argv[0];
 411       break;
 412
 413     case VM_END: return 1;
 414     case VM_BRK: return -1;
 415
 416     case VM_NEW: { // new thread
 417       int xtid = vmFindFreeThread();
 418       //
 419       if (argc == 0) {
 420         STACK_WANT(1);
 421         argv[0] = STACK_POP();
 422       }
 423       if (xtid >= 0) {
 424         if (vmInitThread(&vmThreads[xtid]) == 0) {
 425           vmThreads[xtid].pc = argv[0];
 426         } else {
 427           xtid = -1;
 428         }
 429       }
 430       if (xtid < 0) vmfatal(tid, opc, "too many threads");
 431       if (xtid > vmLastThreadId) vmLastThreadId = xtid;
 432       if (argc > 1) {
 433         if (argp[1]) *(argp[1]) = xtid;
 434       } else {
 435         STACK_FSPC(1);
 436         STACK_PUSH(xtid);
 437       }
 438       break; }
 439
 440     case VM_SET:
 441       switch (argc) {
 442         case 0:
 443           STACK_WANT(2);
 444           argv[0] = STACK_POP(); // varid
 445           argv[1] = STACK_POP(); // value
 446           if (argv[0] < 0) {
 447             argv[0] = -argv[0];
 448             if (argv[0] < VM_VARS_SIZE) vmGVars[argv[0]] = argv[1];
 449           } else if (argv[0] < VM_VARS_SIZE) {
 450             trd->tvars[argv[0]] = argv[1];
 451           }
 452           break;
 453         case 1:
 454           STACK_WANT(1);
 455           argv[1] = STACK_POP(); // value
 456           // fallthru
 457         case 2:
 458           if (argp[0]) *(argp[0]) = argv[1];
 459           break;
 460         case 3: {
 461           int xtid = argv[2], vid = argv[0];
 462           //
 463           if (xtid < 0 || xtid >= VM_MAX_THREADS || vmThreads[xtid].stack == NULL || vid < 0 || vid >= VM_VARS_SIZE) break;
 464           vmThreads[xtid].tvars[vid] = argv[1];
 465           break; }
 466       }
 467       break;
 468
 469     case VM_GET: {
 470       int xtid, vid, pushit;
 471       //
 472       switch (argc) {
 473         case 0:
 474           STACK_WANT(2);
 475           vid = STACK_POP();
 476           xtid = STACK_POP();
 477           pushit = 1;
 478           break;
 479         case 1:
 480           STACK_WANT(1);
 481           vid = argv[0];
 482           xtid = STACK_POP();
 483           pushit = 1;
 484           break;
 485         case 2:
 486           xtid = argv[0];
 487           vid = argv[1];
 488           pushit = 1;
 489           break;
 490         default:
 491           xtid = argv[0];
 492           vid = argv[1];
 493           pushit = 0;
 494           break;
 495       }
 496       if (xtid >= 0 && xtid < VM_MAX_THREADS && vmThreads[xtid].stack != NULL && vid >= 0 && vid < VM_VARS_SIZE) {
 497         argv[0] = vmThreads[xtid].tvars[vid];
 498       } else {
 499         argv[0] = 0;
 500       }
 501       if (!pushit) {
 502         if (argp[2]) *(argp[2]) = argv[0];
 503       } else {
 504         STACK_FSPC(1);
 505         STACK_PUSH(argv[0]);
 506       }
 507       break;
 508
 509     case VM_PSH:
 510       if (argc > 0) {
 511         STACK_FSPC(argc);
 512         for (int f = 0; f < argc; ++f) STACK_PUSH(argv[f]);
 513       } else {
 514         // dup
 515         STACK_WANT(1);
 516         STACK_FSPC(1);
 517         trd->stack[trd->sp] = trd->stack[trd->sp-1];
 518         ++(trd->sp);
 519       }
 520       break;
 521     case VM_POP:
 522       switch (argc) {
 523         case 0: // drop one
 524           STACK_WANT(1);
 525           --(trd->sp);
 526           break;
 527         case 1:
 528           if (argp[0] == NULL && argv[0] < 0) {
 529             // allocate stack space
 530             argc = -argv[0];
 531             STACK_FSPC(argc);
 532             for (; argc > 0; --argc) STACK_PUSH(0);
 533             break;
 534           }
 535           // fallthru
 536         default:
 537           for (int f = 0; f < argc; ++f) {
 538             if (argp[f]) {
 539               // pop
 540               STACK_WANT(1);
 541               *(argp[f]) = STACK_POP();
 542             } else if (argv[f] > 0) {
 543               // drop
 544               STACK_WANT(argv[f]);
 545               trd->sp -= argv[f];
 546             }
 547           }
 548           break;
 549         }
 550       }
 551       break;
 552     case VM_SWP:
 553       switch (argc) {
 554         case 0:
 555           STACK_WANT(2);
 556           argc = trd->stack[trd->sp-2];
 557           trd->stack[trd->sp-2] = trd->stack[trd->sp-1];
 558           trd->stack[trd->sp-1] = argc;
 559           break;
 560         case 1:
 561           STACK_WANT(1);
 562           argc = trd->stack[trd->sp-1];
 563           trd->stack[trd->sp-1] = argv[0];
 564           if (argp[0]) *(argp[0]) = argc;
 565           break;
 566         default: // 2, 3
 567           if (argp[0]) *(argp[0]) = argv[1];
 568           if (argp[1]) *(argp[1]) = argv[0];
 569           break;
 570       }
 571       break;
 572     case VM_PCK:
 573     case VM_ROL:
 574       if (argc < 1) {
 575         STACK_WANT(1);
 576         argv[0] = STACK_POP();
 577       }
 578       // get item
 579       if (argv[0] < 0) argv[0] += trd->sp;
 580       if (argv[0] < 0 || argv[0] >= trd->sp) vmfatal(tid, opc, "invalid stack index (%d)", argv[0]);
 581       argv[2] = trd->stack[argv[0]];
 582       //
 583       if (opcode == VM_ROL) {
 584         for (int f = argv[0]+1; f < trd->sp; ++f) trd->stack[f-1] = trd->stack[f];
 585         --(trd->sp);
 586       }
 587       //
 588       switch (argc) {
 589         case 0:
 590         case 1:
 591           STACK_FSPC(1);
 592           STACK_PUSH(argv[2]);
 593           break;
 594         default:
 595           if (argp[1]) *(argp[1]) = argv[2];
 596           break;
 597       }
 598       break;
 599     case VM_DPT:
 600       if (argc > 0) {
 601         if (argp[0]) *(argp[0]) = trd->sp;
 602       } else {
 603         STACK_FSPC(1);
 604         argc = trd->sp;
 605         STACK_PUSH(argc);
 606       }
 607       break;
 608
 609     case VM_TID:
 610       if (argc > 0) {
 611         if (argp[0]) *(argp[0]) = tid;
 612       } else {
 613         STACK_FSPC(1);
 614         STACK_PUSH(tid);
 615       }
 616       break;
 617
 618     case VM_KIL:
 619     case VM_SUS:
 620     case VM_RES:
 621       if (argc == 0) {
 622         STACK_WANT(1);
 623         argv[0] = STACK_POP();
 624       }
 625       if (argv[0] >= 0 && argv[0] < VM_MAX_THREADS && vmThreads[argv[0]].stack != NULL) {
 626         switch (opcode) {
 627           case VM_KIL:
 628             if (argv[0] == tid) return 1;
 629             vmFreeThread(&vmThreads[argv[0]]);
 630             fixLastThreadId();
 631             break;
 632           case VM_SUS:
 633             if (argv[0] == tid) return -1;
 634             vmThreads[argv[0]].suspended = 1;
 635             break;
 636           case VM_RES:
 637             vmThreads[argv[0]].suspended = 0;
 638             break;
 639         }
 640       }
 641       break;
 642
 643     case VM_STA:
 644       if (argc == 0) {
 645         STACK_WANT(1);
 646         argv[0] = STACK_POP();
 647       }
 648       if (argv[0] >= 0 && argv[0] < VM_MAX_THREADS && vmThreads[argv[0]].stack != NULL) {
 649         argv[0] = vmThreads[argv[0]].suspended;
 650       } else {
 651         argv[0] = -1;
 652       }
 653       if (argc > 1) {
 654         if (argp[1]) *(argp[1]) = argv[0];
 655       } else {
 656         STACK_FSPC(1);
 657         STACK_PUSH(argv[0]);
 658       }
 659       break;
 660
 661     case VM_RXC:
 662       if (argc == 0) {
 663         STACK_WANT(1);
 664         argv[0] = STACK_POP();
 665       }
 666       if (argv[0] < 0 || argv[0] >= vmCodeSize) vmfatal(tid, opc, "invalid address in RXC (%d)", argv[0]);
 667       if (argc < 2) {
 668         STACK_FSPC(1);
 669         STACK_PUSH(vmCode[argv[0]]);
 670       } else if (argp[1]) {
 671         *(argp[1]) = vmCode[argv[0]];
 672       }
 673       break;
 674
 675     case VM_WXC:
 676       switch (argc) {
 677         case 0:
 678           STACK_WANT(2);
 679           argv[1] = STACK_POP(); // byte
 680           argv[0] = STACK_POP(); // address
 681           break;
 682         case 1:
 683           STACK_WANT(1);
 684           argv[1] = STACK_POP(); // byte
 685           break;
 686       }
 687       if (argv[0] < 0 || argv[0] >= vmCodeSize) vmfatal(tid, opc, "invalid address in WXC (%d)", argv[0]);
 688       if (argv[1] < -128 || argv[1] > 255) vmfatal(tid, opc, "invalid value in WXC (%d)", argv[1]);
 689       if (argv[1] < 0) argv[1] &= 0xff;
 690       vmCode[argv[0]] = argv[1];
 691       break;
 692
 693     case VM_RET:
 694       switch (argc) {
 695         case 0: // simple
 696           STACK_WANT(1);
 697           trd->pc = STACK_POP();
 698           break;
 699         case 1:
 700           vmfatal(tid, opc, "invalid RET");
 701         case 2: // # of locals to pop, # of arguments to pop
 702         case 3: // # of locals to pop, # of arguments to pop, retvalue (taken before all pops, pushes after returning)
 703           if (argv[0] < 0) argv[0] = 0;
 704           if (argv[1] < 0) argv[1] = 0;
 705           STACK_WANT(argv[0]+argv[1]+1);
 706           trd->sp -= argv[0]; // drop locals
 707           trd->pc = STACK_POP();
 708           trd->sp -= argv[1]; // drop arguments
 709           if (argc == 3) {
 710             // push result
 711             STACK_FSPC(1);
 712             STACK_PUSH(argv[2]);
 713           }
 714           break;
 715       }
 716       break;
 717
 718     case VM_RST:
 719       if (vmRSTCB) {
 720         if (argc == 0) {
 721           STACK_WANT(1);
 722           argv[0] = STACK_POP();
 723           argc = 1;
 724         }
 725         vmRSTCB(tid, opcode, argc, argv, argp);
 726       } else if (argc == 0) {
 727         STACK_WANT(1);
 728         --(trd->sp);
 729       }
 730       break;
 731
 732     case VM_MGF:
 733     case VM_MGB:
 734       switch (argc) {
 735         case 0: // nothing
 736         case 1: // only dest
 737           STACK_WANT(2);
 738           argv[1] = STACK_POP(); // y
 739           argv[0] = STACK_POP(); // x
 740           break;
 741       }
 742       if (vmMapGetCB) argv[0] = vmMapGetCB(tid, opcode==VM_MGF, argv[0], argv[1]); else argv[0] = 0;
 743       if (argc == 3) {
 744         if (argp[2]) *(argp[2]) = argv[0];
 745       } else if (argc == 1) {
 746         if (argp[0]) *(argp[0]) = argv[0];
 747       } else {
 748         STACK_FSPC(1);
 749         STACK_PUSH(argv[0]);
 750       }
 751       break;
 752     case VM_MSF:
 753     case VM_MSB:
 754       switch (argc) {
 755         case 0:
 756           STACK_WANT(2);
 757           argv[2] = STACK_POP(); // tile
 758           argv[1] = STACK_POP(); // y
 759           argv[0] = STACK_POP(); // x
 760           break;
 761         case 1:
 762           STACK_WANT(2);
 763           argv[2] = argv[0]; // tile
 764           argv[1] = STACK_POP(); // y
 765           argv[0] = STACK_POP(); // x
 766           break;
 767         case 2:
 768           STACK_WANT(1);
 769           argv[2] = STACK_POP(); // tile
 770           break;
 771       }
 772       if (vmMapSetCB) vmMapSetCB(tid, opcode==VM_MSF, argv[0], argv[1], argv[2]);
 773       break;
 774
 775     default:
 776       vmfatal(tid, opc, "invalid opcode (%d)", opcode);
 777   }
 778   return 0;
 779 }
 780
 781
 782 void vmExecuteAll (void) {
 783   int runned;
 784   //
 785   memset(vmExecuted, 0, sizeof(vmExecuted));
 786   do {
 787     runned = 0;
 788     for (int t = 0; t < VM_MAX_THREADS; ++t) {
 789       if (!vmExecuted[t] && vmThreads[t].stack != NULL && !vmThreads[t].suspended) {
 790         int f;
 791         //
 792         vmExecuted[t] = 1;
 793         runned = 1;
 794         for (f = MAX_INST_COUNT; f >= 0; --f) {
 795           int res = vmExecuteOne(t);
 796           //
 797           if (res < 0) {
 798             // BRK
 799             //fprintf(stderr, "!!!\n");
 800             break;
 801           }
 802           if (res > 0) {
 803             // END
 804             vmFreeThread(&vmThreads[t]);
 805             fixLastThreadId();
 806             break;
 807           }
 808         }
 809         if (f < 0) vmfatal(t, vmThreads[t].pc, "too many instructions in frame");
 810       }
 811     }
 812   } while (runned);
 813 }
 814
 815
 816 // <0: BRK; >0: END; 0: ok
 817 // maxinst<0: any number of instructions
 818 int vmExecuteBSR (int tid, int pc, int maxinst) {
 819   int opc;
 820   //
 821   if (tid < 0 || tid >= VM_MAX_THREADS || vmThreads[tid].stack == NULL || vmThreads[tid].suspended) return 2; // END
 822   opc = vmThreads[tid].pc;
 823   vmPush(tid, -666666);
 824   vmThreads[tid].pc = pc;
 825   if (maxinst == 0) maxinst = MAX_INST_COUNT;
 826   for (;;) {
 827     int res = vmExecuteOne(tid);
 828     //
 829     if (!vmThreads[tid].stack) return 1;
 830     if (vmThreads[tid].suspended) return -2;
 831     if (res > 0) vmFreeThread(&vmThreads[tid]);
 832     if (res != 0) return res;
 833     if (vmThreads[tid].pc == -666666) {
 834       vmThreads[tid].pc = opc;
 835       return 0;
 836     }
 837     if (maxinst == 1) vmfatal(tid, vmThreads[tid].pc, "too many instructions in vmExecuteBSR");
 838     if (maxinst > 0) --maxinst;
 839   }
 840 }
 841
 842
 843 int vmIsThreadAlive (int tid) {
 844   if (tid >= 0 && tid < VM_MAX_THREADS) return vmThreads[tid].stack != NULL;
 845   return 0;
 846 }
 847
 848
 849 int vmNewThread (int pc) {
 850   int tid = vmFindFreeThread();
 851   //
 852   if (tid >= 0) {
 853     if (vmInitThread(&vmThreads[tid]) != 0) return -1;
 854     vmThreads[tid].pc = pc;
 855     if (tid > vmLastThreadId) vmLastThreadId = tid;
 856   }
 857   return tid;
 858 }
 859
 860
 861 int vmKillThread (int tid) {
 862   if (vmIsThreadAlive(tid)) {
 863     vmFreeThread(&vmThreads[tid]);
 864     fixLastThreadId();
 865     return 1;
 866   }
 867   return 0;
 868 }
 869
 870
 871 int vmIsSuspendedThread (int tid) {
 872   if (vmIsThreadAlive(tid)) return vmThreads[tid].suspended;
 873   return 0;
 874 }
 875
 876
 877 int vmSuspendThread (int tid) {
 878   if (vmIsThreadAlive(tid)) { vmThreads[tid].suspended = 1; return 0; }
 879   return -1;
 880 }
 881
 882
 883 int vmResumeThread (int tid) {
 884   if (vmIsThreadAlive(tid)) { vmThreads[tid].suspended = 0; return 0; }
 885   return -1;
 886 }
 887
 888
 889 int vmGetTVar (int tid, int idx) {
 890   if (idx >= 0 && idx < VM_VARS_SIZE && vmIsThreadAlive(tid)) return vmThreads[tid].tvars[idx];
 891   return 0;
 892 }
 893
 894
 895 int vmSetTVar (int tid, int idx, int value) {
 896   if (idx >= 0 && idx < VM_VARS_SIZE && vmIsThreadAlive(tid)) { vmThreads[tid].tvars[idx] = value; return 0; }
 897   return -1;
 898 }
 899
 900
 901 int vmGetSP (int tid) {
 902   if (vmIsThreadAlive(tid)) return vmThreads[tid].sp;
 903   return -1;
 904 }
 905
 906
 907 int vmGetPC (int tid) {
 908   if (vmIsThreadAlive(tid)) return vmThreads[tid].pc;
 909   return -1;
 910 }
 911
 912
 913 int vmSetPC (int tid, int pc) {
 914   if (vmIsThreadAlive(tid) && pc >= 0 && pc < vmCodeSize) { vmThreads[tid].pc = pc; return 0; }
 915   return -1;
 916 }
 917
 918
 919 int vmSetSP (int tid, int value) {
 920   if (vmIsThreadAlive(tid)) { vmThreads[tid].sp = value; return 0; }
 921   return -1;
 922 }
 923
 924
 925 int vmGetStack (int tid, int idx) {
 926   if (vmIsThreadAlive(tid)) {
 927     if (idx < 0) idx += vmThreads[tid].sp;
 928     if (idx >= 0 && idx < VM_STACK_SIZE) return vmThreads[tid].stack[idx];
 929   }
 930   return -1;
 931 }
 932
 933
 934 int vmSetStack (int tid, int idx, int value) {
 935   if (vmIsThreadAlive(tid)) {
 936     if (idx < 0) idx += vmThreads[tid].sp;
 937     if (idx >= 0 && idx < VM_STACK_SIZE) { vmThreads[tid].stack[idx] = value; return 0; }
 938   }
 939   return -1;
 940 }
 941
 942
 943 int vmPush (int tid, int value) {
 944   if (vmIsThreadAlive(tid) && vmThreads[tid].sp < VM_STACK_SIZE) {
 945     vmThreads[tid].stack[vmThreads[tid].sp++] = value;
 946     return 0;
 947   }
 948   return -1;
 949 }
 950
 951
 952 int vmPop (int tid) {
 953   if (vmIsThreadAlive(tid) && vmThreads[tid].sp > 0) return vmThreads[tid].stack[--vmThreads[tid].sp];
 954   return 0;
 955 }
 956
 957
 958 int vmLoadArgs (int tid, int argc, int argv[], int *argp[], int aargc, int aargv[], int *aargp[]) {
 959   if (!vmIsThreadAlive(tid)) return -1;
 960   if (argc > 0) {
 961     int e = argc;
 962     //
 963     if (e > aargc) e = aargc;
 964     for (int f = 0; f < e; ++f) { argv[f] = aargv[f]; argp[f] = aargp[f]; }
 965     for (int f = e; f < argc; ++f) {
 966       if (vmThreads[tid].sp <= 0) return -1;
 967       argp[argc-f] = NULL;
 968       argv[argc-f] = vmThreads[tid].stack[--vmThreads[tid].sp];
 969     }
 970   }
 971   return 0;
 972 }
 973
 974
 975 int vmLastThread (void) {
 976   return vmLastThreadId;
 977 }
 978
 979
 980 static int readBuf (FILE *fl, void *buf, int len) {
 981   unsigned char *c = (unsigned char *)buf;
 982   //
 983   while (len-- > 0) {
 984     unsigned char b;
 985     //
 986     if (fread(&b, 1, 1, fl) != 1) return -1;
 987     b ^= SECRET;
 988     *c++ = b;
 989   }
 990   return 0;
 991 }
 992
 993
 994 static int writeBuf (FILE *fl, const void *buf, int len) {
 995   const unsigned char *c = (const unsigned char *)buf;
 996   //
 997   while (len-- > 0) {
 998     unsigned char b = *c++;
 999     //
1000     b ^= SECRET;
1001     if (fwrite(&b, 1, 1, fl) != 1) return -1;
1002   }
1003   return 0;
1004 }
1005
1006
1007 static int readDW (FILE *fl, int *v) {
1008   int t[4];
1009   //
1010   for (int f = 0; f < 4; ++f) {
1011     unsigned char b;
1012     //
1013     if (fread(&b, 1, 1, fl) != 1) return -1;
1014     t[f] = b^SECRET;
1015   }
1016   //
1017   if (v) {
1018     *v = 0;
1019     for (int f = 0; f < 4; ++f) *v |= t[f]<<(8*f);
1020   }
1021   return 0;
1022 }
1023
1024
1025 static int writeDW (FILE *fl, int v) {
1026   for (int f = 0; f < 4; ++f) {
1027     unsigned char b;
1028     //
1029     b = v&0xff;
1030     b ^= SECRET;
1031     if (fwrite(&b, 1, 1, fl) != 1) return -1;
1032     v >>= 8;
1033   }
1034   return 0;
1035 }
1036
1037
1038 ////////////////////////////////////////////////////////////////////////////////
1039 static VMLabelInfo *labels = NULL;
1040
1041
1042 ////////////////////////////////////////////////////////////////////////////////
1043 void vmFreeLabels (void) {
1044   while (labels != NULL) {
1045     VMLabelInfo *l = labels;
1046     //
1047     labels = l->next;
1048     if (l->name) free(l->name);
1049     free(l);
1050   }
1051 }
1052
1053
1054 void vmFreeLabelsUntilMark (const char *name) {
1055   while (labels != NULL) {
1056     VMLabelInfo *l = labels;
1057     int isMark = (l->type == LB_MARK);
1058     //
1059     if (!(isMark && ((name == NULL && l->name == NULL) || (l->name != NULL && name != NULL && strcmp(name, l->name) == 0)))) isMark = 0;
1060     labels = l->next;
1061     if (l->name) free(l->name);
1062     free(l);
1063     if (isMark) break;
1064   }
1065 }
1066
1067
1068 VMLabelInfo *vmLabelAddMark (const char *name) {
1069   VMLabelInfo *l = malloc(sizeof(VMLabelInfo));
1070   //
1071   if (l == NULL) fatalis("out of memory");
1072   l->name = NULL;
1073   if (name != NULL) {
1074     l->name = strdup(name);
1075     if (l->name == NULL) fatalis("out of memory");
1076   }
1077   l->type = LB_MARK;
1078   l->value = -1;
1079   l->next = labels;
1080   l->pub = 0;
1081   labels = l;
1082   return l;
1083 }
1084
1085
1086 VMLabelInfo *vmAddLabel (const char *name, int type, int value, int pub) {
1087   if (name != NULL && name[0]) {
1088     VMLabelInfo *l = malloc(sizeof(VMLabelInfo));
1089     //
1090     if (l == NULL) fatalis("out of memory");
1091     if (name != NULL) {
1092       l->name = strdup(name);
1093       if (l->name == NULL) fatalis("out of memory");
1094     } else {
1095       l->name = NULL;
1096     }
1097     l->type = type;
1098     l->value = value;
1099     l->pub = pub;
1100     l->next = labels;
1101     labels = l;
1102     return l;
1103   }
1104   return NULL;
1105 }
1106
1107
1108 static VMLabelInfo *vmAddLabelToEnd (const char *name, int type, int value, int pub) {
1109   if (name != NULL && name[0]) {
1110     VMLabelInfo *l = malloc(sizeof(VMLabelInfo)), *last = NULL;
1111     //
1112     if (l == NULL) fatalis("out of memory");
1113     if (name != NULL) {
1114       l->name = strdup(name);
1115       if (l->name == NULL) fatalis("out of memory");
1116     } else {
1117       l->name = NULL;
1118     }
1119     l->type = type;
1120     l->value = value;
1121     l->pub = pub;
1122     l->next = NULL;
1123     if (labels == NULL) {
1124       labels = l;
1125     } else {
1126       for (last = labels; last->next != NULL; last = last->next) ;
1127       last->next = l;
1128     }
1129     return l;
1130   }
1131   return NULL;
1132 }
1133
1134
1135 VMLabelInfo *vmFindLabel (const char *name) {
1136   if (name != NULL && name[0]) {
1137     for (VMLabelInfo *l = labels; l != NULL; l = l->next) {
1138       if (l->name && l->name[0] && strcasecmp(l->name, name) == 0) return l;
1139     }
1140   }
1141   return NULL;
1142 }
1143
1144
1145 int vmFindPC (const char *name) {
1146   VMLabelInfo *l = vmFindLabel(name);
1147   //
1148   if (l == NULL && l->type != LB_CODE) fatalis("no code label: '%s'", name);
1149   return l->value;
1150 }
1151
1152
1153 int vmFindVarIndex (const char *name) {
1154   VMLabelInfo *l = vmFindLabel(name);
1155   //
1156   if (l == NULL || (l->type != LB_GVAR && l->type != LB_TVAR && l->type != LB_SVAR)) fatalis("no var label: '%s'", name);
1157   return l->value;
1158 }
1159
1160
1161 int vmFindGVarIndex (const char *name) {
1162   VMLabelInfo *l = vmFindLabel(name);
1163   //
1164   if (l == NULL || l->type != LB_GVAR) fatalis("no global var label: '%s'", name);
1165   return l->value;
1166 }
1167
1168
1169 int vmFindTVarIndex (const char *name) {
1170   VMLabelInfo *l = vmFindLabel(name);
1171   //
1172   if (l == NULL || l->type != LB_TVAR) fatalis("no thread var label: '%s'", name);
1173   return l->value;
1174 }
1175
1176
1177 int vmFindSVarIndex (const char *name) {
1178   VMLabelInfo *l = vmFindLabel(name);
1179   //
1180   if (l == NULL || l->type != LB_SVAR) fatalis("no thread var label: '%s'", name);
1181   return l->value;
1182 }
1183
1184
1185 int vmFindConst (const char *name) {
1186   VMLabelInfo *l = vmFindLabel(name);
1187   //
1188   if (l == NULL || l->type != LB_CONST) fatalis("no const label: '%s'", name);
1189   return l->value;
1190 }
1191
1192
1193 VMLabelInfo *vmFindMark (const char *name) {
1194   for (VMLabelInfo *l = labels; l != NULL; l = l->next) {
1195     if (l->type != LB_MARK) continue;
1196     if (name == NULL && l->name == NULL) return l;
1197     if (name != NULL && l->name != NULL && strcmp(name, l->name) == 0) return l;
1198   }
1199   return NULL;
1200 }
1201
1202
1203 #define XREAD(dest,size,errlabel)  do { \
1204   if (pos+(size) > rsz) goto errlabel; \
1205   if ((size) > 0) memcpy((dest), buf+pos, (size)); \
1206   pos += (size); \
1207 } while (0)
1208
1209
1210 #define XREADB(dest,errlabel)  do { \
1211   if (pos+1 > rsz) goto errlabel; \
1212   (dest) = buf[pos]; \
1213   ++pos; \
1214 } while (0)
1215
1216
1217 #define XREADW(dest,errlabel)  do { \
1218   if (pos+2 > rsz) goto errlabel; \
1219   (dest) = buf[pos+1]; \
1220   (dest) <<= 8; \
1221   (dest) |= buf[pos+0]; \
1222   pos += 2; \
1223 } while (0)
1224
1225
1226
1227 extern int vmLoadCodeFileFromDump (const void *data, int datasize, int pc, int gvfirst, int tvfirst, int *gvmax, int *tvmax) {
1228   int rsz = datasize, pos = 4;
1229   const uint8_t *dta = (const uint8_t *)data;
1230   uint8_t *buf;
1231   int csize, lcnt, rcnt, elcnt, tlast, glast;
1232   //
1233   if (rsz < 4) return -1;
1234   if (memcmp(data, "AVM2", 4) != 0) goto quitbufonly;
1235   buf = malloc(rsz);
1236   if (buf == NULL) return 1;
1237   //
1238   for (int f = 4; f < rsz; ++f) buf[f] = dta[f]^SECRET;
1239   //
1240   XREADW(csize, quitbufonly);
1241   XREADW(rcnt, quitbufonly); // fixups
1242   XREADW(elcnt, quitbufonly); // extern labels
1243   XREADW(lcnt, quitbufonly); // labels
1244   XREADW(glast, quitbufonly); // last used global
1245   XREADW(tlast, quitbufonly); // last used thread local
1246   if (pc < 0 || pc+csize > 65535) goto quitbufonly;
1247   //
1248   /*if (goobers)*/ fprintf(stderr, "code: %d bytes, %d public labels, %d relocations, %d externs\n", csize, lcnt, rcnt, elcnt);
1249   //
1250   XREAD(vmCode+pc, csize, quitbufonly);
1251   //
1252   // do relocations
1253   for (int f = 0; f < rcnt; ++f) {
1254     int rel, newpc, val;
1255     //
1256     XREADW(rel, quitbufonly);
1257     if (rel < 0 || rel+1 >= csize) goto quitbufonly;
1258     newpc = pc+rel; // fix here
1259     // get old value
1260     val = vmCode[newpc+1];
1261     val <<= 8;
1262     val |= vmCode[newpc+0];
1263     // fix it
1264     val += pc;
1265     // set new value
1266     vmCode[newpc+0] = val&0xff;
1267     vmCode[newpc+1] = (val>>8)&0xff;
1268   }
1269   //
1270   // load extern labels and perform fixups
1271   for (int f = 0; f < elcnt; ++f) {
1272     char name[258];
1273     int type, namelen;
1274     int rcnt;
1275     //
1276     XREADB(type, quitbufonly);
1277     XREADB(namelen, quitbufonly);
1278     XREAD(name, namelen, quitbufonly);
1279     XREADW(rcnt, quitbufonly);
1280     //
1281     if (type < LB_MIN_TYPE || type > LB_MAX_TYPE) goto quitbufonly;
1282     if (namelen < 1) goto quitbufonly;
1283     name[namelen] = 0;
1284     //
1285     for (int c = 0; c < rcnt; ++c) {
1286       int xpc, size, val;
1287       VMLabelInfo *l;
1288       //
1289       XREADB(size, quitbufonly);
1290       XREADW(xpc, quitbufonly);
1291       //
1292       if (size != 1 && size != 2) goto quitbufonly;
1293       if (xpc < 0 || xpc+size > csize) goto quitbufonly;
1294       //
1295       xpc += pc;
1296       l = vmFindLabel(name);
1297       if (l == NULL) {
1298         /*if (goobers)*/ fprintf(stderr, "VM: unknown extern: '%s'\n", name);
1299         goto quitbufonly;
1300       }
1301       val = l->value;
1302       if (l->type == LB_GVAR) val |= 0x80;
1303       //fprintf(stderr, "%d: [%s]: ofs=%d, size=%d, value=%d (%d)\n", c, l->name, xpc, size, val, vmCode[xpc]);
1304       if (size == 1 && (val < -128 || val > 255)) {
1305         /*if (goobers)*/ fprintf(stderr, "VM: extern too big: '%s'\n", name);
1306         goto quitbufonly;
1307       }
1308       vmCode[xpc+0] = val&0xff;
1309       if (size == 2) vmCode[xpc+1] = (val>>8)&0xff;
1310     }
1311   }
1312   //
1313   vmLabelAddMark(NULL); // for this code labels
1314   for (int f = 0; f < lcnt; ++f) {
1315     unsigned char type, namelen, b;
1316     char name[258];
1317     int value;
1318     //
1319     XREADB(type, quit);
1320     //
1321     switch (type&0x7f) {
1322       case LB_GVAR:
1323       case LB_TVAR:
1324         XREADB(b, quit);
1325         value = b;
1326         break;
1327       case LB_SVAR:
1328       case LB_CONST:
1329         XREADW(value, quit);
1330         if (value >= 32768) value -= 65536;
1331         break;
1332       case LB_CODE:
1333         XREADW(value, quit);
1334         value += pc; // fixup
1335         break;
1336       default:
1337         fatalis("invalid label type: %d\n", type);
1338         goto quit;
1339     }
1340     //
1341     XREADB(namelen, quit);
1342     XREAD(name, namelen, quit);
1343     name[namelen] = 0;
1344     //
1345     if (namelen > 0) vmAddLabel(name, type&0x7f, value, type&0x80?1:0);
1346     //if (l->type == LB_CODE) printf("%d/%d: [%s] %d : %d\n", f, lcnt, l->name, l->value-pc, l->value);
1347   }
1348   //
1349   {
1350     int cnt;
1351     //
1352     XREADW(cnt, quit);
1353     while (cnt-- > 0) {
1354       int fpc;
1355       //
1356       XREADW(fpc, quit);
1357       if (gvfirst > 0) {
1358         //fprintf(stderr, "GVFIX at 0x%04x: %d --> %d\n", fpc, vmCode[pc+fpc], vmCode[pc+fpc]+gvfirst);
1359         vmCode[pc+fpc] += gvfirst;
1360       }
1361     }
1362     //
1363     XREADW(cnt, quit);
1364     while (cnt-- > 0) {
1365       int fpc;
1366       //
1367       XREADW(fpc, quit);
1368       if (tvfirst > 0) {
1369         //fprintf(stderr, "TVFIX at 0x%04x: %d --> %d\n", fpc, vmCode[pc+fpc], vmCode[pc+fpc]+tvfirst);
1370         vmCode[pc+fpc] += tvfirst;
1371       }
1372     }
1373     //
1374     if (gvmax) *gvmax = glast+gvfirst+1;
1375     if (tvmax) *tvmax = tlast+tvfirst+1;
1376   }
1377   free(buf);
1378   return csize;
1379 quit:
1380   vmFreeLabelsUntilMark(NULL);
1381 quitbufonly:
1382   free(buf);
1383   return -1;
1384 }
1385
1386
1387 ////////////////////////////////////////////////////////////////////////////////
1388 int vmSaveState (FILE *fl) {
1389   int lcnt = 0;
1390   //
1391   fixLastThreadId();
1392   //
1393   if (writeDW(fl, VM_VARS_SIZE) != 0) return -1;
1394   //if (writeDW(fl, VM_STACK_SIZE) != 0) return -1;
1395   if (writeDW(fl, vmMaxGVar) != 0) return -1;
1396   if (writeDW(fl, vmMaxTVar) != 0) return -1;
1397   if (writeDW(fl, vmLastThreadId) != 0) return -1;
1398   if (writeDW(fl, vmCodeSize) != 0) return -1;
1399   if (writeBuf(fl, vmCode, vmCodeSize) != 0) return -1;
1400   for (int f = 0; f < VM_VARS_SIZE; ++f) if (writeDW(fl, vmGVars[f]) != 0) return -1;
1401   for (int f = 0; f <= vmLastThreadId; ++f) {
1402     if (vmThreads[f].stack != NULL) {
1403       if (writeDW(fl, f) != 0) return -1;
1404       if (writeDW(fl, vmThreads[f].pc) != 0) return -1;
1405       if (writeDW(fl, vmThreads[f].suspended) != 0) return -1;
1406       if (writeDW(fl, vmThreads[f].sp) != 0) return -1;
1407       for (int c = 0; c < vmThreads[f].sp; ++c) if (writeDW(fl, vmThreads[f].stack[c]) != 0) return -1;
1408       for (int c = 0; c < VM_VARS_SIZE; ++c) if (writeDW(fl, vmThreads[f].tvars[c]) != 0) return -1;
1409     } else {
1410       if (writeDW(fl, -1) != 0) return -1;
1411     }
1412   }
1413   //
1414   for (VMLabelInfo *l = labels; l != NULL; l = l->next) ++lcnt;
1415   if (writeDW(fl, lcnt) != 0) return -1;
1416   for (VMLabelInfo *l = labels; l != NULL; l = l->next) {
1417     int nlen = l->name != NULL ? strlen(l->name) : -1;
1418     //
1419     if (writeDW(fl, l->type) != 0) return -1;
1420     if (writeDW(fl, nlen) != 0) return -1;
1421     if (nlen > 0) {
1422       if (writeBuf(fl, l->name, nlen) != 0) return -1;
1423     }
1424     if (writeDW(fl, l->value) != 0) return -1;
1425     if (writeDW(fl, l->pub) != 0) return -1;
1426   }
1427   //
1428   return 0;
1429 }
1430
1431
1432 int vmLoadState (FILE *fl) {
1433   int v, lcnt;
1434   //
1435   vmDeinitialize();
1436   if (vmInitialize() != 0) goto fail;
1437   //
1438   if (readDW(fl, &v) != 0 || v != VM_VARS_SIZE) goto fail;
1439   //if (readDW(fl, &ssz) != 0) goto fail;
1440   if (readDW(fl, &vmMaxGVar) != 0 || vmMaxGVar < 0 || vmMaxGVar > VM_VARS_SIZE) goto fail;
1441   if (readDW(fl, &vmMaxTVar) != 0 || vmMaxTVar < 0 || vmMaxTVar > VM_VARS_SIZE) goto fail;
1442   if (readDW(fl, &vmLastThreadId) != 0 || vmLastThreadId < 0 || vmLastThreadId > VM_MAX_THREADS) goto fail;
1443   if (readDW(fl, &vmCodeSize) != 0 || vmCodeSize < 1 || vmCodeSize > 65536) goto fail;
1444   if (readBuf(fl, vmCode, vmCodeSize) != 0) goto fail;
1445   for (int f = 0; f < VM_VARS_SIZE; ++f) if (readDW(fl, &vmGVars[f]) != 0) goto fail;
1446   for (int f = 0; f <= vmLastThreadId; ++f) {
1447     int flag;
1448     //
1449     if (readDW(fl, &flag) != 0) goto fail;
1450     if (flag == -1) continue;
1451     if (flag != f) goto fail;
1452     if (vmInitThread(&vmThreads[f]) != 0) goto fail;
1453     if (readDW(fl, &vmThreads[f].pc) != 0) goto fail;
1454     if (readDW(fl, &vmThreads[f].suspended) != 0) goto fail;
1455     if (readDW(fl, &vmThreads[f].sp) != 0) goto fail;
1456     if (!vmThreads[f].suspended) {
1457       if (vmThreads[f].pc < 0 || vmThreads[f].pc >= vmCodeSize) goto fail;
1458       if (vmThreads[f].sp < 0 || vmThreads[f].sp > VM_STACK_SIZE) goto fail;
1459     }
1460     for (int c = 0; c < vmThreads[f].sp; ++c) if (readDW(fl, &vmThreads[f].stack[c]) != 0) goto fail;
1461     for (int c = 0; c < VM_VARS_SIZE; ++c) if (readDW(fl, &vmThreads[f].tvars[c]) != 0) goto fail;
1462   }
1463   //
1464   if (readDW(fl, &lcnt) != 0) goto fail;
1465   for (; lcnt > 0; --lcnt) {
1466     int type, namelen, value, pub;
1467     char name[257];
1468     //
1469     if (readDW(fl, &type) != 0) goto fail;
1470     if (readDW(fl, &namelen) != 0) goto fail;
1471     if (namelen > 255) goto fail;
1472     if (namelen >= 0) {
1473       if (readBuf(fl, name, namelen) != 0) goto fail;
1474       name[namelen] = 0;
1475     }
1476     if (readDW(fl, &value) != 0) goto fail;
1477     if (readDW(fl, &pub) != 0) goto fail;
1478     vmAddLabelToEnd(namelen>=0 ? name : NULL, type, value, pub);
1479   }
1480   return 0;
1481 fail:
1482   vmDeinitialize();
1483   return -1;
1484 }