src/exec.c

   1 #include "exec.h"
   2
   3 /**
   4  * @brief プログラムレジスタ（PR）を表すWORD値を文字列に変換
   5  *
   6  * @return 文字列「PR:XXXX」（Xは16進数の数字）
   7  *
   8  * @param pr プログラムレジスタ（PR）を表すWORD値
   9  */
  10 char *pr2str(WORD pr);
  11
  12 /**
  13  * @brief 標準入力から文字データを読込（SVC 1）
  14  *
  15  * @return なし
  16  */
  17 void svcin();
  18
  19 /**
  20  * @brief 標準出力へ文字データを書出（SVC 2）
  21  *
  22  * @return なし
  23  */
  24 void svcout();
  25
  26 /**
  27  * @brief ロード／論理積／論理和／排他的論理和のフラグ設定。OFは常に0
  28  *
  29  * @return なし
  30  *
  31  * @param adr アドレス
  32  */
  33 void setfr(WORD adr);
  34
  35 /**
  36  * @brief WORD値からr/r1を取得
  37  *
  38  * @return r/r1を表すWORD値
  39  *
  40  * @param oprx オペランドを表すWORD値
  41  */
  42 WORD get_r_r1(WORD oprx);
  43
  44 /**
  45  * @brief WORD値からx/r2を取得
  46  *
  47  * @return x/r2を表すWORD値
  48  *
  49  * @param oprx オペランドを表すWORD値
  50  */
  51 WORD get_x_r2(WORD oprx);
  52
  53 /**
  54  * @brief 2つのWORD値からadr[,x]を取得
  55  *
  56  * @return adr[,x]を表すWORD値
  57  *
  58  * @param adr アドレスを表すWORD値
  59  * @param oprx オペランドを表すWORD値
  60  */
  61 WORD get_adr_x(WORD adr, WORD oprx);
  62
  63 /**
  64  * @brief 2つのWORD値からadr[,x]のアドレスに格納されている値を取得
  65  *
  66  * @return adr[,x]のアドレスに格納されている値を表すWORD値
  67  *
  68  * @param adr アドレスを表すWORD値
  69  * @param oprx オペランドを表すWORD値
  70  */
  71 WORD get_val_adr_x(WORD adr, WORD oprx);
  72
  73 /**
  74  * @brief 実行エラーの定義
  75  */
  76 static CERR cerr_exec[] = {
  77     { 201, "Program Register (PR) - memory overflow" },
  78     { 202, "Stack Pointer (SP) - stack overflow" },
  79     { 203, "Stack Pointer (SP) - stack underflow" },
  80     { 204, "OP in word #1 - not command code" },
  81     { 205, "r/r1 in word #1 - not GR" },
  82     { 206, "x/r2 in word #1 - not GR" },
  83     { 207, "address in word #2 - out of memory" },
  84     { 208, "SVC input - memory overflow" },
  85     { 209, "SVC output - memory overflow" },
  86 };
  87
  88 /**
  89  * @brief アセンブル結果読み込みエラーの定義
  90  */
  91 static CERR cerr_load[] = {
  92     { 210, "load - memory overflow" },
  93     { 211, "object file not specified" },
  94 };
  95
  96 /**
  97  * @brief 実行モード: trace, logical, dump, step
  98  */
  99 EXECMODE execmode = {false, false, false, false};
 100
 101 char *pr2str(WORD pr)
 102 {
 103     char *str = malloc_chk(CERRSTRSIZE + 1, "pr2str.pr");
 104
 105     sprintf(str, "PR:#%04X", pr);
 106     return str;
 107 }
 108
 109 void svcin()
 110 {
 111     int i;
 112     char *buf = malloc_chk(INSIZE + 1, "svcin.buf");
 113
 114     if(fgets(buf, INSIZE, stdin) == NULL) {
 115         sys->memory[sys->cpu->gr[1]] = sys->memory[sys->cpu->gr[2]] = 0x0;
 116         return;
 117     }
 118     for(i = 0; i < INSIZE; i++) {
 119         if(*(buf + i) == '\0' || *(buf + i) == '\n') {
 120             --i;
 121             break;
 122         }
 123         if(sys->cpu->gr[1] + i > execptr->end) {
 124             setcerr(208, "");    /* SVC input - memory overflow */
 125             break;
 126         }
 127         sys->memory[sys->cpu->gr[1]+i] = *(buf + i);
 128     }
 129     sys->memory[sys->cpu->gr[2]] = i + 1;
 130     FREE(buf);
 131 }
 132
 133 void svcout()
 134 {
 135     int i;
 136     WORD w;
 137
 138     for(i = 0; i < sys->memory[sys->cpu->gr[2]]; i++) {
 139         if(sys->cpu->gr[1] + i > execptr->end) {
 140             setcerr(209, "");    /* SVC output - memory overflow */
 141             return;
 142         }
 143         /* 「JIS X 0201ラテン文字・片仮名用8ビット符号で規定する文字の符号表」
 144            に記載された文字と、改行（CR）／タブを表示 */
 145         /* それ以外の文字は、「.」で表す */
 146         if(((w = sys->memory[sys->cpu->gr[1]+i]) >= 0x20 && w <= 0x7E) ||    /* JIS X 0201ラテン文字 */
 147            (w >= 0xA0 && w <= 0xFE) ||                                       /* JIS X 0201片仮名用8ビット符号 */
 148            w == 0xA || w == '\t')
 149         {
 150             putchar((char)w);
 151         } else {
 152             putchar('.');
 153         }
 154     }
 155 }
 156
 157 void setfr(WORD adr)
 158 {
 159     sys->cpu->fr = 0x0;
 160     /* 第15ビットが1のとき、SFは1 */
 161     if((adr & 0x8000) == 0x8000) {
 162         sys->cpu->fr += SF;
 163     }
 164     /* 演算結果が0のとき、ZFは1 */
 165     if(adr == 0x0) {
 166         sys->cpu->fr += ZF;
 167     }
 168 }
 169
 170 WORD get_r_r1(WORD oprx)
 171 {
 172     WORD r;
 173     char *s;
 174
 175     if((r = ((oprx & 0x00F0) >>4)) > GRSIZE - 1) {
 176         setcerr(205, s = pr2str(sys->cpu->pr));    /* r/r1 in word #1 - not GR */
 177         FREE(s);
 178         return 0x0;
 179     }
 180     return r;
 181 }
 182
 183 WORD get_x_r2(WORD oprx)
 184 {
 185     WORD x;
 186     char *s;
 187
 188     if((x = (oprx & 0x000F)) > GRSIZE - 1) {
 189         setcerr(206, s = pr2str(sys->cpu->pr));    /* r/r1 in word #1 - not GR */
 190         FREE(s);
 191         return 0x0;
 192     }
 193     return x;
 194 }
 195
 196 WORD get_adr_x(WORD adr, WORD oprx)
 197 {
 198     WORD a = adr, x;
 199     if((x = get_x_r2(oprx)) > 0) {
 200         a += sys->cpu->gr[x];
 201     }
 202     return a;
 203 }
 204
 205 WORD get_val_adr_x(WORD adr, WORD oprx)
 206 {
 207     WORD a;
 208     char *s;
 209
 210     if((a = get_adr_x(adr, oprx)) >= sys->memsize) {
 211         setcerr(207, s = pr2str(sys->cpu->pr + 1));    /* address in word #2 - out of memory */
 212         FREE(s);
 213         return 0x0;
 214     }
 215     return sys->memory[a];
 216 }
 217
 218 /* exec.hで定義された関数群 */
 219 void addcerrlist_load()
 220 {
 221     addcerrlist(ARRAYSIZE(cerr_load), cerr_load);
 222 }
 223
 224 void addcerrlist_exec()
 225 {
 226     addcerrlist(ARRAYSIZE(cerr_exec), cerr_exec);
 227 }
 228
 229 bool loadassemble(const char *file)
 230 {
 231     FILE *fp;
 232     bool stat = true;
 233
 234     assert(file != NULL);
 235     if((fp = fopen(file, "rb")) == NULL) {
 236         perror(file);
 237         return false;
 238     }
 239     execptr->end = execptr->start +
 240         fread(sys->memory, sizeof(WORD), sys->memsize - execptr->start, fp);
 241     if(execptr->end == sys->memsize) {
 242         setcerr(210, file);    /* load - memory overflow */
 243         fprintf(stderr, "Load error - %d: %s\n", cerr->num, cerr->msg);
 244         stat = false;
 245     }
 246     fclose(fp);
 247     return stat;
 248 }
 249
 250 void nop()
 251 {
 252     sys->cpu->pr += 1;
 253 }
 254
 255 void ld_r_adr_x()
 256 {
 257     WORD w[2];
 258     w[0] = sys->memory[sys->cpu->pr];
 259     w[1] = sys->memory[sys->cpu->pr + 1];
 260     setfr(sys->cpu->gr[get_r_r1(w[0])] = get_val_adr_x(w[1], w[0]));
 261     sys->cpu->pr += 2;
 262 }
 263
 264 void ld_r1_r2()
 265 {
 266     WORD w[1];
 267     w[0] = sys->memory[sys->cpu->pr];
 268     setfr(sys->cpu->gr[get_r_r1(w[0])] = sys->cpu->gr[get_x_r2(w[0])]);
 269     sys->cpu->pr += 1;
 270 }
 271
 272 void st()
 273 {
 274     WORD w[2];
 275     w[0] = sys->memory[sys->cpu->pr];
 276     w[1] = sys->memory[sys->cpu->pr + 1];
 277     sys->memory[get_adr_x(w[1], w[0])] = sys->cpu->gr[get_r_r1(w[0])];
 278     sys->cpu->pr += 2;
 279 }
 280
 281 void lad()
 282 {
 283     WORD w[2];
 284     w[0] = sys->memory[sys->cpu->pr];
 285     w[1] = sys->memory[sys->cpu->pr + 1];
 286     sys->cpu->gr[get_r_r1(w[0])] = get_adr_x(w[1], w[0]);
 287     sys->cpu->pr += 2;
 288 }
 289
 290 void adda(WORD r, WORD val)
 291 {
 292     long tmp;
 293
 294     sys->cpu->fr = 0x0;
 295     /* 引数の値を16ビット符号付整数として加算し、オーバーフローをチェック */
 296     assert(sizeof(short) * 8 == 16 && (short)0xFFFF == -1);
 297     if((tmp = (short)(sys->cpu->gr[r]) + (short)val) > 32767 || tmp < -32768) {
 298         sys->cpu->fr += OF;
 299     }
 300     /* 加算した結果を、WORD値に戻す */
 301     sys->cpu->gr[r] = (WORD)(tmp & 0xFFFF);
 302     if((sys->cpu->gr[r] & 0x8000) == 0x8000) {
 303         sys->cpu->fr += SF;
 304     } else if(sys->cpu->gr[r] == 0x0) {
 305         sys->cpu->fr += ZF;
 306     }
 307 }
 308
 309 void adda_r_adr_x()
 310 {
 311     WORD w[2];
 312     w[0] = sys->memory[sys->cpu->pr];
 313     w[1] = sys->memory[sys->cpu->pr + 1];
 314     adda(get_r_r1(w[0]), get_val_adr_x(w[1], w[0]));
 315     sys->cpu->pr += 2;
 316 }
 317
 318 void adda_r1_r2()
 319 {
 320     WORD w[1];
 321     w[0] = sys->memory[sys->cpu->pr];
 322     adda(get_r_r1(w[0]), sys->cpu->gr[get_x_r2(w[0])]);
 323     sys->cpu->pr += 1;
 324 }
 325
 326 void suba_r_adr_x()
 327 {
 328     WORD w[2];
 329     w[0] = sys->memory[sys->cpu->pr];
 330     w[1] = sys->memory[sys->cpu->pr + 1];
 331     adda(get_r_r1(w[0]), ~(get_val_adr_x(w[1], w[0])) + 1);
 332     sys->cpu->pr += 2;
 333 }
 334
 335 void suba_r1_r2()
 336 {
 337     WORD w[1];
 338     w[0] = sys->memory[sys->cpu->pr];
 339     adda(get_r_r1(w[0]), ~(sys->cpu->gr[get_x_r2(w[0])]) + 1);
 340     sys->cpu->pr += 1;
 341 }
 342
 343 void addl_gr(WORD r, WORD val, bool add)
 344 {
 345     unsigned long o, s;
 346
 347     o = sys->cpu->gr[r];
 348     sys->cpu->fr = 0x0;    /* flag initialize */
 349
 350     if(add == true) {
 351         s = o + val;
 352         if(s > 0xFFFF) {
 353             sys->cpu->fr += OF;
 354         }
 355     } else {
 356         if(o < val) {
 357             sys->cpu->fr += OF;
 358         }
 359         s = o + (~val + 1);
 360         if(s > 0xFFFF) {
 361             s &= 0xFFFF;
 362         }
 363     }
 364     sys->cpu->gr[r] = (WORD)s;
 365
 366     if((s & 0x8000) == 0x8000) {
 367         sys->cpu->fr += SF;
 368     }
 369     else if(s == 0x0) {
 370         sys->cpu->fr += ZF;
 371     }
 372 }
 373
 374 void addl_r_adr_x()
 375 {
 376     WORD w[2];
 377     w[0] = sys->memory[sys->cpu->pr];
 378     w[1] = sys->memory[sys->cpu->pr + 1];
 379     addl_gr(get_r_r1(w[0]), get_val_adr_x(w[1], w[0]), true);
 380     sys->cpu->pr += 2;
 381 }
 382
 383 void addl_r1_r2()
 384 {
 385     WORD w[1];
 386     w[0] = sys->memory[sys->cpu->pr];
 387     addl_gr(get_r_r1(w[0]), sys->cpu->gr[get_x_r2(w[0])], true);
 388     sys->cpu->pr += 1;
 389 }
 390
 391 void subl_r_adr_x()
 392 {
 393     WORD w[2];
 394     w[0] = sys->memory[sys->cpu->pr];
 395     w[1] = sys->memory[sys->cpu->pr + 1];
 396     addl_gr(get_r_r1(w[0]), get_val_adr_x(w[1], w[0]), false);
 397     sys->cpu->pr += 2;
 398 }
 399
 400 void subl_r1_r2()
 401 {
 402     WORD w[1];
 403     w[0] = sys->memory[sys->cpu->pr];
 404     addl_gr(get_r_r1(w[0]), sys->cpu->gr[get_x_r2(w[0])], false);
 405     sys->cpu->pr += 1;
 406 }
 407
 408 void and_r_adr_x()
 409 {
 410     WORD w[2];
 411     w[0] = sys->memory[sys->cpu->pr];
 412     w[1] = sys->memory[sys->cpu->pr + 1];
 413     setfr(sys->cpu->gr[get_r_r1(w[0])] &= get_val_adr_x(w[1], w[0]));
 414     sys->cpu->pr += 2;
 415 }
 416
 417 void and_r1_r2()
 418 {
 419     WORD w[1];
 420     w[0] = sys->memory[sys->cpu->pr];
 421     setfr(sys->cpu->gr[get_r_r1(w[0])] &= sys->cpu->gr[get_x_r2(w[0])]);
 422     sys->cpu->pr += 1;
 423 }
 424
 425 void or_r_adr_x()
 426 {
 427     WORD w[2];
 428     w[0] = sys->memory[sys->cpu->pr];
 429     w[1] = sys->memory[sys->cpu->pr + 1];
 430     setfr(sys->cpu->gr[get_r_r1(w[0])] |= get_val_adr_x(w[1], w[0]));
 431     sys->cpu->pr += 2;
 432 }
 433
 434 void or_r1_r2()
 435 {
 436     WORD w[1];
 437     w[0] = sys->memory[sys->cpu->pr];
 438     setfr(sys->cpu->gr[get_r_r1(w[0])] |= sys->cpu->gr[get_x_r2(w[0])]);
 439     sys->cpu->pr += 1;
 440 }
 441
 442 void xor_r_adr_x()
 443 {
 444     WORD w[2];
 445     w[0] = sys->memory[sys->cpu->pr];
 446     w[1] = sys->memory[sys->cpu->pr + 1];
 447     setfr(sys->cpu->gr[get_r_r1(w[0])] ^= get_val_adr_x(w[1], w[0]));
 448     sys->cpu->pr += 2;
 449 }
 450
 451 void xor_r1_r2()
 452 {
 453     WORD w[1];
 454     w[0] = sys->memory[sys->cpu->pr];
 455     setfr(sys->cpu->gr[get_r_r1(w[0])] ^= sys->cpu->gr[get_x_r2(w[0])]);
 456     sys->cpu->pr += 1;
 457 }
 458
 459 void cpa(WORD r, WORD val)
 460 {
 461     sys->cpu->fr = 0x0;
 462     if((short)sys->cpu->gr[r] < (short)val) {
 463         sys->cpu->fr = SF;
 464     } else if(sys->cpu->gr[r] == val) {
 465         sys->cpu->fr = ZF;
 466     }
 467 }
 468
 469 void cpa_r_adr_x()
 470 {
 471     WORD w[2];
 472     w[0] = sys->memory[sys->cpu->pr];
 473     w[1] = sys->memory[sys->cpu->pr + 1];
 474     cpa(get_r_r1(w[0]), get_val_adr_x(w[1], w[0]));
 475     sys->cpu->pr += 2;
 476 }
 477
 478 void cpa_r1_r2()
 479 {
 480     WORD w[1];
 481     w[0] = sys->memory[sys->cpu->pr];
 482     cpa(get_r_r1(w[0]), sys->cpu->gr[get_x_r2(w[0])]);
 483     sys->cpu->pr += 1;
 484 }
 485
 486 void cpl(WORD r, WORD val)
 487 {
 488     sys->cpu->fr = 0x0;
 489     if(sys->cpu->gr[r] < val) {
 490         sys->cpu->fr = SF;
 491     } else if(sys->cpu->gr[r] == val) {
 492         sys->cpu->fr = ZF;
 493     }
 494 }
 495
 496 void cpl_r_adr_x()
 497 {
 498     WORD w[2];
 499     w[0] = sys->memory[sys->cpu->pr];
 500     w[1] = sys->memory[sys->cpu->pr + 1];
 501     cpl(get_r_r1(w[0]), get_val_adr_x(w[1], w[0]));
 502     sys->cpu->pr += 2;
 503 }
 504
 505 void cpl_r1_r2()
 506 {
 507     WORD w[1];
 508     w[0] = sys->memory[sys->cpu->pr];
 509     cpl(get_r_r1(w[0]), sys->cpu->gr[get_x_r2(w[0])]);
 510     sys->cpu->pr += 1;
 511 }
 512
 513 void sla()
 514 {
 515     WORD w[2], sign, last = 0x0, r;
 516     int i;
 517
 518     w[0] = sys->memory[sys->cpu->pr];
 519     w[1] = sys->memory[sys->cpu->pr + 1];
 520     sys->cpu->fr = 0x0;
 521     sign = sys->cpu->gr[(r = get_r_r1(w[0]))] & 0x8000;
 522     sys->cpu->gr[r] &= 0x7FFF;
 523     for(i = 0; i < get_adr_x(w[1], w[0]); i++) {
 524         last = sys->cpu->gr[r] & 0x4000;
 525         sys->cpu->gr[r] <<= 1;
 526     }
 527     sys->cpu->gr[r] = sign | (sys->cpu->gr[r] & 0x7FFF);
 528     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 529     if(last > 0x0) {
 530         sys->cpu->fr += OF;
 531     }
 532     /* 符号（第15ビット）が1のとき、SFは1 */
 533     if(sign > 0x0) {
 534         sys->cpu->fr += SF;
 535     }
 536     /* 演算結果が0のとき、ZFは1 */
 537     if(sys->cpu->gr[r] == 0x0) {
 538         sys->cpu->fr += ZF;
 539     }
 540     sys->cpu->pr += 2;
 541 }
 542
 543 void sra()
 544 {
 545     WORD w[2], sign, last = 0x0, r;
 546     int i;
 547
 548     w[0] = sys->memory[sys->cpu->pr];
 549     w[1] = sys->memory[sys->cpu->pr + 1];
 550     sys->cpu->fr = 0x0;
 551     sign = sys->cpu->gr[(r = get_r_r1(w[0]))] & 0x8000;
 552     sys->cpu->gr[r] &= 0x7FFF;
 553     for(i = 0; i < get_adr_x(w[1], w[0]); i++) {
 554         last = sys->cpu->gr[r] & 0x1;
 555         sys->cpu->gr[r] >>= 1;
 556         if(sign > 0) {
 557             sys->cpu->gr[r] |= 0x4000;
 558         }
 559     }
 560     sys->cpu->gr[r] = sign | sys->cpu->gr[r];
 561     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 562     if(last > 0x0) {
 563         sys->cpu->fr += OF;
 564     }
 565     /* 符号（第15ビット）が1のとき、SFは1 */
 566     if(sign > 0x0) {
 567         sys->cpu->fr += SF;
 568     }
 569     /* 演算結果が0のとき、ZFは1 */
 570     if(sys->cpu->gr[r] == 0x0) {
 571         sys->cpu->fr += ZF;
 572     }
 573     sys->cpu->pr += 2;
 574 }
 575
 576 void sll()
 577 {
 578     WORD w[2], last = 0x0, r;
 579     int i;
 580
 581     w[0] = sys->memory[sys->cpu->pr];
 582     w[1] = sys->memory[sys->cpu->pr + 1];
 583     sys->cpu->fr = 0x0;
 584     for(i = 0; i < get_adr_x(w[1], w[0]); i++) {
 585         last = sys->cpu->gr[(r = get_r_r1(w[0]))] & 0x8000;
 586         sys->cpu->gr[r] <<= 1;
 587     }
 588     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 589     if(last > 0x0) {
 590         sys->cpu->fr += OF;
 591     }
 592     /* 第15ビットが1のとき、SFは1 */
 593     if((sys->cpu->gr[r] & 0x8000) > 0x0) {
 594         sys->cpu->fr += SF;
 595     }
 596     /* 演算結果が0のとき、ZFは1 */
 597     if(sys->cpu->gr[r] == 0x0) {
 598         sys->cpu->fr += ZF;
 599     }
 600     sys->cpu->pr += 2;
 601 }
 602
 603 void srl()
 604 {
 605     WORD w[2], last = 0x0, r;
 606     int i;
 607
 608     w[0] = sys->memory[sys->cpu->pr];
 609     w[1] = sys->memory[sys->cpu->pr + 1];
 610     sys->cpu->fr = 0x0;
 611     r = get_r_r1(w[0]);
 612     for(i = 0; i < get_adr_x(w[1], w[0]); i++) {
 613         last = sys->cpu->gr[r] & 0x0001;
 614         sys->cpu->gr[r] >>= 1;
 615     }
 616     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 617     if(last > 0x0) {
 618         sys->cpu->fr += OF;
 619     }
 620     /* 第15ビットが1のとき、SFは1 */
 621     if((sys->cpu->gr[r] & 0x8000) > 0x0) {
 622         sys->cpu->fr += SF;
 623     }
 624     /* 演算結果が0のとき、ZFは1 */
 625     if(sys->cpu->gr[r] == 0x0) {
 626         sys->cpu->fr += ZF;
 627     }
 628     sys->cpu->pr += 2;
 629 }
 630
 631 void jpl()
 632 {
 633     WORD w[2];
 634     w[0] = sys->memory[sys->cpu->pr];
 635     w[1] = sys->memory[sys->cpu->pr + 1];
 636     if((sys->cpu->fr & (SF | ZF)) == 0) {
 637         sys->cpu->pr = get_adr_x(w[1], w[0]);
 638     } else {
 639         sys->cpu->pr += 2;
 640     }
 641 }
 642
 643 void jmi()
 644 {
 645     WORD w[2];
 646     w[0] = sys->memory[sys->cpu->pr];
 647     w[1] = sys->memory[sys->cpu->pr + 1];
 648     if((sys->cpu->fr & SF) > 0) {
 649         sys->cpu->pr = get_adr_x(w[1], w[0]);
 650     } else {
 651         sys->cpu->pr += 2;
 652     }
 653 }
 654
 655 void jnz()
 656 {
 657     WORD w[2];
 658     w[0] = sys->memory[sys->cpu->pr];
 659     w[1] = sys->memory[sys->cpu->pr + 1];
 660     if((sys->cpu->fr & ZF) == 0) {
 661         sys->cpu->pr = get_adr_x(w[1], w[0]);
 662     } else {
 663         sys->cpu->pr += 2;
 664     }
 665 }
 666
 667 void jze()
 668 {
 669     WORD w[2];
 670     w[0] = sys->memory[sys->cpu->pr];
 671     w[1] = sys->memory[sys->cpu->pr + 1];
 672     if((sys->cpu->fr & ZF) > 0) {
 673         sys->cpu->pr = get_adr_x(w[1], w[0]);
 674     } else {
 675         sys->cpu->pr += 2;
 676     }
 677 }
 678
 679 void jov()
 680 {
 681     WORD w[2];
 682     w[0] = sys->memory[sys->cpu->pr];
 683     w[1] = sys->memory[sys->cpu->pr + 1];
 684     if((sys->cpu->fr & OF) > 0) {
 685         sys->cpu->pr = get_adr_x(w[1], w[0]);
 686     } else {
 687         sys->cpu->pr += 2;
 688     }
 689 }
 690
 691 void jump()
 692 {
 693     WORD w[2];
 694     w[0] = sys->memory[sys->cpu->pr];
 695     w[1] = sys->memory[sys->cpu->pr + 1];
 696     sys->cpu->pr = get_adr_x(w[1], w[0]);
 697 }
 698
 699 void push()
 700 {
 701     assert(sys->cpu->sp > execptr->end && sys->cpu->sp <= sys->memsize);
 702     WORD w[2];
 703
 704     w[0] = sys->memory[sys->cpu->pr];
 705     w[1] = sys->memory[sys->cpu->pr + 1];
 706     sys->memory[--(sys->cpu->sp)] = get_adr_x(w[1], w[0]);
 707     sys->cpu->pr += 2;
 708 }
 709
 710 void pop()
 711 {
 712     assert(sys->cpu->sp > execptr->end);
 713     WORD w;
 714     char *s;
 715
 716     if(sys->cpu->sp >= sys->memsize) {
 717         setcerr(203, s = pr2str(sys->cpu->pr));        /* Stack Pointer (SP) - stack underflow */
 718         FREE(s);
 719     } else {
 720         w = sys->memory[sys->cpu->pr];
 721         sys->cpu->gr[get_r_r1(w)] = sys->memory[(sys->cpu->sp)++];
 722         sys->cpu->pr += 1;
 723     }
 724 }
 725
 726 void call()
 727 {
 728     assert(sys->cpu->sp > execptr->end && sys->cpu->sp <= sys->memsize);
 729     WORD w[2];
 730     w[0] = sys->memory[sys->cpu->pr];
 731     w[1] = sys->memory[sys->cpu->pr + 1];
 732     sys->memory[--(sys->cpu->sp)] = sys->cpu->pr + 1;
 733     sys->cpu->pr = get_adr_x(w[1], w[0]);
 734 }
 735
 736 void ret()
 737 {
 738     assert(sys->cpu->sp <= sys->memsize);
 739     if(sys->cpu->sp == sys->memsize) {
 740         execptr->stop = true;
 741     } else if(sys->cpu->sp < sys->memsize) {
 742         sys->cpu->pr = sys->memory[(sys->cpu->sp)++] + 1;
 743     }
 744 }
 745
 746 void svc()
 747 {
 748     WORD w[2];
 749     w[0] = sys->memory[sys->cpu->pr];
 750     w[1] = sys->memory[sys->cpu->pr + 1];
 751     switch(get_adr_x(w[1], w[0]))
 752     {
 753     case 0x0:                   /* STOP */
 754         execptr->stop = true;
 755         break;
 756     case 0x1:                   /* IN */
 757         svcin();
 758         break;
 759     case 0x2:                   /* OUT */
 760         svcout();
 761         break;
 762     }
 763     sys->cpu->pr += 2;
 764 }
 765
 766 char *grstr(WORD word)
 767 {
 768     assert(word <= 7);
 769     char *str = malloc_chk(3 + 1, "grstr.str");
 770     sprintf(str, "GR%d", word);
 771     return str;
 772 }
 773
 774 void exec()
 775 {
 776     clock_t clock_begin, clock_end;
 777     void (*cmdptr)();
 778     char *s;
 779
 780     create_code_cmdtype();                          /* 命令のコードとタイプがキーのハッシュ表を作成 */
 781     if(execmode.trace == true) {
 782         fprintf(stdout, "\nExecuting machine codes\n");
 783     }
 784     /* 機械語の実行 */
 785     for (sys->cpu->pr = execptr->start; ; ) {
 786         clock_begin = clock();                     /* クロック周波数設定のため、実行開始時間を格納 */
 787         if(execmode.dump || execmode.trace) {      /* traceまたはdumpオプション指定時、改行を出力 */
 788             if(execmode.trace) {                   /* traceオプション指定時、レジスタを出力 */
 789                 fprintf(stdout, "#%04X: Register::::\n", sys->cpu->pr);
 790                 dspregister();
 791             }
 792             if(execmode.dump) {                    /* dumpオプション指定時、メモリを出力 */
 793                 fprintf(stdout, "#%04X: Memory::::\n", sys->cpu->pr);
 794                 dumpmemory(0x0, 0xFFFF);
 795             }
 796             fprintf(stdout, "\n");
 797         }
 798         /* デバッガーモードの場合、デバッガーを起動 */
 799         if(execmode.step == true || getbps(sys->cpu->pr) == true) {
 800             monitor();
 801         }
 802         /* プログラムレジスタをチェック */
 803         if(sys->cpu->pr >= sys->memsize) {
 804             setcerr(201, s = pr2str(sys->cpu->pr));        /* Program Register (PR) - memory overflow */
 805             FREE(s);
 806             goto execfin;
 807         }
 808         /* スタックポインタをチェック */
 809         if(sys->cpu->sp <= execptr->end) {
 810             setcerr(202, s = pr2str(sys->cpu->pr));        /* Stack Pointer (SP) - stack overflow */
 811             FREE(s);
 812             goto execfin;
 813         }
 814         /* コードから命令を取得 */
 815         /* 取得できない場合はエラー終了 */
 816         if((cmdptr = getcmdptr(sys->memory[sys->cpu->pr] & 0xFF00)) == NULL) {
 817             setcerr(204, s = pr2str(sys->cpu->pr));            /* OP in word #1 - not command code */
 818             FREE(s);
 819             goto execfin;
 820         }
 821         /* 命令の実行 */
 822         (*cmdptr)();
 823         /* エラー発生時はエラー終了 */
 824         if(cerr->num > 0) {
 825             goto execfin;
 826         }
 827         /* 終了フラグがtrueの場合は、正常終了 */
 828         if(execptr->stop == true) {
 829             break;
 830         }
 831         /* クロック周波数の設定 */
 832         do {
 833             clock_end = clock();
 834         } while(clock_end - clock_begin < CLOCKS_PER_SEC / sys->clocks);
 835     }
 836 execfin:
 837     freebps();
 838     free_code_cmdtype();                           /* 命令のコードとタイプがキーのハッシュ表を解放 */
 839     if(cerr->num > 0) {
 840         fprintf(stderr, "Execute error - %d: %s\n", cerr->num, cerr->msg);
 841     }
 842 }