// $(NEMU_HOME)/src/cpu/cpu-exec.c
void cpu_exec(uint64_t n) {
  g_print_step = (n < MAX_INST_TO_PRINT);
  switch (nemu_state.state) {
    case NEMU_END: case NEMU_ABORT:
      printf("Program execution has ended. To restart the program, exit NEMU and run again.\n");
      return;
    default: nemu_state.state = NEMU_RUNNING;
  }

  uint64_t timer_start = get_time();

  execute(n);

  uint64_t timer_end = get_time();
  g_timer += timer_end - timer_start;

  switch (nemu_state.state) {
    case NEMU_RUNNING: nemu_state.state = NEMU_STOP; break;

    case NEMU_END: case NEMU_ABORT:
      Log("nemu: %s at pc = " FMT_WORD,
          (nemu_state.state == NEMU_ABORT ? ANSI_FMT("ABORT", ANSI_FG_RED) :
           (nemu_state.halt_ret == 0 ? ANSI_FMT("HIT GOOD TRAP", ANSI_FG_GREEN) :
            ANSI_FMT("HIT BAD TRAP", ANSI_FG_RED))),
          nemu_state.halt_pc);
      // fall through
    case NEMU_QUIT: statistic();
  }
}

// $(NEMU_HOME)/src/cpu/cpu-exec.c
static void execute(uint64_t n) {
  Decode s;
  for (;n > 0; n --) {
    exec_once(&s, cpu.pc);
    g_nr_guest_inst ++;
    trace_and_difftest(&s, cpu.pc);
    if (nemu_state.state != NEMU_RUNNING) break;
    IFDEF(CONFIG_DEVICE, device_update());
  }
}

typedef struct Decode {
  vaddr_t pc;
  vaddr_t snpc; // static next pc
  vaddr_t dnpc; // dynamic next pc
  ISADecodeInfo isa;
  IFDEF(CONFIG_ITRACE, char logbuf[128]);
} Decode;

// $(NEMU_HOME)/src/cpu/cpu-exec.c
static void exec_once(Decode *s, vaddr_t pc) {
  s->pc = pc;
  s->snpc = pc;
  isa_exec_once(s);
  cpu.pc = s->dnpc;
#ifdef CONFIG_ITRACE
  char *p = s->logbuf;
  p += snprintf(p, sizeof(s->logbuf), FMT_WORD ":", s->pc);
  int ilen = s->snpc - s->pc;
  int i;
  uint8_t *inst = (uint8_t *)&s->isa.inst.val;
  for (i = ilen - 1; i >= 0; i --) {
    p += snprintf(p, 4, " %02x", inst[i]);
  }
  int ilen_max = MUXDEF(CONFIG_ISA_x86, 8, 4);
  int space_len = ilen_max - ilen;
  if (space_len < 0) space_len = 0;
  space_len = space_len * 3 + 1;
  memset(p, ' ', space_len);
  p += space_len;

#ifndef CONFIG_ISA_loongarch32r
  void disassemble(char *str, int size, uint64_t pc, uint8_t *code, int nbyte);
  disassemble(p, s->logbuf + sizeof(s->logbuf) - p,
      MUXDEF(CONFIG_ISA_x86, s->snpc, s->pc), (uint8_t *)&s->isa.inst.val, ilen);
#else
  p[0] = '\0'; // the upstream llvm does not support loongarch32r
#endif
#endif
}

// $(NEMU_HOME)/src/isa/riscv32/inst.c
int isa_exec_once(Decode *s) {
  s->isa.inst.val = inst_fetch(&s->snpc, 4);
  return decode_exec(s); 
}
// $(NEMU_HOME)/include/cpu/ifetch.h
static inline uint32_t inst_fetch(vaddr_t *pc, int len) {
  uint32_t inst = vaddr_ifetch(*pc, len);
  (*pc) += len;
  return inst;
}

