src/assemble.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <ctype.h>
   5 #include <assert.h>
   6 #include <errno.h>
   7
   8 #include "assemble.h"
   9 #include "cerr.h"
  10
  11 /**
  12  * @brief ファイルストリームの現在行を番号付きで表示する
  13  *
  14  * @return なし
  15  *
  16  * @param *stream ファイルストリーム
  17  * @param *filename ファイル名
  18  * @param lineno 行番号
  19  * @param line 行の文字列
  20  */
  21 void printline(FILE *stream, const char *filename, int lineno, char *line);
  22
  23 /**
  24  * @brief アドレスを返す
  25  *
  26  * アドレスには、リテラル／10進定数／16進定数／アドレス定数が含まれる
  27  *
  28  * @return アドレス
  29  *
  30  * @param *prog プログラム名
  31  * @param *str アドレスを表す文字列
  32  * @param pass アセンブラが何回目かを表す数
  33  */
  34 WORD getadr(const char *prog, const char *str, PASS pass);
  35
  36 /**
  37  * @brief 汎用レジスタを表す文字列 からレジスタ番号を返す
  38  *
  39  * @brief 文字列が汎用レジスタを表さない場合は、0xFFFFを返す
  40  *
  41  * is_xがtrueの場合は指標レジスタとなり、GR0が指定された場合はCOMET IIの仕様によりエラー発生
  42  *
  43  * @return レジスタ番号[0-7]を表すWORD値
  44  *
  45  * @param *str 汎用レジスタを表す文字列。「GR0」「GR1」・・・「GR7」のいずれか
  46  * @param is_x trueの場合は指標レジスタ
  47  */
  48 WORD getgr(const char *str, bool is_x);
  49
  50 /**
  51  * @brief リテラルを返す
  52  *
  53  * リテラルには、10進定数／16進定数／文字定数が含まれる
  54  *
  55  * @param *str リテラル。定数の前に等号（=）をつけて記述される
  56  * @param pass アセンブラが何回目かを表す数
  57  */
  58 WORD getliteral(const char *str, PASS pass);
  59
  60 /**
  61  * @brief アドレス値をメモリに書き込む
  62  *
  63  * @return なし
  64  *
  65  * @param word アドレス値
  66  * @param adr アドレス
  67  * @param pass アセンブラが何回目かを表す数
  68  */
  69 void writememory(WORD word, WORD adr, PASS pass);
  70
  71 /**
  72  * @brief 文字をメモリに書き込む
  73  *
  74  * @return なし
  75  *
  76  * @param *str アドレスを表す文字列。リテラル／10進定数／16進定数／アドレス定数が含まれる
  77  * @param literal リテラルの場合はtrue
  78  * @param pass アセンブラが何回目かを表す数
  79  */
  80 void writestr(const char *str, bool literal, PASS pass);
  81
  82 /**
  83  * @brief DC命令を書込
  84  *
  85  * @return なし
  86  *
  87  * @param str アドレスを表す文字列。10進定数／16進定数／アドレス定数が含まれる
  88  * @param pass アセンブラが何回目かを表す数
  89  */
  90 void writedc(const char *str, PASS pass);
  91
  92 /**
  93  * @brief アセンブラ命令STARTの処理
  94  * @relatesalso Casl2cmd
  95  *
  96  * @return なし
  97  *
  98  * @param *cmdl 1行分のラベル・コマンド・オペランド
  99  * @param pass アセンブラが何回目かを表す数
 100  */
 101 void assemble_start(const CMDLINE *cmdl, PASS pass);
 102
 103 /**
 104  * @brief アセンブラ命令DSの処理
 105  * @relatesalso Casl2cmd
 106  *
 107  * @return なし
 108  *
 109  * @param *cmdl 1行分のラベル・コマンド・オペランド
 110  * @param pass アセンブラが何回目かを表す数
 111  */
 112 void assemble_ds(const CMDLINE *cmdl, PASS pass);
 113
 114 /**
 115  * @brief アセンブラ命令ENDの処理
 116  * @relatesalso Casl2cmd
 117  *
 118  * @return なし
 119  *
 120  * @param *cmdl 1行分のラベル・コマンド・オペランド
 121  * @param pass アセンブラが何回目かを表す数
 122  */
 123 void assemble_end(const CMDLINE *cmdl, PASS pass);
 124
 125 /**
 126  * @brief アセンブラ命令DCの処理
 127  * @relatesalso Casl2cmd
 128  *
 129  * @return なし
 130  *
 131  * @param *cmdl 1行分のラベル・コマンド・オペランド
 132  * @param pass アセンブラが何回目かを表す数
 133  */
 134 void assemble_dc(const CMDLINE *cmdl, PASS pass);
 135
 136 /**
 137  * @brief マクロ命令 "IN IBUF,LEN" をアセンブル
 138  *
 139  * @code
 140  *      PUSH 0,GR1
 141  *      PUSH 0,GR2
 142  *      LAD GR1,IBUF
 143  *      LAD GR2,LEN
 144  *      SVC 1
 145  *      POP GR2
 146  *      POP GR1
 147  * @endcode
 148  * @relatesalso Casl2cmd
 149  *
 150  *
 151  * @return なし
 152  *
 153  * @param *cmdl 1行分のラベル・コマンド・オペランド
 154  * @param pass アセンブラが何回目かを表す数
 155  */
 156 void assemble_in(const CMDLINE *cmdl, PASS pass);
 157
 158 /**
 159  * @brief マクロ命令 "OUT OBUF,LEN" をアセンブル
 160  *
 161  * @code
 162  *      PUSH 0,GR1
 163  *      PUSH 0,GR2
 164  *      LAD GR1,OBUF
 165  *      LAD GR2,LEN
 166  *      SVC 2
 167  *      LAD GR1,=#A
 168  *      LAD GR2,=1
 169  *      SVC 2
 170  *      POP GR2
 171  *      POP GR1
 172  * @endcode
 173  * @relatesalso Casl2cmd
 174  *
 175  * @return なし
 176  *
 177  * @param *cmdl 1行分のラベル・コマンド・オペランド
 178  * @param pass アセンブラが何回目かを表す数
 179  */
 180 void assemble_out(const CMDLINE *cmdl, PASS pass);
 181
 182 /**
 183  * @brief マクロ命令 "RPUSH" をメモリに書き込む
 184  *
 185  * @code
 186  *       PUSH 0,GR1
 187  *       PUSH 0,GR2
 188  *       PUSH 0,GR3
 189  *       PUSH 0,GR4
 190  *       PUSH 0,GR5
 191  *       PUSH 0,GR6
 192  *       PUSH 0,GR7
 193  * @endcode
 194  * @relatesalso Casl2cmd
 195  *
 196  * @return なし
 197  *
 198  * @param *cmdl 1行分のラベル・コマンド・オペランド
 199  * @param pass アセンブラが何回目かを表す数
 200  */
 201 void assemble_rpush(const CMDLINE *cmdl, PASS pass);
 202
 203 /**
 204  * @brief マクロ命令 "RPOP" をメモリに書き込む
 205  *
 206  * @code
 207  *      POP GR7
 208  *      POP GR6
 209  *      POP GR5
 210  *      POP GR4
 211  *      POP GR3
 212  *      POP GR3
 213  *      POP GR2
 214  *      POP GR1
 215  * @endcode
 216  * @relatesalso Casl2cmd
 217  *
 218  * @return なし
 219  *
 220  * @param *cmdl 1行分のラベル・コマンド・オペランド
 221  * @param pass アセンブラが何回目かを表す数
 222  */
 223 void assemble_rpop(const CMDLINE *cmdl, PASS pass);
 224
 225 /**
 226  * @class Casl2cmd
 227  * @brief casl2cmdから関数ポインタで呼び出される関数
 228  */
 229
 230 /**
 231  * @brief アセンブラ言語CASL IIの命令を処理する。
 232  *
 233  * エラー発生時は、cerrを設定
 234  *
 235  * @relatesalso Casl2cmd
 236  *
 237  * @return 命令が表で定義されている場合はtrue、それ以外の場合はfalseを返す
 238  *
 239  * @param *cmdtbl アセンブラ言語CASL IIの命令表
 240  * @param *cmdl 1行分のラベル・コマンド・オペランド
 241  * @param pass アセンブルが何回目か
 242  */
 243 bool casl2cmd(CMD *cmdtbl, const CMDLINE *cmdl, PASS pass);
 244
 245 /**
 246  * @brief システムCOMET IIの命令をアセンブルする
 247  *
 248  * @return アセンブル成功時はtrue、失敗時はfalseを返す
 249  *
 250  * @param *cmdl 1行分のラベル・コマンド・オペランド
 251  * @param pass アセンブルが何回目か
 252  */
 253 bool assemble_comet2cmd(const CMDLINE *cmdl, PASS pass);
 254
 255 /**
 256  * @brief トークンをアセンブルする
 257  *
 258  * @return アセンブル成功時はtrue、失敗時はfalseを返す
 259  *
 260  * @param *cmdl 1行分のラベル・コマンド・オペランド
 261  * @param pass アセンブラが何回目かを表す数
 262  */
 263 bool assembletok(const CMDLINE *cmdl, PASS pass);
 264
 265 /**
 266  * @brief 1行をアセンブルする
 267  *
 268  * passが1の場合はラベルを登録し、2の場合はラベルからアドレスを読み込む
 269  *
 270  * @return アセンブル成功時はtrue、失敗時はfalseを返す
 271  *
 272  * @param *line 1行分の文字列
 273  * @param pass アセンブラが何回目かを表す数
 274  */
 275 bool assembleline(const char *line, PASS pass);
 276
 277 /**
 278  * @brief アセンブルのエラー
 279  */
 280 static CERR cerr_assemble[] = {
 281     { 106, "operand mismatch in CASL II command" },
 282     { 107, "no label in START" },
 283     { 108, "not command of operand \"r\"" },
 284     { 109, "not command of operand \"r1,r2\"" },
 285     { 110, "not command of operand \"r,adr[,x]\"" },
 286     { 111, "not command of operand \"adr[,x]\"" },
 287     { 112, "not command of no operand" },
 288     { 113, "operand too many in COMET II command" },
 289     { 119, "out of COMET II memory" },
 290     { 120, "GR0 in operand x" },
 291     { 122, "cannot create hash table" },
 292     { 124, "more than one character in literal" },
 293     { 125, "not GR in operand x" },
 294 };
 295
 296 /**
 297  * @brief アセンブラ命令
 298  */
 299 static CMD ascmd[] = {
 300     { "START", assemble_start },
 301     { "END", assemble_end },
 302     { "DS", assemble_ds },
 303     { "DC", assemble_dc },
 304     { "", NULL }
 305 };
 306
 307 /**
 308  * @brief マクロ命令
 309  */
 310 static CMD macrocmd[] = {
 311     { "OUT", assemble_out },
 312     { "IN", assemble_in },
 313     { "RPUSH", assemble_rpush },
 314     { "RPOP", assemble_rpop },
 315     { "", NULL }
 316 };
 317
 318 ASPTR *asptr;
 319
 320 ASMODE asmode = {false, false, false, false, false};
 321
 322 void printline(FILE *stream, const char *filename, int lineno, char *line)
 323 {
 324     fprintf(stream, "%s:%5d:%s", filename, lineno, line);
 325 }
 326
 327 WORD getadr(const char *prog, const char *str, PASS pass)
 328 {
 329     WORD adr = 0x0;
 330
 331     if(*str == '=') {
 332         adr = getliteral(str, pass);
 333     } else if(isdigit(*str) || *str == '-' || *str == '#') {
 334         adr = nh2word(str);
 335     } else {
 336         if(pass == SECOND) {
 337             if((adr = getlabel(prog, str)) == 0xFFFF) {
 338                 setcerr(103, str);    /* label not found */
 339             }
 340         }
 341     }
 342     return adr;
 343 }
 344
 345 WORD getgr(const char *str, bool is_x)
 346 {
 347     WORD r;
 348
 349     /*  "GR[0-7]" 以外の文字列では、0xFFFFを返して終了 */
 350     if(!(strlen(str) == 3 && strncmp(str, "GR", 2) == 0 &&
 351          (*(str+2) >= '0' && *(str+2) <= '0' + (GRSIZE - 1))))
 352     {
 353         return 0xFFFF;
 354     }
 355     r = (WORD)(*(str+2) - '0');
 356     /* GR0は指標レジスタとして用いることができない */
 357     if(is_x == true && r == 0x0) {
 358         setcerr(120, "");    /* GR0 in operand x */
 359         return 0x0;
 360     }
 361     return r;
 362 }
 363
 364 WORD getliteral(const char *str, PASS pass)
 365 {
 366     assert(*str == '=');
 367     WORD adr = asptr->lptr;
 368
 369     if(*(++str) == '\'') {    /* 文字定数 */
 370         writestr(str, true, pass);
 371     } else {
 372         writememory(nh2word(str), (asptr->lptr)++, pass);
 373     }
 374     return adr;
 375 }
 376
 377 void writememory(WORD word, WORD adr, PASS pass)
 378 {
 379     char *n;
 380
 381     /* メモリオーバーの場合、エラー発生 */
 382     if(adr >= sys->memsize) {
 383         setcerr(119, (n = word2n(adr)));    /* out of COMET II memory */
 384         FREE(n)
 385         return;
 386     }
 387     (sys->memory)[adr] = word;
 388     if(pass == SECOND && asmode.asdetail == true) {
 389         fprintf(stdout, "\t#%04X\t#%04X\n", adr, word);
 390     }
 391 }
 392
 393 void writestr(const char *str, bool literal, PASS pass)
 394 {
 395     assert(*str == '\'');
 396     const char *p = str + 1;
 397     bool lw = false;
 398
 399     for(; ;) {
 400         /* 閉じ「'」がないまま文字列が終了した場合 */
 401         if(*p == '\0') {
 402             setcerr(123, str);    /* unclosed quote */
 403             break;
 404         }
 405         /* 「'」の場合、次の文字が「'」でない場合は正常終了 */
 406         if(*p == '\'' && *(++p) != '\'') {
 407             break;
 408         } else if(literal == true && lw == true) {
 409             setcerr(124, str);    /* more than one character in literal */
 410             break;
 411         }
 412         /*リテラルの場合はリテラル領域に書込 */
 413         if(literal == true) {
 414             writememory(*(p++), (asptr->lptr)++, pass);
 415             lw = true;
 416         } else {
 417             writememory(*(p++), (asptr->ptr)++, pass);
 418         }
 419     }
 420 }
 421
 422 void writedc(const char *str, PASS pass)
 423 {
 424     WORD adr = 0x0;
 425
 426     if(*str == '\'') {
 427         writestr(str, false, pass);
 428     } else {
 429         if(*str == '#' || isdigit(*str) || *str == '-') {
 430             adr = nh2word(str);
 431         } else {
 432             if(pass == SECOND && (adr = getlabel(asptr->prog, str)) == 0xFFFF) {
 433                 setcerr(103, str);    /* label not found */
 434             }
 435         }
 436         writememory(adr, (asptr->ptr)++, pass);
 437     }
 438 }
 439
 440 void assemble_start(const CMDLINE *cmdl, PASS pass)
 441 {
 442     if(cmdl->opd->opdc > 1) {
 443         setcerr(106, "");    /* operand count mismatch */
 444         return;
 445     }
 446     if(*(cmdl->label) == '\0') {
 447         setcerr(107, "");    /* no label in START */
 448         return;
 449     }
 450     /* プログラム名の設定 */
 451     strcpy(asptr->prog, cmdl->label);
 452     /* オペランドがある場合、実行開始アドレスを設定 */
 453     if(pass == SECOND && cmdl->opd->opdv[0] != NULL) {
 454         if((execptr->start = getlabel(asptr->prog, cmdl->opd->opdv[0])) == 0xFFFF) {
 455             setcerr(103, cmdl->opd->opdv[0]);    /* label not found */
 456         }
 457     }
 458 }
 459
 460 void assemble_end(const CMDLINE *cmdl, PASS pass)
 461 {
 462     if(cmdl->opd->opdc > 0) {
 463         setcerr(106, "");    /* operand count mismatch */
 464         return;
 465     }
 466     /* 1回目のアセンブルの場合は、リテラル領域開始アドレスを設定 */
 467     if(pass == FIRST) {
 468         asptr->lptr = asptr->ptr;
 469     }
 470     /* 2回目のアセンブルの場合は、リテラル領域終了アドレスを実行終了アドレスとして設定 */
 471     else if(pass == SECOND) {
 472         execptr->end = asptr->lptr;
 473     }
 474     *(asptr->prog) = '\0';
 475 }
 476
 477 void assemble_ds(const CMDLINE *cmdl, PASS pass)
 478 {
 479     int i;
 480     if(cmdl->opd->opdc != 1) {
 481         setcerr(106, "");    /* operand count mismatch */
 482         return;
 483     }
 484     for(i = 0; i < atoi(cmdl->opd->opdv[0]); i++) {
 485         writememory(0x0, (asptr->ptr)++, pass);
 486         if(cerr->num > 0) {
 487             break;
 488         }
 489     }
 490 }
 491
 492 void assemble_dc(const CMDLINE *cmdl, PASS pass)
 493 {
 494     int i;
 495     if(cmdl->opd->opdc == 0 || cmdl->opd->opdc >= OPDSIZE) {
 496         setcerr(106, "");    /* operand count mismatch */
 497         return;
 498     }
 499     for(i = 0; i < cmdl->opd->opdc; i++) {
 500         writedc(cmdl->opd->opdv[i], pass);
 501         if(cerr->num > 0) {
 502             break;
 503         }
 504     }
 505 }
 506
 507 void assemble_in(const CMDLINE *cmdl, PASS pass)
 508 {
 509     char *line = malloc_chk(LINESIZE + 1, "assemble_in.line");
 510     if(cmdl->opd->opdc == 0 || cmdl->opd->opdc > 2) {
 511         setcerr(106, "");    /* operand count mismatch */
 512         return;
 513     }
 514     assembleline("    PUSH 0,GR1", pass);
 515     assembleline("    PUSH 0,GR2", pass);
 516     sprintf(line, "    LAD GR1,%s", cmdl->opd->opdv[0]);
 517     assembleline(line, pass);
 518     sprintf(line, "    LAD GR2,%s", cmdl->opd->opdv[1]);
 519     assembleline(line, pass);
 520     assembleline("    SVC 1", pass);
 521     assembleline("    POP GR2", pass);
 522     assembleline("    POP GR1", pass);
 523     FREE(line);
 524 }
 525
 526 void assemble_out(const CMDLINE *cmdl, PASS pass)
 527 {
 528     char *line = malloc_chk(LINESIZE + 1, "assemble_out.line");
 529     if(cmdl->opd->opdc == 0 || cmdl->opd->opdc > 2) {
 530         setcerr(106, "");    /* operand count mismatch */
 531         return;
 532     }
 533     assembleline("    PUSH 0,GR1", pass);
 534     assembleline("    PUSH 0,GR2", pass);
 535     sprintf(line, "    LAD GR1,%s", cmdl->opd->opdv[0]);
 536     assembleline(line, pass);
 537     sprintf(line, "    LAD GR2,%s", cmdl->opd->opdv[1]);
 538     assembleline(line, pass);
 539     assembleline("    SVC 2", pass);
 540     assembleline("    LAD GR1,=#A", pass);
 541     assembleline("    LAD GR2,=1", pass);
 542     assembleline("    SVC 2", pass);
 543     assembleline("    POP GR2", pass);
 544     assembleline("    POP GR1", pass);
 545     FREE(line);
 546 }
 547
 548 void assemble_rpush(const CMDLINE *cmdl, PASS pass)
 549 {
 550     int i;
 551     char *line = malloc_chk(LINESIZE + 1, "assemble_rpush.line");
 552     if(cmdl->opd->opdc > 0) {
 553         setcerr(106, "");    /* operand count mismatch */
 554         return;
 555     }
 556     for(i = 1; i <= GRSIZE-1; i++) {
 557         sprintf(line, "    PUSH 0,GR%d", i);
 558         assembleline(line, pass);
 559     }
 560     FREE(line);
 561 }
 562
 563 void assemble_rpop(const CMDLINE *cmdl, PASS pass)
 564 {
 565     int i;
 566     char *line = malloc_chk(LINESIZE + 1, "assemble_rpop.line");
 567     if(cmdl->opd->opdc > 0) {
 568         setcerr(106, "");    /* operand count mismatch */
 569         return;
 570     }
 571     for(i = GRSIZE-1; i >= 1; i--) {
 572         sprintf(line, "    POP GR%d", i);
 573         assembleline(line, pass);
 574     }
 575     FREE(line);
 576 }
 577
 578 bool casl2cmd(CMD *cmdtbl, const CMDLINE *cmdl, PASS pass)
 579 {
 580     int i;
 581     void (*cmdptr)();
 582     for(i = 0; *(cmdtbl[i].name) != '\0'; i++) {
 583         if(strcmp(cmdl->cmd, cmdtbl[i].name) == 0) {
 584             cmdptr = cmdtbl[i].ptr;
 585             (*cmdptr)(cmdl, pass);
 586             return true;
 587         }
 588     }
 589     return false;
 590 }
 591
 592 bool assemble_comet2cmd(const CMDLINE *cmdl, PASS pass)
 593 {
 594     WORD cmd, r_r1, x_r2, adr;
 595
 596     /* オペランドなし */
 597     if(cmdl->opd->opdc == 0) {
 598         if((cmd = getcmdcode(cmdl->cmd, NONE)) == 0xFFFF) {
 599             setcerr(112, cmdl->cmd);    /* not command of no operand */
 600             return false;
 601         }
 602         writememory(cmd, (asptr->ptr)++, pass);
 603     }
 604     /* 第1オペランドは汎用レジスタ */
 605     else if((r_r1 = getgr(cmdl->opd->opdv[0], false)) != 0xFFFF) {
 606         /* オペランド数1 */
 607         if(cmdl->opd->opdc == 1) {
 608             if((cmd = getcmdcode(cmdl->cmd, R_)) == 0xFFFF) {
 609                 setcerr(108, cmdl->cmd);    /* not command of operand "r" */
 610                 return false;
 611             }
 612             cmd |= (r_r1 << 4);
 613             writememory(cmd, (asptr->ptr)++, pass);
 614         }
 615         /* オペランド数2。第2オペランドは汎用レジスタ */
 616         else if(cmdl->opd->opdc == 2 && (x_r2 = getgr(cmdl->opd->opdv[1], false)) != 0xFFFF) {
 617             if((cmd = getcmdcode(cmdl->cmd, R1_R2)) == 0xFFFF) {
 618                 setcerr(109, cmdl->cmd);    /* not command of operand "r1,r2" */
 619                 return false;
 620             }
 621             cmd |= ((r_r1 << 4) | x_r2);               /* 第1オペランド、第2オペランドともに汎用レジスタ */
 622             /* メモリへの書き込み */
 623             writememory(cmd, (asptr->ptr)++, pass);
 624         }
 625         /* オペランド数2または3 */
 626         else if(cmdl->opd->opdc == 2 || cmdl->opd->opdc == 3) {
 627             if((cmd = getcmdcode(cmdl->cmd, R_ADR_X)) == 0xFFFF) {
 628                 setcerr(110, cmdl->cmd);    /* not command of operand "r,adr[,x]" */
 629                 return false;
 630             }
 631             cmd |= (r_r1 << 4);                    /* 第1オペランドは汎用レジスタ */
 632             /* オペランド数3の場合 */
 633             if(cmdl->opd->opdc == 3) {             /* 第3オペランドは指標レジスタとして用いる汎用レジスタ */
 634                 if((x_r2 = getgr(cmdl->opd->opdv[2], true)) == 0xFFFF) {
 635                     setcerr(125, cmdl->cmd);    /* not GR in operand x */
 636                     return false;
 637                 }
 638                 cmd |= x_r2;
 639             }
 640             adr = getadr(asptr->prog, cmdl->opd->opdv[1], pass); /* 第2オペランドはアドレス */
 641             /* メモリへの書き込み */
 642             writememory(cmd, (asptr->ptr)++, pass);
 643             writememory(adr, (asptr->ptr)++, pass);
 644         } else {
 645             setcerr(113, cmdl->cmd);    /* operand too many in COMET II command */
 646             return false;
 647         }
 648     }
 649     /* オペランド数1または2。第1オペランドはアドレス */
 650     else if(cmdl->opd->opdc == 1 || cmdl->opd->opdc == 2) {
 651         if((cmd = getcmdcode(cmdl->cmd, ADR_X)) == 0xFFFF) {
 652             setcerr(111, cmdl->cmd);    /* not command of operand "adr[,x]" */
 653             return false;
 654         }
 655         /* オペランド数2の場合 */
 656         if(cmdl->opd->opdc == 2) {             /* 第2オペランドは指標レジスタとして用いる汎用レジスタ */
 657             x_r2 = getgr(cmdl->opd->opdv[1], true);
 658             if(cerr->num > 0) {
 659                 return false;
 660             }
 661             cmd |= x_r2;
 662         }
 663         /* CALLの場合はプログラムの入口名を表すラベルを取得 */
 664         /* CALL以外の命令の場合と、プログラムの入口名を取得できない場合は、 */
 665         /* 同一プログラム内のラベルを取得 */
 666         if(pass == SECOND && cmd == 0x8000) {        /* CALL命令 */
 667             adr = getlabel("", cmdl->opd->opdv[0]);
 668         }
 669         if(cmd != 0x8000 || (pass == SECOND && adr == 0xFFFF)) {
 670             adr = getadr(asptr->prog, cmdl->opd->opdv[0], pass);
 671         }
 672         /* メモリへの書込 */
 673         writememory(cmd, (asptr->ptr)++, pass);
 674         writememory(adr, (asptr->ptr)++, pass);
 675     }
 676     return (cerr->num == 0) ? true : false;
 677 }
 678
 679 bool assembletok(const CMDLINE *cmdl, PASS pass)
 680 {
 681     /* 命令がない場合 */
 682     if(*(cmdl->cmd) == '\0') {
 683         return true;
 684     }
 685     /* アセンブラ命令またはマクロ命令の書込 */
 686     if(casl2cmd(ascmd, cmdl, pass) == false && casl2cmd(macrocmd, cmdl, pass) == false) {
 687         /* 機械語命令の書込 */
 688         if(assemble_comet2cmd(cmdl, pass) == false) {
 689             if(cerr->num == 0) {
 690                 setcerr(113, cmdl->cmd);    /* operand too many in COMET II command */
 691             }
 692         }
 693     }
 694     return (cerr->num == 0) ? true : false;
 695 }
 696
 697 bool assembleline(const char *line, PASS pass)
 698 {
 699     CMDLINE *cmdl;
 700     bool stat = true;
 701     int i;
 702
 703     cmdl = linetok(line);
 704     stat = (cerr->num == 0) ? true : false;
 705     if(cmdl != NULL) {
 706         if(stat == true) {
 707             if(pass == FIRST && *(cmdl->label) != '\0') {
 708                 stat = addlabel(asptr->prog, cmdl->label, asptr->ptr);
 709             }
 710         }
 711         if(stat == true) {
 712             stat = assembletok(cmdl, pass);
 713         }
 714         FREE(cmdl->label);
 715         if(cmdl->opd != NULL) {
 716             for(i = 0; i < cmdl->opd->opdc; i++) {
 717                 FREE(cmdl->opd->opdv[i]);
 718             }
 719         }
 720         FREE(cmdl->opd);
 721         FREE(cmdl->cmd);
 722     }
 723     FREE(cmdl);
 724     return stat;
 725 }
 726
 727 /**
 728  * @brief 指定された名前のファイルをアセンブル
 729  *
 730  * アセンブル完了時はtrue、エラー発生時はfalseを返す
 731  */
 732 bool assemblefile(const char *file, PASS pass)
 733 {
 734     int lineno = 1;
 735     char *line;
 736     FILE *fp;
 737
 738     if((fp = fopen(file, "r")) == NULL) {
 739         cerr->num = errno;
 740         perror(file);
 741         return false;
 742     }
 743     for(line = malloc_chk(LINESIZE + 1, "assemble.line"); fgets(line, LINESIZE, fp); lineno++) {
 744         if((pass == FIRST && asmode.src == true) || (pass == SECOND && asmode.asdetail == true)) {
 745             printline(stdout, file, lineno, line);
 746         }
 747         if(assembleline(line, pass) == false) {
 748             break;
 749         }
 750     }
 751     if(cerr->num > 0) {
 752         fprintf(stderr, "Assemble error - %d: %s\n", cerr->num, cerr->msg);
 753         printline(stderr, file, lineno, line);
 754     }
 755     FREE(line);
 756     fclose(fp);
 757     return (cerr->num == 0) ? true : false;
 758 }
 759
 760 /* assemble.hで定義された関数群 */
 761 void addcerrlist_assemble()
 762 {
 763     addcerrlist_tok();
 764     addcerrlist_word();
 765     addcerrlist_label();
 766     addcerrlist(ARRAYSIZE(cerr_assemble), cerr_assemble);
 767 }
 768
 769 void outassemble(const char *file)
 770 {
 771     FILE *fp;
 772
 773     if((fp = fopen(file, "w")) == NULL) {
 774         perror(file);
 775         exit(1);
 776     }
 777     fwrite(sys->memory, sizeof(WORD), execptr->end, fp);
 778     fclose(fp);
 779 }