SymbolTable *malloc_table() {
    SymbolTable *t = malloc(sizeof(SymbolTable));
    t->table_length = 0;
    t->table_space  = 8;   // 初始容量隨意，8 或 16 都行
    t->table_array  = malloc(t->table_space * sizeof(TableEntry *));
    return t;
}

void add_to_table(SymbolTable *t, const char *name, int address) {
    if (t->table_length == t->table_space) {   // 滿了就倍增
        t->table_space *= 2;
        t->table_array = realloc(t->table_array,
                                 t->table_space * sizeof(TableEntry *));
    }
    TableEntry *e = malloc(sizeof(TableEntry));
    e->name = malloc(strlen(name) + 1);   // 必須「複製」名字！
    strcpy(e->name, name);
    e->address = address;
    t->table_array[t->table_length++] = e;
}

int get_table_entry(const SymbolTable *t, const char *search_name) {
    for (int i = 0; i < t->table_length; i++)
        if (strcmp(t->table_array[i]->name, search_name) == 0)
            return i;
    return -1;    // 找不到
}

void free_table(SymbolTable *t) {
    for (int i = 0; i < t->table_length; i++) {
        free(t->table_array[i]->name);    // 先釋放名字
        free(t->table_array[i]);          // 再釋放 entry
    }
    free(t->table_array);                 // 再釋放指標陣列
    free(t);                              // 最後釋放表本身
}

data.int_val = 42;   printf("%d", data.int_val);   // 印 42
data.char_val = '@'; printf("%c", data.char_val);  // 印 @
data.char_val = '@'; printf("%d", data.int_val);   // 印 64！

void lex_line(const char *line, int *rom_address,
              FILE *output, SymbolTable *labels) {
    int i = 0;
    bool emitted = false;          // 這一行有沒有吐出真正的權杖？
    while (line[i] != '\0' && line[i] != '\n') {
        // --- 填空 1：空白直接跳過 ---
        if (line[i] == ' ' || line[i] == '\t' || line[i] == '\r') {
            i++;
            continue;
        }
        // --- 填空 2：// 之後整行都是註解，直接收工 ---
        if (line[i] == '/' && line[i+1] == '/')
            break;
        // --- 骨架已給：標籤與一般權杖 ---
        if (line[i] == '(') {
            i += lex_label(line + i, *rom_address, labels);
        } else {
            Token *t = ...;                  // 依骨架建立權杖
            i += lex_token(line + i, t);
            write_token(output, t);          // 寫進 .lex 中繼檔
            emitted = true;
        }
    }
    if (emitted) {
        write_token(output, newline_token);  // 指令以換行權杖收尾
        (*rom_address)++;                    // --- 填空 3 ---
    }
}

// 講義給的關鍵字集合（順序須與 token.h 的 Keyword enum 一致）
static const char *KEYWORDS[] = {
    "A", "D", "M",
    "JGT", "JEQ", "JLT", "JGE", "JNE", "JLE", "JMP",
    "SP", "LCL", "ARG", "THIS", "THAT", "SCREEN", "KBD",
    "R0","R1","R2","R3","R4","R5","R6","R7",
    "R8","R9","R10","R11","R12","R13","R14","R15",
};
#define NUM_KEYWORDS (sizeof KEYWORDS / sizeof KEYWORDS[0])

// 識別字的合法字元：字母數字加 _ . $ :（pong.asm 會用到！）
static bool is_word_char(char c) {
    return isalnum((unsigned char)c) ||
           c == '_' || c == '.' || c == '$' || c == ':';
}

int lex_token(const char *line, Token *dest) {
    // ...（已給）換行、符號 @=;+-&|!、整數字面值 ...

    // --- 填空：關鍵字與識別字 ---
    if (isalpha((unsigned char)line[0]) || line[0] == '_') {
        int len = 0;                       // 1. 最長吞法：先讀整個單字
        while (is_word_char(line[len]))
            len++;
        char word[MAX_TOKEN_LENGTH];
        strncpy(word, line, len);
        word[len] = '\0';
        for (int k = 0; k < NUM_KEYWORDS; k++)   // 2. 查關鍵字表
            if (strcmp(word, KEYWORDS[k]) == 0) {
                *dest = /* 依骨架建立 KEYWORD 權杖，key_val = k */;
                return len;
            }
        *dest = /* 依骨架建立 IDENTIFIER 權杖（複製 word！） */;
        return len;                        // 3. 都不是 -> 識別字
    }
    ...
}

int lex_label(const char *line, int rom_address,
              SymbolTable *labels) {
    int len = 1;                       // 跳過 '('
    while (line[len] != ')')
        len++;                         // 找到 ')'
    char name[MAX_TOKEN_LENGTH];
    strncpy(name, line + 1, len - 1);  // 取括號中間的名字
    name[len - 1] = '\0';
    add_to_table(labels, name, rom_address);
        // rom_address = 下一條真指令的位址（4.1 節的不變量）
    return len + 1;                    // 連同 ')' 一共吃掉的字元數
}