// $(NEMU_HOME)/src/isa/riscv32/inst.c
static int decode_exec(Decode *s) {
  int rd = 0;
  word_t src1 = 0, src2 = 0, imm = 0;
  s->dnpc = s->snpc;

#define INSTPAT_INST(s) ((s)->isa.inst.val)
#define INSTPAT_MATCH(s, name, type, ... /* execute body */ ) { \
  decode_operand(s, &rd, &src1, &src2, &imm, concat(TYPE_, type)); \
  __VA_ARGS__ ; \
}

  INSTPAT_START();
  // Instruction
  INSTPAT("??????? ????? ????? ??? ????? 00101 11", auipc  , U, R(rd) = s->pc + imm); // add upper immediate to pc
  INSTPAT("0000000 00001 00000 000 00000 11100 11", ebreak , N, NEMUTRAP(s->pc, R(10))); // R(10) is $a0
  INSTPAT("??????? ????? ????? ??? ????? ????? ??", inv    , N, INV(s->pc));

  INSTPAT_END();

  R(0) = 0; // reset $zero to 0

  return 0;
}

// $(NEMU_HOME)/include/cpu/decode.h
#define INSTPAT(pattern, ...) do { \
  uint64_t key, mask, shift; \
  pattern_decode(pattern, STRLEN(pattern), &key, &mask, &shift); \
  if ((((uint64_t)INSTPAT_INST(s) >> shift) & mask) == key) { \
    INSTPAT_MATCH(s, ##__VA_ARGS__); \
    goto *(__instpat_end); \
  } \
} while (0)

#define INSTPAT_START(name) { const void ** __instpat_end = &&concat(__instpat_end_, name);
#define INSTPAT_END(name)   concat(__instpat_end_, name): ; }

// $(NEMU_HOME)/src/isa/riscv32/inst.c
#define INSTPAT_INST(s) ((s)->isa.inst.val)
#define INSTPAT_MATCH(s, name, type, ... /* execute body */ ) { \
  decode_operand(s, &rd, &src1, &src2, &imm, concat(TYPE_, type)); \
  __VA_ARGS__ ; \

// 宏INSTPAT_START();
{ const void ** __instpat_end = &&__instpat_end_;
 
// 宏INSTPAT("??????? ????? ????? ??? ????? 00101 11", auipc  , U, R(rd) = s->pc + imm);
do {
  uint64_t key, mask, shift;
  /* Step 1 */
  pattern_decode("??????? ????? ????? ??? ????? 00101 11", 38, &key, &mask, &shift);
  if ((((uint64_t)s->isa.inst.val >> shift) & mask) == key) {
    {
      // 宏INSTPAT_MATCH();
      /* Step 2 */
      decode_operand(s, &rd, &src1, &src2, &imm, TYPE_U);
      /* Step 3 */
      R(rd) = s->pc + imm;
    }
    goto *(__instpat_end);
  }
} while (0);
 
// ... 其他INSTPAT宏
 
// 宏INSTPAT_END();
__instpat_end_: ; }

enum {
  TYPE_I, TYPE_U, TYPE_S, TYPE_R, TYPE_B, TYPE_J,
  TYPE_N, // none
};

#define src1R() do { *src1 = R(rs1); } while (0)
#define src2R() do { *src2 = R(rs2); } while (0)

#define immI() do { *imm = SEXT(BITS(i, 31, 20), 12); } while(0)
#define immU() do { *imm = SEXT(BITS(i, 31, 12) << 12, 32); } while(0)
#define immS() do { *imm = SEXT((BITS(i, 31, 25) << 5) | BITS(i, 11, 7), 12); } while(0)
#define immB() do { *imm = SEXT((BITS(i, 31, 31) << 12) | (BITS(i, 30, 25) << 5) | (BITS(i, 11, 8) << 1) | (BITS(i, 7, 7) << 11), 13); } while(0)
#define immJ() do { *imm = SEXT((BITS(i, 31, 31) << 20) | (BITS(i, 30, 21) << 1) | (BITS(i, 20, 20) << 11) | (BITS(i, 19, 12) << 12), 21); } while(0)

static void decode_operand(Decode *s, int *rd, word_t *src1, word_t *src2, word_t *imm, int type) {
  uint32_t i = s->isa.inst.val;
  int rs1 = BITS(i, 19, 15);
  int rs2 = BITS(i, 24, 20);
  *rd     = BITS(i, 11, 7);
  switch (type) {
    case TYPE_I: src1R();          immI(); break;
    case TYPE_U:                   immU(); break;
    case TYPE_S: src1R(); src2R(); immS(); break;
    case TYPE_R: src1R(); src2R();         break;
    case TYPE_B: src1R(); src2R(); immB(); break;
    case TYPE_J:                   immJ(); break;
  }
}

