WeiHaiMIPS汇编转机器码译码器

于 2024-05-23 21:02:14 发布
阅读量415 收藏 4
点赞数 14
文章标签： javascript vscode 课程设计 汇编
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaochen0/article/details/139157442
版权

介绍：供对哈工大威海校区的计组课设使用的WeiHaiMIPS指令集做汇编指令译码机器码的一个译码器。经过实战检验了，应该没bug，但是有少部分指令没有添加译码逻辑。

译码器仓库链接（不用配置任何环境，下载即用）：WeiHaiMIPS译码: 特供哈工大威海校区的计组课设使用的，方便大家把weihaimips汇编转成机器码。需要特别注意使用方式

使用请一定要确保转换前输入的指令格式是对的，指令格式要求必须要英文逗号并且逗号后面打一个空格，并且末尾不需要加任何东西！并且，本网页并没有实现全部的指令，有部分指令如lbu，sw，sh，sb，lw，lhu等没有写（因为当年选的项目没用到这几个指令）。

开源不易，觉得好用的话还请仓库留下你的star哦。

下面贴一下源码水水字数，当然要用的话直接去仓库里下载看就好了：

HTML:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>WeiHaiMIPS汇编转机器码</title>
  <link rel="stylesheet" href="./index.css">
</head>
<body>
  <div class="container" id="container">
    <img 
      src="https://pic.baike.soso.com/ugc/baikepic2/19600/20180227161041-1231386841_jpg_904_609_72018.jpg/0" 
      alt="HIT校徽"
      style="width: 180px;"
      class="HIT-img"
    >
    <span class="index-title">WeiHaiMIPS汇编转机器码 - By PC</span>
    <span class="index-explain" id="explain">点击此处查看使用说明(使用前必读！)</span>
    <input 
      type="text" 
      placeholder="请输入指令，指令的逗号后必须加空格。鼠标放上点右键即可粘贴。" 
      id="input"
      class="index-input"
      autofocus
    >
    <button id="btn-reset" class="btn reset">重置</button>
    <button id="btn" class="btn change">转换</button>
    <div class="show-container re1">
      <span style="user-select: none; font-weight: 600;">正确格式示例：</span>
      <span class="res-res">add $5, $6, $5</span>
    </div>
    <div class="show-container re2">
      <span class="res-title">指令对应二进制码：</span>
      <span id="result" class="res-res"></span>
    </div>
    <div class="show-container re3">
      <span class="res-title">指令对应十六进制码：</span>
      <span id="result16" class="res-res"></span>
    </div>
    <div class="show-container re4">
      <button id="templateBtn" class="btn reset">下载模板</button>
      <button id="fileBtn" class="btn reset">上传TXT</button>
    </div>
  </div>
  <input type="file" id="file" style="display: none;">
</body>
<script src="./index.js"></script>
</html>

CSS:

*{
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

html, body{
  width: 100%;
  height: 100%;
}

.container{
  position: relative;
  width: 100%;
  height: 100%;
  display: flex;
  justify-content: center;
  align-items: center;
}

.HIT-img{
  position: absolute;
  left: 50%;
  top: 10vh;
  transform: translateX(-50%);
}

.index-title{
  position: absolute;
  left: 50%;
  top: 32vh;
  transform: translateX(-50%);
  font-size: max(2vw, 1.2rem);
  font-weight: 600;
  user-select: none;
}

@keyframes ca {
  0%{
    opacity: 1;
  }
  50%{
    opacity: 0;
  }
  100%{
    opacity: 1;
  }
}

.index-explain{
  position: absolute;
  left: 50%;
  top: 38vh;
  transform: translateX(-50%);
  cursor: pointer;
  font-weight: 600;
  font-size: max(1.2vw, 1rem);
  color: rgb(255, 71, 71);
  animation: ca .3s linear 5 forwards;
}

.index-explain:hover{
  text-decoration: underline;
}

.index-input{
  width: 35%;
  height: 5vh;
  border: 1px solid rgba(0, 0, 0, .2);
  outline: none;
  padding-left: 10px;
  border-radius: 8px;
  font-size: max(0.9vw, 0.5rem);
  transition: all .2s;
}

.index-input:hover, .index-input:focus{
  border: 1px solid rgb(107, 188, 255);
}

.btn{
  width: 8%;
  height: 5vh;
  border: none;
  cursor: pointer;
  border-radius: 10px;
  margin-left: 1%;
  font-weight: 600;
  font-size: max(1vw, 0.6rem);
  transition: all .2s;
}

.btn:hover{
  opacity: .6;
}

.change{
  background-color: rgb(51, 163, 254);
  color: #fff;
}

.reset{
  background-color: #fff;
  color: #000;
  border: 1px solid rgba(0, 0, 0, .2);
}

.show-container{
  position: absolute;
  width: 80%;
  height: 10vh;
  display: flex;
  justify-content: center;
  align-items: center;
}

.re1{
  top: 55vh;
}

.re2{
  top: 65vh;
}

.re3{
  top: 75vh;
}

.re4{
  top: 85vh;
}

.res-title{
  font-weight: 600;
  font-size: 16px;
}

.res-res{
  cursor: pointer;
}

.res-res:hover{
  text-decoration: underline;
  color: rgb(88, 178, 252);
}

.res-res:hover::before{
  content: "提示：点击即可复制";
  position: absolute;
  bottom: 0;
  width: 15%;
  height: 35%;
  background-color: transparent;
  color: #979797;
}



@keyframes toBot {
  0%, 100%{
    top: -10vh;
    opacity: 0;
  }
  20%, 70%{
    top: 5vh;
    opacity: 1;
  }
}

.copy-basic{
  display: flex;
  justify-content: center;
  align-items: center;
  position: absolute;
  user-select: none;
  padding: 20px;
  height: 35px;
  border-radius: 10px;
  animation: toBot 2s 1 forwards;
  font-weight: 400;
  z-index: 99;
}

.copy-success{
  background-color: rgb(207, 250, 207);
  color: rgb(54, 128, 54);
}

.copy-error{
  background-color: rgb(254, 175, 175);
  color: rgb(103, 0, 0);
}

.copy-info{
  background-color: rgb(197, 197, 197);
  color: rgb(76, 76, 76);
}

JS:

/* 
  Written By: PiaoChen
  Time: 2023-06-27
  With VSCode.
*/

class MsgShow {
  constructor(mainId, time){
    this.msgQueue = []; 
    this.index = 0;
    this.container = document.getElementById(mainId);
    this.aliveTime = time;
  }

  addMsg(content, type){
    type = type || "info"; 
    const msg = {
      id: this.index,
      content,
      type
    };
    this.msgQueue.push(msg); 
    ++this.index;
    this.displayMsg(msg); 
  }

  displayMsg(msg){
    const span = document.createElement('span');
    span.classList.add('copy-basic', `copy-${msg.type}`);
    span.setAttribute('id', msg.id.toString());
    span.innerHTML = msg.content;
    this.container.appendChild(span);
    setTimeout(() => {
      this.container.removeChild(document.getElementById(msg.id.toString()));
      this.msgQueue.shift(); 
    }, this.aliveTime+20);
  }
}

const msg = new MsgShow("container", 2000); 

if(window.innerWidth <= 900){
  alert("屏幕太小，未做移动适配可能影响展示，建议使用桌面端访问！");
}

function binary(number, bit) {
  let binary = (number >>> 0).toString(2);
  while (binary.length < bit) {
      binary = '0' + binary;
  }
  while(binary.length > bit){
    binary = binary.slice(1);
  }
  return binary;
}


function dec2bin(decNumber, bit) {
    if (decNumber < 0) {
      msg.addMsg("请输入一个非负整数", "error");
    } else {
      var q = binary(decNumber, bit);
      return q;
    }
}

function getNumber(s){
  if(s.charAt(0)==="$"){
    s = s.slice(1);
  }
  if(s.charAt(s.length-1) === ","){
    s = s.substring(0, s.length - 1);
  }
  return Number.parseInt(s);
}

let input = document.getElementById("input");
let btn = document.getElementById("btn");
let result = document.getElementById("result");
let result16 = document.getElementById("result16");
const btnReset = document.getElementById("btn-reset");

/**
 * 译码核心逻辑
 * @returns {string}
 */
function getRes(){
  result.innerHTML="";
  result16.innerHTML="";
  if(input.value === ""){
    msg.addMsg("输入内容不能为空！", "error");
    return;
  }
  let indexArr = input.value.split(" ");
  let op = indexArr[0];
  let numberArr = [];
  let temp = []
  var resArr;
  switch (op){
    case "add": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100000";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "addi": {
      resArr = new Array(4)
      resArr[0] = "001000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "addiu": {
      resArr = new Array(4)
      resArr[0] = "001001";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "addu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100001"
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "and": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100100"
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "andi": {
      resArr = new Array(4)
      resArr[0] = "001100";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "beq": {
      resArr = new Array(4)
      resArr[0] = "000100";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = temp[1];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "bgtz": {
      resArr = new Array(4)
      resArr[0] = "000111";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = "00000";
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "bltz": {
      resArr = new Array(4)
      resArr[0] = "000001";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = "00000";
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "bne": {
      resArr = new Array(4)
      resArr[0] = "000101";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = temp[1];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "j": {
      resArr = new Array(2)
      resArr[0] = "000010";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 26));
        
      }
      resArr[1] = temp[0];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "jal": {
      resArr = new Array(2)
      resArr[0] = "000011";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 26));
        
      }
      resArr[1] = temp[0];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "jr": {
      resArr = new Array(4)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 5));
        
      }
      resArr[1] = temp[0];
      resArr[2] = "000000000000000";
      resArr[3] = "001000";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "lbu": {
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "lhu": {
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "lui": {
      resArr = new Array(4)
      resArr[0] = "001111";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i==1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
          
        
      }
      resArr[1] = "00000";
      resArr[2] = temp[0];
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "lw": {
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "nor": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100111"
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "or": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100101"
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "ori": {
      resArr = new Array(4)
      resArr[0] = "001101";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sb": {
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "sh": {
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "sll": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000000";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sllv": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[2];
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "000100";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "slt": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "101010";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "slti": {
      resArr = new Array(4)
      resArr[0] = "001010";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sltiu": {
      resArr = new Array(4)
      resArr[0] = "001011";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sltu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "101011";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sra": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000011";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "srav": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[2];
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "000111";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "srl": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000010";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sub": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100010";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "subu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100011";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "sw":{
      msg.addMsg("这个的处理逻辑没写", "error");
      return;
    }
    case "xor": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100110";
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    case "xori": {
      resArr = new Array(4)
      resArr[0] = "001110";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        result.innerHTML+=resArr[i];
        result.innerHTML+=" ";
      }
      break;
    }
    default: {
      msg.addMsg("可能写错指令了，或者这个指令我没写逻辑...", "error");
      return;
    }  
  }
  let str = ""
  for(let i = 0; i<resArr.length; ++i){
    str += resArr[i];
  }
  str = parseInt(str,2).toString(16);
  let t = "";
  if(str.length < 8){
    for(let i = 0; i<8-str.length; ++i){
      t += "0";
    }
    str = t + str;
  }
  result16.innerHTML = str.toUpperCase();
  msg.addMsg("转换成功！", "success");
}

/**
 * 文件译码核心逻辑，新加功能，懒得改了
 * @param {string} item 
 * @returns {string}
 */
function getFileRes(item){
  let indexArr = item.split(" ");
  let op = indexArr[0];
  let numberArr = [];
  let temp = []
  var resArr;
  let parts = ""
  switch (op){
    case "add": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100000";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "addi": {
      resArr = new Array(4)
      resArr[0] = "001000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "addiu": {
      resArr = new Array(4)
      resArr[0] = "001001";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "addu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100001"
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "and": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100100"
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "andi": {
      resArr = new Array(4)
      resArr[0] = "001100";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "beq": {
      resArr = new Array(4)
      resArr[0] = "000100";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = temp[1];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "bgtz": {
      resArr = new Array(4)
      resArr[0] = "000111";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = "00000";
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "bltz": {
      resArr = new Array(4)
      resArr[0] = "000001";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = "00000";
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "bne": {
      resArr = new Array(4)
      resArr[0] = "000101";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i===2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
      }
      resArr[1] = temp[0];
      resArr[2] = temp[1];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "j": {
      resArr = new Array(2)
      resArr[0] = "000010";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 26));
        
      }
      resArr[1] = temp[0];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "jal": {
      resArr = new Array(2)
      resArr[0] = "000011";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 26));
        
      }
      resArr[1] = temp[0];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "jr": {
      resArr = new Array(4)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        
          temp.push(binary(numberArr[i], 5));
        
      }
      resArr[1] = temp[0];
      resArr[2] = "000000000000000";
      resArr[3] = "001000";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "lbu": {
      return `(lbu逻辑没写)-${item}`;
    }
    case "lhu": {
      return `(lhu逻辑没写)-${item}`;
    }
    case "lui": {
      resArr = new Array(4)
      resArr[0] = "001111";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制    
        if(i==1){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
          
        
      }
      resArr[1] = "00000";
      resArr[2] = temp[0];
      resArr[3] = temp[1];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "lw": {
      return `(lw逻辑没写)-${item}`;
    }
    case "nor": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100111"
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "or": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000"
      resArr[5] = "100101"
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "ori": {
      resArr = new Array(4)
      resArr[0] = "001101";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sb": {
      return `(sb的逻辑没写)-${item}`;
    }
    case "sh": {
      return `(sh逻辑没写)-${item}`;
    }
    case "sll": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000000";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sllv": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[2];
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "000100";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "slt": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "101010";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "slti": {
      resArr = new Array(4)
      resArr[0] = "001010";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sltiu": {
      resArr = new Array(4)
      resArr[0] = "001011";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sltu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "101011";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sra": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000011";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "srav": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[2];
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "000111";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "srl": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = "00000";
      resArr[2] = temp[1];
      resArr[3] = temp[0];
      resArr[4] = temp[2];
      resArr[5] = "000010";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sub": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100010";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "subu": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100011";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "sw":{
      return `(sw逻辑没写)-${item}`;
    }
    case "xor": {
      resArr = new Array(6)
      resArr[0] = "000000";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        temp.push(binary(numberArr[i], 5));
      }
      resArr[1] = temp[1];
      resArr[2] = temp[2];
      resArr[3] = temp[0];
      resArr[4] = "00000";
      resArr[5] = "100110";
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    case "xori": {
      resArr = new Array(4)
      resArr[0] = "001110";
      for(let i = 1; i<indexArr.length; ++i){ // 把操作数拆出来
        numberArr.push(getNumber(indexArr[i]));
      }
      for(let i = 0; i<numberArr.length; ++i){// 操作数转二进制
        if(i==2){
          temp.push(binary(numberArr[i], 16));
        }else{
          temp.push(binary(numberArr[i], 5));
        }
        
      }
      resArr[1] = temp[1];
      resArr[2] = temp[0];
      resArr[3] = temp[2];
      for(let i = 0; i<resArr.length; ++i){
        parts+=resArr[i];
        parts+=" ";
      }
      break;
    }
    default: {
      return `没写这个-(${item})`;
    }  
  }
  let str = ""
  for(let i = 0; i<resArr.length; ++i){
    str += resArr[i];
  }
  str = parseInt(str,2).toString(16);
  let t = "";
  if(str.length < 8){
    for(let i = 0; i<8-str.length; ++i){
      t += "0";
    }
    str = t + str;
  }
  return str.toUpperCase();
}

// 转换得答案
btn.addEventListener("click", getRes);
// let s = "add $5, $6, $5";

// 使用须知
const explain = document.getElementById("explain");
explain.addEventListener('click', ()=>{ // 懒得写弹窗了
  alert(`
    使用须知：
    ⚠ 重要：请一定要确保转换前输入的指令格式是对的，指令格式要求必须要英文逗号并且逗号后面打一个空格，并且末尾不需要加任何东西！并且，本网页并没有实现全部的指令，有部分指令如lbu，sw，sh，sb，lw，lhu等没有写（因为老学长当年选的项目没用到这几个指令）。
    ⚠ 注意，如果指令是对的但是格式错误/部分使用方式错误情况，结果会出现undefined，但是如果是使用方式错了，本页面没有细致检查使用方式正确与否的功能，所以会正常译码，此时结果会看着没问题（但是这个就会出大问题了）
    关于本网页：本网页是老学长自己写来自己用的（纯原生写的~），本着互帮互助的心态分享给大家。
    本网页汇编命令转到机器码没有任何问题，已经经过了老学长亲自使用测试了，拿下了计组课设95+。
    最后：加油各位！实在不会就什么chatGPT，New Bing，文心一言用起来啊！嘎嘎好用啊家人们！要是觉得好用的话不要忘了进老学长的仓库里给个star😁。
  `);
});

// 重置功能
btnReset.addEventListener('click', ()=>{
  input.value = ""; 
  result.innerHTML=""; 
  result16.innerHTML="";
  msg.addMsg("重置成功！", "info");
});

// 点击复制
const copyItems = document.querySelectorAll(".res-res");
function doCopy(item) {
  return async () => {
    try {
      const text = item.textContent;
      await navigator.clipboard.writeText(text); // 实现复制到粘贴板
      msg.addMsg('复制成功', 'success');
    } catch (err) {
      msg.addMsg('复制出现问题了！请重试', 'error');
      console.error(err);
    }
  };
}
copyItems.forEach((item) => {// 绑上
  item.addEventListener("click", doCopy(item));
});

// 右键粘贴
input.addEventListener('contextmenu', (e) => {
  e.preventDefault(); // 阻止右键菜单
  navigator.clipboard.readText()
    .then(text => {
        input.value = text;
        msg.addMsg("粘贴成功！", "success");
    })
    .catch(err => {
      msg.addMsg("访问粘贴板出错！", "error");
      console.log(err);
      return;
    });
});

/**
 * 生成下载文件
 * @param {string[]} fileStringArr 文件内容数组 
 * @param {string} fileName 文件名
 * @param {string} type 文件类型
 */
function letsDownloadFile(fileStringArr, fileName, type){
  // 创建一个File对象
  let file = new File(
    fileStringArr, 
    fileName, 
    {
      type,
    }
  );
  // 创建一个指向File对象的URL
  let url = URL.createObjectURL(file);
  // 创建一个a标签并模拟点击来下载文件
  let a = document.createElement("a");
  a.href = url;
  a.download = file.name;
  a.click();
}

/**
 * 解析字符串
 * @param {string} fileString 
 * @returns {string} 直接可生成文件下载的内容
 */
function parseStr(fileString){
  let strs = fileString.split("\r\n");
  let res = "";
  strs.forEach((item)=>{
    if(item !== ""){
      res += getFileRes(item.trim());
      res += "\r\n";
    }
  });
  return res;
}

// 拿到上传文件
const file = document.getElementById("file");
// 按钮
const templateBtn = document.getElementById("templateBtn");
templateBtn.addEventListener("click", ()=>{
  alert(`
    🧨文件格式：多个指令之前不需要添加分号，只需回车换行即可。除了指令之外，别的什么都不要有。
      点击确定继续。
  `);
  letsDownloadFile(
    [`add $5, $61, $5\r\nadd $15, $6, $5\r\nadd $5, $6, $9`], 
    "WeiHaiMIPS-template.txt",
    "text/plain"
  );
});
const uploadFileBtn = document.getElementById("fileBtn");
uploadFileBtn.addEventListener("click", ()=>{
  alert(`
    
    请注意，上传的文件必须符合格式要求的！检错不一定能检出来错误，格式错误甚至可能继续转换，导致机器码出错🧨！而这很难被发现。
    内容将转换为16进制数。
    无法处理汇编内容，跳转部分需要自己计算！
    点击确定继续。（如果没继续让上传说明已经上传过一次了，刷新一下）
  `);
  file.click();
});
let fileString;
file.onchange = (e)=>{
  const fileReader = new FileReader();
  fileReader.readAsText(e.target.files[0]);
  fileReader.onload = (e)=>{
    fileString = e.target.result;
    msg.addMsg("上传成功！", "success");
    const result = parseStr(fileString);
    msg.addMsg("转换完毕！", "success");
    letsDownloadFile([result], "ResultOfWeiHaiMIPS.txt", "text/plain");
  }
}

piaochen0
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值