Invasion: Earth

diff -u m6502.asm M6502.MAC.txt
--- m6502.asm
+++ M6502.MAC.txt
@@ -6952,4 +6952,4 @@
 IF2,<
        PURGE   A,X,Y>
 IFNDEF START,<START==0>
-       END     $Z+START
\ No newline at end of file
+       END     $Z+START

// WAIT文の実装
int cmd_wait(basic_state_t* state, parser_state_t* parser_ptr) {
    // WAIT address, mask [, xor]
    
    eval_result_t addr_result = evaluate_expression(state, parser_ptr);
    if (has_error(state) || addr_result.type != 0) {
        set_error(state, ERR_TYPE_MISMATCH, "Numeric address expected");
        return -1;
    }
    
    token_t comma1 = get_next_token(state, parser_ptr);
    if (comma1.type != TOKEN_DELIMITER || comma1.value.operator != ',') {
        set_error(state, ERR_SYNTAX, ", expected in WAIT");
        return -1;
    }
    
    eval_result_t mask_result = evaluate_expression(state, parser_ptr);
    if (has_error(state) || mask_result.type != 0) {
        set_error(state, ERR_TYPE_MISMATCH, "Numeric mask expected");
        return -1;
    }
    
    uint8_t xor_val = 0;
    token_t comma2 = get_next_token(state, parser_ptr);
    if (comma2.type == TOKEN_DELIMITER && comma2.value.operator == ',') {
        eval_result_t xor_result = evaluate_expression(state, parser_ptr);
        if (has_error(state) || xor_result.type != 0) {
            set_error(state, ERR_TYPE_MISMATCH, "Numeric XOR value expected");
            return -1;
        }
        xor_val = (uint8_t)numeric_to_double(xor_result.value.num);
    }
    
    uint16_t address = (uint16_t)numeric_to_double(addr_result.value.num);
    uint8_t mask = (uint8_t)numeric_to_double(mask_result.value.num);
    
    init_virtual_memory();
    
    // WAIT条件の実装（簡略化）
    // 実際の6502では指定アドレスの値がマスクとXORの条件を満たすまで待機
    uint8_t value = virtual_memory[address];
    if ((value ^ xor_val) & mask) {
        // 条件を満たしている場合は即座に復帰
        return 0;
    }
    
    // 簡易実装：短時間待機
    struct timespec ts = {0, 10000000}; // 10ms
    nanosleep(&ts, NULL);
    
    return 0;
}

// 次のトークンを取得
token_t get_next_token(basic_state_t* state, parser_state_t* parser) {
    token_t token = {0};
    
    skip_whitespace(parser);
    
    if (parser->current_char == '\0') {
        token.type = TOKEN_EOF;
        return token;
    }
    
    token.position = parser->position;
    
    // 数値
    if (isdigit(parser->current_char) || parser->current_char == '.') {
        token.type = TOKEN_NUMBER;
        if (!parse_number(parser, &token.value.number)) {
            set_error(state, ERR_SYNTAX, "Invalid number format");
        }
        return token;
    }
    
    // 文字列
    if (parser->current_char == '"') {
        token.type = TOKEN_STRING;
        if (!parse_string(parser, &token.value.string)) {
            set_error(state, ERR_SYNTAX, "Unterminated string");
        }
        return token;
    }
    
    // 変数またはキーワード
    if (isalpha(parser->current_char)) {
        char word[32];
        uint16_t word_len = 0;
        uint16_t start_pos = parser->position;
        
        // 単語を読み取り
        while ((isalnum(parser->current_char) || parser->current_char == '$') && 
               word_len < sizeof(word) - 1) {
            word[word_len++] = toupper(parser->current_char);
            advance_parser(parser);
        }
        word[word_len] = '\0';
        
        // キーワードチェック
        uint8_t keyword_id = find_keyword(word);
        if (keyword_id) {
            token.type = TOKEN_KEYWORD;
            token.value.keyword_id = keyword_id;
        } else {
            token.type = TOKEN_VARIABLE;
            token.value.string = (char*)malloc(strlen(word) + 1);
            if (token.value.string) {
                strcpy(token.value.string, word);
            }
        }
        return token;
    }
    
    // 演算子と区切り文字
    char ch = parser->current_char;
    advance_parser(parser);
    
    switch (ch) {
        case '+': case '-': case '*': case '/': case '^':
        case '=': case '<': case '>':
            token.type = TOKEN_OPERATOR;
            token.value.operator = ch;
            
            // 複合演算子のチェック
            if ((ch == '<' || ch == '>') && parser->current_char == '=') {
                advance_parser(parser);
                // <= または >= として処理
            } else if (ch == '<' && parser->current_char == '>') {
                advance_parser(parser);
                // <> として処理
            }
            break;
            
        case '(': case ')': case ',': case ';': case ':':
            token.type = TOKEN_DELIMITER;
            token.value.operator = ch;
            break;
            
        case '\n': case '\r':
            token.type = TOKEN_EOL;
            break;
            
        default:
            set_error(state, ERR_SYNTAX, "Unexpected character");
            token.type = TOKEN_EOF;
            break;
    }
    
    return token;
}