#define BITMASK(bits) ((1ull << (bits)) - 1)  // make bitmask like 1111...111 len of mask is `bits`
#define BITS(x, hi, lo) (((x) >> (lo)) & BITMASK((hi) - (lo) + 1)) // similar to x[hi:lo] in verilog
#define SEXT(x, len) ({ struct { int64_t n : len; } __x = { .n = x }; (uint64_t)__x.n; }) // signed extended from x[len-1:0] to x[63:0]

int main(int argc, char *argv[]) {
  /* Initialize the monitor. */
#ifdef CONFIG_TARGET_AM
  am_init_monitor();
#else
  init_monitor(argc, argv);
#endif

  /* Start engine. */
  engine_start();

  return is_exit_status_bad();
}

// $(NEMU_HOMU)/src/monitor/monitor.c
void init_monitor(int argc, char *argv[]) {
  /* Perform some global initialization. */
  /* Parse arguments. */
  parse_args(argc, argv);
  /* Set random seed. */
  init_rand();
  /* Open the log file. */
  init_log(log_file);
  /* Initialize memory. */
  init_mem();
  /* Initialize devices. */
  IFDEF(CONFIG_DEVICE, init_device());
  /* Perform ISA dependent initialization. */
  init_isa();
  /* Load the image to memory. This will overwrite the built-in image. */
  long img_size = load_img();
  /* Initialize differential testing. */
  init_difftest(diff_so_file, img_size, difftest_port);
  /* Initialize the simple debugger. */
  init_sdb();

#ifndef CONFIG_ISA_loongarch32r
  IFDEF(CONFIG_ITRACE, init_disasm(
    MUXDEF(CONFIG_ISA_x86,     "i686",
    MUXDEF(CONFIG_ISA_mips32,  "mipsel",
    MUXDEF(CONFIG_ISA_riscv,
      MUXDEF(CONFIG_RV64,      "riscv64",
                               "riscv32"),
                               "bad"))) "-pc-linux-gnu"
  ));
#endif

  /* Display welcome message. */
  welcome();
}

void engine_start() {
#ifdef CONFIG_TARGET_AM
  cpu_exec(-1);
#else
  /* Receive commands from user. */
  sdb_mainloop();
#endif
}

static struct {
  const char *name;
  const char *description;
  int (*handler) (char *);
} cmd_table [] = {
  { "help", "Display information about all supported commands", cmd_help },
  { "c", "Continue the execution of the program", cmd_c },
  { "q", "Exit NEMU", cmd_q },

  /* TODO: Add more commands */
  // si [N]
  { "si", "Let the program step through N instructions and then pause execution", cmd_si},
  // info r / w
  { "info", "Print the status of program", cmd_info},
  // p Expr
  { "p", "Evalute the expression", cmd_p},
  // x N Expr
  { "x", "Evalute the expression and take the reuslt as the begin address, print the continous N bytes as Hex", cmd_x},
  // w Expr
  { "w", "Watch the expression, if the expression change, stop the program", cmd_w},
  // d N
  { "d", "Delete the watchpoint N", cmd_d},
  // history
  { "history", "show history command", cmd_history}
};

// $(NEMU_HOMU)/src/monitor/sdb/sdb.c
void sdb_mainloop() {
  if (is_batch_mode) {
    cmd_c(NULL);
    return;
  }

  for (char *str; (str = rl_gets()) != NULL; ) {
    char *str_end = str + strlen(str);

    /* extract the first token as the command */
    char *cmd = strtok(str, " ");
    if (cmd == NULL) { continue; } // just read the "Enter"

    /* treat the remaining string as the arguments,
     * which may need further parsing
     */
    char *args = cmd + strlen(cmd) + 1;
    if (args >= str_end) {
      args = NULL;
    }

#ifdef CONFIG_DEVICE
    extern void sdl_clear_event_queue();
    sdl_clear_event_queue();
#endif

    int i;
    for (i = 0; i < NR_CMD; i ++) {
      if (strcmp(cmd, cmd_table[i].name) == 0) {
        if (cmd_table[i].handler(args) < 0) { return; } // if enter "q", cme_q will return -1
        break;
      }
    }

    if (i == NR_CMD) { printf("Unknown command '%s'\n", cmd); }
  }
}

