bool asdetail; /* アセンブラ詳細結果を表示する場合はtrue */
bool onlyassemble; /* アセンブルだけを行う場合はtrue */
} ASMODE;
-extern ASMODE asmode;
-/* 値を格納するポインタ */
-extern WORD ptr;
+extern ASMODE asmode;
-/* リテラル（=付きの値）を格納するポインタ */
-extern WORD lptr;
+/* アセンブル時のプロパティ */
+typedef struct {
+ WORD ptr; /* 現在のポインタ */
+ WORD lptr; /* リテラル（=付きの値）を格納するポインタ */
+ char *prog; /* 他のプログラムで参照する入口名 */
+} ASPROP;
-/* 他のプログラムで参照する入口名 */
-extern char *prog;
+extern ASPROP *asprop;
/* アセンブラ命令とマクロ命令を表す番号 */
typedef enum {
/* COMET IIの規格 */
enum {
- CMDSIZE = 4, /* 命令の最大文字数 */
- REGSIZE = 8, /* 汎用レジスタの数 */
+ CMDSIZE = 4, /* 命令の最大文字数 */
+ GRSIZE = 8, /* 汎用レジスタの数。COMET II規格で、7 */
DEFAULT_MEMSIZE = 512, /* デフォルトのメモリ容量。COMET II規格では、65536語 */
DEFAULT_CLOCKS = 5000000, /* デフォルトのクロック周波数。COMET II規格では、未定義 */
};
/* COMET IIのメモリ */
extern WORD *memory;
-/* COMET IIのCPUレジスタ */
-extern WORD GR[REGSIZE], SP, PR, FR;
+/* メモリサイズ */
+extern int memsize;
/* COMET II フラグのマスク値 */
enum {
ZF = 0x1, /* Zero Flag */
};
-/* メモリーサイズ */
-extern int memsize;
+/* COMET IIのCPU */
+typedef struct {
+ WORD gr[GRSIZE]; /* 汎用レジスタ */
+ WORD sp; /* スタックポインタ */
+ WORD pr; /* プログラムレジスタ */
+ WORD fr; /* フラグレジスタ */
+} CPU;
+
+/* COMET IIのCPU */
+extern CPU *cpu;
/* クロック周波数 */
extern int clocks;
-/* 実行開始番地 */
-extern WORD startptr;
-
-/* 実行終了番地 */
-extern WORD endptr;
-
/* COMET II 命令 */
/* 命令タイプは、オペランドにより6種類に分類 */
typedef enum {
/* 命令コード配列 */
typedef struct {
- char *cmd;
+ char *name;
CMDTYPE type;
WORD code;
-} CMDCODEARRAY;
+} CMD;
/* 命令コード配列のサイズ */
-extern int cmdcodesize;
+extern int comet2cmdsize;
/* 命令コードのハッシュ表 */
-typedef struct _CMDCODETAB {
- struct _CMDCODETAB *next;
- CMDCODEARRAY *cca;
-} CMDCODETAB;
+typedef struct _CMDTAB {
+ struct _CMDTAB *next;
+ CMD *cmd;
+} CMDTAB;
-extern CMDCODETAB **cmdtype_code;
-extern CMDCODETAB **code_type;
+extern CMDTAB **cmdtype_code;
+extern CMDTAB **code_type;
extern int cmdtabsize;
+/* CASL2プログラムのプロパティ */
+typedef struct {
+ WORD start; /* プログラムの開始番地 */
+ WORD end; /* プログラムの終了番地 */
+} PROGPROP;
+
+extern PROGPROP *progprop;
+
/* COMET II仮想マシンのリセット */
void reset();
#define ARRAYSIZE(array) (sizeof(array)/sizeof(array[0]))
#endif
-/* エラー番号 */
-extern int cerrno;
+/* mallocを実行し、メモリを確保できない場合は */
+/* エラーを出力して終了 */
+void *malloc_chk(size_t size, char *tag);
-/* エラーメッセージ */
-extern char *cerrmsg;
-
-/* エラーコード配列 */
+/* エラーの構造体 */
typedef struct {
- int num;
- char *msg;
-} CERRARRAY;
+ int num; /* エラー番号 */
+ char *msg; /* エラーメッセージ */
+} CERR;
+
+/* 現在のエラー */
+extern CERR *cerr;
-/* ã\82¨ã\83©ã\83¼ã\82³ã\83¼ã\83\89ã\83ªã\82¹ã\83\88 */
+/* エラーリスト */
typedef struct _CERRLIST {
struct _CERRLIST *next;
- CERRARRAY *err;
+ CERR *cerr;
} CERRLIST;
-/* エラーメッセージ */
-extern CERRLIST *cerr;
+extern CERRLIST *cerrlist;
enum {
CERRSTRSIZE = 10, /* エラーメッセージ中に挿入できる文字列のサイズ */
CERRMSGSIZE = 70, /* エラーメッセージのサイズ */
};
-/* ã\82¨ã\83©ã\83¼ã\82\92追加する */
-bool addcerrlist(int cerrc, CERRARRAY cerrv[]);
+/* ã\82¨ã\83©ã\83¼ã\83ªã\82¹ã\83\88ã\82\92ä½\9cæ\88\90ã\83»追加する */
+bool addcerrlist(int cerrc, CERR cerrv[]);
/* エラー番号とエラーメッセージを設定 */
void setcerr(int num, const char *str);
#ifndef YACASL2_EXEC_INCLUDED
#define YACASL2_EXEC_INCLUDED
-/* コードから命令のパターンを取得 */
-CMDTYPE getcmdtype(WORD code);
-
enum {
INSIZE = 256 /* CASL IIの、IN命令入力領域 */
};
bool logical; /* レジストリの内容を論理値（0〜65535）で表示する場合はtrue */
bool dump; /* メモリの内容を表示する場合はtrue */
} EXECMODE;
+
extern EXECMODE execmode;
+/* コードから命令のパターンを取得 */
+CMDTYPE getcmdtype(WORD code);
+
/* 実行のエラー定義 */
bool addcerrlist_exec();
void reset();
/* コードの実行 */
-void exec();
+bool exec();
/* COMET IIのメモリを表示 */
void dumpmemory();
/* アセンブルモード: src, label, onlylabel, asdetail, onlyassemble */
ASMODE asmode = {false, false, false, false, false};
-/* 値を格納するポインタ */
-WORD ptr;
-
-/* リテラル（=付きの値）を格納するポインタ */
-WORD lptr;
-
-/* 他のプログラムで参照する入口名 */
-char *prog;
+/* アセンブル時のプロパティ */
+ASPROP *asprop;
/* アセンブルのエラー定義 */
-CERRARRAY cerr_assemble[] = {
+CERR cerr_assemble[] = {
{ 101, "label already defined" },
{ 102, "label table is full" },
{ 103, "label not found" },
WORD r;
/* 「GR[0-7]」以外の文字列では、0xFFFFを返して終了 */
if(!(strlen(str) == 3 && strncmp(str, "GR", 2) == 0 &&
- (*(str+2) >= '0' && *(str+2) <= '7')))
+ (*(str+2) >= '0' && *(str+2) <= '0' + GRSIZE)))
{
return 0xFFFF;
}
if(adr >= memsize) {
setcerr(119, word2n(adr)); /* out of COMET II memory */
}
- if(cerrno == 0) {
+ if(cerr->num == 0) {
memory[adr] = word;
if(pass == SECOND && asmode.asdetail == true) {
fprintf(stdout, "\t#%04X\t#%04X\n", adr, word);
/* リテラルには、10進定数／16進定数／文字定数が含まれる */
WORD getliteral(const char *str, PASS pass)
{
- WORD adr = lptr;
+ WORD adr = asprop->lptr;
assert(*str == '=');
if(*(++str) == '\'') { /* 文字定数 */
writestr(str, true, pass);
} else {
- writememory(nh2word(str), lptr++, pass);
+ writememory(nh2word(str), (asprop->lptr)++, pass);
}
return adr;
}
/* DC命令とリテラルで使い、リテラルの場合はリテラル領域に書込 */
void writestr(const char *str, bool literal, PASS pass)
{
- assert(cerrno == 0 && *str == '\'');
+ assert(cerr->num == 0 && *str == '\'');
const char *p = str + 1;
bool lw = false;
}
/*リテラルの場合はリテラル領域に書込 */
if(literal == true) {
- writememory(*(p++), lptr++, pass);
+ writememory(*(p++), (asprop->lptr)++, pass);
lw = true;
} else {
- writememory(*(p++), ptr++, pass);
+ writememory(*(p++), (asprop->ptr)++, pass);
}
}
}
if(*str == '#' || isdigit(*str) || *str == '-') {
adr = nh2word(str);
} else {
- if(pass == SECOND && (adr = getlabel(prog, str)) == 0xFFFF) {
+ if(pass == SECOND && (adr = getlabel(asprop->prog, str)) == 0xFFFF) {
setcerr(103, str); /* label not found */
}
}
- writememory(adr, ptr++, pass);
+ writememory(adr, (asprop->ptr)++, pass);
}
}
return false;
}
/* プログラム名の設定 */
- prog = strdup(cmdl->label);
+ asprop->prog = strdup(cmdl->label);
/* オペランドがある場合、実行開始番地を設定 */
if(pass == SECOND && cmdl->opd->opdc == 1) {
- if((startptr = getlabel(prog, cmdl->opd->opdv[0])) == 0xFFFF) {
+ if((progprop->start = getlabel(asprop->prog, cmdl->opd->opdv[0])) == 0xFFFF) {
setcerr(103, cmdl->opd->opdv[0]); /* label not found */
}
}
case END:
/* リテラル領域の設定 */
if(pass == FIRST) {
- lptr = ptr;
+ asprop->lptr = asprop->ptr;
}
/* 実行終了番地と次のプログラムの実行開始番地を設定 */
else if(pass == SECOND) {
- endptr = lptr;
+ progprop->end = asprop->lptr;
}
- prog = NULL;
+ asprop->prog = NULL;
status = true;
break;
case DS:
for(i = 0; i < atoi(cmdl->opd->opdv[0]); i++) {
- writememory(0x0, ptr++, pass);
- if(cerrno > 0) {
+ writememory(0x0, (asprop->ptr)++, pass);
+ if(cerr->num > 0) {
return false;
}
}
case DC:
for(i = 0; i < cmdl->opd->opdc; i++) {
writeDC(cmdl->opd->opdv[i], pass);
- if(cerrno > 0) {
+ if(cerr->num > 0) {
return false;
}
}
default:
return false;
}
- if(cerrno > 0) {
+ if(cerr->num > 0) {
status = false;
}
return status;
setcerr(112, cmdl->cmd); /* not command of no operand */
return false;
}
- if(writememory(cmd, ptr++, pass) == true) {
+ if(writememory(cmd, (asprop->ptr)++, pass) == true) {
status = true;
}
}
return false;
}
cmd |= (r1 << 4);
- if(writememory(cmd, ptr++, pass) == true) {
+ if(writememory(cmd, (asprop->ptr)++, pass) == true) {
status = true;
}
}
return false;
}
cmd |= ((r1 << 4) | r2);
- if(cerrno == 0 && writememory(cmd, ptr++, pass) == true) {
+ if(cerr->num == 0 && writememory(cmd, (asprop->ptr)++, pass) == true) {
status = true;
}
}
}
cmd |= x;
}
- adr = getadr(prog, cmdl->opd->opdv[1], pass);
- writememory(cmd, ptr++, pass);
- writememory(adr, ptr++, pass);
- if(cerrno == 0) {
+ adr = getadr(asprop->prog, cmdl->opd->opdv[1], pass);
+ writememory(cmd, (asprop->ptr)++, pass);
+ writememory(adr, (asprop->ptr)++, pass);
+ if(cerr->num == 0) {
status = true;
}
} else {
/* オペランド数2の場合、第2オペランドは指標レジスタとして用いる汎用レジスタ */
if(cmdl->opd->opdc == 2) {
x = getgr(cmdl->opd->opdv[1], true);
- if(cerrno > 0) {
+ if(cerr->num > 0) {
return false;
}
cmd |= x;
adr = getlabel(NULL, cmdl->opd->opdv[0]);
}
if(cmd != 0x8000 || (pass == SECOND && adr == 0xFFFF)) {
- adr = getadr(prog, cmdl->opd->opdv[0], pass);
+ adr = getadr(asprop->prog, cmdl->opd->opdv[0], pass);
}
- writememory(cmd, ptr++, pass);
- writememory(adr, ptr++, pass);
- if(cerrno == 0) {
+ writememory(cmd, (asprop->ptr)++, pass);
+ writememory(adr, (asprop->ptr)++, pass);
+ if(cerr->num == 0) {
status = true;
}
}
}
}
/* アセンブラ命令の処理 */
- else if(cerrno == 0 && assemblecmd(cmdl, pass) == true) {
+ else if(cerr->num == 0 && assemblecmd(cmdl, pass) == true) {
;
}
/* マクロ命令の書込 */
- else if(cerrno == 0 && macrocmd(cmdl, pass) == true) {
+ else if(cerr->num == 0 && macrocmd(cmdl, pass) == true) {
;
}
/* 機械語命令の書込 */
- else if(cerrno == 0 && cometcmd(cmdl, pass) == true) {
+ else if(cerr->num == 0 && cometcmd(cmdl, pass) == true) {
;
}
- else if(cerrno == 0) {
+ else if(cerr->num == 0) {
setcerr(113, cmdl->cmd); /* operand too many in COMET II command */
}
/* エラーが発生していないか確認 */
- if(cerrno == 0) {
+ if(cerr->num == 0) {
status = true;
}
return status;
return false;
}
for(; ;) {
- cmdl = malloc(sizeof(CMDLINE));
- line = malloc(LINESIZE + 1);
+ cmdl = malloc_chk(sizeof(CMDLINE), "cmdl");
+ line = malloc_chk(LINESIZE + 1, "line");
if((line = fgets(line, LINESIZE, fp)) == NULL) {
break;
}
}
if((cmdl = linetok(line)) != NULL) {
if(pass == FIRST && cmdl->label != NULL) {
- if(addlabel(prog, cmdl->label, ptr) == false) {
+ if(addlabel(asprop->prog, cmdl->label, asprop->ptr) == false) {
break;
}
}
break;
}
}
- if(cerrno > 0) {
+ if(cerr->num > 0) {
break;
}
}
- if(cerrno > 0) {
- fprintf(stderr, "Assemble error - %d: %s\n", cerrno, cerrmsg);
+ if(cerr->num > 0) {
+ fprintf(stderr, "Assemble error - %d: %s\n", cerr->num, cerr->msg);
printline(stderr, file, lineno, line);
status = false;
}
};
/* casl2のエラー定義 */
-CERRARRAY cerr_casl2[] = {
+CERR cerr_casl2[] = {
{ 126, "source file is not specified" },
};
bool addcerrlist_casl2()
perror(file);
exit(-1);
}
- fwrite(memory, sizeof(WORD), endptr, fp);
+ fwrite(memory, sizeof(WORD), progprop->end, fp);
fclose(fp);
}
/* casl2コマンドのメイン */
int main(int argc, char *argv[])
{
- int opt, i;
+ int opt, i, retval = 0;
PASS pass;
bool status = false;
WORD beginptr[argc];
const char *usage =
"Usage: %s [-slLaAtTdh] [-oO<OBJECTFILE>] [-M <MEMORYSIZE>] [-C <CLOCKS>] FILE ...\n";
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
+ addcerrlist_casl2();
+ /* オプションの処理 */
while((opt = getopt_long(argc, argv, "tTdslLao::O::AM:C:h", longopts, NULL)) != -1) {
switch(opt) {
case 's':
exit(-1);
}
}
-
- addcerrlist_casl2();
/* ソースファイルが指定されていない場合は終了 */
if(argv[optind] == NULL) {
setcerr(126, NULL); /* source file is not specified */
- fprintf(stderr, "CASL2 error - %d: %s\n", cerrno, cerrmsg);
- goto casl2err;
+ fprintf(stderr, "CASL2 error - %d: %s\n", cerr->num, cerr->msg);
+ exit(-1);
}
/* COMET II仮想マシンのリセット */
reset();
/* アセンブル。ラベル表作成のため、2回行う */
for(pass = FIRST; pass <= SECOND; pass++) {
- if(pass == FIRST && create_cmdtype_code() == false) {
- goto casl2err;
+ if(pass == FIRST) {
+ create_cmdtype_code(); /* 命令と命令タイプがキーのハッシュ表を作成 */
+ asprop = malloc_chk(sizeof(ASPROP), "asprop");
}
for(i = optind; i < argc; i++) {
/* データの格納開始位置 */
if(pass == FIRST) {
- beginptr[i] = ptr;
+ beginptr[i] = asprop->ptr;
} else if(pass == SECOND) {
- ptr = beginptr[i];
+ asprop->ptr = beginptr[i];
}
if(execmode.trace == true || execmode.dump == true || asmode.src == true ||
asmode.label == true || asmode.asdetail == true)
fprintf(stdout, "\nAssemble %s (%d)\n", argv[i], pass);
}
if((status = assemble(argv[i], pass)) == false) {
- goto casl2err;
+ exit(-1);
}
}
if(pass == FIRST && asmode.label == true) {
return 0;
}
}
+ if(pass == SECOND) {
+ free_cmdtype_code(); /* 命令と命令タイプがキーのハッシュ表を解放 */
+ freelabel(); /* ラベルハッシュ表を解放 */
+ }
}
- free_cmdtype_code(); /* 命令表の解放 */
- freelabel(); /* ラベル表の解放 */
if(status == true) {
if(objfile != NULL) {
outassemble(objfile);
}
if(asmode.onlyassemble == false) {
- exec(); /* プログラム実行 */
+ create_code_type(); /* 命令と命令タイプがキーのハッシュ表を作成 */
+ status = exec(); /* プログラム実行 */
+ free_code_type(); /* 命令と命令タイプがキーのハッシュ表を解放 */
}
}
/* COMET II仮想マシンのシャットダウン */
shutdown();
- if(cerrno > 0) {
- goto casl2err;
+ if(cerr->num > 0) {
+ retval = -1;
}
- return 0;
-casl2err:
+ /* エラーの解放 */
freecerr();
- exit(-1);
+ return retval;
}
#include "cerr.h"
-/* エラー番号 */
-int cerrno = 0;
+/* mallocを実行し、メモリを確保できない場合は */
+/* エラーを出力して終了 */
+void *malloc_chk(size_t size, char *tag)
+{
+ void *p;
+
+ if((p = malloc(size)) == NULL) {
+ fprintf(stderr, "%s: cannot allocate memory\n", tag);
+ exit(-1);
+ }
+ return p;
+}
-/* エラーメッセージ */
-char *cerrmsg;
+/* 現在のエラー */
+CERR *cerr;
/* エラーリスト */
-CERRLIST *cerr;
+CERRLIST *cerrlist;
-/* エラーリストを作成する */
-bool addcerrlist(int newerrc, CERRARRAY newerrv[])
+/* ã\82¨ã\83©ã\83¼ã\83ªã\82¹ã\83\88ã\82\92ä½\9cæ\88\90ã\83»è¿½å\8a ã\81\99ã\82\8b */
+bool addcerrlist(int newerrc, CERR newerrv[])
{
int i;
CERRLIST *p, *q;
assert(newerrc > 0 && newerrv != NULL);
- if(cerr != NULL) {
- for(p = cerr; p != NULL; p = p->next) {
+ if(cerrlist == NULL) {
+ p = cerrlist = malloc_chk(sizeof(CERRLIST), "cerrlist");
+ } else {
+ for(p = cerrlist; p != NULL; p = p->next) {
q = p;
}
- if((p = q->next = malloc(sizeof(CERRLIST))) == NULL) {
- goto addcerrlisterr;
- }
- } else if((p = cerr = malloc(sizeof(CERRLIST))) == NULL) {
- goto addcerrlisterr;
+ p = q->next = malloc_chk(sizeof(CERRLIST), "cerrlist.next");
}
for(i = 0; i < newerrc; i++) {
- p->err = &(newerrv[i]);
- if((p->next = malloc(sizeof(CERRLIST))) == NULL) {
- goto addcerrlisterr;
- }
+ p->cerr = &(newerrv[i]);
+ p->next = malloc_chk(sizeof(CERRLIST), "cerrlist.next");
q = p;
p = p->next;
}
q->next = NULL;
return true;
-addcerrlisterr:
- fprintf(stderr, "addcerrlist: cannot allocate memory\n");
- exit(-1);
}
-/* エラー番号とエラーメッセージを設定する */
+/* 現在のエラーを設定する */
void setcerr(int num, const char *str)
{
- cerrno = num;
- cerrmsg = malloc(CERRMSGSIZE + 1);
+ cerr->num = num;
+ cerr->msg = malloc_chk(CERRMSGSIZE + 1, "cerr.msg");
if(str != NULL && strlen(str) <= CERRSTRSIZE) {
- sprintf(cerrmsg, "%s: %s", str, getcerrmsg(cerrno));
+ sprintf(cerr->msg, "%s: %s", str, getcerrmsg(cerr->num));
} else {
- strcpy(cerrmsg, getcerrmsg(cerrno));
+ strcpy(cerr->msg, getcerrmsg(cerr->num));
}
}
-/* リストから、エラー番号に対応するメッセージを返す */
+/* ã\82¨ã\83©ã\83¼ã\83ªã\82¹ã\83\88ã\81\8bã\82\89ã\80\81ã\82¨ã\83©ã\83¼ç\95ªå\8f·ã\81«å¯¾å¿\9cã\81\99ã\82\8bã\83¡ã\83\83ã\82»ã\83¼ã\82¸ã\82\92è¿\94ã\81\99 */
char *getcerrmsg(int num)
{
CERRLIST *p;
- for(p = cerr; p != NULL; p = p->next) {
- if(num == p->err->num) {
- return p->err->msg;
+ for(p = cerrlist; p != NULL; p = p->next) {
+ if(num == p->cerr->num) {
+ return p->cerr->msg;
}
}
return "unkown error";
}
-/* エラーを解放する */
+/* ã\82¨ã\83©ã\83¼ã\83ªã\82¹ã\83\88ã\81¨ç\8f¾å\9c¨ã\81®ã\82¨ã\83©ã\83¼ã\82\92解æ\94¾ã\81\99ã\82\8b */
void freecerr()
{
- assert(cerrno > 0);
- cerrno = 0;
- if(strlen(cerrmsg) > 0) {
- free(cerrmsg);
+ CERRLIST *p = cerrlist, *q;
+
+ /* エラーリストを解放 */
+ while(p != NULL) {
+ q = p->next;
+ free(p);
+ p = q;
}
+ /* 現在のエラーを解放 */
+ free(cerr);
}
#include "casl2.h"
-CMDCODEARRAY cmdcodearray[] = {
+CMD comet2cmd[] = {
{ "NOP", NONE, 0x0 },
{ "LD", R_ADR_X_, 0x1000 },
{ "ST", R_ADR_X, 0x1100 },
{ "RET", NONE, 0x8100 },
};
-int cmdcodesize = ARRAYSIZE(cmdcodearray);
+int comet2cmdsize = ARRAYSIZE(comet2cmd);
int cmdtabsize;
-CMDCODETAB **cmdtype_code, **code_type;
+CMDTAB **cmdtype_code, **code_type;
/* 命令と命令タイプからハッシュ値を生成する */
unsigned hash_cmdtype(const char *cmd, CMDTYPE type) {
HKEY *keys[2];
/* 命令をセット */
- keys[0] = malloc(sizeof(HKEY));
+ keys[0] = malloc_chk(sizeof(HKEY), "hash_cmdtype.key");
keys[0]->type = CHARS;
keys[0]->val.s = strdup(cmd);
/* 命令タイプをセット */
- keys[1] = malloc(sizeof(HKEY));
+ keys[1] = malloc_chk(sizeof(HKEY), "hash_cmdtype.key");
keys[1]->type = INT;
keys[1]->val.i = (int)(type & 070);
/* ハッシュ値を返す */
/* 命令と命令タイプがキーのハッシュ表を作成する */
bool create_cmdtype_code()
{
- CMDCODETAB *np;
+ CMDTAB *np;
unsigned hashval;
int i;
- cmdtabsize = cmdcodesize;
- cmdtype_code = malloc(cmdtabsize * sizeof(CMDCODETAB *));
- for(i = 0; i < cmdcodesize; i++) {
- if((np = malloc(sizeof(CMDCODETAB))) == NULL) {
- setcerr(122, NULL); /* cannot create hash table */
- return false;
- }
+ cmdtabsize = comet2cmdsize;
+ cmdtype_code = malloc_chk(cmdtabsize * sizeof(CMDTAB *), "cmdtype_code");
+ for(i = 0; i < cmdtabsize; i++) {
+ *(cmdtype_code + i) = NULL;
+ }
+ for(i = 0; i < comet2cmdsize; i++) {
+ np = malloc_chk(sizeof(CMDTAB), "cmdtype_code.next");
+ np->cmd = NULL;
+ np->next = NULL;
/* ハッシュ値の生成 */
- hashval = hash_cmdtype(cmdcodearray[i].cmd, cmdcodearray[i].type);
+ hashval = hash_cmdtype(comet2cmd[i].name, comet2cmd[i].type);
/* ハッシュ表に値を追加 */
np->next = cmdtype_code[hashval];
cmdtype_code[hashval] = np;
- np->cca = &(cmdcodearray[i]);
+ np->cmd = &(comet2cmd[i]);
}
return true;
}
/* 無効な場合は0xFFFFを返す */
WORD getcmdcode(const char *cmd, CMDTYPE type)
{
- CMDCODETAB *np;
+ CMDTAB *np;
+
assert(cmd != NULL);
for(np = cmdtype_code[hash_cmdtype(cmd, type)]; np != NULL; np = np->next){
- if(strcmp(cmd, np->cca->cmd) == 0 && type == np->cca->type) {
- return np->cca->code;
+ if(strcmp(cmd, np->cmd->name) == 0 && type == np->cmd->type) {
+ return np->cmd->code;
}
}
return 0xFFFF;
void free_cmdtype_code()
{
int i;
- CMDCODETAB *np, *nq;
- for(i = 0; i < cmdtabsize; i++){
+ CMDTAB *np, *nq;
+
+ for(i = 0; i < cmdtabsize; i++) {
np = cmdtype_code[i];
while(np != NULL) {
nq = np->next;
np = nq;
}
}
+ free(cmdtype_code);
}
/* 命令コードからハッシュ値を生成する */
HKEY *keys[1];
/* 命令コードをセット */
- keys[0] = malloc(sizeof(HKEY));
+ keys[0] = malloc_chk(sizeof(HKEY), "hash_code.key");
keys[0]->type = INT;
keys[0]->val.i = (int)(code >> 8);
/* ハッシュ値を返す */
/* 命令コードがキーのハッシュ表を作成する */
bool create_code_type()
{
- CMDCODETAB *np;
+ CMDTAB *np;
unsigned hashval;
int i;
- cmdtabsize = hashtabsize(cmdcodesize);
- code_type = malloc(cmdtabsize * sizeof(CMDCODETAB *));
- for(i = 0; i < cmdcodesize; i++) {
- if((np = malloc(sizeof(CMDCODETAB))) == NULL) {
- setcerr(122, NULL); /* cannot create hash table */
- return false;
- }
+ cmdtabsize = comet2cmdsize;
+ code_type = malloc_chk(cmdtabsize * sizeof(CMDTAB *), "code_type");
+ for(i = 0; i < cmdtabsize; i++) {
+ *(code_type + i) = NULL;
+ }
+ for(i = 0; i < comet2cmdsize; i++) {
+ np = malloc_chk(sizeof(CMDTAB), "code_type.next");
+ np->cmd = NULL;
+ np->next = NULL;
/* ハッシュ値の生成 */
- hashval = hash_code((&cmdcodearray[i])->code);
+ hashval = hash_code((&comet2cmd[i])->code);
/* ハッシュ表に値を追加 */
np->next = code_type[hashval];
code_type[hashval] = np;
- np->cca = &cmdcodearray[i];
+ np->cmd = &comet2cmd[i];
}
return true;
}
/* 無効な場合はNONEを返す */
CMDTYPE getcmdtype(WORD code)
{
- CMDCODETAB *np;
+ CMDTAB *np;
for(np = code_type[hash_code(code)]; np != NULL; np = np->next) {
- if(code == np->cca->code) {
- return np->cca->type;
+ if(code == np->cmd->code) {
+ return np->cmd->type;
}
}
return NONE;
void free_code_type()
{
int i;
- CMDCODETAB *np, *nq;
- for(i = 0; i < cmdtabsize; i++){
+ CMDTAB *np, *nq;
+ for(i = 0; i < cmdtabsize; i++) {
np = code_type[i];
while(np != NULL) {
nq = np->next;
np = nq;
}
}
+ free(code_type);
}
};
/* comet2のエラー定義 */
-CERRARRAY cerr_comet2[] = {
- { 201, "Load object file - full of COMET II memory" },
+CERR cerr_comet2[] = {
+ { 201, "load object file - full of COMET II memory" },
{ 208, "object file is not specified" },
};
bool addcerrlist_comet2()
perror(file);
return false;
}
- if((endptr = startptr + fread(memory, sizeof(WORD), memsize-startptr, fp)) == memsize) {
+ progprop->end = progprop->start +
+ fread(memory, sizeof(WORD), memsize-progprop->start, fp);
+ if(progprop->end == memsize) {
setcerr(201, NULL); /* Load object file - full of COMET II memory */
- fprintf(stderr, "Execute error - %d: %s\n", cerrno, cerrmsg);
+ fprintf(stderr, "Execute error - %d: %s\n", cerr->num, cerr->msg);
status = false;
}
fclose(fp);
/* comet2コマンド */
int main(int argc, char *argv[])
{
- int opt;
+ int opt, retval = 0;
const char *usage = "Usage: %s [-tTdh] [-M <MEMORYSIZE>] [-C <CLOCKS>] FILE\n";
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
addcerrlist_comet2();
+ /* オプションの処理 */
while((opt = getopt_long(argc, argv, "tTdM:C:h", longopts, NULL)) != -1) {
switch(opt) {
case 't':
}
if(argv[optind] == NULL) {
setcerr(208, NULL); /* object file is not specified */
- fprintf(stderr, "comet2 error - %d: %s\n", cerrno, cerrmsg);
- goto comet2err;
+ fprintf(stderr, "comet2 error - %d: %s\n", cerr->num, cerr->msg);
+ exit(-1);
}
reset();
- startptr = 0;
+ progprop->start = 0;
if(loadassemble(argv[optind]) == true) {
- exec(); /* プログラム実行 */
+ create_code_type(); /* 命令と命令タイプがキーのハッシュ表を作成 */
+ exec(); /* プログラム実行 */
+ free_code_type(); /* 命令と命令タイプがキーのハッシュ表を解放 */
}
/* COMET II仮想マシンのシャットダウン */
shutdown();
- if(cerrno > 0) {
- goto comet2err;
+ if(cerr->num > 0) {
+ retval = -1;
}
- return 0;
-comet2err:
+ /* エラーの解放 */
freecerr();
- exit(-1);
+ return retval;
}
const int col = 16;
int i;
/* Header */
- fprintf(stdout, "#%04X: adr :", PR);
+ fprintf(stdout, "#%04X: adr :", cpu->pr);
for(i = 0; i < memsize && i < col; i++) {
fprintf(stdout, " %04X", i);
}
/* Memory */
for(i = 0; i < memsize; i++) {
if(i % col == 0) {
- fprintf(stdout, "#%04X: %04X: ", PR, i);
+ fprintf(stdout, "#%04X: %04X: ", cpu->pr, i);
}
fprintf(stdout, "%04X", memory[i]);
if(i > 0 && (i + 1) % col == 0) {
void dspregister()
{
int i;
- for(i = 0; i < REGSIZE; i++ ) {
- fprintf(stdout, "#%04X: GR%d: ", PR, i);
- print_dumpword(GR[i], (&execmode)->logical);
+ for(i = 0; i < GRSIZE; i++ ) {
+ fprintf(stdout, "#%04X: GR%d: ", cpu->pr, i);
+ print_dumpword(cpu->gr[i], (&execmode)->logical);
}
- fprintf(stdout, "#%04X: SP: %6d = #%04X = %s\n", PR, SP, SP, word2bit(SP));
- fprintf(stdout, "#%04X: PR: %6d = #%04X = %s\n", PR, PR, PR, word2bit(PR));
- fprintf(stdout, "#%04X: FR (OF SF ZF): %s\n", PR, (word2bit(FR)+13));
+ fprintf(stdout, "#%04X: SP: %6d = #%04X = %s\n",
+ cpu->pr, cpu->sp, cpu->sp, word2bit(cpu->sp));
+ fprintf(stdout, "#%04X: PR: %6d = #%04X = %s\n",
+ cpu->pr, cpu->pr, cpu->pr, word2bit(cpu->pr));
+ fprintf(stdout, "#%04X: FR (OF SF ZF): %s\n",
+ cpu->pr, (word2bit(cpu->fr)+13));
}
WORD word;
const char *usage = "Usage: %s [-alh] WORD\n";
+ cerr = malloc_chk(sizeof(CERR), "cerr");
while((opt = getopt_long(argc, argv, "alh", longopts, NULL)) != -1) {
switch(opt) {
case 'l':
}
/* WORD値に変換 */
word = nh2word(argv[optind]);
- if(cerrno > 0) {
- fprintf(stderr, "Dumpword Error - %d: %s\n", cerrno, cerrmsg);
+ if(cerr->num > 0) {
+ fprintf(stderr, "Dumpword Error - %d: %s\n", cerr->num, cerr->msg);
exit(-1);
}
fprintf(stdout, "%6s: ", argv[optind]);
#include "exec.h"
/* 実行のエラー定義 */
-CERRARRAY cerr_exec[] = {
+CERR cerr_exec[] = {
{ 202, "SVC input - out of Input memory" },
{ 203, "SVC output - out of COMET II memory" },
{ 204, "Program Register (PR) - out of COMET II memory" },
void svcin()
{
int i;
- char *buffer = malloc(INSIZE + 1);
+ char *buffer = malloc_chk(INSIZE + 1,"svcin.buffer");
if(fgets(buffer, INSIZE, stdin) == NULL) {
- memory[GR[1]] = memory[GR[2]] = 0x0;
+ memory[cpu->gr[1]] = memory[cpu->gr[2]] = 0x0;
return;
}
for(i = 0; i < INSIZE; i++) {
--i;
break;
}
- if(GR[1] + i >= memsize - 1) {
+ if(cpu->gr[1] + i >= memsize - 1) {
setcerr(202, NULL); /* SVC input - out of Input memory */
break;
}
- memory[GR[1]+i] = *(buffer + i);
+ memory[cpu->gr[1]+i] = *(buffer + i);
}
- memory[GR[2]] = i + 1;
+ memory[cpu->gr[2]] = i + 1;
}
/* 標準出力へ文字データを書出（SVC 2） */
int i;
WORD w;
- for(i = 0; i < memory[GR[2]]; i++) {
- if(GR[1] + i >= memsize - 1) {
+ for(i = 0; i < memory[cpu->gr[2]]; i++) {
+ if(cpu->gr[1] + i >= memsize - 1) {
setcerr(203, NULL); /* SVC output - out of Comet II memory */
return;
}
/* 「文字の組」の符号表に記載された文字と、改行（CR）／タブを表示 */
/* それ以外の文字は、「.」で表す */
- if(((w = memory[GR[1]+i]) >= 0x20 && w <= 0x7E) || w == 0xA || w == '\t') {
+ if(((w = memory[cpu->gr[1]+i]) >= 0x20 && w <= 0x7E) || w == 0xA || w == '\t') {
putchar((char)w);
} else {
putchar('.');
/* ロード／論理積／論理和／排他的論理和のフラグ設定。OFは常に0 */
void setfr(WORD val)
{
- FR = 0x0;
+ cpu->fr = 0x0;
/* 第15ビットが1のとき、SFは1 */
if((val & 0x8000) > 0x0) {
- FR += SF;
+ cpu->fr += SF;
}
/* 演算結果が0のとき、ZFは1 */
if(val == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
}
{
WORD res;
long temp;
- FR = 0x0;
+ cpu->fr = 0x0;
temp = (signed short)val0 + (signed short)val1;
if(temp > 32767 || temp < -32768) {
- FR += OF;
+ cpu->fr += OF;
}
if(((res = (WORD)(temp & 0xFFFF)) & 0x8000) == 0x8000) {
- FR += SF;
+ cpu->fr += SF;
} else if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
{
long temp;
WORD res;
- FR = 0x0;
+ cpu->fr = 0x0;
if((temp = val0 + val1) < 0 || temp > 65535) {
- FR += OF;
+ cpu->fr += OF;
}
if(((res = (WORD)(temp & 0xFFFF)) & 0x8000) == 0x8000) {
- FR += SF;
+ cpu->fr += SF;
} else if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
/* 算術比較のフラグ設定。OFは常に0 */
void cpa(WORD val0, WORD val1)
{
- FR = 0x0;
+ cpu->fr = 0x0;
if((short)val0 < (short)val1) {
- FR = SF;
+ cpu->fr = SF;
} else if(val0 == val1) {
- FR = ZF;
+ cpu->fr = ZF;
}
}
/* 論理比較のフラグ設定。OFは常に0 */
void cpl(WORD val0, WORD val1)
{
- FR = 0x0;
+ cpu->fr = 0x0;
if(val0 < val1) {
- FR = SF;
+ cpu->fr = SF;
} else if(val0 == val1) {
- FR = ZF;
+ cpu->fr = ZF;
}
}
WORD sign, res, last = 0x0;
int i;
- FR = 0x0;
+ cpu->fr = 0x0;
sign = val0 & 0x8000;
res = val0 & 0x7FFF;
for(i = 0; i < val1; i++) {
res = sign | (res & 0x7FFF);
/* OFに、レジスタから最後に送り出されたビットの値を設定 */
if(last > 0x0) {
- FR += OF;
+ cpu->fr += OF;
}
/* 符号（第15ビット）が1のとき、SFは1 */
if(sign > 0x0) {
- FR += SF;
+ cpu->fr += SF;
}
/* 演算結果が0のとき、ZFは1 */
if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
WORD sign, res, last = 0x0;
int i;
- FR = 0x0;
+ cpu->fr = 0x0;
sign = val0 & 0x8000;
res = val0 & 0x7FFF;
for(i = 0; i < val1; i++) {
res = sign | res;
/* OFに、レジスタから最後に送り出されたビットの値を設定 */
if(last > 0x0) {
- FR += OF;
+ cpu->fr += OF;
}
/* 符号（第15ビット）が1のとき、SFは1 */
if(sign > 0x0) {
- FR += SF;
+ cpu->fr += SF;
}
/* 演算結果が0のとき、ZFは1 */
if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
WORD res = val0, last = 0x0;
int i;
- FR = 0x0;
+ cpu->fr = 0x0;
for(i = 0; i < val1; i++) {
last = res & 0x8000;
res <<= 1;
}
/* OFに、レジスタから最後に送り出されたビットの値を設定 */
if(last > 0x0) {
- FR += OF;
+ cpu->fr += OF;
}
/* 第15ビットが1のとき、SFは1 */
if((res & 0x8000) > 0x0) {
- FR += SF;
+ cpu->fr += SF;
}
/* 演算結果が0のとき、ZFは1 */
if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
WORD res = val0, last = 0x0;
int i;
- FR = 0x0;
+ cpu->fr = 0x0;
for(i = 0; i < val1; i++) {
last = res & 0x0001;
res >>= 1;
}
/* OFに、レジスタから最後に送り出されたビットの値を設定 */
if(last > 0x0) {
- FR += OF;
+ cpu->fr += OF;
}
/* 第15ビットが1のとき、SFは1 */
if((res & 0x8000) > 0x0) {
- FR += SF;
+ cpu->fr += SF;
}
/* 演算結果が0のとき、ZFは1 */
if(res == 0x0) {
- FR += ZF;
+ cpu->fr += ZF;
}
return res;
}
/* 仮想マシンCOMET IIでの実行 */
-void exec()
+bool exec()
{
WORD op, r_r1, x_r2, val;
CMDTYPE cmdtype;
- char *errpr = malloc(CERRSTRSIZE + 1);
+ char *errpr = malloc_chk(CERRSTRSIZE + 1, "exec.errpr");
clock_t clock_begin, clock_end;
addcerrlist_exec();
if(execmode.trace) {
fprintf(stdout, "\nExecuting machine codes\n");
}
- /* フラグレジスタの初期値設定 */
- FR = 0x0;
- SP = memsize;
- PR = startptr;
- if(create_code_type() == false) {
- goto execerr;
- }
+ /* レジスタの初期化 */
+ cpu->sp = memsize;
+ cpu->pr = progprop->start;
/* 機械語の実行 */
for (; ; ) {
clock_begin = clock();
/* プログラムレジスタのアドレスが主記憶の範囲外の場合はエラー */
- if(PR >= memsize) {
- sprintf(errpr, "PR:#%04X", PR);
+ if(cpu->pr >= memsize) {
+ sprintf(errpr, "PR:#%04X", cpu->pr);
setcerr(204, errpr); /* Program Register (PR) - out of COMET II memory */
}
/* スタック領域のアドレスが主記憶の範囲外の場合はエラー */
- if(SP > memsize) {
- sprintf(errpr, "PR:#%04X", PR);
+ if(cpu->sp > memsize) {
+ sprintf(errpr, "PR:#%04X", cpu->pr);
setcerr(207, errpr); /* Stack Pointer (SP) - out of COMET II memory */
}
/* スタック領域を確保できない場合はエラー */
- if(SP <= endptr) {
- sprintf(errpr, "PR:#%04X", PR);
+ if(cpu->sp <= progprop->end) {
+ sprintf(errpr, "PR:#%04X", cpu->pr);
setcerr(205, errpr); /* Stack Pointer (SP) - cannot allocate stack buffer */
}
/* 命令の取り出し */
- op = memory[PR] & 0xFF00;
+ op = memory[cpu->pr] & 0xFF00;
/* 命令の解読 */
cmdtype = getcmdtype(op);
- r_r1 = (memory[PR] >> 4) & 0xF;
- x_r2 = memory[PR] & 0xF;
+ r_r1 = (memory[cpu->pr] >> 4) & 0xF;
+ x_r2 = memory[cpu->pr] & 0xF;
/* エラー発生時は終了 */
- if(cerrno > 0) {
+ if(cerr->num > 0) {
goto execerr;
}
/* traceオプション指定時、レジスタを出力 */
if(execmode.trace){
- fprintf(stdout, "#%04X: Register::::\n", PR);
+ fprintf(stdout, "#%04X: Register::::\n", cpu->pr);
dspregister();
}
/* dumpオプション指定時、メモリを出力 */
if(execmode.dump){
- fprintf(stdout, "#%04X: Memory::::\n", PR);
+ fprintf(stdout, "#%04X: Memory::::\n", cpu->pr);
dumpmemory();
}
/* どちらかのオプション指定時、改行を出力 */
if(execmode.dump || execmode.trace) {
fprintf(stdout, "\n");
}
- PR++;
+ cpu->pr++;
/* オペランドの取り出し */
if(cmdtype == R1_R2) {
- assert(x_r2 < REGSIZE);
- val = GR[x_r2];
+ assert(x_r2 < GRSIZE);
+ val = cpu->gr[x_r2];
}
else if(cmdtype == R_ADR_X || cmdtype == R_ADR_X_ || cmdtype == ADR_X) {
- assert(x_r2 < REGSIZE);
+ assert(x_r2 < GRSIZE);
/* 実効アドレス（値または値が示す番地）を取得 */
- val = memory[PR++];
+ val = memory[cpu->pr++];
/* 指標アドレスを加算 */
if(x_r2 > 0x0) {
- val += GR[x_r2];
+ val += cpu->gr[x_r2];
}
/* ロード／算術論理演算命令／比較演算命令では、アドレスに格納されている内容を取得 */
if(cmdtype == R_ADR_X_) {
if(val >= memsize) {
- sprintf(errpr, "PR:#%04X", PR-1);
+ sprintf(errpr, "PR:#%04X", cpu->pr-1);
setcerr(206, errpr); /* Address - out of COMET II memory */
goto execerr;
}
case 0x0: /* NOP */
break;
case 0x1000: /* LD */
- setfr(GR[r_r1] = val);
+ setfr(cpu->gr[r_r1] = val);
break;
case 0x1100: /* ST */
- memory[val] = GR[r_r1];
+ memory[val] = cpu->gr[r_r1];
break;
case 0x1200: /* LAD */
- GR[r_r1] = val;
+ cpu->gr[r_r1] = val;
break;
case 0x2000: /* ADDA */
- GR[r_r1] = adda(GR[r_r1], val);
+ cpu->gr[r_r1] = adda(cpu->gr[r_r1], val);
break;
case 0x2100: /* SUBA */
- GR[r_r1] = suba(GR[r_r1], val);
+ cpu->gr[r_r1] = suba(cpu->gr[r_r1], val);
break;
case 0x2200: /* ADDL */
- GR[r_r1] = addl(GR[r_r1], val);
+ cpu->gr[r_r1] = addl(cpu->gr[r_r1], val);
break;
case 0x2300: /* SUBL */
- GR[r_r1] = subl(GR[r_r1], val);
+ cpu->gr[r_r1] = subl(cpu->gr[r_r1], val);
break;
case 0x3000: /* AND */
- setfr(GR[r_r1] &= val);
+ setfr(cpu->gr[r_r1] &= val);
break;
case 0x3100: /* OR */
- setfr(GR[r_r1] |= val);
+ setfr(cpu->gr[r_r1] |= val);
break;
case 0x3200: /* XOR */
- setfr(GR[r_r1] ^= val);
+ setfr(cpu->gr[r_r1] ^= val);
break;
case 0x4000: /* CPA */
- cpa(GR[r_r1], val);
+ cpa(cpu->gr[r_r1], val);
break;
case 0x4100: /* CPL */
- cpl(GR[r_r1], val);
+ cpl(cpu->gr[r_r1], val);
break;
case 0x5000: /* SLA */
- GR[r_r1] = sla(GR[r_r1], val);
+ cpu->gr[r_r1] = sla(cpu->gr[r_r1], val);
break;
case 0x5100: /* SRA */
- GR[r_r1] = sra(GR[r_r1], val);
+ cpu->gr[r_r1] = sra(cpu->gr[r_r1], val);
break;
case 0x5200: /* SLL */
- GR[r_r1] = sll(GR[r_r1], val);
+ cpu->gr[r_r1] = sll(cpu->gr[r_r1], val);
break;
case 0x5300: /* SRL */
- GR[r_r1] = srl(GR[r_r1], val);
+ cpu->gr[r_r1] = srl(cpu->gr[r_r1], val);
break;
case 0x6100: /* JMI */
- if((FR & SF) > 0) {
- PR = val;
+ if((cpu->fr & SF) > 0) {
+ cpu->pr = val;
}
break;
case 0x6200: /* JNZ */
- if((FR & ZF) == 0) {
- PR = val;
+ if((cpu->fr & ZF) == 0) {
+ cpu->pr = val;
}
break;
case 0x6300: /* JZE */
- if((FR & ZF) > 0) {
- PR = val;
+ if((cpu->fr & ZF) > 0) {
+ cpu->pr = val;
}
break;
case 0x6400: /* JUMP */
- PR = val;
+ cpu->pr = val;
break;
case 0x6500: /* JPL */
- if((FR & (SF | ZF)) == 0) {
- PR = val;
+ if((cpu->fr & (SF | ZF)) == 0) {
+ cpu->pr = val;
}
break;
case 0x6600: /* JOV */
- if((FR & OF) > 0) {
- PR = val;
+ if((cpu->fr & OF) > 0) {
+ cpu->pr = val;
}
break;
case 0x7000: /* PUSH */
- assert(SP > endptr && SP <= memsize);
- memory[--SP] = val;
+ assert(cpu->sp > progprop->end && cpu->sp <= memsize);
+ memory[--cpu->sp] = val;
break;
case 0x7100: /* POP */
- assert(SP > endptr && SP <= memsize);
- GR[r_r1] = memory[SP++];
+ assert(cpu->sp > progprop->end && cpu->sp <= memsize);
+ cpu->gr[r_r1] = memory[cpu->sp++];
break;
case 0x8000: /* CALL */
- assert(SP > endptr && SP <= memsize);
- memory[--SP] = PR;
- PR = val;
+ assert(cpu->sp > progprop->end && cpu->sp <= memsize);
+ memory[--(cpu->sp)] = cpu->pr;
+ cpu->pr = val;
break;
case 0x8100: /* RET */
- assert(SP > endptr && SP <= memsize);
- if(SP == memsize) {
- return;
+ assert(cpu->sp > progprop->end && cpu->sp <= memsize);
+ if(cpu->sp == memsize) {
+ return false;
} else {
- PR = memory[SP++];
+ cpu->pr = memory[(cpu->sp)++];
break;
}
case 0xF000: /* SVC */
switch(val)
{
case 0x0: /* EXIT */
- return;
+ return true;
case 0x1: /* IN */
svcin();
break;
do {
clock_end = clock();
} while(clock_end - clock_begin < CLOCKS_PER_SEC / clocks);
- #if 0
- printf("PR:%04X; time: %f\n", PR, (double)((clock_end - clock_begin) * CLOCKS_PER_SEC));
- #endif
}
+ return true;
execerr:
- fprintf(stderr, "Execute error - %d: %s\n", cerrno, cerrmsg);
+ fprintf(stderr, "Execute error - %d: %s\n", cerr->num, cerr->msg);
+ return false;
}
HKEY *keys[2];
int i = 0;
if(prog != NULL) {
- keys[i] = malloc(sizeof(HKEY));
+ keys[i] = malloc_chk(sizeof(HKEY), "labelhash.key");
keys[i]->type = CHARS;
keys[i++]->val.s = strdup(prog);
}
- keys[i] = malloc(sizeof(HKEY));
+ keys[i] = malloc_chk(sizeof(HKEY), "labelhash.key");
keys[i]->type = CHARS;
keys[i]->val.s = strdup(label);
/* ハッシュ値を返す */
return false;
}
/* メモリを確保 */
- if((np = malloc(sizeof(LABELTAB))) == NULL) {
+ if((np = malloc_chk(sizeof(LABELTAB), "addlabel.np")) == NULL) {
goto cerr102;
}
/* プログラム名を設定 */
for(i = 0; i < LABELTABSIZE; i++) {
for(np = labels[i]; np != NULL; np = np->next) {
assert(np->label != NULL);
- ar[asize] = malloc(sizeof(LABELARRAY));
+ ar[asize] = malloc_chk(sizeof(LABELARRAY), "ar[asize]");
ar[asize]->prog = (np->prog == NULL ? NULL : strdup(np->prog));
ar[asize]->label = strdup(np->label);
ar[asize++]->adr = np->adr;
bool status = false;
/* PUSH 0,GR1 */
- writememory(0x7001, ptr++, pass);
- writememory(0x0, ptr++, pass);
+ writememory(0x7001, (asprop->ptr)++, pass);
+ writememory(0x0, (asprop->ptr)++, pass);
/* PUSH 0,GR2 */
- writememory(0x7002, ptr++, pass);
- writememory(0x0, ptr++, pass);
+ writememory(0x7002, (asprop->ptr)++, pass);
+ writememory(0x0, (asprop->ptr)++, pass);
/* LAD GR1,IBUF */
- writememory(0x1210, ptr++, pass);
- writememory(getadr(prog, ibuf, pass), ptr++, pass);
+ writememory(0x1210, (asprop->ptr)++, pass);
+ writememory(getadr(asprop->prog, ibuf, pass), (asprop->ptr)++, pass);
/* LAD GR2,LEN */
- writememory(0x1220, ptr++, pass);
- writememory(getadr(prog, len, pass), ptr++, pass);
+ writememory(0x1220, (asprop->ptr)++, pass);
+ writememory(getadr(asprop->prog, len, pass), (asprop->ptr)++, pass);
/* SVC 1 */
- writememory(0xF000, ptr++, pass);
- writememory(0x0001, ptr++, pass);
+ writememory(0xF000, (asprop->ptr)++, pass);
+ writememory(0x0001, (asprop->ptr)++, pass);
/* POP GR2 */
- writememory(0x7120, ptr++, pass);
+ writememory(0x7120, (asprop->ptr)++, pass);
/* POP GR1 */
- writememory(0x7110, ptr++, pass);
- if(cerrno == 0) {
+ writememory(0x7110, (asprop->ptr)++, pass);
+ if(cerr->num == 0) {
status = true;
}
return status;
bool status = false;
/* PUSH 0,GR1 */
- writememory(0x7001, ptr++, pass);
- writememory(0x0, ptr++, pass);
+ writememory(0x7001, (asprop->ptr)++, pass);
+ writememory(0x0, (asprop->ptr)++, pass);
/* PUSH 0,GR2 */
- writememory(0x7002, ptr++, pass);
- writememory(0x0, ptr++, pass);
+ writememory(0x7002, (asprop->ptr)++, pass);
+ writememory(0x0, (asprop->ptr)++, pass);
/* LAD GR1,OBUF */
- writememory(0x1210, ptr++, pass);
- writememory(getadr(prog, obuf, pass), ptr++, pass);
+ writememory(0x1210, (asprop->ptr)++, pass);
+ writememory(getadr(asprop->prog, obuf, pass), (asprop->ptr)++, pass);
/* LAD GR2,OLEN */
- writememory(0x1220, ptr++, pass);
- writememory(getadr(prog, len, pass), ptr++, pass);
+ writememory(0x1220, (asprop->ptr)++, pass);
+ writememory(getadr(asprop->prog, len, pass), (asprop->ptr)++, pass);
/* SVC 2 */
- writememory(0xF000, ptr++, pass);
- writememory(0x0002, ptr++, pass);
+ writememory(0xF000, (asprop->ptr)++, pass);
+ writememory(0x0002, (asprop->ptr)++, pass);
/* LAD GR1,=#A */
- writememory(0x1210, ptr++, pass);
+ writememory(0x1210, (asprop->ptr)++, pass);
if(pass == FIRST) {
- ptr++;
+ (asprop->ptr)++;
} else {
- writememory(lptr, ptr++, pass); /* リテラルのアドレスを書込 */
+ writememory(asprop->lptr, (asprop->ptr)++, pass); /* リテラルのアドレスを書込 */
}
- writememory(0xA, lptr++, pass);
+ writememory(0xA, (asprop->lptr)++, pass);
/* LAD GR2,=1 */
- writememory(0x1220, ptr++, pass);
+ writememory(0x1220, (asprop->ptr)++, pass);
if(pass == FIRST) {
- ptr++;
+ (asprop->ptr)++;
} else {
- writememory(lptr, ptr++, pass); /* リテラルのアドレスを書込 */
+ writememory(asprop->lptr, (asprop->ptr)++, pass); /* リテラルのアドレスを書込 */
}
- writememory(0x1, lptr++, pass);
+ writememory(0x1, (asprop->lptr)++, pass);
/* SVC 2 */
- writememory(0xF000, ptr++, pass);
- writememory(0x0002, ptr++, pass);
+ writememory(0xF000, (asprop->ptr)++, pass);
+ writememory(0x0002, (asprop->ptr)++, pass);
/* POP GR2 */
- writememory(0x7120, ptr++, pass);
+ writememory(0x7120, (asprop->ptr)++, pass);
/* POP GR1 */
- writememory(0x7110, ptr++, pass);
- if(cerrno == 0) {
+ writememory(0x7110, (asprop->ptr)++, pass);
+ if(cerr->num == 0) {
status = true;
}
return status;
bool status = false;
for(i = 1; i <= 7; i++) {
- writememory(0x7000 + i, ptr++, pass); /* PUSH GRn */
- writememory(0x0, ptr++, pass);
+ writememory(0x7000 + i, (asprop->ptr)++, pass); /* PUSH GRn */
+ writememory(0x0, (asprop->ptr)++, pass);
}
- if(cerrno == 0) {
+ if(cerr->num == 0) {
status = true;
}
return status;
int i;
bool status = false;
for(i = 7; i >= 1; i--) {
- writememory((0x7100 + (i << 4)), ptr++, pass); /* POP GRn */
+ writememory((0x7100 + (i << 4)), (asprop->ptr)++, pass); /* POP GRn */
}
- if(cerrno == 0) {
+ if(cerr->num == 0) {
status = true;
}
return status;
/* COMET IIのメモリ */
WORD *memory;
-/* COMET IIのCPUレジスタ */
-WORD GR[REGSIZE], SP, PR, FR;
-
-/* メモリーサイズ */
+/* メモリサイズ */
int memsize = DEFAULT_MEMSIZE;
+/* COMET IIのCPU */
+CPU *cpu;
+
/* クロック周波数 */
int clocks = DEFAULT_CLOCKS;
-/* 実行開始番地 */
-WORD startptr = 0x0;
-
-/* 実行終了番地 */
-WORD endptr = 0x0;
+/* CASL2プログラムのプロパティ */
+PROGPROP *progprop;
/* COMET II仮想マシンのリセット */
void reset()
{
int i;
- for(i = 0; i < REGSIZE; i++) {
- GR[i] = 0x0;
- }
- SP = PR = FR = 0x0;
- memory = malloc(memsize * sizeof(WORD));
+ /* メモリの初期化 */
+ memory = malloc_chk(memsize * sizeof(WORD), "memory");
for(i = 0; i < memsize; i++) {
memory[i] = 0x0;
}
+ /* CPUの初期化 */
+ cpu = malloc_chk(sizeof(CPU), "cpu");
+ for(i = 0; i < GRSIZE; i++) {
+ cpu->gr[i] = 0x0;
+ }
+ cpu->sp = cpu->pr = cpu->fr = 0x0;
+ /* CASL2プログラムのプロパティ */
+ progprop = malloc_chk(sizeof(PROGPROP), "progprop");
}
/* COMET II仮想マシンのシャットダウン */
void shutdown()
{
+ free(cpu);
free(memory);
}
/* 「,」区切りの文字列から、オペランドのトークンを取得 */
OPD *opdtok(const char *str)
{
- OPD *opd = malloc(sizeof(OPD));
+ OPD *opd = malloc_chk(sizeof(OPD), "opd");
char *p, *q, *sepp;
int sepc = ',', qcnt = 0;
bool quoting = false;
{
char *tokens, *p, *sepp;
bool quoting = false;
- CMDLINE *cmdl = malloc(sizeof(CMDLINE));
+ CMDLINE *cmdl = malloc_chk(sizeof(CMDLINE), "cmdl");
if(line == NULL || strlen(line) == 0) {
return NULL;
p++;
}
/* オペランドを取得 */
- cmdl->opd = malloc(sizeof(OPD));
+ cmdl->opd = malloc_chk(sizeof(OPD), "cmdl->opd");
/* 改行かタブまでの文字列を取得。
「'」で囲まれた文字列に含まれる場合があるため、空白は無視 */
if((sepp = p + strcspn(p, "\t\n")) > p) {
#include "word.h"
/* wordのエラー定義 */
-CERRARRAY cerr_word[] = {
+CERR cerr_word[] = {
{ 114, "not integer" },
{ 115, "not hex" },
{ 116, "out of hex range" },
};
+
bool addcerrlist_word()
{
return addcerrlist(ARRAYSIZE(cerr_word), cerr_word);
/* WORD値を10進数の文字列に変換 */
char *word2n(WORD word)
{
- char *p = malloc(6), *q = malloc(6);
+ char *p = malloc_chk(6, "word2n.p"), *q = malloc_chk(6, "word2n.q");
int i = 0, j;
do{
*(p + i++) = word % 10 + '0';
char *word2bit(const WORD word)
{
WORD mask = 0x8000;
- char *bit = malloc(16 + 1), *p;
+ char *bit = malloc_chk(16 + 1, "word2bit.bit"), *p;
p = bit;
do {
*p++ = (word & mask) ? '1' : '0';
../../../../comet2 -M8 a.o
-Execute error - 201: Load object file - full of COMET II memory
+Execute error - 201: load object file - full of COMET II memory
#include "cerr.h"
/* エラー番号とエラーメッセージ */
-CERRARRAY cerr_utest[] = {
+CERR cerr_utest[] = {
{ 101, "label already defined" },
{ 102, "label table is full" },
{ 103, "label not found" },
#include <stdio.h>
#include "casl2.h"
-CERRARRAY cerr_0[] = {
+CERR cerr_0[] = {
{ 126, "source file is not specified" },
};
-CERRARRAY cerr_1[] = {
+CERR cerr_1[] = {
{ 101, "label already defined" },
{ 102, "label table is full" },
{ 103, "label not found" },
{ 125, "not GR in operand x" },
};
-CERRARRAY cerr_2[] = {
+CERR cerr_2[] = {
{ 114, "not integer" },
{ 115, "not hex" },
{ 116, "out of hex range" },
};
-CERRARRAY cerr_3[] = {
+CERR cerr_3[] = {
{ 114, "not integer" },
{ 115, "not hex" },
{ 116, "out of hex range" },
};
-CERRARRAY cerr_4[] = {
+CERR cerr_4[] = {
{ 201, "Load object file - full of COMET II memory" },
};
-CERRARRAY cerr_5[] = {
+CERR cerr_5[] = {
{ 202, "SVC input - out of Input memory" },
{ 203, "SVC output - out of COMET II memory" },
{ 204, "Program Register (PR) - out of COMET II memory" },
int main(){
CERRLIST *p;
+ /* エラーの追加 */
addcerrlist(ARRAYSIZE(cerr_0), cerr_0);
addcerrlist(ARRAYSIZE(cerr_1), cerr_1);
addcerrlist(ARRAYSIZE(cerr_2), cerr_2);
addcerrlist(ARRAYSIZE(cerr_3), cerr_3);
addcerrlist(ARRAYSIZE(cerr_4), cerr_4);
addcerrlist(ARRAYSIZE(cerr_5), cerr_5);
- for(p = cerr; p != NULL; p = p->next) {
- printf("%d: %s\n", p->err->num, p->err->msg);
+ for(p = cerrlist; p != NULL; p = p->next) {
+ printf("%d: %s\n", p->cerr->num, p->cerr->msg);
}
return 0;
}
#include <stdio.h>
#include "casl2.h"
-static CERRARRAY cerr_utest[] = {
+static CERR cerr_utest[] = {
{ 101, "label already defined" },
{ 102, "label table is full" },
{ 103, "label not found" },
};
const char *str[] = {NULL, "foobar"};
addcerrlist(ARRAYSIZE(cerr_utest), cerr_utest);
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
for(i = 0; i < ARRAYSIZE(str); i++) {
for(j = 0; j < ARRAYSIZE(code); j++) {
setcerr(code[j], str[i]);
- printf("%d: %s - %d\t%s\n", code[j], str[i], cerrno, cerrmsg);
- if(cerrno != 0) {
- freecerr();
- }
+ printf("%d: %s - %d\t%s\n", code[j], str[i], cerr->num, cerr->msg);
}
}
+ freecerr();
return 0;
}
{ "SVC", ADR_X }, { "RET", NONE }
};
create_cmdtype_code();
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
for(i = 0; i < sizeof(cmdcodelist)/sizeof(cmdcodelist[0]); i++) {
code = getcmdcode(cmdcodelist[i].cmd, cmdcodelist[i].type);
printf("%s:0%02o ---> #%04X\n", cmdcodelist[i].cmd, cmdcodelist[i].type, code);
- if(cerrno != 0) {
- printf("\terror - %d: %s", cerrno, cerrmsg);
- freecerr();
+ if(cerr->num != 0) {
+ printf("\terror - %d: %s", cerr->num, cerr->msg);
}
}
+ freecerr();
free_cmdtype_code();
return 0;
}
int compare_code(const void *a, const void *b)
{
- const CMDCODEARRAY ca = **(const CMDCODEARRAY **)a;
- const CMDCODEARRAY cb = **(const CMDCODEARRAY **)b;
+ const CMDTYPECODE ca = **(const CMDTYPECODE **)a;
+ const CMDTYPECODE cb = **(const CMDTYPECODE **)b;
int diff;
if((diff = strcmp(ca.cmd, cb.cmd)) == 0) {
return ca.type - cb.type;
{
int i, j = 0;
CMDCODETAB *np;
- CMDCODEARRAY **ar;
- ar = malloc(sizeof(*ar) * cmdcodesize);
+ CMDTYPECODE **ar;
+ ar = malloc(sizeof(*ar) * cmdtypecodesize);
for(i = 0; i < cmdtabsize; i++) {
np = cmdtype_code[i];
while(np != NULL) {
- ar[j++] = np->cca;
+ ar[j++] = np->cmdtypecode;
np = np->next;
}
}
int main()
{
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
+ /* ハッシュ表作成 */
create_cmdtype_code();
+ /* 命令表の表示 */
print_cmdtype_code();
+ /* ハッシュ表解放 */
free_cmdtype_code();
- if(cerrno != 0) {
- printf("\terror - %d: %s\n", cerrno, cerrmsg);
+ if(cerr->num != 0) {
+ printf("\terror - %d: %s\n", cerr->num, cerr->msg);
freecerr();
exit(-1);
}
np = cmdtype_code[i];
while(np != NULL) {
fprintf(stdout, "(%2d) - %s\t0%02o\t#%04X\n",
- i, np->cca->cmd, np->cca->type, np->cca->code);
+ i, np->cmdtypecode->cmd, np->cmdtypecode->type, np->cmdtypecode->code);
np = np->next;
}
}
}
int main(){
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
+ /* ハッシュ表作成 */
create_cmdtype_code();
+ /* ハッシュ表表示 */
print_cmdtype_code();
+ /* ハッシュ表解放 */
free_cmdtype_code();
- if(cerrno != 0) {
- printf("\terror - %d: %s\n", cerrno, cerrmsg);
+ /* エラーの表示 */
+ if(cerr->num != 0) {
+ printf("\terror - %d: %s\n", cerr->num, cerr->msg);
freecerr();
exit(-1);
}
int compare_code(const void *a, const void *b)
{
- return (**(const CMDCODEARRAY **)a).code - (**(const CMDCODEARRAY **)b).code;
+ return (**(const CMDTYPECODE **)a).code - (**(const CMDTYPECODE **)b).code;
}
/* 命令コードがキーのハッシュ表を表示する */
{
int i, j = 0;
CMDCODETAB *np;
- CMDCODEARRAY **ar;
- ar = malloc(sizeof(*ar) * cmdcodesize);
+ CMDTYPECODE **ar;
+ ar = malloc(sizeof(*ar) * cmdtypecodesize);
for(i = 0; i < cmdtabsize; i++) {
np = code_type[i];
while(np != NULL) {
- ar[j++] = np->cca;
+ ar[j++] = np->cmdtypecode;
np = np->next;
}
}
- qsort(ar, cmdcodesize, sizeof(*ar), (int (*)(const void*, const void*))compare_code);
- for(i = 0; i < cmdcodesize; i++) {
+ qsort(ar, cmdtypecodesize, sizeof(*ar), (int (*)(const void*, const void*))compare_code);
+ for(i = 0; i < cmdtypecodesize; i++) {
fprintf(stdout, "#%04X\t0%02o\t%s\n", ar[i]->code, ar[i]->type, ar[i]->cmd);
}
}
int main()
{
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
+ /* ハッシュ表作成 */
create_code_type();
+ /* 命令表表示 */
print_code_type();
+ /* ハッシュ表削除 */
free_code_type();
- if(cerrno != 0) {
- printf("\terror - %d: %s\n", cerrno, cerrmsg);
+ /* エラーの表示 */
+ if(cerr->num != 0) {
+ printf("\terror - %d: %s\n", cerr->num, cerr->msg);
freecerr();
exit(-1);
}
CMDCODETAB *np;
for(i = 0; i < cmdtabsize; i++){
for(np = code_type[i]; np != NULL; np = np->next) {
- fprintf(stdout, "(%2d) - #%04X\t0%02o\t%s\n", i, np->cca->code, np->cca->type, np->cca->cmd);
+ fprintf(stdout, "(%2d) - #%04X\t0%02o\t%s\n",
+ i, np->cmdtypecode->code, np->cmdtypecode->type, np->cmdtypecode->cmd);
}
}
}
int main()
{
+ /* エラーの初期化 */
+ cerr = malloc_chk(sizeof(CERR), "cerr");
+ /* ハッシュ表作成 */
create_code_type();
+ /* ハッシュ表表示 */
print_code_type();
+ /* ハッシュ表解放 */
free_code_type();
- if(cerrno != 0) {
- printf("\terror - %d: %s\n", cerrno, cerrmsg);
+ /* エラーの表示 */
+ if(cerr->num != 0) {
+ printf("\terror - %d: %s\n", cerr->num, cerr->msg);
freecerr();
exit(-1);
}
projects / YACASL2.git / commitdiff