src/assemble.c

   1 #include "casl2.h"
   2 #include "assemble.h"
   3
   4 /* アセンブルモード: src, label, onlylabel, asdetail, onlyassemble */
   5 ASMODE asmode = {false, false, false, false, false};
   6
   7 /* 値を格納するポインタ */
   8 WORD ptr;
   9
  10 /* リテラル（=付きの値）を格納するポインタ */
  11 WORD lptr;
  12
  13 /* 他のプログラムで参照する入口名 */
  14 char *prog;
  15
  16 /* 汎用レジスタを表す文字列「GR[0-7]」から、レジスタ番号[0-7]をWORD値で返す */
  17 /* 文字列が汎用レジスタを表さない場合は、0xFFFFを返す */
  18 /* is_xがtrueの場合は指標レジスタ。GR0は、COMET IIの仕様により、エラー発生 */
  19 WORD getgr(const char *str, bool is_x)
  20 {
  21     assert(str != NULL);
  22     WORD r;
  23     /* 「GR[0-7]」以外の文字列では、0xFFFFを返して終了 */
  24     if(!(strlen(str) == 3 && strncmp(str, "GR", 2) == 0 &&
  25          (*(str+2) >= '0' && *(str+2) <= '7')))
  26     {
  27         return 0xFFFF;
  28     }
  29     r = (WORD)(*(str+2) - '0');
  30     /* 指標レジスタとして用いることはできない */
  31     if(is_x == true && r == 0x0) {
  32         setcerr(120, NULL);    /* GR0 in operand x */
  33         return 0x0;
  34     }
  35     return r;
  36 }
  37
  38 /* アドレスを返す */
  39 /* アドレスには、リテラル／10進定数／16進定数／アドレス定数が含まれる */
  40 WORD getadr(const char *prog, const char *str, PASS pass)
  41 {
  42     WORD adr = 0x0;
  43     if(*str == '=') {
  44         adr = getliteral(str, pass);
  45     } else if((*str == '#') || isdigit(*str) || *str == '-') {
  46         adr = nh2word(str);
  47     } else {
  48         if(pass == SECOND && (adr = getlabel(prog, str)) == 0xFFFF) {
  49             if(prog != NULL) {
  50                 setcerr(103, str);    /* label not found */
  51             }
  52         }
  53     }
  54     return adr;
  55 }
  56
  57 /* WORD値wordをアドレスadrに書込 */
  58 /* 書込に成功した場合はtrue、失敗した場合はfalseを返す */
  59 bool writememory(WORD word, WORD adr, PASS pass)
  60 {
  61     bool status = false;
  62     /* COMET IIメモリオーバーの場合 */
  63     if(adr >= memsize) {
  64         setcerr(119, word2n(adr));    /* out of COMET II memory */
  65     }
  66     if(cerrno == 0) {
  67         memory[adr] = word;
  68         if(pass == SECOND && (&asmode)->asdetail == true) {
  69             fprintf(stdout, "\t#%04X\t#%04X\n", adr, word);
  70         }
  71         status = true;
  72     }
  73     return status;
  74 }
  75
  76 /* 定数の前に等号（=）をつけて記述されるリテラルを返す */
  77 /* リテラルには、10進定数／16進定数／文字定数が含まれる */
  78 WORD getliteral(const char *str, PASS pass)
  79 {
  80     WORD adr = lptr;
  81     assert(*str == '=');
  82     if(*(++str) == '\'') {    /* 文字定数 */
  83         writestr(str, true, pass);
  84     } else {
  85         writememory(nh2word(str), lptr++, pass);
  86     }
  87     return adr;
  88 }
  89
  90 /* ' 'で囲まれた文字定数をメモリに書込 */
  91 /* DC命令とリテラルで使い、リテラルの場合はリテラル領域に書込 */
  92 void writestr(const char *str, bool literal, PASS pass)
  93 {
  94     assert(cerrno == 0 && *str == '\'');
  95     const char *p = str + 1;
  96     bool lw = false;
  97
  98     for(; ;) {
  99         /* 閉じ「'」がないまま文字列が終了した場合 */
 100         if(*p == '\0') {
 101             setcerr(123, str);    /* illegal string */
 102             break;
 103         }
 104         /* 「'」の場合、次の文字が「'」でない場合は正常終了 */
 105         if(*p == '\'' && *(++p) != '\'') {
 106             break;
 107         } else if(literal == true && lw == true) {
 108             setcerr(124, str);    /* more than one character in literal */
 109             break;
 110         }
 111         /*リテラルの場合はリテラル領域に書込 */
 112         if(literal == true) {
 113             writememory(*(p++), lptr++, pass);
 114             lw = true;
 115         } else {
 116             writememory(*(p++), ptr++, pass);
 117         }
 118     }
 119 }
 120
 121 /* アセンブラ命令DCをメモリに書込 */
 122 void writeDC(const char *str, PASS pass)
 123 {
 124     WORD adr = 0x0;
 125     if(*str == '\'') {
 126         writestr(str, false, pass);
 127     } else {
 128         if(*str == '#' || isdigit(*str) || *str == '-') {
 129             adr = nh2word(str);
 130         } else {
 131             if(pass == SECOND && (adr = getlabel(prog, str)) == 0xFFFF) {
 132                 setcerr(103, str);    /* label not found */
 133             }
 134         }
 135         writememory(adr, ptr++, pass);
 136     }
 137 }
 138
 139 /* 命令がアセンブラ命令の場合は処理を実行 */
 140 /* 実行に成功した場合はtrue、それ以外の場合はfalseを返す */
 141 bool assemblecmd(const CMDLINE *cmdl, PASS pass)
 142 {
 143     int i = 0;
 144     CASLCMD cmd = 0;
 145     bool status = false;
 146     CMDARRAY ascmd[] = {
 147         { START, 0, 1, "START" },
 148         { END, 0, 0, "END" },
 149         { DC, 1, OPDSIZE, "DC" },
 150         { DS, 1, 1, "DS" },
 151         { 0, 0, 0, NULL }
 152     };
 153
 154     do {
 155         if(strcmp(cmdl->cmd, ascmd[i].cmd) == 0) {
 156             if(cmdl->opd->opdc < ascmd[i].opdc_min || cmdl->opd->opdc > ascmd[i].opdc_max) {
 157                 setcerr(106, NULL);    /* operand count mismatch */
 158                 return false;
 159             }
 160             cmd = ascmd[i].cmdid;
 161             break;
 162         }
 163     } while(ascmd[++i].cmdid != 0);
 164     /* アセンブラ命令 */
 165     switch(cmd)
 166     {
 167     case START:
 168         if(cmdl->label == NULL) {
 169             setcerr(107, NULL);    /* no label in START */
 170             return false;
 171         }
 172         /* プログラム名の設定 */
 173         prog = strdup(cmdl->label);
 174         /* オペランドがある場合、実行開始番地を設定 */
 175         if(pass == SECOND && cmdl->opd->opdc == 1) {
 176             if((startptr = getlabel(prog, cmdl->opd->opdv[0])) == 0xFFFF) {
 177                 setcerr(103, cmdl->opd->opdv[0]);    /* label not found */
 178             }
 179         }
 180         status = true;
 181         break;
 182     case END:
 183         /* リテラル領域の設定 */
 184         if(pass == FIRST) {
 185             lptr = ptr;
 186         }
 187         /* 実行終了番地と次のプログラムの実行開始番地を設定 */
 188         else if(pass == SECOND) {
 189             endptr = lptr;
 190         }
 191         prog = NULL;
 192         status = true;
 193         break;
 194     case DS:
 195         for(i = 0; i < atoi(cmdl->opd->opdv[0]); i++) {
 196             writememory(0x0, ptr++, pass);
 197             if(cerrno > 0) {
 198                 return false;
 199             }
 200         }
 201         status = true;
 202         break;
 203     case DC:
 204         for(i = 0; i < cmdl->opd->opdc; i++) {
 205             writeDC(cmdl->opd->opdv[i], pass);
 206             if(cerrno > 0) {
 207                 return false;
 208             }
 209         }
 210         status = true;
 211         break;
 212     default:
 213         return false;
 214     }
 215     if(cerrno > 0) {
 216         status = false;
 217     }
 218     return status;
 219 }
 220
 221 /* 命令がマクロ命令の場合はメモリに書込 */
 222 /* 書込に成功した場合はtrue、それ以外の場合はfalseを返す */
 223 bool macrocmd(const CMDLINE *cmdl, PASS pass)
 224 {
 225     int i = 0;
 226     CASLCMD cmd;
 227     bool status = false;
 228     CMDARRAY macrocmd[] = {
 229         { IN, 2, 2, "IN" },
 230         { OUT, 2, 2, "OUT" },
 231         { RPUSH, 0, 0, "RPUSH" },
 232         { RPOP, 0, 0, "RPOP" },
 233         { 0, 0, 0, NULL }
 234     };
 235
 236     do {
 237         if(strcmp(cmdl->cmd, macrocmd[i].cmd) == 0) {
 238             if(cmdl->opd->opdc < macrocmd[i].opdc_min || cmdl->opd->opdc > macrocmd[i].opdc_max) {
 239                 setcerr(106, NULL);    /* operand count mismatch */
 240                 return false;
 241             }
 242             cmd = macrocmd[i].cmdid;
 243             break;
 244         }
 245     } while(macrocmd[++i].cmdid != 0);
 246     switch(cmd)
 247     {
 248     case IN:
 249         status = writeIN(cmdl->opd->opdv[0], cmdl->opd->opdv[1], pass);
 250         break;
 251     case OUT:
 252         status = writeOUT(cmdl->opd->opdv[0], cmdl->opd->opdv[1], pass);
 253         break;
 254     case RPUSH:
 255         status = writeRPUSH(pass);
 256         break;
 257     case RPOP:
 258         status = writeRPOP(pass);
 259         break;
 260     default:
 261         return false;
 262     }
 263     return status;
 264 }
 265
 266 /* 機械語命令の書込 */
 267 /* 書込に成功した場合はtrue、それ以外の場合はfalseを返す */
 268 bool cometcmd(const CMDLINE *cmdl, PASS pass)
 269 {
 270     WORD cmd, adr, r1, r2, x;
 271     bool status = false;
 272
 273     /* オペランドなし */
 274     if(cmdl->opd->opdc == 0) {
 275         if((cmd = getcmdcode(cmdl->cmd, NONE)) == 0xFFFF) {
 276             setcerr(112, cmdl->cmd);    /* not command of no operand */
 277             return false;
 278         }
 279         if(writememory(cmd, ptr++, pass) == true) {
 280             status = true;
 281         }
 282     }
 283     /* 第1オペランドは汎用レジスタ */
 284     else if((r1 = getgr(cmdl->opd->opdv[0], false)) != 0xFFFF) {
 285         /* オペランド数1 */
 286         if(cmdl->opd->opdc == 1) {
 287             if((cmd = getcmdcode(cmdl->cmd, R_)) == 0xFFFF) {
 288                 setcerr(108, cmdl->cmd);    /* not command of operand "r" */
 289                 return false;
 290             }
 291             cmd |= (r1 << 4);
 292             if(writememory(cmd, ptr++, pass) == true) {
 293                 status = true;
 294             }
 295         }
 296         /* オペランド数2。第2オペランドは汎用レジスタ */
 297         else if(cmdl->opd->opdc == 2 && (r2 = getgr(cmdl->opd->opdv[1], false)) != 0xFFFF) {
 298             if((cmd = getcmdcode(cmdl->cmd, R1_R2)) == 0xFFFF) {
 299                 setcerr(109, cmdl->cmd);    /* not command of operand "r1,r2" */
 300                 return false;
 301             }
 302             cmd |= ((r1 << 4) | r2);
 303             if(cerrno == 0 && writememory(cmd, ptr++, pass) == true) {
 304                 status = true;
 305             }
 306         }
 307         /* オペランド数2〜3。第2オペランドはアドレス、
 308            第3オペランドは指標レジスタとして用いる汎用レジスタ */
 309         else if(cmdl->opd->opdc == 2 || cmdl->opd->opdc == 3) {
 310             if((cmd = getcmdcode(cmdl->cmd, R_ADR_X_)) == 0xFFFF &&
 311                (cmd = getcmdcode(cmdl->cmd, R_ADR_X)) == 0xFFFF)
 312             {
 313                 setcerr(110, cmdl->cmd);    /* not command of operand "r,adr[,x]" */
 314                 return false;
 315             }
 316             cmd |= (r1 << 4);
 317             /* オペランド数3 */
 318             if(cmdl->opd->opdc == 3) {
 319                 if((x = getgr(cmdl->opd->opdv[2], true)) == 0xFFFF) {
 320                     setcerr(125, cmdl->cmd);    /* not GR in operand x */
 321                     return false;
 322                 }
 323                 cmd |= x;
 324             }
 325             adr = getadr(prog, cmdl->opd->opdv[1], pass);
 326             writememory(cmd, ptr++, pass);
 327             writememory(adr, ptr++, pass);
 328             if(cerrno == 0) {
 329                 status = true;
 330             }
 331         } else {
 332             setcerr(113, cmdl->cmd);    /* command not defined */
 333             return false;
 334         }
 335     }
 336     /* オペランド数1〜2。第1オペランドはアドレス */
 337     else if(cmdl->opd->opdc == 1 || cmdl->opd->opdc == 2) {
 338         if((cmd = getcmdcode(cmdl->cmd, ADR_X)) == 0xFFFF) {
 339             setcerr(111, cmdl->cmd);    /* not command of operand "adr[,x]" */
 340             return false;
 341         }
 342         /* オペランド数2の場合、第2オペランドは指標レジスタとして用いる汎用レジスタ */
 343         if(cmdl->opd->opdc == 2) {
 344             x = getgr(cmdl->opd->opdv[1], true);
 345             if(cerrno > 0) {
 346                 return false;
 347             }
 348             cmd |= x;
 349         }
 350         /* CALLの場合はプログラムの入口名を表すラベルを取得 */
 351         /* CALL以外の命令の場合と、プログラムの入口名を取得できない場合は、 */
 352         /* 同一プログラム内のラベルを取得 */
 353         if(pass == SECOND && cmd == 0x8000) {        /* CALL命令 */
 354             adr = getlabel(NULL, cmdl->opd->opdv[0]);
 355         }
 356         if(cmd != 0x8000 || (pass == SECOND && adr == 0xFFFF)) {
 357             adr = getadr(prog, cmdl->opd->opdv[0], pass);
 358         }
 359         writememory(cmd, ptr++, pass);
 360         writememory(adr, ptr++, pass);
 361         if(cerrno == 0) {
 362             status = true;
 363         }
 364     }
 365     return status;
 366 }
 367
 368 /* 命令行を1行アセンブルする */
 369 bool assembleline(const CMDLINE *cmdl, PASS pass)
 370 {
 371     bool status = false;
 372     /* 命令がない場合 */
 373     if(cmdl->cmd == NULL){
 374         /* ラベルが定義されていて命令がない場合はエラー */
 375         if(cmdl->label != NULL) {
 376             setcerr(105, NULL);    /* no command in the line */
 377         }
 378     }
 379     /* アセンブラ命令の処理 */
 380     else if(cerrno == 0 && assemblecmd(cmdl, pass) == true) {
 381         ;
 382     }
 383     /* マクロ命令の書込 */
 384     else if(cerrno == 0 && macrocmd(cmdl, pass) == true) {
 385         ;
 386     }
 387     /* 機械語命令の書込 */
 388     else if(cerrno == 0 && cometcmd(cmdl, pass) == true) {
 389         ;
 390     }
 391     else if(cerrno == 0) {
 392         setcerr(113, cmdl->cmd);    /* command not defined */
 393     }
 394     /* エラーが発生していないか確認 */
 395     if(cerrno == 0) {
 396         status = true;
 397     }
 398     return status;
 399 }
 400
 401 void printline(FILE *stream, const char *filename, int lineno, char *line) {
 402     fprintf(stream, "%s:%5d:%s", filename, lineno, line);
 403 }
 404
 405 /* 指定された名前のファイルをアセンブル */
 406 /* 2回実行される */
 407 bool assemble(const char *file, PASS pass)
 408 {
 409     int lineno = 0;
 410     bool status = true;
 411     CMDLINE *cmdl;
 412     char *line;
 413     FILE *fp;
 414
 415     if(create_cmdtype_code() == false) {
 416         return false;
 417     }
 418     if((fp = fopen(file, "r")) == NULL) {
 419         perror(file);
 420         return false;
 421     }
 422     for(; ;) {
 423         cmdl = malloc(sizeof(CMDLINE));
 424         line = malloc(LINESIZE+1);
 425         if((line = fgets(line, LINESIZE, fp)) == NULL) {
 426             break;
 427         }
 428         lineno++;
 429         if((pass == FIRST && (&asmode)->src == true) ||
 430            (pass == SECOND && (&asmode)->asdetail == true))
 431         {
 432             printline(stdout, file, lineno, line);
 433         }
 434         if((cmdl = linetok(line)) != NULL) {
 435             if(pass == FIRST && cmdl->label != NULL) {
 436                 if(addlabel(prog, cmdl->label, ptr) == false) {
 437                     break;
 438                 }
 439             }
 440             if(assembleline(cmdl, pass) == false) {
 441                 break;
 442             }
 443         }
 444         if(cerrno > 0) {
 445             break;
 446         }
 447     }
 448     if(cerrno > 0) {
 449         fprintf(stderr, "Assemble error - %d: %s\n", cerrno, cerrmsg);
 450         printline(stderr, file, lineno, line);
 451         status = false;
 452     }
 453     fclose(fp);
 454     return status;
 455 }