// $(NEMU_HOMU)/src/monitor/sdb/sdb.c
static char* rl_gets() {
  static char *line_read = NULL;

  if (line_read) {
    free(line_read);
    line_read = NULL;
  }

  line_read = readline("(nemu) ");

  if (line_read && *line_read) {
    add_history(line_read);
  }

  return line_read;
}

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_help(char *args) {
  /* extract the first argument */
  char *arg = strtok(NULL, " ");
  int i;

  if (arg == NULL) {
    /* no argument given */
    for (i = 0; i < NR_CMD; i ++) {
      printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
    }
  }
  else {
    for (i = 0; i < NR_CMD; i ++) {
      if (strcmp(arg, cmd_table[i].name) == 0) {
        printf("%s - %s\n", cmd_table[i].name, cmd_table[i].description);
        return 0;
      }
    }
    printf("Unknown command '%s'\n", arg);
  }
  return 0;
}

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_c(char *args) {
  cpu_exec(-1);
  return 0;
}

void cpu_exec(uint64_t n);

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_q(char *args) {
  return -1;
}

nemu_state.state = NEMU_QUIT;

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_si(char *args) {
  char *num_str = strtok(NULL, " ");
  int num = 0;
  if (num_str != NULL) {
    Assert(sscanf(num_str, "%d", &num), "The input step num is not a number");
  } else {
    /* no argument given, the default num of step is 1 */
    num = 1;
  }
  cpu_exec(num);
  return 0;
}

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_info(char *args) {
  char *arg = strtok(NULL, " ");
  if (strcmp(arg, "r") == 0) {
    /* info r : print the status of Rigister File*/
    isa_reg_display();
  } else if (strcmp(arg, "w") == 0) {
    /* info w : print the info of watch point*/
    print_watchpoint();
  } else {
    printf("command info need argument r or w\n");
  }
  return 0;
}

// $(NEMU_HOME)/src/isa/riscv32/reg.c
const char *regs[] = {
  "0", "ra", "sp", "gp", "tp", "t0", "t1", "t2",
  "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5",
  "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7",
  "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6"
};

void isa_reg_display() {
  printf(ANSI_FMT("[Register status]", ANSI_BG_YELLOW) "\n");
  printf("Reg \tHex\t\tDec\n");
  printf("%-4s\t" FMT_WORD "\n", "PC", cpu.pc);
  for(int i = 0; i < MUXDEF(CONFIG_RVE, 16, 32); i++) {
    // printf("[%s] / [x%d] => " FMT_WORD "\n", reg_name(i), i, gpr(i));
    printf("%-4s%-4d" FMT_WORD "\t%-20d\n", reg_name(i), i, gpr(i), gpr(i));
  }
  return;
}

// $(NEMU_HOME)/src/monitor/sdb/sdb.c
static int cmd_x(char *args) {
  char *N_str = strtok(NULL, " ");
  if (N_str == NULL) {
    printf("cmd_x Usage: x N Expr\n");
    return 0;
  }
  int32_t N = strtol(N_str, NULL, 10);
  char *addr_str = strtok(NULL, " ");
  if (addr_str == NULL) {
    printf("cmd_x Usage: x N Expr\n");
    return 0;
  }
  vaddr_t addr = strtol(addr_str, NULL, 16);
  printf(ANSI_FMT("[Memory status]", ANSI_BG_GREEN) "\n");
  printf("[ADDRESS] --> [VALUE]\n");
  for (int i = 0; i < N; i++) {
    printf("0x%08x : 0x%08x\n", addr, vaddr_read(addr, 4));
    addr += 4;
  }
  return 0;
}

word_t expr(char *e, bool *success) {
  *success = true;
  if (!make_token(e)) {
    *success = false;
    return 0;
  }
  return eval(0, nr_token);
}

// $(NEMU_HOME)/src/monitor/sdb/expr.c
typedef struct token {
  int type;
  char str[32];
} Token;

static Token tokens[32] __attribute__((used)) = {};
static int nr_token __attribute__((used))  = 0;

