src/cmd.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include <string.h>
   4 #include "hash.h"
   5 #include "struct.h"
   6 #include "cmem.h"
   7 #include "exec.h"
   8
   9 /**
  10  * 機械語命令のリスト
  11  */
  12 static COMET2CMD comet2cmd[] = {
  13     { "NOP", NONE, 0x0, nop },
  14     { "LD", R_ADR_X, 0x1000, ld_r_adr_x },
  15     { "ST", R_ADR_X, 0x1100, st },
  16     { "LAD", R_ADR_X, 0x1200, lad },
  17     { "LD", R1_R2, 0x1400, ld_r1_r2 },
  18     { "ADDA", R_ADR_X, 0x2000, adda_r_adr_x },
  19     { "SUBA", R_ADR_X, 0x2100, suba_r_adr_x },
  20     { "ADDL", R_ADR_X, 0x2200, addl_r_adr_x },
  21     { "SUBL", R_ADR_X, 0x2300, subl_r_adr_x },
  22     { "ADDA", R1_R2, 0x2400, adda_r1_r2 },
  23     { "SUBA", R1_R2, 0x2500, suba_r1_r2 },
  24     { "ADDL", R1_R2, 0x2600, addl_r1_r2 },
  25     { "SUBL", R1_R2, 0x2700, subl_r1_r2 },
  26     { "AND", R_ADR_X, 0x3000, and_r_adr_x },
  27     { "OR", R_ADR_X, 0x3100, or_r_adr_x },
  28     { "XOR", R_ADR_X, 0x3200, xor_r_adr_x },
  29     { "AND", R1_R2, 0x3400, and_r1_r2 },
  30     { "OR", R1_R2, 0x3500, or_r1_r2 },
  31     { "XOR", R1_R2, 0x3600, xor_r1_r2 },
  32     { "CPA", R_ADR_X, 0x4000, cpa_r_adr_x },
  33     { "CPL", R_ADR_X, 0x4100, cpl_r_adr_x },
  34     { "CPA", R1_R2, 0x4400, cpa_r1_r2 },
  35     { "CPL", R1_R2, 0x4500, cpl_r1_r2 },
  36     { "SLA", R_ADR_X, 0x5000, sla },
  37     { "SRA", R_ADR_X, 0x5100, sra },
  38     { "SLL", R_ADR_X, 0x5200, sll },
  39     { "SRL", R_ADR_X, 0x5300, srl },
  40     { "JMI", ADR_X, 0x6100, jmi },
  41     { "JNZ", ADR_X, 0x6200, jnz },
  42     { "JZE", ADR_X, 0x6300, jze },
  43     { "JUMP", ADR_X, 0x6400, jump },
  44     { "JPL", ADR_X, 0x6500, jpl },
  45     { "JOV", ADR_X, 0x6600, jov },
  46     { "PUSH", ADR_X, 0x7000, push },
  47     { "POP", R_, 0x7100, pop },
  48     { "CALL", ADR_X, 0x8000, call },
  49     { "SVC", ADR_X, 0xF000, svc },
  50     { "RET", NONE, 0x8100, ret },
  51 };
  52
  53 /**
  54  * 命令コード配列のサイズ
  55  */
  56 static int comet2cmdsize = ARRAYSIZE(comet2cmd);
  57
  58 /**
  59  * ハッシュ表のサイズ
  60  */
  61 enum {
  62     CMDTABSIZE = 39,
  63 };
  64
  65 /**
  66  * ハッシュ表
  67  */
  68 static CMDTAB *cmdtype_code[CMDTABSIZE], *code_type[CMDTABSIZE];
  69
  70 /**
  71  * 命令の名前とタイプからハッシュ値を生成する
  72  */
  73 unsigned hash_cmdtype(const char *cmd, CMDTYPE type)
  74 {
  75     HKEY *keys[2];
  76     unsigned hashval;
  77
  78     /* 命令名を設定 */
  79     keys[0] = malloc_chk(sizeof(HKEY), "hash_cmdtype.keys[0]");
  80     keys[0]->type = CHARS;
  81     keys[0]->val.s = strdup_chk(cmd, "keys[0].val.s");
  82     /* 命令タイプを設定 */
  83     keys[1] = malloc_chk(sizeof(HKEY), "hash_cmdtype.keys[1]");
  84     keys[1]->type = INT;
  85     keys[1]->val.i = (int)(type & 070);
  86     /* ハッシュ値の計算 */
  87     hashval = hash(2, keys, CMDTABSIZE);
  88     FREE(keys[0]->val.s);
  89     FREE(keys[0]);
  90     FREE(keys[1]);
  91     /* ハッシュ値を返す */
  92     return hashval;
  93 }
  94
  95 /**
  96  * 名前とタイプがキーの命令ハッシュ表を作成する
  97  */
  98 bool create_cmdtype_code()
  99 {
 100     CMDTAB *p;
 101     unsigned hashval;
 102     int i;
 103
 104     for(i = 0; i < comet2cmdsize; i++) {
 105         hashval = hash_cmdtype(comet2cmd[i].name, comet2cmd[i].type);    /* ハッシュ値の生成 */
 106         p = malloc_chk(sizeof(CMDTAB), "cmdtype_code");
 107         p->cmd = &comet2cmd[i];
 108         p->next = cmdtype_code[hashval];                                 /* ハッシュ表に値を追加 */
 109         cmdtype_code[hashval] = p;
 110     }
 111     return true;
 112 }
 113
 114 /**
 115  * 命令の名前とタイプから、命令コードを返す
 116  * 無効な場合は0xFFFFを返す
 117  */
 118 WORD getcmdcode(const char *cmd, CMDTYPE type)
 119 {
 120     CMDTAB *p;
 121     WORD w = 0xFFFF;
 122
 123     assert(cmd != NULL);
 124     for(p = cmdtype_code[hash_cmdtype(cmd, type)]; p != NULL; p = p->next) {
 125         if(strcmp(cmd, p->cmd->name) == 0 && type == p->cmd->type) {
 126             w = p->cmd->code;
 127             break;
 128         }
 129     }
 130     return w;
 131 }
 132
 133 /**
 134  * 名前とタイプがキーの命令ハッシュ表を解放する
 135  */
 136 void free_cmdtype_code()
 137 {
 138     int i;
 139     CMDTAB *p, *q;
 140
 141     for(i = 0; i < CMDTABSIZE; i++) {
 142         for(p = cmdtype_code[i]; p != NULL; p = q) {
 143             q = p->next;
 144             FREE(p);
 145         }
 146     }
 147 }
 148
 149 /**
 150  * 命令コードからハッシュ値を生成する
 151  */
 152 unsigned hash_code(WORD code)
 153 {
 154     HKEY *keys[1];
 155     unsigned h;
 156
 157     /* 命令コードを設定 */
 158     keys[0] = malloc_chk(sizeof(HKEY), "hash_code.key");
 159     keys[0]->type = INT;
 160     keys[0]->val.i = (int)(code >> 8);
 161     h = hash(1, keys, CMDTABSIZE);
 162     FREE(keys[0]);
 163     return h;
 164 }
 165
 166 /**
 167  * コードがキーの命令ハッシュ表を作成する
 168  */
 169 bool create_code_type()
 170 {
 171     CMDTAB *p;
 172     unsigned hashval;
 173     int i;
 174
 175     for(i = 0; i < comet2cmdsize; i++) {
 176         hashval = hash_code((&comet2cmd[i])->code);    /* ハッシュ値の生成 */
 177         p = malloc_chk(sizeof(CMDTAB), "code_type");
 178         p->cmd = &comet2cmd[i];
 179         p->next = code_type[hashval];                  /* ハッシュ表に値を追加 */
 180         code_type[hashval] = p;
 181     }
 182     return true;
 183 }
 184
 185 /**
 186  * 命令コードから命令の関数ポインタを返す
 187  */
 188 const void (*getcmdptr(WORD code))
 189 {
 190     CMDTAB *t;
 191     const void (*ptr);
 192
 193     for(t = code_type[hash_code(code)]; t != NULL; t = t->next) {
 194         if(code == t->cmd->code) {
 195             ptr = t->cmd->ptr;
 196             break;
 197         }
 198     }
 199     return ptr;
 200 }
 201
 202 /**
 203  * コードがキーの命令ハッシュ表を解放する
 204  */
 205 void free_code_type()
 206 {
 207     int i;
 208     CMDTAB *p, *q;
 209     for(i = 0; i < CMDTABSIZE; i++) {
 210         for(p = code_type[i]; p != NULL; p = q) {
 211             q = p->next;
 212             FREE(p);
 213         }
 214     }
 215 }