src/assemble.c

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