static bool make_token(char *e) {
  int position = 0;
  int i;
  regmatch_t pmatch;
  nr_token = 0;

  while (e[position] != '\0') {
    /* Try all rules one by one. */
    for (i = 0; i < NR_REGEX; i ++) {
      if (regexec(&re[i], e + position, 1, &pmatch, 0) == 0 && pmatch.rm_so == 0) {
        char *substr_start = e + position;
        int substr_len = pmatch.rm_eo;

        // Log("match rules[%d] = \"%s\" at position %d with len %d: %.*s",
            // i, rules[i].regex, position, substr_len, substr_len, substr_start);

        position += substr_len;

        switch (rules[i].token_type) {
          case TK_NOTYPE:
              break;
          case '+':
              tokens[nr_token++].type = '+';
              break;
          case '-':
              tokens[nr_token++].type = '-';
              break;
          case '*':
              tokens[nr_token++].type = '*';
              break;
          case '/':
              tokens[nr_token++].type = '/';
              break;
          case '(':
              tokens[nr_token++].type = '(';
              break;
          case ')':
              tokens[nr_token++].type = ')';
              break;
          case TK_EQ:
              tokens[nr_token++].type = TK_EQ;
              break;
          case TK_NEQ:
              tokens[nr_token++].type = TK_NEQ;
              break;
          case TK_DEC:
              tokens[nr_token].type = TK_DEC; 
              Assert(substr_len < 32, "length of int is too long (> 31)");
              strncpy(tokens[nr_token].str, substr_start, substr_len);
              tokens[nr_token++].str[substr_len] = '\0';
              break;
          default:
              TODO();
              break;
        }
        break;
      }
    }

    if (i == NR_REGEX) {
      printf("no match at position %d\n%s\n%*.s^\n", position, e, position, "");
      return false;
    }
  }
  nr_token--;
  return true;
}

int regcomp(regex_t *compiled, const char *pattern, int cflags)

// $(NEMU_HOME)/src/monitor/sdb/expr.c
static struct rule {
  const char *regex;
  int token_type;
} rules[] = {
  {" +", TK_NOTYPE},    // spaces

  {"\\+", '+'},         // plus (the first \ is to escape the second \ in C, the second \ is to escape the + in regex)
  {"\\-", '-'},         // minus
  {"\\*", '*'},         // mutiply
  {"\\/", '/'},         // divide

  {"\\(", '('},         // left bracket
  {"\\)", ')'},         // right bracket

  {"[1-9]+[0-9]*", TK_DEC},  // decimal integer
};

#define NR_REGEX ARRLEN(rules)

static regex_t re[NR_REGEX] = {};

void init_regex() {
  int i;
  char error_msg[128];
  int ret;

  for (i = 0; i < NR_REGEX; i ++) {
    ret = regcomp(&re[i], rules[i].regex, REG_EXTENDED);
    if (ret != 0) {
      regerror(ret, &re[i], error_msg, 128);
      panic("regex compilation failed: %s\n%s", error_msg, rules[i].regex);
    }
  }
}

int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags)

if (regexec(&re[i], e + position, 1, &pmatch, 0) == 0 && pmatch.rm_so == 0) {
    ...
}

typedef struct
{
   regoff_t rm_so;
   regoff_t rm_eo;
} regmatch_t;

<expr> ::= 
    <decimal-number>
  | "(" <expr> ")"          # 在表达式两边加个括号也是表达式
  | <expr> "+" <expr>       # 两个表达式相加也是表达式
  | <expr> "-" <expr>       # minus
  | <expr> "*" <expr>       # mutiply
  | <expr> "/" <expr>       # divide

eval(p, q) {
  if (p > q) {
    // 表达式求值异常
  }
  else if (p == q) {
    // 表达式仅为一个token，应该是一个数字
  }
  else if (check_parentheses(p, q) == true) {
    // 如果表达式被一对括号包围，那么去掉括号即可
    return eval(p + 1, q - 1);
  }
  else {
    // 此时表达式可以分为多个子表达式，需要寻找 “主运算符”，再将子表达式按照主运算符进行运算
    int op = find_main_op(p, q);
    word_t val1 = eval(p, op-1);
    word_t val2 = eval(op+1, q);
    switch (tokens[op].type) {
      case '+': return val1 + val2;
      case '-': return val1 - val2;
      case '*': return val1 * val2;
      case '/': return val1 / val2;
    }
  }
}

