C 将MIPS指令转换为二进制，然后转换为十六进制

对于一个类项目，我需要在一个至少包含MIPS指令的文件中读取，如：

add $t0, $s1, $s4
addi $t1, $a0, 7

等等…（我可以根据需要制作文件，只需担心I和R格式） 我的问题是从文件中读取并首先将其转换为二进制，然后将二进制转换为十六进制应该不难。 我只是不知道如何正确地读入指令并将其转换为二进制

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 10
#define SIZE 128
struct{
        const char *name;
        char *address;
}registers[] = {{ "zero", "00000"},
                { "at", "00001" },
                { "v0", "00010" },
                { "v1", "00011" },
                { "a0", "00100" },
                { "a1", "00101" },
                { "a2", "00110" },
                { "a3", "00111" },
                { "t0", "01000" },
                { "t1", "01001" },
                { "t2", "01010" },
                { "t3", "01011" },
                { "t4", "01100" },
                { "t5", "01101" },
                { "t6", "01110" },
                { "t7", "01111" },
                { "s0", "10000" },
                { "s1", "10001" },
                { "s2", "10010" },
                { "s3", "10011" },
                { "s4", "10100" },
                { "s5", "10101" },
                { "s6", "10110" },
                { "s7", "10111" },
                { "t8", "11000" },
                { "t9", "11001" },
                { NULL, 0 } };


struct{
        const char *name;
        char *function;
}rInst[] = {{ "add", "100000" },
                { "sub", "100001" },
                { "and", "100100" },
                { "or",  "100101" },
                { "sll", "000000" },
                { "slt", "101010" },
                { "srl", "000010" },
                { "jr",  "001000" },
                { NULL, 0 } };

struct {
        const char *name;
        char *function;
} iInst[] = {{ "lw",   "100011" },
                { "sw",   "101011" },
                { "andi", "001100" },
                { "ori",  "001101" },
                { "lui",  "001111" },
                { "beq",  "000100" },
                { "slti", "001010" },
                { "addi", "001000" },
                { NULL, 0 } };

struct inst{
        char opcode[MAX];
        char register1[MAX];
        char register2[MAX];
        char register3[MAX];
        int num;
        struct inst *next;
}*first, *current;

int main(){
         FILE *fp = fopen( "/home/js0939/CompOrg/MIPSLab5.txt", "r");
         char *result[10][4];
         char line[SIZE];
         char *value;
         if(fp == NULL){
                 printf("Error.");
                 return 1;
         }


    int i=0;
    int j=0;
    int k=0;
    int l=0;
    char* func;
    char* reg;

    // loop through each entry in file
    while(fgets(line, sizeof(line), fp)){
        //retrieves instruction
        value = strtok(line, " ");
        result[i][0] = strdup(value);
        for (i = 0; rInst[i].name != NULL; i++) {
                if (strcmp(value, rInst[i].name) == 0) {
                        func = rInst[i].function;
                        printf("%s ", func);
                }
        }

        for (i = 0; iInst[i].name != NULL; i++) {
                if (strcmp(value, iInst[i].name) == 0) {
                        func = iInst[i].function;
                        printf("%s ", func);
                }
        }

        //retrieves first register
        value = strtok(NULL, " ");
        result[i][1] = strdup(value);
        printf("%s ", value);
        for (i = 0; registers[i].name != NULL; i++){
                if(strcmp(value, registers[i].address) == 0){
                        reg = registers[i].address;
                        printf("%s ", reg);
                }
        }

        //retreives second register
        value = strtok(NULL, " ");
    result[i][2] = strdup(value);
        printf("%s ", value);
        for (i = 0; registers[i].name != NULL; i++){
                if(strcmp(value, registers[i].address) == 0){
                        reg = registers[i].address;
                        printf("%s ", reg);
                }
        }


        //retreives third register
        value = strtok(NULL, " \n");
        result[i][3] = strdup(value);
        printf("%s ", value);
        for (i = 0; registers[i].name != NULL; i++){
                if(strcmp(value, registers[i].address) == 0){
                        reg = registers[i].address;
                        printf("%s ", reg);
                }
        }


        //go to next line
        printf("\n");
        i++;
    }

    fclose(fp);
    return 0;
}