bool is_a_instruction =
    instruction[0].type == SYMBOL &&
    instruction[0].data.char_val == '@';

Token operand = instruction[1];
int value_to_load;

switch (operand.type) {
case INTEGER_LITERAL:                    // @431
    value_to_load = operand.data.int_val;
    break;

case KEYWORD:                            // @THAT、@R13、@SCREEN
    value_to_load = keyword_address(operand.data.key_val);
    break;

case IDENTIFIER: {                       // @LOOP 或 @counter
    int i = get_table_entry(labels, operand.data.str_val);
    if (i != -1) {                       // (1) 先查標籤表
        value_to_load = labels->table_array[i]->address;
        break;
    }
    i = get_table_entry(variables, operand.data.str_val);
    if (i != -1) {                       // (2) 再查已知變數
        value_to_load = variables->table_array[i]->address;
        break;
    }
    value_to_load = 16 + variables->table_length;
    add_to_table(variables, operand.data.str_val,
                 value_to_load);         // (3) 新變數：16 起依序配
    break;
}
}
int_to_bin_string(value_to_load, dest, 16);   // 骨架已給

// 無 jump 部分時輸出 "000"
void parse_c_jump(Token *jump_token, char *dest) {
    if (jump_token == NULL) { strcpy(dest, "000"); return; }
    switch (jump_token->data.key_val) {
    case KW_JGT: strcpy(dest, "001"); break;
    case KW_JEQ: strcpy(dest, "010"); break;
    case KW_JGE: strcpy(dest, "011"); break;
    case KW_JLT: strcpy(dest, "100"); break;
    case KW_JNE: strcpy(dest, "101"); break;
    case KW_JLE: strcpy(dest, "110"); break;
    case KW_JMP: strcpy(dest, "111"); break;
    }
}

void parse_c_dest(Token *dest_token, char *dest) {
    bool a = false, d = false, m = false;
    if (dest_token != NULL) {
        if (dest_token->type == KEYWORD) {        // A= / D= / M=
            a = (dest_token->data.key_val == KW_A);
            d = (dest_token->data.key_val == KW_D);
            m = (dest_token->data.key_val == KW_M);
        } else {                                  // AD= / MD= / AMD=
            const char *s = dest_token->data.str_val;
            a = (strchr(s, 'A') != NULL);
            d = (strchr(s, 'D') != NULL);
            m = (strchr(s, 'M') != NULL);
        }
    }
    dest[0] = a ? '1' : '0';    // d1
    dest[1] = d ? '1' : '0';    // d2
    dest[2] = m ? '1' : '0';    // d3
    dest[3] = '\0';
}

void parse_c_comp(Token *comp_tokens, int n, char *dest) {
    char text[8] = "";                  // 1. 權杖串回文字
    for (int i = 0; i < n; i++) {
        switch (comp_tokens[i].type) {
        case KEYWORD:
            strcat(text, keyword_string(comp_tokens[i].data.key_val));
            break;                       // "A" / "D" / "M"
        case SYMBOL: {
            char s[2] = { comp_tokens[i].data.char_val, '\0' };
            strcat(text, s);             // "+" "-" "!" "&" "|"
            break;
        }
        case INTEGER_LITERAL:            // comp 裡只會有 0 或 1
            strcat(text, comp_tokens[i].data.int_val ? "1" : "0");
            break;
        }
    }
    static const struct { const char *comp; const char *bits; }
    COMP_TABLE[] = {                    // 2. 查表（a + c1..c6）
        {"0",  "0101010"}, {"1",  "0111111"}, {"-1", "0111010"},
        {"D",  "0001100"}, {"A",  "0110000"}, {"M",  "1110000"},
        {"!D", "0001101"}, {"!A", "0110001"}, {"!M", "1110001"},
        {"-D", "0001111"}, {"-A", "0110011"}, {"-M", "1110011"},
        {"D+1","0011111"}, {"A+1","0110111"}, {"M+1","1110111"},
        {"D-1","0001110"}, {"A-1","0110010"}, {"M-1","1110010"},
        {"D+A","0000010"}, {"D+M","1000010"},
        {"D-A","0010011"}, {"D-M","1010011"},
        {"A-D","0000111"}, {"M-D","1000111"},
        {"D&A","0000000"}, {"D&M","1000000"},
        {"D|A","0010101"}, {"D|M","1010101"},
    };
    for (size_t i = 0; i < sizeof COMP_TABLE / sizeof *COMP_TABLE; i++)
        if (strcmp(text, COMP_TABLE[i].comp) == 0) {
            strcpy(dest, COMP_TABLE[i].bits);
            return;
        }
}

./assembler add.asm        # 產生 add.hack
diff add.hack add-expected.hack && echo PASS