エラーの重複を削除
[YACASL2.git] / 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 }