// $(NEMU_HOME)/src/monitor/sdb/expr.c
static bool check_parentheses(int p, int q) {
  // Step 1, check if the entire expr is surrounded by ()
  if (!(tokens[p].type == '(' && tokens[q].type == ')')) return false;
  // Step 2, check if the expr is closed by ()
  int diff = 0;
  for (int i = p; i <= q; i++) {
    if (tokens[i].type == '(') diff++;
    if (tokens[i].type == ')') diff--;
    if (diff < 0) return false;
  }
  if (diff != 0) return false;
  return true;
}

// $(NEMU_HOME)/src/monitor/sdb/expr.c
static int get_op_priority(int op) {
  switch(op) {
    case TK_NEG:
    case TK_DEREF:
      return 2;
    case '*':
    case '/':
      return 3;
    case '+':
    case '-':
      return 4;
    case TK_EQ:
    case TK_NEQ:
      return 7;
    case TK_L_AND:
      return 11;
    case TK_L_OR:
      return 12;
    default:
      return 0;
  }
}

static int find_main_op(int p, int q) {
  int op = -1;
  int last_priority = 0;
  for (int i = p; i <= q; i++) {
    int op_type = tokens[i].type;
    int op_priority = get_op_priority(op_type);
    // Log("[%d] Priority:%d", op_type, op_priority);
    // if the token is not op type, it can not be the main op 
    if (op_priority == 0) continue;
    // if the op is surrounded by bracket, it can not be the main op
    if (!surrounded_by_bracket(i, p, q)) continue;
    // Consider the op type priority and the sequence priority between this op and last op
    // in case the op priority is different, the low priority op will be the domain op
    if (op_priority > last_priority) {
      last_priority = op_priority;
      op = i;
    }
    // in case the priority is the same, the right one will be the domain op
    else if (op_priority == last_priority) {
      op = i;
    }
  }
  Assert(op >= 0, "Find No main op");
  return op;
}

// $(NEMU_HOME)/src/monitor/sdb/expr.c
static bool surrounded_by_bracket(int x, int p, int q) {
  int left_bracket = 0;
  int right_bracket = 0;
  for (int i = x - 1; i >= p; i--) {
    if (tokens[i].type == '(') left_bracket++;
    if (tokens[i].type == ')') left_bracket--;
  }
  for (int i = x + 1; i <= q; i++) {
    if (tokens[i].type == ')') right_bracket++;
    if (tokens[i].type == '(') right_bracket--;
  }
  // Log("left_bracket = %d, right_bracket = %d\n", left_bracket, right_bracket);
  if (left_bracket == 0 && right_bracket == 0) return true;
  Assert(left_bracket == right_bracket, "The bracket is not closed!");
  return false;
}

float f = 100; // 100是int类型的数据，需要先转换为 float 类型才能赋值给变量 f
int n = f; // f 是 float 类型的数据，需要先转换为 int 类型才能赋值给变量 n

char a = 1;
short b = 2;
int c = 3;
float d = 1.1;
int result = a + b + c + d;
// 运算时会将a, b, c, d都转换为double类型再相加

//例子
char c = 128;		// 存储空间：0b1000_0000 char的角度看是-1
unsigned char uc = 128;	// 0b1000_0000 unsigned char的角度看是128
unsigned short ushort;

ushort = (unsigned short)c + uc;
//翻译成汇编后，这一条语句做的事情如下
/* 
* Step 1
将c从char强制类型转换为unsigned short，需要进行扩展，原数据类型是有符号的，所以进行符号扩展
0b 1000_0000 => 0b 1111_1111_1000_0000 unsigned short的角度看是一个很大的数
* Step 2
将c从unsigned short隐式转换为int，需要进行扩展，原数据类型是无符号的，所以进行零扩展
0b 1111_1111_1000_0000 => 0b 0000_0000_0000_0000_1111_1111_1000_0000
将uc从unsigned char隐式转换为int，需要进行扩展，原数据类型是无符号的，所以进行零扩展
0b1000_0000 => 0b 0000_0000_0000_0000_0000_0000_1000_0000
* Step 3
进行加法
 0b 0000_0000_0000_0000_1111_1111_1000_0000
+0b 0000_0000_0000_0000_0000_0000_1000_0000
=0b 0000_0000_0000_0001_0000_0000_0000_0000
* Step 4
由于左值是unsigned short，空间为2B，所以取最低的2B，即 0b 0000_0000_0000_0000，unsigned short的角度看是0
*/