#包括
#包括
#包括
#定义最大值10
#定义大小128
结构{
常量字符*名称；
字符*地址；
}寄存器[]={{“零”，“00000”}，
{“at”，“00001”}，
{“v0”，“00010”}，
{“v1”，“00011”}，
{“a0”，“00100”}，
{“a1”，“00101”}，
{“a2”，“00110”}，
{“a3”，“00111”}，
{“t0”，“01000”}，
{“t1”，“01001”}，
{“t2”，“01010”}，
{“t3”，“01011”}，
{“t4”，“01100”}，
{“t5”，“01101”}，
{“t6”，“01110”}，
{“t7”，“01111”}，
{“s0”，“10000”}，
{“s1”，“10001”}，
{“s2”，“10010”}，
{“s3”，“10011”}，
{“s4”，“10100”}，
{“s5”，“10101”}，
{“s6”，“10110”}，
{“s7”，“10111”}，
{“t8”，“11000”}，
{“t9”，“11001”}，
{NULL，0}}；
结构{
常量字符*名称；
char*函数；
}漂洗[]={{“添加”，“100000”}，
{“sub”，“100001”}，
{“和”，“100100”}，
{“或”，“100101”}，
{“sll”，“000000”}，
{“slt”，“101010”}，
{“srl”，“000010”}，
{“jr”，“001000”}，
{NULL，0}}；
结构{
常量字符*名称；
char*函数；
}iInst[]={{“lw”，“100011”}，
{“sw”，“101011”}，
{“andi”，“001100”}，
{“ori”，“001101”}，
{“lui”，“001111”}，
{“beq”，“000100”}，
{“slti”，“001010”}，
{“addi”，“001000”}，
{NULL，0}}；
结构仪表{
字符操作码[MAX]；
字符寄存器1[MAX]；
字符寄存器2[MAX]；
字符寄存器3[MAX]；
int-num；
结构安装*下一步；
}*第一，*当前；
int main（）{
文件*fp=fopen（“/home/js0939/CompOrg/MIPSLab5.txt”，“r”）；
字符*结果[10][4]；
字符行[大小]；
字符*值；
如果（fp==NULL）{
printf（“错误”）；
返回1；
}
int i=0；
int j=0；
int k=0；
int l=0；
char*func；
char*reg；
//循环遍历文件中的每个条目
while（fgets（line，sizeof（line），fp））{
//检索指令
值=strtok（第“”行）；
结果[i][0]=strdup（值）；
for（i=0；rInst[i].name！=NULL；i++）{
if（strcmp（值，rInst[i].name）==0）{
func=rInst[i]。函数；
printf（“%s”，func）；
}
}
对于（i=0；iInst[i].name！=NULL；i++）{
if（strcmp（值，iInst[i].name）==0）{
func=iInst[i]。函数；
printf（“%s”，func）；
}
}
//检索第一个寄存器
值=strtok（空，“”）；
结果[i][1]=标准偏差（值）；
printf（“%s”，值）；
对于（i=0；寄存器[i].name！=NULL；i++）{
if（strcmp（值，寄存器[i]。地址）==0）{
reg=寄存器[i]。地址；
printf（“%s”，reg）；
}
}
//第二寄存器
值=strtok（空，“”）；
结果[i][2]=标准偏差（值）；
printf（“%s”，值）；
对于（i=0；寄存器[i].name！=NULL；i++）{
if（strcmp（值，寄存器[i]。地址）==0）{
reg=寄存器[i]。地址；
printf（“%s”，reg）；
}
}
//检索第三寄存器
值=strtok（空，“\n”）；
结果[i][3]=标准偏差（值）；
printf（“%s”，值）；
对于（i=0；寄存器[i].name！=NULL；i++）{
if（strcmp（值，寄存器[i]。地址）==0）{
reg=寄存器[i]。地址；
printf（“%s”，reg）；
}
}
//转到下一行
printf（“\n”）；
i++；
}
fclose（fp）；
返回0；
}