// キーワードテーブル
static const keyword_t keywords[] = {
    {"END", 0x80}, {"FOR", 0x81}, {"NEXT", 0x82}, {"DATA", 0x83},
    {"INPUT", 0x84}, {"DIM", 0x85}, {"READ", 0x86}, {"LET", 0x87},
    {"GOTO", 0x88}, {"RUN", 0x89}, {"IF", 0x8A}, {"RESTORE", 0x8B},
    {"GOSUB", 0x8C}, {"RETURN", 0x8D}, {"REM", 0x8E}, {"STOP", 0x8F},
    {"ON", 0x90}, {"NULL", 0x91}, {"WAIT", 0x92}, {"LOAD", 0x93},
    {"SAVE", 0x94}, {"DEF", 0x95}, {"POKE", 0x96}, {"PRINT", 0x97},
    {"CONT", 0x98}, {"LIST", 0x99}, {"CLEAR", 0x9A}, {"GET", 0x9B},
    {"NEW", 0x9C}, {"TAB", 0x9D}, {"TO", 0x9E}, {"FN", 0x9F},
    {"SPC", 0xA0}, {"THEN", 0xA1}, {"NOT", 0xA2}, {"STEP", 0xA3},
    {"+", 0xA4}, {"-", 0xA5}, {"*", 0xA6}, {"/", 0xA7},
    {"^", 0xA8}, {"AND", 0xA9}, {"OR", 0xAA}, {">", 0xAB},
    {"=", 0xAC}, {"<", 0xAD}, {"SGN", 0xAE}, {"INT", 0xAF},
    {"ABS", 0xB0}, {"USR", 0xB1}, {"FRE", 0xB2}, {"POS", 0xB3},
    {"SQR", 0xB4}, {"RND", 0xB5}, {"LOG", 0xB6}, {"EXP", 0xB7},
    {"COS", 0xB8}, {"SIN", 0xB9}, {"TAN", 0xBA}, {"ATN", 0xBB},
    {"PEEK", 0xBC}, {"LEN", 0xBD}, {"STR$", 0xBE}, {"VAL", 0xBF},
    {"ASC", 0xC0}, {"CHR$", 0xC1}, {"LEFT$", 0xC2}, {"RIGHT$", 0xC3},
    {"MID$", 0xC4}, {NULL, 0}
};

    // 文字列をコピー
    *result = (char*)malloc(length + 1);
    if (!*result) return false;
    
    strncpy(*result, parser->text + start_pos, length);
    (*result)[length] = '\0';
    
    advance_parser(parser); // 終了の"をスキップ
    return true;

for (position = 0; (pointer[position] >= '0') && (pointer[0] <= '9'); position++)
{
    parsed_index = (10 * parsed_index) + (size_t)(pointer[position] - '0');
}

#include <stdio.h>
#include <stdlib.h>
int
main() {
    const char *pointer = "0A";
    size_t parsed_index = 0;
    size_t position = 0;
    for (position = 0; (pointer[position] >= '0') && (pointer[0] <= '9'); position++) {
        parsed_index = (10 * parsed_index) + (size_t)(pointer[position] - '0');
    }

    printf("pointer=%s, parsed_index=%d\n", pointer, parsed_index);
}