int main() { fs_hash_init(FS_HASH_UMAC); int passes = 0; int fails = 0; #if 1 #define DUMP(t) printf("%lld %s\n", fs_c.xsd_##t, #t); DUMP(double); DUMP(float); DUMP(decimal); DUMP(integer); DUMP(boolean); #endif #define TEST1(f, a, x) printf("[%s] ", fs_value_equal(f(NULL, a), x) ? "PASS" : "FAIL"); printf("%s(", #f); fs_value_print(a); printf(") = "); fs_value_print(f(NULL, a)); printf("\n"); if (!fs_value_equal(f(NULL, a), x)) { fails++; printf(" should have been "); fs_value_print(x); printf("\n"); } else { passes++; } #define TEST2(f, a, b, x) printf("[%s] ", fs_value_equal(f(NULL, a, b), x) ? "PASS" : "FAIL"); printf("%s(", #f); fs_value_print(a); printf(", "); fs_value_print(b); printf(") = "); fs_value_print(f(NULL, a, b)); printf("\n"); if (!fs_value_equal(f(NULL, a, b), x)) { fails++; printf(" should have been "); fs_value_print(x); printf("\n"); } else { passes++; } #define TEST3(f, a, b, c, x) printf("[%s] ", fs_value_equal(f(NULL, a, b, c), x) ? "PASS" : "FAIL"); printf("%s(", #f); fs_value_print(a); printf(", "); fs_value_print(b); printf(", "); fs_value_print(c); printf(") = "); fs_value_print(f(NULL, a, b, c)); printf("\n"); if (!fs_value_equal(f(NULL, a, b, c), x)) { fails++; printf(" should have been "); fs_value_print(x); printf("\n"); } else { passes++; } #define URI(x) fs_value_uri(x) #define RID(x) fs_value_rid(x) #define BND(x) fs_value_rid(0x8000000000000000LL | x) #define STR(x) fs_value_string(x) #define PLN(x) fs_value_plain(x) #define PLN_L(x, l) fs_value_plain_with_lang(x, l) #define DBL(x) fs_value_double(x) #define FLT(x) fs_value_float(x) #define DEC(x) fs_value_decimal(x) #define INT(x) fs_value_integer(x) #define BLN(x) fs_value_boolean(x) #define DAT(x) fs_value_datetime(x) #define DAT_S(x) fs_value_datetime_from_string(x) #define ERR() fs_value_error(FS_ERROR_INVALID_TYPE, NULL) #define BLK() fs_value_blank() TEST2(fn_numeric_add, BLK(), BLK(), ERR()); TEST2(fn_numeric_add, INT(1), URI("test:"), ERR()); TEST2(fn_numeric_add, STR("2"), INT(3), ERR()); TEST2(fn_numeric_add, INT(2), INT(3), INT(5)); TEST2(fn_numeric_add, DEC(2.5), DEC(-1), DEC(1.5)); TEST2(fn_numeric_add, DEC(-2.5), DEC(-1.5), DEC(-4)); TEST2(fn_numeric_subtract, INT(2), INT(3), INT(-1)); TEST2(fn_numeric_add, DBL(1), INT(2), DBL(3)); TEST2(fn_numeric_add, FLT(17000), INT(2), FLT(17002)); TEST2(fn_numeric_subtract, FLT(17000), INT(2), FLT(16998)); TEST2(fn_numeric_subtract, DEC(17000.5), INT(2), DEC(16998.5)); TEST2(fn_numeric_multiply, URI("http://example.com/"), INT(2), ERR()); TEST2(fn_numeric_multiply, DEC(3.5), INT(2), DEC(7)); TEST2(fn_numeric_multiply, DEC(35), DBL(-0.1), DBL(-3.5)); TEST2(fn_numeric_multiply, INT(1), FLT(23), FLT(23)); TEST2(fn_numeric_multiply, INT(10), INT(23), INT(230)); TEST2(fn_numeric_divide, INT(9), URI("http://example.org/"), ERR()); TEST2(fn_numeric_divide, INT(9), INT(2), DEC(4.5)); TEST2(fn_numeric_divide, INT(-9), INT(2), DEC(-4.5)); TEST2(fn_numeric_divide, INT(-9), INT(-2), DEC(4.5)); TEST2(fn_numeric_divide, DBL(90), FLT(10), DBL(9)); TEST2(fn_numeric_divide, FLT(99), FLT(-10), FLT(-9.9)); TEST2(fn_equal, URI("http://example.com/"), DEC(23), BLN(0)); TEST2(fn_equal, URI("http://example.com/"), URI("http://example.com/"), BLN(1)); TEST2(fn_equal, INT(23), DEC(23), BLN(1)); TEST2(fn_equal, fs_value_decimal_from_string("-23.0"), DEC(-23), BLN(1)); TEST2(fn_equal, STR("foo"), PLN("foo"), BLN(0)); TEST2(fn_equal, PLN("foo"), PLN("foo"), BLN(1)); TEST2(fn_equal, BLN(0), BLN(0), BLN(1)); TEST2(fn_greater_than, STR("BBB"), STR("AAA"), BLN(1)); TEST2(fn_greater_than, PLN("BBB"), PLN("AAA"), BLN(1)); TEST2(fn_greater_than, PLN("AAA"), PLN("BBB"), BLN(0)); TEST2(fn_less_than, PLN("BBB"), PLN("AAA"), BLN(0)); TEST2(fn_less_than, PLN("AAA"), PLN("BBB"), BLN(1)); TEST2(fn_less_than, INT(20), INT(15), BLN(0)); TEST2(fn_numeric_equal, INT(23), INT(23), BLN(1)); TEST2(fn_numeric_equal, INT(23), DEC(23), BLN(1)); TEST2(fn_numeric_equal, INT(23), FLT(23), BLN(1)); TEST2(fn_numeric_equal, INT(23), DBL(23), BLN(1)); TEST2(fn_numeric_equal, fn_minus(NULL, INT(23)), DBL(-23), BLN(1)); TEST2(fn_datetime_equal, DAT(1000), DAT(1000), BLN(1)); TEST2(fn_datetime_equal, DAT(time(NULL)), DAT(1000), BLN(0)); TEST2(fn_numeric_less_than, INT(0), DBL(23), BLN(1)); TEST2(fn_numeric_less_than, INT(23), DBL(23), BLN(0)); TEST2(fn_numeric_less_than, DBL(22.99999), INT(23), BLN(1)); TEST2(fn_numeric_less_than, DEC(-18.51), DEC(-18.5), BLN(1)); TEST2(fn_numeric_less_than, DBL(-18.51), DBL(-18.5), BLN(1)); TEST2(fn_numeric_less_than, DEC(-18.5), DEC(-18.51), BLN(0)); TEST2(fn_numeric_less_than, DBL(-18.5), DBL(-18.51), BLN(0)); TEST2(fn_numeric_greater_than, DEC(-121.98882), DEC(-121.739856), BLN(0)); TEST2(fn_numeric_greater_than, DEC(37.67473), DEC(37.677954), BLN(0)); TEST2(fn_numeric_greater_than, INT(0), DBL(23), BLN(0)); TEST2(fn_numeric_greater_than, INT(23), DBL(23), BLN(0)); TEST2(fn_numeric_greater_than, DBL(22.99999), INT(23), BLN(0)); TEST2(fn_numeric_greater_than, DEC(-18.51), DEC(-18.5), BLN(0)); TEST2(fn_numeric_greater_than, DBL(-18.51), DBL(-18.5), BLN(0)); TEST2(fn_numeric_greater_than, DEC(-18.5), DEC(-18.51), BLN(1)); TEST2(fn_numeric_greater_than, DBL(-18.5), DBL(-18.51), BLN(1)); TEST2(fn_logical_and, BLN(1), BLN(0), BLN(0)); TEST2(fn_logical_and, BLN(1), BLN(1), BLN(1)); TEST2(fn_logical_and, INT(0), INT(1), BLN(0)); TEST2(fn_logical_and, INT(1), INT(1), BLN(1)); TEST2(fn_logical_and, STR("true"), INT(1), BLN(1)); TEST2(fn_logical_and, STR("false"), INT(1), BLN(1)); TEST2(fn_logical_and, INT(1), ERR(), ERR()); TEST2(fn_logical_and, ERR(), INT(1), ERR()); TEST2(fn_logical_and, INT(0), ERR(), BLN(0)); TEST2(fn_logical_and, ERR(), INT(0), BLN(0)); TEST2(fn_logical_and, ERR(), ERR(), ERR()); TEST2(fn_logical_or, BLN(1), BLN(0), BLN(1)); TEST2(fn_logical_or, BLN(1), BLN(1), BLN(1)); TEST2(fn_logical_or, INT(0), INT(1), BLN(1)); TEST2(fn_logical_or, INT(1), INT(1), BLN(1)); TEST2(fn_logical_or, STR("true"), INT(32), BLN(1)); TEST2(fn_logical_or, STR("false"), INT(1), BLN(1)); TEST2(fn_logical_or, INT(1), ERR(), BLN(1)); TEST2(fn_logical_or, ERR(), INT(1), BLN(1)); TEST2(fn_logical_or, INT(0), ERR(), ERR()); TEST2(fn_logical_or, ERR(), INT(0), ERR()); TEST2(fn_logical_or, ERR(), ERR(), ERR()); TEST2(fn_compare, STR("AAA"), STR("BBB"), INT(-1)); TEST2(fn_compare, STR("BBB"), STR("BBB"), INT(0)); TEST2(fn_compare, STR("BBB"), STR("AAA"), INT(1)); TEST2(fn_compare, PLN("BBB"), PLN("AAA"), INT(1)); TEST2(fn_compare, STR("BBB"), PLN("BBB"), ERR()); TEST2(fn_compare, STR("http://example.com/"), URI("http://example.com/"), ERR()); TEST2(fn_compare, URI("http://example.com/"), URI("http://example.com/"), ERR()); TEST2(fn_compare, INT(1), PLN("BBB"), ERR()); TEST3(fn_matches, PLN("foobar"), PLN("foo"), BLK(), BLN(1)); TEST3(fn_matches, PLN("foobar"), PLN("^foo"), BLK(), BLN(1)); TEST3(fn_matches, PLN("foobar"), PLN("bar$"), BLK(), BLN(1)); TEST3(fn_matches, PLN("foobar"), PLN("BAR"), STR("i"), BLN(1)); TEST3(fn_matches, PLN("foobar"), PLN("^FOOB[AO]R$"), STR("i"), BLN(1)); TEST3(fn_matches, PLN("foobar"), PLN("^bar"), BLK(), BLN(0)); TEST3(fn_matches, PLN("foobar"), PLN("^foo$"), BLK(), BLN(0)); TEST3(fn_matches, PLN("foobar"), PLN("foo bar"), PLN("x"), BLN(1)); TEST3(fn_matches, INT(23), PLN("foo bar"), PLN("x"), ERR()); TEST3(fn_matches, PLN("foobar"), DAT(1000), PLN("x"), ERR()); TEST1(fn_bound, URI("http://example.com/"), BLN(1)); TEST1(fn_bound, STR("http"), BLN(1)); TEST1(fn_bound, PLN(""), BLN(1)); TEST1(fn_bound, BND(100), BLN(1)); TEST1(fn_bound, RID(FS_RID_NULL), BLN(0)); TEST1(fn_is_blank, URI("http://example.com/"), BLN(0)); TEST1(fn_is_blank, STR("http"), BLN(0)); TEST1(fn_is_blank, PLN(""), BLN(0)); TEST1(fn_is_blank, BND(100), BLN(1)); TEST1(fn_is_blank, RID(FS_RID_NULL), BLN(0)); TEST1(fn_is_iri, URI("http://example.com/"), BLN(1)); TEST1(fn_is_iri, STR("http"), BLN(0)); TEST1(fn_is_iri, PLN(""), BLN(0)); TEST1(fn_is_iri, BND(100), BLN(0)); TEST1(fn_is_iri, RID(FS_RID_NULL), BLN(0)); TEST1(fn_is_literal, URI("http://example.com/"), BLN(0)); TEST1(fn_is_literal, STR("http"), BLN(1)); TEST1(fn_is_literal, PLN(""), BLN(1)); TEST1(fn_is_literal, BND(100), BLN(0)); TEST1(fn_is_literal, RID(FS_RID_NULL), BLN(0)); TEST1(fn_str, URI("http://example.com/"), PLN("http://example.com/")); TEST1(fn_str, STR("http"), PLN("http")); TEST1(fn_str, PLN(""), PLN("")); TEST1(fn_str, BLN(1), PLN("true")); TEST1(fn_str, INT(1), PLN("1")); TEST1(fn_str, FLT(11.1), PLN("11.100000")); TEST1(fn_str, DBL(11.1), PLN("11.100000")); TEST1(fn_str, DEC(23), PLN("23.000000")); TEST1(fn_str, DAT(1000), PLN("1970-01-01T00:16:40")); TEST1(fn_str, BND(100), ERR()); TEST1(fn_str, RID(FS_RID_NULL), ERR()); TEST1(fn_lang, PLN("foo"), PLN("")); TEST1(fn_lang, STR("foo"), PLN("")); TEST1(fn_lang, PLN_L("foo", "en"), PLN("en")); TEST1(fn_lang, PLN_L("foo", ""), PLN("")); TEST1(fn_lang, BLN(1), PLN("")); TEST1(fn_lang, INT(1), PLN("")); TEST1(fn_lang, DEC(1.1), PLN("")); TEST1(fn_lang, FLT(1.1), PLN("")); TEST1(fn_lang, DBL(1.1), PLN("")); TEST1(fn_lang, URI("http://example.org/"), ERR()); TEST1(fn_datatype, PLN("foo"), ERR()); TEST1(fn_datatype, STR("foo"), URI(XSD_STRING)); TEST1(fn_datatype, PLN_L("foo", "en"), ERR()); TEST1(fn_datatype, PLN_L("foo", ""), ERR()); TEST1(fn_datatype, BLN(1), URI(XSD_BOOLEAN)); TEST1(fn_datatype, INT(1), URI(XSD_INTEGER)); TEST1(fn_datatype, DEC(1.1), URI(XSD_DECIMAL)); TEST1(fn_datatype, FLT(1.1), URI(XSD_FLOAT)); TEST1(fn_datatype, DBL(1.1), URI(XSD_DOUBLE)); TEST1(fn_datatype, DAT(1000), URI(XSD_DATETIME)); TEST1(fn_datatype, URI("http://example.org/"), ERR()); TEST2(fn_equal, DAT_S("1975-01-07"), DAT(158284800), BLN(1)); TEST2(fn_equal, DAT_S("1975-01-07T00:00:01"), DAT(158284801), BLN(1)); TEST2(fn_equal, DAT_S("1975-01-07T01:00:01+0000"), DAT(158288401), BLN(1)); TEST2(fn_equal, DAT_S("1975-01-07T01:00:01-0900"), DAT(158320801), BLN(1)); TEST2(fn_cast, DBL(2.1), URI(XSD_INTEGER), INT(2)); TEST2(fn_cast, PLN("2.23"), URI(XSD_DOUBLE), DBL(2.23)); TEST2(fn_cast, PLN_L("2.23", "en"), URI(XSD_DOUBLE), DBL(2.23)); TEST2(fn_cast, STR("2.23"), URI(XSD_DOUBLE), DBL(2.23)); TEST2(fn_cast, URI("http://example.com/"), URI(XSD_STRING), ERR()); TEST2(fn_cast, DAT(1000), URI(XSD_STRING), STR("1970-01-01T00:16:40")); TEST2(fn_cast, STR("1975-01-07T01:00:01-0900"), URI(XSD_DATETIME), DAT(158320801)); printf("\n=== pass %d, fail %d\n", passes, fails); if (fails) { return 1; } return 0; }
int main(int argc, const char * argv[]) { check_same("Mov literal", 3, Asm<int>( MOV(eax, 3_d), RET())() ); check_same("64 bit register MOV", 6, Asm<int>( MOV(rax, 6_q), RET())() ); check_same("Negative literal", -103, Asm<int>( MOV(eax, -3_d), ADD(eax, - - -100_d), RET())() ); check_same("Move reg to reg", 4, Asm<int>( MOV(ecx, 4_d), MOV(eax, ecx), RET())() ); check_same("Simple jmp", 3, Asm<int>( MOV(eax, 3_d), JMP("a"_rel8), ADD(eax, 2_d), "a"_label, RET())() ); check_same("Simple loop", 30, Asm<int>( MOV(ecx, 5_d), MOV(eax, 0_d), "start"_label, CMP(ecx, 0_d), JE("done"_rel8), ADD(eax, 6_d), DEC(ecx), JMP("start"_rel8), "done"_label, RET())() ); check_same("Macro simple loop", 30, Asm<int>( MOV(eax, 0_d), do_x_times(5_d, ADD(eax, 6_d)), RET())() ); check_same("Access arg using esp", 1, Asm<int>( MOV(eax, _[esp + 28_d]), RET())(1, 2, 3) ); check_same("Access arg using ebp", 1, Asm<int>( MOV(eax, _[ebp - 0xc_b]), RET())(1, 2, 3) ); check_same("Index ebp", 1, Asm<int>( MOV(ecx, 2_d), MOV(eax, _[ebp + ecx * 2_b - 0x10_d]), RET())(1, 2, 3) ); check_same("Access args using ebp", 5, Asm<int>( MOV(edx, 0_d), MOV(eax, _[ebp - 0xc_b]), MOV(ecx, _[ebp - 0x10_b]), DIV(ecx), MOV(ecx, _[ebp - 0x14_b]), DIV(ecx), RET())(100, 5, 4) ); check_same("Access arg with 64 bit reg", 2, Asm<int>( MOV(rax, _[rsp + 24_d]), RET())(1, 2, 3) ); check_same("Access second register zero", 1, Asm<int>( MOV(ecx, 0_d), MOV(eax, _[esp + 28_d + ecx]), RET())(1, 2, 3) ); check_same("Access second register with offset", 1, Asm<int>( MOV(ecx, 8_d), MOV(eax, _[esp + 20_d + ecx]), RET())(1, 2, 3) ); check_same("Access second register with offset and 1 scale", 1, Asm<int>( MOV(ecx, 8_d), MOV(eax, _[esp + 20_d + ecx * 1_b]), RET())(1, 2, 3) ); check_same("Access second register with offset and 4 scale", 1, Asm<int>( MOV(ecx, 2_d), MOV(eax, _[esp + 20_d + ecx * 4_b]), RET())(1, 2, 3) ); check_same("Call c function from assembly", 66, Asm<int>( MOV(rbx, _[rsp + 8_d]), CALL(rbx), RET())(&ret66) ); check_same("Call c function from esp directly", 66, Asm<int>( CALL(_[rsp + 8_d]), RET())(&ret66) ); check_same("Call c function from ebp directly", 66, Asm<int>( CALL(_[rbp - 0x10_d]), RET())(&ret66) ); // auto p = Asm<int>(CALL(_[rbp - 0xc_d])); // Print<decltype(p)::program> x{}; std::cout << "done" << std::endl; return 0; }
int arch_6502_translate_instr(cpu_t *cpu, addr_t pc, BasicBlock *bb) { uint8_t opcode = cpu->RAM[pc]; //LOG("%s:%d PC=$%04X\n", __func__, __LINE__, pc); switch (get_instr(opcode)) { /* flags */ case INSTR_CLC: LET1(cpu->ptr_C, FALSE); break; case INSTR_CLD: LET1(ptr_D, FALSE); break; case INSTR_CLI: LET1(ptr_I, FALSE); break; case INSTR_CLV: LET1(cpu->ptr_V, FALSE); break; case INSTR_SEC: LET1(cpu->ptr_C, TRUE); break; case INSTR_SED: LET1(ptr_D, TRUE); break; case INSTR_SEI: LET1(ptr_I, TRUE); break; /* register transfer */ case INSTR_TAX: SET_NZ(LET(X,R(A))); break; case INSTR_TAY: SET_NZ(LET(Y,R(A))); break; case INSTR_TXA: SET_NZ(LET(A,R(X))); break; case INSTR_TYA: SET_NZ(LET(A,R(Y))); break; case INSTR_TSX: SET_NZ(LET(X,R(S))); break; case INSTR_TXS: SET_NZ(LET(S,R(X))); break; /* load */ case INSTR_LDA: SET_NZ(LET(A,OPERAND)); break; case INSTR_LDX: SET_NZ(LET(X,OPERAND)); break; case INSTR_LDY: SET_NZ(LET(Y,OPERAND)); break; /* store */ case INSTR_STA: STORE(R(A),LOPERAND); break; case INSTR_STX: STORE(R(X),LOPERAND); break; case INSTR_STY: STORE(R(Y),LOPERAND); break; /* stack */ case INSTR_PHA: PUSH(R(A)); break; case INSTR_PHP: PUSH(arch_flags_encode(cpu, bb)); break; case INSTR_PLA: SET_NZ(LET(A,PULL)); break; case INSTR_PLP: arch_flags_decode(cpu, PULL, bb); break; /* shift */ case INSTR_ASL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, false)); break; case INSTR_LSR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, false)); break; case INSTR_ROL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, true)); break; case INSTR_ROR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, true)); break; /* bit logic */ case INSTR_AND: SET_NZ(LET(A,AND(R(A),OPERAND))); break; case INSTR_ORA: SET_NZ(LET(A,OR(R(A),OPERAND))); break; case INSTR_EOR: SET_NZ(LET(A,XOR(R(A),OPERAND))); break; case INSTR_BIT: SET_NZ(OPERAND); break; /* arithmetic */ case INSTR_ADC: SET_NZ(ADC(ptr_A, ptr_A, OPERAND, true, false)); break; case INSTR_SBC: SET_NZ(ADC(ptr_A, ptr_A, COM(OPERAND), true, false)); break; case INSTR_CMP: SET_NZ(ADC(NULL, ptr_A, COM(OPERAND), false, true)); break; case INSTR_CPX: SET_NZ(ADC(NULL, ptr_X, COM(OPERAND), false, true)); break; case INSTR_CPY: SET_NZ(ADC(NULL, ptr_Y, COM(OPERAND), false, true)); break; /* increment/decrement */ case INSTR_INX: SET_NZ(LET(X,INC(R(X)))); break; case INSTR_INY: SET_NZ(LET(Y,INC(R(Y)))); break; case INSTR_DEX: SET_NZ(LET(X,DEC(R(X)))); break; case INSTR_DEY: SET_NZ(LET(Y,DEC(R(Y)))); break; case INSTR_INC: SET_NZ(STORE(INC(OPERAND),LOPERAND)); break; case INSTR_DEC: SET_NZ(STORE(DEC(OPERAND),LOPERAND)); break; /* control flow */ case INSTR_JMP: if (get_addmode(opcode) == ADDMODE_IND) { Value *v = LOAD_RAM16(CONST32(OPERAND_16)); new StoreInst(v, cpu->ptr_PC, bb); } break; case INSTR_JSR: PUSH16(pc+2); break; case INSTR_RTS: STORE(ADD(PULL16, CONST16(1)), cpu->ptr_PC); break; /* branch */ case INSTR_BEQ: case INSTR_BNE: case INSTR_BCS: case INSTR_BCC: case INSTR_BMI: case INSTR_BPL: case INSTR_BVS: case INSTR_BVC: break; /* other */ case INSTR_NOP: break; case INSTR_BRK: arch_6502_trap(cpu, pc, bb); break; case INSTR_RTI: arch_6502_trap(cpu, pc, bb); break; case INSTR_XXX: arch_6502_trap(cpu, pc, bb); break; } return get_length(get_addmode(opcode)); }
bool check(uint8_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, uint8_t maxrow) { uint8_t maxcol = MAXCOL(m_posVert); #ifdef NAVIGATION_RE1 // check rotary encoder 1 if changed -> cursor down/up static int16_t re1valprev; p1valdiff = 0; scrollRE = re1valprev - g_rotenc[0]; if (scrollRE) { re1valprev = g_rotenc[0]; if (s_editMode > 0) { p1valdiff = - scrollRE; scrollRE = 0; } } if (event == EVT_KEY_LONG(BTN_RE1)) { if (!menuTab && !s_editMode) { popMenu(); killEvents(event); } } if (event == EVT_KEY_BREAK(BTN_RE1)) { if (s_editMode > 0 && (maxcol & ZCHAR)) { if (m_posHorz < maxcol-ZCHAR) { m_posHorz++; } else { s_editMode = 0; } } else { scrollRE = 0; if (s_editMode++ > 0) s_editMode = 0; if (s_editMode > 0 && m_posVert == 0 && menuTab) s_editMode = -1; } } #else #define scrollRE 0 #endif #ifdef NAVIGATION_POT1 // check pot 1 - if changed -> scroll values static int16_t p1valprev; p1valdiff = (p1valprev-calibratedStick[6]) / SCROLL_POT1_TH; if (p1valdiff) p1valprev = calibratedStick[6]; #endif #ifdef NAVIGATION_POT2 // check pot 2 - if changed -> scroll menu static int16_t p2valprev; int8_t scrollLR = (p2valprev-calibratedStick[4]) / SCROLL_TH; if (scrollLR) p2valprev = calibratedStick[4]; #else #define scrollLR 0 #endif #ifdef NAVIGATION_POT3 // check pot 3 if changed -> cursor down/up static int16_t p3valprev; int8_t scrollUD = (p3valprev-calibratedStick[5]) / SCROLL_TH; if (scrollUD) p3valprev = calibratedStick[5]; #else #define scrollUD 0 #endif if(scrollLR || scrollUD || p1valdiff) g_LightOffCounter = g_eeGeneral.lightAutoOff*500; // on keypress turn the light on 5*100 if (menuTab) { uint8_t attr = 0; if (m_posVert==0 && !s_noScroll) { attr = INVERS; int8_t cc = curr; if (scrollLR || (scrollRE && s_editMode < 0)) { cc = limit((int8_t)0, (int8_t)(curr - scrollLR + scrollRE), (int8_t)(menuTabSize-1)); } switch(event) { case EVT_KEY_FIRST(KEY_LEFT): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; break; case EVT_KEY_FIRST(KEY_RIGHT): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); return false; } } s_noScroll = 0; DisplayScreenIndex(curr, menuTabSize, attr); } theFile.DisplayProgressBar(menuTab ? lcd_lastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); if (s_editMode<=0) { if (scrollUD) { m_posVert = limit((int8_t)0, (int8_t)(m_posVert - scrollUD), (int8_t)maxrow); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; } if (scrollLR && m_posVert>0) { m_posHorz = limit((int8_t)0, (int8_t)(m_posHorz - scrollLR), (int8_t)maxcol); BLINK_SYNC; } #ifdef NAVIGATION_RE1 while (!s_editMode && scrollRE) { if (scrollRE > 0) { --scrollRE; maxcol = MAXCOL(m_posVert); if (maxcol & ZCHAR) maxcol = 0; if (++m_posHorz > maxcol) { m_posHorz = 0; if (++m_posVert > maxrow) { m_posVert = maxrow; m_posHorz = MAXCOL(m_posVert); scrollRE = 0; } } } else { ++scrollRE; if (m_posHorz-- == 0) { if (m_posVert-- == 0) { m_posVert = 0; m_posHorz = 0; scrollRE = 0; } else { m_posHorz = MAXCOL(m_posVert); } } } } #endif } switch(event) { case EVT_ENTRY: minit(); #ifdef NAVIGATION_RE1 if (menuTab) { s_editMode = -1; break; } // no break #else s_editMode = -1; break; #endif #ifdef NAVIGATION_RE1 case EVT_ENTRY_UP: s_editMode = 0; break; #endif case EVT_KEY_FIRST(KEY_MENU): if (maxcol > 0) s_editMode = (s_editMode<=0); break; case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; popMenu(); break; case EVT_KEY_BREAK(KEY_EXIT): if(s_editMode>0) { s_editMode = 0; break; } if (m_posVert==0 || !menuTab) { popMenu(); //beeps itself } else { beepKey(); minit(); BLINK_SYNC; } break; case EVT_KEY_REPT(KEY_RIGHT): //inc if(m_posHorz==maxcol) break; case EVT_KEY_FIRST(KEY_RIGHT)://inc if(!horTab || s_editMode>0)break; INC(m_posHorz,maxcol); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_LEFT): //dec if(m_posHorz==0) break; case EVT_KEY_FIRST(KEY_LEFT)://dec if(!horTab || s_editMode>0)break; DEC(m_posHorz,maxcol); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_DOWN): //inc if(m_posVert==maxrow) break; case EVT_KEY_FIRST(KEY_DOWN): //inc if(s_editMode>0)break; do { INC(m_posVert,maxrow); } while(MAXCOL(m_posVert) == (uint8_t)-1); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; break; case EVT_KEY_REPT(KEY_UP): //dec if(m_posVert==0) break; case EVT_KEY_FIRST(KEY_UP): //dec if(s_editMode>0)break; do { DEC(m_posVert,maxrow); } while(MAXCOL(m_posVert) == (uint8_t)-1); m_posHorz = min(m_posHorz, MAXCOL(m_posVert)); BLINK_SYNC; break; } uint8_t max = menuTab ? 7 : 6; if(m_posVert<1) s_pgOfs=0; else if(m_posVert-s_pgOfs>max) s_pgOfs = m_posVert-max; else if(m_posVert-s_pgOfs<1) s_pgOfs = m_posVert-1; return true; }
/** Reads a key code from a window. @param win The window to read from. @return The key code. **/ int OVERLOAD(wgetch)(WINDOW * const win) { log_call("wgetch(" PTRF ").", PTRS(win)); if (options.play_on) { int key = play_key(win); if (key == KEY_EOF) { options.play_on = FALSE; } else { return key; } } if (options.roll_on) { int key = play_key(win); if (key == KEY_EOF) { options.roll_on = FALSE; } else { return key; } } /* Keeps track of the actual turn count. */ if (*exec_turns < previous_turns) { negative_turns++; } else if (*exec_turns > previous_turns) { options.k_on = TRUE; } else { options.k_on = FALSE; } previous_turns = *exec_turns; turns = *exec_turns + negative_turns; /* Waits for a key. */ const int key = orig_wgetch(win); /* Handles a key. */ if (key == cfg_save_key) { put_fwrite(cfg_output_paths[current_save]); save_state(current_save); } else if (key == cfg_load_key) { load_state(current_save); } else if (key == cfg_next_save_key) { INC(current_save, 1, cfg_saves); } else if (key == cfg_prev_save_key) { DEC(current_save, 1, cfg_saves); } else if (key == cfg_longer_duration_key) { if (current_duration < frame_rate * frame_rate) { current_duration *= 2; } } else if (key == cfg_shorter_duration_key) { if (current_duration > frame_rate / frame_rate) { current_duration /= 2; } } else if (key == cfg_more_time_key) { if (cfg_timestamp - record.timestamp < LONG_MAX) { cfg_timestamp++; } } else if (key == cfg_less_time_key) { if (cfg_timestamp - record.timestamp > 0) { cfg_timestamp--; } } else if (key == cfg_menu_key) { options.gui_menu = !options.gui_menu; options.gui_info = FALSE; } else if (key == cfg_info_key) { options.gui_menu = FALSE; options.gui_info = !options.gui_info; } else if (key == cfg_condense_key) { options.gui_condensed = !options.gui_condensed; } else if (key == cfg_hide_key) { options.gui_hidden = !options.gui_hidden; } else if (key == cfg_play_key) { if (options.play_on) { options.play_on = !options.play_on; } else if (record.frames == 0) { options.play_on = TRUE; put_fread(cfg_input_path); record.current = record.first; } } else if (key == cfg_stop_key) { options.play_on = FALSE; record.current = NULL; } else if (key == cfg_quit_key) { options.progress = EXIT; *shared.state = HAD_ENOUGH; shared.pids[0] = 0; uninit(FALSE); exit(NO_PROBLEM); } else { if (record.frames == 0 && key != ' ') { return KEY_NULL; } else { const size_t inputs = sizeof previous_inputs / sizeof *previous_inputs - 1; for (size_t input = 0; input < inputs; input++) {//shifts the array left previous_inputs[input] = previous_inputs[input + 1]; } previous_inputs[inputs] = key; rec_add_key_frame(current_duration, key); } } wrefresh(win); return key; }
void copy_to_cooked(struct tty_struct * tty) { signed char c; while (!EMPTY(tty->read_q) && !FULL(tty->secondary)) { GETCH(tty->read_q,c); if (c==13) if (I_CRNL(tty)) c=10; else if (I_NOCR(tty)) continue; else ; else if (c==10 && I_NLCR(tty)) c=13; if (I_UCLC(tty)) c=tolower(c); if (L_CANON(tty)) { if (c==KILL_CHAR(tty)) { /* deal with killing the input line */ while(!(EMPTY(tty->secondary) || (c=LAST(tty->secondary))==10 || c==EOF_CHAR(tty))) { if (L_ECHO(tty)) { if (c<32) PUTCH(127,tty->write_q); PUTCH(127,tty->write_q); tty->write(tty); } DEC(tty->secondary.head); } continue; } if (c==ERASE_CHAR(tty)) { if (EMPTY(tty->secondary) || (c=LAST(tty->secondary))==10 || c==EOF_CHAR(tty)) continue; if (L_ECHO(tty)) { if (c<32) PUTCH(127,tty->write_q); PUTCH(127,tty->write_q); tty->write(tty); } DEC(tty->secondary.head); continue; } if (c==STOP_CHAR(tty)) { tty->stopped=1; continue; } if (c==START_CHAR(tty)) { tty->stopped=0; continue; } } if (L_ISIG(tty)) { if (c==INTR_CHAR(tty)) { tty_intr(tty,INTMASK); continue; } if (c==QUIT_CHAR(tty)) { tty_intr(tty,QUITMASK); continue; } } if (c==10 || c==EOF_CHAR(tty)) tty->secondary.data++; if (L_ECHO(tty)) { if (c==10) { PUTCH(10,tty->write_q); PUTCH(13,tty->write_q); } else if (c<32) { if (L_ECHOCTL(tty)) { PUTCH('^',tty->write_q); PUTCH(c+64,tty->write_q); } } else PUTCH(c,tty->write_q); tty->write(tty); } PUTCH(c,tty->secondary); } wake_up(&tty->secondary.proc_list); }
bool check(check_event_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, vertpos_t maxrow, uint8_t flags) { vertpos_t l_posVert = m_posVert; horzpos_t l_posHorz = m_posHorz; uint8_t maxcol = MAXCOL(l_posVert); #define scrollUD 0 if (p2valdiff || scrollUD || p1valdiff) backlightOn(); // on keypress turn the light on if (menuTab) { uint8_t attr = 0; int8_t cc = curr; switch (event) { case EVT_KEY_LONG(KEY_MENU): if (menuTab == menuTabModel) { killEvents(event); if (modelHasNotes()) { MENU_ADD_SD_ITEM(STR_VIEW_CHANNELS); MENU_ADD_ITEM(STR_VIEW_NOTES); menuHandler = onLongMenuPress; } else { pushMenu(menuChannelsView); return false; } } break; case EVT_KEY_LONG(KEY_PAGE): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; killEvents(event); break; case EVT_KEY_BREAK(KEY_PAGE): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (!calibrationState && cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); return false; } if (!(flags&CHECK_FLAG_NO_SCREEN_INDEX)) { displayScreenIndex(curr, menuTabSize, attr); } lcd_filled_rect(0, 0, LCD_W, FH, SOLID, FILL_WHITE|GREY_DEFAULT); } DISPLAY_PROGRESS_BAR(menuTab ? lcdLastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); if (s_editMode<=0) { if (scrollUD) { l_posVert = limit((int8_t)0, (int8_t)(l_posVert - scrollUD), (int8_t)maxrow); l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); } if (p2valdiff && l_posVert>0) { l_posHorz = limit((int8_t)0, (int8_t)((uint8_t)l_posHorz - p2valdiff), (int8_t)maxcol); } } switch(event) { case EVT_ENTRY: menuEntryTime = get_tmr10ms(); l_posVert = POS_VERT_INIT; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); #if defined(ROTARY_ENCODER_NAVIGATION) if (menuTab) { s_editMode = EDIT_MODE_INIT; break; } // no break #else s_editMode = EDIT_MODE_INIT; break; #endif case EVT_ENTRY_UP: menuEntryTime = get_tmr10ms(); s_editMode = 0; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); break; case EVT_ROTARY_BREAK: if (s_editMode > 1) break; if (m_posHorz < 0 && maxcol > 0 && READ_ONLY_UNLOCKED()) { l_posHorz = 0; break; } if (!menuTab || l_posVert>0) { if (READ_ONLY_UNLOCKED()) { s_editMode = (s_editMode<=0); } } break; #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ROTARY_LONG: if (s_editMode > 1) break; killEvents(event); if (l_posVert != POS_VERT_INIT) { l_posVert = POS_VERT_INIT; s_editMode = EDIT_MODE_INIT; break; } // no break #endif case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; // TODO needed? we call ENTRY_UP after which does the same popMenu(); return false; case EVT_KEY_BREAK(KEY_EXIT): #if defined(ROTARY_ENCODER_NAVIGATION) if (s_editMode == 0) s_editMode = EDIT_MODE_INIT; else #endif if (s_editMode>0) { s_editMode = 0; break; } if (l_posHorz >= 0 && (COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { l_posHorz = -1; } else { uint8_t posVertInit = POS_VERT_INIT; if (s_pgOfs != 0 || l_posVert != posVertInit) { s_pgOfs = 0; l_posVert = posVertInit; l_posHorz = POS_HORZ_INIT(l_posVert); } else { popMenu(); return false; } } break; CASE_EVT_ROTARY_MOVE_RIGHT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { INC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz < maxcol) { l_posHorz++; break; } else { l_posHorz = 0; if (!IS_ROTARY_MOVE_RIGHT(event)) break; } } do { INC(l_posVert, POS_VERT_INIT, maxrow); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go down, we must be in this mode l_posHorz = POS_HORZ_INIT(l_posVert); break; CASE_EVT_ROTARY_MOVE_LEFT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { DEC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz > 0) { l_posHorz--; break; } else if (IS_ROTARY_MOVE_LEFT(event) && s_editMode == 0) { l_posHorz = 0xff; } else { l_posHorz = maxcol; break; } } do { DEC(l_posVert, POS_VERT_INIT, maxrow); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go up, we must be in this mode if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) l_posHorz = -1; else l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); break; } if (l_posVert == 0 || (l_posVert==2 && MAXCOL(vertpos_t(1)) >= HIDDEN_ROW) || (l_posVert==3 && MAXCOL(vertpos_t(1)) >= HIDDEN_ROW && MAXCOL(vertpos_t(2)) >= HIDDEN_ROW)) { s_pgOfs = 0; } else if (menuTab && horTab) { if (maxrow > LCD_LINES-1) { while (1) { vertpos_t firstLine = s_pgOfs + (MAXCOL(vertpos_t(1)) == HIDDEN_ROW ? 2 : 1); vertpos_t line = firstLine; for (int numLines=0; line<=maxrow && numLines<LCD_LINES-1; line++) { if (MAXCOL(line) != HIDDEN_ROW) { numLines++; } } int max = line - firstLine; if (l_posVert > max+firstLine-1) { s_pgOfs++; } else if (l_posVert < firstLine) { s_pgOfs--; } else { break; } } } } else { uint8_t max = menuTab ? LCD_LINES-1 : LCD_LINES-2; if (l_posVert>max+s_pgOfs) { s_pgOfs = l_posVert-max; } else if (l_posVert<1+s_pgOfs) { s_pgOfs = l_posVert-1; } } if (maxrow > LCD_LINES-1 && scrollbar_X) { displayScrollbar(scrollbar_X, FH, LCD_H-FH, s_pgOfs, menuTab ? maxrow : maxrow+1, LCD_LINES-1); } m_posVert = l_posVert; m_posHorz = l_posHorz; return true; }
void vsyslogp_r(int pri, struct syslog_data *data, const char *msgid, const char *sdfmt, const char *msgfmt, va_list ap) { static const char BRCOSP[] = "]: "; static const char CRLF[] = "\r\n"; size_t cnt, prlen, tries; char ch, *p, *t; struct timeval tv; struct tm tmnow; time_t now; int fd, saved_errno; #define TBUF_LEN 2048 #define FMT_LEN 1024 #define MAXTRIES 10 char tbuf[TBUF_LEN], fmt_cpy[FMT_LEN], fmt_cat[FMT_LEN] = ""; size_t tbuf_left, fmt_left, msgsdlen; char *fmt = fmt_cat; int signal_safe = pri & LOG_SIGNAL_SAFE; struct iovec iov[7]; /* prog + [ + pid + ]: + fmt + crlf */ int opened, iovcnt; pri &= ~LOG_SIGNAL_SAFE; #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog_r(INTERNALLOG | signal_safe, data, "syslog_r: unknown facility/priority: %x", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask)) return; saved_errno = errno; /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= data->log_fac; /* Build the message. */ p = tbuf; tbuf_left = TBUF_LEN; #define DEC() \ do { \ if (prlen >= tbuf_left) \ prlen = tbuf_left - 1; \ p += prlen; \ tbuf_left -= prlen; \ } while (/*CONSTCOND*/0) prlen = snprintf_ss(p, tbuf_left, "<%d>1 ", pri); DEC(); if (!signal_safe && (gettimeofday(&tv, NULL) != -1)) { /* strftime() implies tzset(), localtime_r() doesn't. */ tzset(); now = (time_t) tv.tv_sec; localtime_r(&now, &tmnow); prlen = strftime(p, tbuf_left, "%FT%T", &tmnow); DEC(); prlen = snprintf(p, tbuf_left, ".%06ld", (long)tv.tv_usec); DEC(); prlen = strftime(p, tbuf_left-1, "%z", &tmnow); /* strftime gives eg. "+0200", but we need "+02:00" */ if (prlen == 5) { p[prlen+1] = p[prlen]; p[prlen] = p[prlen-1]; p[prlen-1] = p[prlen-2]; p[prlen-2] = ':'; prlen += 1; } } else { prlen = snprintf_ss(p, tbuf_left, "-"); /* if gmtime_r() was signal-safe we could output the UTC-time: gmtime_r(&now, &tmnow); prlen = strftime(p, tbuf_left, "%FT%TZ", &tmnow); */ } DEC(); prlen = snprintf_ss(p, tbuf_left, " %s ", hostname); DEC(); if (data->log_tag == NULL) data->log_tag = getprogname(); prlen = snprintf_ss(p, tbuf_left, "%s ", data->log_tag ? data->log_tag : "-"); if (data->log_stat & (LOG_PERROR|LOG_CONS)) { iovcnt = 0; iov[iovcnt].iov_base = p; iov[iovcnt].iov_len = prlen - 1; iovcnt++; } DEC(); if (data->log_stat & LOG_PID) { prlen = snprintf_ss(p, tbuf_left, "%d ", getpid()); if (data->log_stat & (LOG_PERROR|LOG_CONS)) { iov[iovcnt].iov_base = __UNCONST("["); iov[iovcnt].iov_len = 1; iovcnt++; iov[iovcnt].iov_base = p; iov[iovcnt].iov_len = prlen - 1; iovcnt++; iov[iovcnt].iov_base = __UNCONST(BRCOSP); iov[iovcnt].iov_len = 3; iovcnt++; } } else { prlen = snprintf_ss(p, tbuf_left, "- "); if (data->log_stat & (LOG_PERROR|LOG_CONS)) { iov[iovcnt].iov_base = __UNCONST(BRCOSP + 1); iov[iovcnt].iov_len = 2; iovcnt++; } } DEC(); /* * concat the format strings, then use one vsnprintf() */ if (msgid != NULL && *msgid != '\0') { strlcat(fmt_cat, msgid, FMT_LEN); strlcat(fmt_cat, " ", FMT_LEN); } else strlcat(fmt_cat, "- ", FMT_LEN); if (sdfmt != NULL && *sdfmt != '\0') { strlcat(fmt_cat, sdfmt, FMT_LEN); } else strlcat(fmt_cat, "-", FMT_LEN); if (data->log_stat & (LOG_PERROR|LOG_CONS)) msgsdlen = strlen(fmt_cat) + 1; else msgsdlen = 0; /* XXX: GCC */ if (msgfmt != NULL && *msgfmt != '\0') { strlcat(fmt_cat, " ", FMT_LEN); strlcat(fmt_cat, msgfmt, FMT_LEN); } /* * We wouldn't need this mess if printf handled %m, or if * strerror() had been invented before syslog(). */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt) != '\0'; ++fmt) { if (ch == '%' && fmt[1] == 'm') { char ebuf[128]; ++fmt; if (signal_safe || strerror_r(saved_errno, ebuf, sizeof(ebuf))) prlen = snprintf_ss(t, fmt_left, "Error %d", saved_errno); else prlen = snprintf_ss(t, fmt_left, "%s", ebuf); if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) { *t++ = '%'; *t++ = '%'; fmt++; fmt_left -= 2; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; if (signal_safe) prlen = vsnprintf_ss(p, tbuf_left, fmt_cpy, ap); else prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); if (data->log_stat & (LOG_PERROR|LOG_CONS)) { iov[iovcnt].iov_base = p + msgsdlen; iov[iovcnt].iov_len = prlen - msgsdlen; iovcnt++; } DEC(); cnt = p - tbuf; /* Output to stderr if requested. */ if (data->log_stat & LOG_PERROR) { iov[iovcnt].iov_base = __UNCONST(CRLF + 1); iov[iovcnt].iov_len = 1; (void)writev(STDERR_FILENO, iov, iovcnt + 1); } /* Get connected, output the message to the local logger. */ #ifndef __minix if (data == &sdata) mutex_lock(&syslog_mutex); #endif opened = !data->opened; if (opened) openlog_unlocked_r(data->log_tag, data->log_stat, 0, data); connectlog_r(data); /* * If the send() failed, there are two likely scenarios: * 1) syslogd was restarted * 2) /dev/log is out of socket buffer space * We attempt to reconnect to /dev/log to take care of * case #1 and keep send()ing data to cover case #2 * to give syslogd a chance to empty its socket buffer. */ for (tries = 0; tries < MAXTRIES; tries++) { if (send(data->log_file, tbuf, cnt, 0) != -1) break; if (errno != ENOBUFS) { disconnectlog_r(data); connectlog_r(data); } else (void)usleep(1); } /* * Output the message to the console; try not to block * as a blocking console should not stop other processes. * Make sure the error reported is the one from the syslogd failure. */ if (tries == MAXTRIES && (data->log_stat & LOG_CONS) && (fd = open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK, 0)) >= 0) { iov[iovcnt].iov_base = __UNCONST(CRLF); iov[iovcnt].iov_len = 2; (void)writev(fd, iov, iovcnt + 1); (void)close(fd); } #ifndef __minix if (data == &sdata) mutex_unlock(&syslog_mutex); #endif if (data != &sdata && opened) { /* preserve log tag */ const char *ident = data->log_tag; closelog_r(data); data->log_tag = ident; } }
MagickImage* ProcessImage::transition(const MagickImage& from, const MagickImage& to, int type, int step, int steps) { int w, h; if (step < 0 || step >= steps) { Q_EMIT signalProcessError(QString("step: %1 is out of range (%2)").arg(step).arg(steps)); return 0; } // create a new target image and copy the from image onto MagickImage* const dst = m_api->createImage("black", w = from.getWidth(), h = from.getHeight()); if (!dst) { return 0; } switch (type) { // sliding case TRANSITION_TYPE_SLIDE_L2R: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); break; case TRANSITION_TYPE_SLIDE_R2L: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); break; case TRANSITION_TYPE_SLIDE_T2B: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, 0, DEC(-h), to); break; case TRANSITION_TYPE_SLIDE_B2T: m_api->overlayImage(*dst, 0, 0, from); m_api->overlayImage(*dst, 0, DEC(h), to); break; // pushing case TRANSITION_TYPE_PUSH_L2R: m_api->overlayImage(*dst, INC(w), 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); break; case TRANSITION_TYPE_PUSH_R2L: m_api->overlayImage(*dst, INC(-w), 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); break; case TRANSITION_TYPE_PUSH_T2B: m_api->overlayImage(*dst, 0, INC(h), from); m_api->overlayImage(*dst, 0, DEC(-h), to); break; case TRANSITION_TYPE_PUSH_B2T: m_api->overlayImage(*dst, 0, INC(-h), from); m_api->overlayImage(*dst, 0, DEC(h), to); break; // swapping case TRANSITION_TYPE_SWAP_L2R: if (step < steps / 2) { m_api->overlayImage(*dst, INC(w), 0, to); m_api->overlayImage(*dst, INC(-w), 0, from); } else { m_api->overlayImage(*dst, DEC(-w), 0, from); m_api->overlayImage(*dst, DEC(w), 0, to); } break; case TRANSITION_TYPE_SWAP_R2L: if (step < steps / 2) { m_api->overlayImage(*dst, INC(-w), 0, to); m_api->overlayImage(*dst, INC(w), 0, from); } else { m_api->overlayImage(*dst, DEC(w), 0, from); m_api->overlayImage(*dst, DEC(-w), 0, to); } break; case TRANSITION_TYPE_SWAP_T2B: if (step < steps / 2) { m_api->overlayImage(*dst, 0, INC(h), to); m_api->overlayImage(*dst, 0, INC(-h), from); } else { m_api->overlayImage(*dst, 0, DEC(-h), from); m_api->overlayImage(*dst, 0, DEC(h), to); } break; case TRANSITION_TYPE_SWAP_B2T: if (step < steps / 2) { m_api->overlayImage(*dst, 0, INC(-h), to); m_api->overlayImage(*dst, 0, INC(h), from); } else { m_api->overlayImage(*dst, 0, DEC(h), from); m_api->overlayImage(*dst, 0, DEC(-h), to); } break; // rolling case TRANSITION_TYPE_ROLL_L2R: if (INC(w)) m_api->scaleblitImage(*dst, 0, 0, INC(w), h, to, 0, 0, w, h); if (DEC(w)) m_api->scaleblitImage(*dst, INC(w), 0, DEC(w), h, from, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_R2L: if (DEC(w)) m_api->scaleblitImage(*dst, 0, 0, DEC(w), h, from, 0, 0, w, h); if (INC(w)) m_api->scaleblitImage(*dst, DEC(w), 0, INC(w), h, to, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_T2B: if (INC(h)) m_api->scaleblitImage(*dst, 0, 0, w, INC(h), to, 0, 0, w, h); if (DEC(h)) m_api->scaleblitImage(*dst, 0, INC(h), w, DEC(h), from, 0, 0, w, h); break; case TRANSITION_TYPE_ROLL_B2T: if (DEC(h)) m_api->scaleblitImage(*dst, 0, 0, w, DEC(h), from, 0, 0, w, h); if (INC(h)) m_api->scaleblitImage(*dst, 0, DEC(h), w, INC(h), to, 0, 0, w, h); break; // fade case TRANSITION_TYPE_FADE: default: m_api->blendImage(*dst, from, to, 1.0 / steps * step); break; } return dst; }
int write_command(int num, int adr, char* block){ if(DEBUG>10){ if(block==0) std::cout<<"DEBUG[commands.cpp] write_command("<<num<<",0,NULL)"<<std::endl; else std::cout<<"DEBUG[commands.cpp] write_command("<<num<<","<<adr<<",{"<<HEX(0xff&block[0])<<HEX(0xff&block[1])<<"...})"<<DEC()<<std::endl; } nwdat=12; // so there are no troubles sending a small packet char* command = wdat; switch(num){ case 0: command[0]=0xf0; command[1]=0xf0; command[2]=0x00; command[3]=0x00; break; case 1: command[0]=0xf1; command[1]=0xf1; command[2]=0x00; command[3]=0x00; break; case 2: command[0]=0xf2; command[1]=0xf2; command[2]=0x00; command[3]=0x00; break; case 3: // read command command[0]=0xf3; command[1]=0xf3; command[2]=adr&0x00ff; command[3]=(adr&0xff00)>>8; break; case 5: command[0]=0xf5; command[1]=0xf5; command[2]=0x00; command[3]=0x00; break; case 7: // write command command[0]=0xf7; command[1]=0xf7; command[2]=adr&0x00ff; command[3]=(adr&0xff00)>>8; memcpy((void*)&command[4], (const void*)&block[0], RAMPAGE_SIZE); // fill 4KB nwdat=4+RAMPAGE_SIZE; break; case 0xe: // send out to otmb (not used now) command[0]=0xfe; command[1]=0xfe; command[2]=adr&0x00ff; command[3]=(adr&0xff00)>>8; break; case 0xd: // send out to otmb command[0]=0xfd; command[1]=0xfd; command[2]=adr&0x00ff; command[3]=0x00; //std::cout << std::endl << "it at least does something right" << std::endl << "This is the byte num " << nwdat << std::endl; break; default: if(DEBUG>10) std::cout<<"DEBUG[commands.cpp] write_command return -1 <== command number "<<num<<" not recognized"<<std::endl; return -1; } // testing >>> //std::cout<<"TESTING: write_command return 0"<<std::endl; //return 0; // <<< testing int n=eth_write(); if(n!=nwdat){ if(DEBUG>10) std::cout<<"DEBUG[commands.cpp] write_command return -2 <== n="<<n<<" != nwdat="<<nwdat<<std::endl; return -2; } if(DEBUG>10) std::cout<<"DEBUG[commands.cpp] write_command return 0"<<std::endl; return 0; }
/*DEC A*/ static void op_0x3d(Z80EX_CONTEXT *cpu) { DEC(A); T_WAIT_UNTIL(4); return; }
void check(const char *name, check_event_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, vertpos_t rowcount, uint8_t flags) { vertpos_t l_posVert = m_posVert; horzpos_t l_posHorz = m_posHorz; uint8_t maxcol = MAXCOL(l_posVert); if (menuTab) { int cc = curr; switch (event) { case EVT_KEY_LONG(KEY_MENU): if (menuTab == menuTabModel) { killEvents(event); if (modelHasNotes()) { MENU_ADD_SD_ITEM(STR_VIEW_CHANNELS); MENU_ADD_ITEM(STR_VIEW_NOTES); menuHandler = onLongMenuPress; } else { pushMenu(menuChannelsView); } } break; case EVT_KEY_LONG(KEY_PAGE): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; killEvents(event); break; case EVT_KEY_BREAK(KEY_PAGE): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (!calibrationState && cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); } if (!(flags&CHECK_FLAG_NO_SCREEN_INDEX)) { displayScreenIndex(curr, menuTabSize, 0); } drawFilledRect(0, 0, LCD_W, MENU_HEADER_HEIGHT, SOLID, FILL_WHITE|GREY_DEFAULT); } DISPLAY_PROGRESS_BAR(menuTab ? lcdLastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); switch(event) { case EVT_ENTRY: menuEntryTime = get_tmr10ms(); l_posVert = POS_VERT_INIT; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); s_editMode = EDIT_MODE_INIT; break; case EVT_ENTRY_UP: menuEntryTime = get_tmr10ms(); s_editMode = 0; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); break; case EVT_ROTARY_BREAK: if (s_editMode > 1) break; if (m_posHorz < 0 && maxcol > 0 && READ_ONLY_UNLOCKED()) { l_posHorz = 0; break; } if (READ_ONLY_UNLOCKED()) { s_editMode = (s_editMode<=0); } break; case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; // TODO needed? we call ENTRY_UP after which does the same popMenu(); break; case EVT_KEY_BREAK(KEY_EXIT): if (s_editMode>0) { s_editMode = 0; break; } if (l_posHorz >= 0 && (COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { l_posHorz = -1; } else { uint8_t posVertInit = POS_VERT_INIT; if (s_pgOfs != 0 || l_posVert != posVertInit) { s_pgOfs = 0; l_posVert = posVertInit; l_posHorz = POS_HORZ_INIT(l_posVert); } else { popMenu(); } } break; CASE_EVT_ROTARY_MOVE_RIGHT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { INC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz < maxcol) { l_posHorz++; break; } else { l_posHorz = 0; if (!IS_ROTARY_MOVE_RIGHT(event)) break; } } do { INC(l_posVert, POS_VERT_INIT, rowcount-1); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go down, we must be in this mode l_posHorz = POS_HORZ_INIT(l_posVert); break; CASE_EVT_ROTARY_MOVE_LEFT if (s_editMode != 0) break; if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) { if (l_posHorz >= 0) { DEC(l_posHorz, 0, maxcol); break; } } else { if (l_posHorz > 0) { l_posHorz--; break; } else if (IS_ROTARY_MOVE_LEFT(event) && s_editMode == 0) { l_posHorz = 0xff; } else { l_posHorz = maxcol; break; } } do { DEC(l_posVert, POS_VERT_INIT, rowcount-1); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); s_editMode = 0; // if we go up, we must be in this mode if ((COLATTR(l_posVert) & NAVIGATION_LINE_BY_LINE)) l_posHorz = -1; else l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); break; } int linesCount = rowcount; if (l_posVert == 0 || (l_posVert==1 && MAXCOL(vertpos_t(0)) >= HIDDEN_ROW) || (l_posVert==2 && MAXCOL(vertpos_t(0)) >= HIDDEN_ROW && MAXCOL(vertpos_t(1)) >= HIDDEN_ROW)) { s_pgOfs = 0; if (horTab) { linesCount = 0; for (int i=0; i<rowcount; i++) { if (i>=horTabMax || horTab[i] != HIDDEN_ROW) { linesCount++; } } } } else if (horTab) { if (rowcount > NUM_BODY_LINES) { while (1) { vertpos_t firstLine = 0; for (int numLines=0; firstLine<rowcount && numLines<s_pgOfs; firstLine++) { if (firstLine>=horTabMax || horTab[firstLine] != HIDDEN_ROW) { numLines++; } } if (l_posVert < firstLine) { s_pgOfs--; } else { vertpos_t lastLine = firstLine; for (int numLines=0; lastLine<rowcount && numLines<NUM_BODY_LINES; lastLine++) { if (lastLine>=horTabMax || horTab[lastLine] != HIDDEN_ROW) { numLines++; } } if (l_posVert >= lastLine) { s_pgOfs++; } else { linesCount = s_pgOfs + NUM_BODY_LINES; for (int i=lastLine; i<rowcount; i++) { if (i>=horTabMax || horTab[i] != HIDDEN_ROW) { linesCount++; } } break; } } } } } else { if (l_posVert>=NUM_BODY_LINES+s_pgOfs) { s_pgOfs = l_posVert-NUM_BODY_LINES+1; } else if (l_posVert<s_pgOfs) { s_pgOfs = l_posVert; } } if (scrollbar_X && linesCount > NUM_BODY_LINES) { displayScrollbar(scrollbar_X, MENU_HEADER_HEIGHT, LCD_H-MENU_HEADER_HEIGHT, s_pgOfs, linesCount, NUM_BODY_LINES); } if (name) { title(name); } m_posVert = l_posVert; m_posHorz = l_posHorz; }
void vsyslog(int pri, char *fmt, va_list ap){ char ch, *p, *t; register int cnt; int tbuf_left, fmt_left, prlen, saved_errno; char *stdp, tbuf[TBUF_LEN], fmt_cpy[FMT_LEN]; time_t now; SOCKET sockfd; struct sockaddr_in sin; HANDLE hEventLog; /* handle to the Event Log. */ if(!pv.syslog_remote_flag) { /* Log to Event Log. */ p = tbuf; tbuf_left = TBUF_LEN; saved_errno = errno; /* * We wouldn't need this mess if printf handled %m, or if * strerror() had been invented before syslog(). */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; prlen = _snprintf(t, fmt_left, "%s", strerror(saved_errno)); if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; _vsnprintf(p, tbuf_left, fmt_cpy, ap); /* Get connected, output the message to the local logger. */ if (!opened) openlog(LogTag, LogStat, 0); hEventLog = RegisterEventSource(NULL, LogTag); if (hEventLog == NULL) return; /* Now, actually report it. */ ReportEvent( hEventLog , EVENTLOG_INFORMATION_TYPE , 0 , EVMSG_SIMPLE , NULL , 1 , 0 , (char **)&p , NULL); DeregisterEventSource(hEventLog); return; } /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog(INTERNALLOG, "syslog: unknown facility/priority: %x", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & LogMask)) return; saved_errno = errno; /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= LogFacility; /* Build the message. */ /* * Although it's tempting, we can't ignore the possibility of * overflowing the buffer when assembling the "fixed" portion * of the message. Strftime's "%h" directive expands to the * locale's abbreviated month name, but if the user has the * ability to construct to his own locale files, it may be * arbitrarily long. */ (void)time(&now); p = tbuf; tbuf_left = TBUF_LEN; #define DEC() \ do { \ if (prlen >= tbuf_left) \ prlen = tbuf_left - 1; \ p += prlen; \ tbuf_left -= prlen; \ } while (0) prlen = snprintf(p, tbuf_left, "<%d>", pri); DEC(); prlen = strftime(p, tbuf_left, "%h %e %T ", localtime(&now)); DEC(); if (LogStat & LOG_PERROR) stdp = p; if (LogTag == NULL) LogTag = VERSION; if (LogTag != NULL) { prlen = snprintf(p, tbuf_left, "%s", LogTag); DEC(); } if (LogStat & LOG_PID) { prlen = snprintf(p, tbuf_left, "[%d]", getpid()); DEC(); } if (LogTag != NULL) { if (tbuf_left > 1) { *p++ = ':'; tbuf_left--; } if (tbuf_left > 1) { *p++ = ' '; tbuf_left--; } } /* * We wouldn't need this mess if printf handled %m, or if * strerror() had been invented before syslog(). */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; prlen = snprintf(t, fmt_left, "%s", strerror(saved_errno)); if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); DEC(); cnt = p - tbuf; /* Connect to Target server. */ if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == SOCKET_ERROR){ ErrorMessage("[!] ERROR: Could not create the socket to send the syslog alert. Error Number: %d.\n", WSAGetLastError()); return; } sin.sin_port = htons((u_short)pv.syslog_server_port); sin.sin_family = AF_INET; if (!(sin.sin_addr.s_addr = resolve_host(pv.syslog_server))){ ErrorMessage("[!] ERROR: Could not resolve syslog server's hostname. Error Number: %d.\n", WSAGetLastError()); closesocket(sockfd); return; } if(sendto(sockfd,tbuf,cnt,(int)NULL, (SOCKADDR *)&sin, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) { ErrorMessage("[!] ERROR: Could not send the alert to the syslog server. Error Number: %d.\n", WSAGetLastError()); closesocket(sockfd); return; } closesocket(sockfd); }
/*DEC IXH*/ static void op_DD_0x25(Z80EX_CONTEXT *cpu) { DEC(IXH); T_WAIT_UNTIL(4); return; }
void vsyslog(int pri, char *fmt, va_list ap){ char ch, *p, *t; LPSTR lpstrings[1]; /* array of strings containing msg */ register int cnt; int tbuf_left, fmt_left, prlen, saved_errno=0; char *stdp, tbuf[TBUF_LEN], fmt_cpy[FMT_LEN]; time_t now; HANDLE hEventLog; /* handle to the Event Log. */ /* * Log to event log locally if remote syslog server * not opened or not specified */ if(strlen(ctl.syslog_server) == 0) { /* Log to Event Log. */ p = tbuf; tbuf_left = TBUF_LEN; saved_errno = errno; /* * We wouldn't need this mess if printf handled %m, or if * strerror() had been invented before syslog(). */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; prlen = _snprintf(t, fmt_left, "%s", strerror(saved_errno)); if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; _vsnprintf(p, tbuf_left, fmt_cpy, ap); /* Get connected, output the message to the local logger. */ assert(outp.syslog_open); /* * if (!opened) * openlog(LogTag, LogStat, 0); */ hEventLog = RegisterEventSource(NULL, LogTag); if (hEventLog == NULL) return; /* Now, actually report it. */ lpstrings[0] = p; ReportEvent(hEventLog, EVENTLOG_INFORMATION_TYPE, 0, MSG, NULL, 1, 0, (LPCTSTR *)lpstrings, NULL); DeregisterEventSource(hEventLog); return; } /* * Else log to remote syslog server */ /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog(INTERNALLOG, "syslog: unknown facility/priority: %x", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & LogMask)) return; saved_errno = errno; /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= LogFacility; /* Build the message. */ /* * Although it's tempting, we can't ignore the possibility of * overflowing the buffer when assembling the "fixed" portion * of the message. Strftime's "%h" directive expands to the * locale's abbreviated month name, but if the user has the * ability to construct to his own locale files, it may be * arbitrarily long. */ (void)time(&now); p = tbuf; tbuf_left = TBUF_LEN; #define DEC() \ do { \ if (prlen >= tbuf_left) \ prlen = tbuf_left - 1; \ p += prlen; \ tbuf_left -= prlen; \ } while (0) prlen = _snprintf(p, tbuf_left, "<%d>", pri); DEC(); prlen = strftime(p, tbuf_left, "%h %e %T ", localtime(&now)); DEC(); if (LogStat & LOG_PERROR) stdp = p; /* if (LogTag == NULL) LogTag = 0; //VERSION zappe a 0 L Gordon 2002-11-13 */ if (LogTag != NULL) { prlen = _snprintf(p, tbuf_left, "%s", LogTag); DEC(); } if (LogStat & LOG_PID) { prlen = _snprintf(p, tbuf_left, "[%d]", _getpid()); DEC(); } if (LogTag != NULL) { if (tbuf_left > 1) { *p++ = ':'; tbuf_left--; } if (tbuf_left > 1) { *p++ = ' '; tbuf_left--; } } /* * We wouldn't need this mess if printf handled %m, or if * strerror() had been invented before syslog(). */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; prlen = _snprintf(t, fmt_left, "%s", strerror(saved_errno)); if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); DEC(); cnt = p - tbuf; if(sendto(sockfd,tbuf,cnt,(int)NULL, (SOCKADDR *)&sin, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) { warnx("*** Could not send the alert to the syslog server. Error Number: %d.\n", WSAGetLastError()); closesocket(sockfd); return; } }
static GstFlowReturn gst_tta_dec_chain (GstPad * pad, GstBuffer * in) { GstTtaDec *ttadec; GstBuffer *outbuf, *buf = GST_BUFFER (in); guchar *data, *p; decoder *dec; unsigned long outsize; unsigned long size; guint32 frame_samples; long res; long *prev; ttadec = GST_TTA_DEC (GST_OBJECT_PARENT (pad)); data = GST_BUFFER_DATA (buf); size = GST_BUFFER_SIZE (buf); ttadec->tta_buf.bit_count = 0; ttadec->tta_buf.bit_cache = 0; ttadec->tta_buf.bitpos = ttadec->tta_buf.buffer_end; ttadec->tta_buf.offset = 0; decoder_init (ttadec->tta, ttadec->channels, ttadec->bytes); if (GST_BUFFER_DURATION_IS_VALID (buf)) { frame_samples = ceil ((gdouble) (GST_BUFFER_DURATION (buf) * ttadec->samplerate) / (gdouble) GST_SECOND); } else { frame_samples = ttadec->samplerate * FRAME_TIME; } outsize = ttadec->channels * frame_samples * ttadec->bytes; dec = ttadec->tta; p = ttadec->decdata; prev = ttadec->cache; for (res = 0; p < ttadec->decdata + frame_samples * ttadec->channels * ttadec->bytes;) { unsigned long unary, binary, depth, k; long value, temp_value; fltst *fst = &dec->fst; adapt *rice = &dec->rice; long *last = &dec->last; // decode Rice unsigned get_unary (&ttadec->tta_buf, data, size, &unary); switch (unary) { case 0: depth = 0; k = rice->k0; break; default: depth = 1; k = rice->k1; unary--; } if (k) { get_binary (&ttadec->tta_buf, data, size, &binary, k); value = (unary << k) + binary; } else value = unary; switch (depth) { case 1: rice->sum1 += value - (rice->sum1 >> 4); if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1]) rice->k1--; else if (rice->sum1 > shift_16[rice->k1 + 1]) rice->k1++; value += bit_shift[rice->k0]; default: rice->sum0 += value - (rice->sum0 >> 4); if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0]) rice->k0--; else if (rice->sum0 > shift_16[rice->k0 + 1]) rice->k0++; } /* this only uses a temporary variable to silence a gcc warning */ temp_value = DEC (value); value = temp_value; // decompress stage 1: adaptive hybrid filter hybrid_filter (fst, &value); // decompress stage 2: fixed order 1 prediction switch (ttadec->bytes) { case 1: value += PREDICTOR1 (*last, 4); break; // bps 8 case 2: value += PREDICTOR1 (*last, 5); break; // bps 16 case 3: value += PREDICTOR1 (*last, 5); break; // bps 24 case 4: value += *last; break; // bps 32 } *last = value; if (dec < ttadec->tta + ttadec->channels - 1) { *prev++ = value; dec++; } else { *prev = value; if (ttadec->channels > 1) { long *r = prev - 1; for (*prev += *r / 2; r >= ttadec->cache; r--) *r = *(r + 1) - *r; for (r = ttadec->cache; r < prev; r++) WRITE_BUFFER (r, ttadec->bytes, p); } WRITE_BUFFER (prev, ttadec->bytes, p); prev = ttadec->cache; res++; dec = ttadec->tta; } } outbuf = gst_buffer_new_and_alloc (outsize); memcpy (GST_BUFFER_DATA (outbuf), ttadec->decdata, outsize); GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf); GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf); gst_buffer_set_caps (outbuf, GST_PAD_CAPS (ttadec->srcpad)); return gst_pad_push (ttadec->srcpad, outbuf); }
int cpu::cpu_emulate(int ciclos){ UINT8 op,b,cbop; UINT32 i; UINT32 clen = 10; UINT16 w; static cpuReg acc; i = ciclos; //next: while((!CPU->IME) && i > 0){ mt.lock(); op = FETCH; ciclos = cycles_table[op]; switch(op) { case 0x00: /* NOP */ case 0x40: /* LD B,B */ case 0x49: /* LD C,C */ case 0x52: /* LD D,D */ case 0x5B: /* LD E,E */ case 0x64: /* LD H,H */ case 0x6D: /* LD L,L */ case 0x7F: /* LD A,A */ break; case 0x41: /* LD B,C */ B = C; break; case 0x42: /* LD B,D */ B = D; break; case 0x43: /* LD B,E */ B = E; break; case 0x44: /* LD B,H */ B = H; break; case 0x45: /* LD B,L */ B = L; break; case 0x46: /* LD B,(HL) */ B = memoria::readByte(xHL); break; case 0x47: /* LD B,A */ B = A; break; case 0x48: /* LD C,B */ C = B; break; case 0x4A: /* LD C,D */ C = D; break; case 0x4B: /* LD C,E */ C = E; break; case 0x4C: /* LD C,H */ C = H; break; case 0x4D: /* LD C,L */ C = L; break; case 0x4E: /* LD C,(HL) */ C = memoria::readByte(xHL); break; case 0x4F: /* LD C,A */ C = A; break; case 0x50: /* LD D,B */ D = B; break; case 0x51: /* LD D,C */ D = C; break; case 0x53: /* LD D,E */ D = E; break; case 0x54: /* LD D,H */ D = H; break; case 0x55: /* LD D,L */ D = L; break; case 0x56: /* LD D,(HL) */ D = memoria::readByte(xHL); break; case 0x57: /* LD D,A */ D = A; break; case 0x58: /* LD E,B */ E = B; break; case 0x59: /* LD E,C */ E = C; break; case 0x5A: /* LD E,D */ E = D; break; case 0x5C: /* LD E,H */ E = H; break; case 0x5D: /* LD E,L */ E = L; break; case 0x5E: /* LD E,(HL) */ E = memoria::readByte(xHL); break; case 0x5F: /* LD E,A */ E = A; break; case 0x60: /* LD H,B */ H = B; break; case 0x61: /* LD H,C */ H = C; break; case 0x62: /* LD H,D */ H = D; break; case 0x63: /* LD H,E */ H = E; break; case 0x65: /* LD H,L */ H = L; break; case 0x66: /* LD H,(HL) */ H = memoria::readByte(xHL); break; case 0x67: /* LD H,A */ H = A; break; case 0x68: /* LD L,B */ L = B; break; case 0x69: /* LD L,C */ L = C; break; case 0x6A: /* LD L,D */ L = D; break; case 0x6B: /* LD L,E */ L = E; break; case 0x6C: /* LD L,H */ L = H; break; case 0x6E: /* LD L,(HL) */ L = memoria::readByte(xHL); break; case 0x6F: /* LD L,A */ L = A; break; case 0x70: /* LD (HL),B */ b = B; goto __LD_HL; case 0x71: /* LD (HL),C */ b = C; goto __LD_HL; case 0x72: /* LD (HL),D */ b = D; goto __LD_HL; case 0x73: /* LD (HL),E */ b = E; goto __LD_HL; case 0x74: /* LD (HL),H */ b = H; goto __LD_HL; case 0x75: /* LD (HL),L */ b = L; goto __LD_HL; case 0x77: /* LD (HL),A */ b = A; __LD_HL: memoria::writeByte(xHL,b); break; case 0x78: /* LD A,B */ A = B; break; case 0x79: /* LD A,C */ A = C; break; case 0x7A: /* LD A,D */ A = D; break; case 0x7B: /* LD A,E */ A = E; break; case 0x7C: /* LD A,H */ A = H; break; case 0x7D: /* LD A,L */ A = L; break; case 0x7E: /* LD A,(HL) */ A = memoria::readByte(xHL); break; case 0x01: /* LD BC,imm */ CPU->BC.w = memoria::readWord(xPC); CPU->PC += 2; break; case 0x11: /* LD DE,imm */ CPU->DE.w = memoria::readWord(xPC); CPU->PC += 2; break; case 0x21: /* LD HL,imm */ CPU->HL.w = memoria::readWord(xPC); CPU->PC += 2; break; case 0x31: /* LD SP,imm */ CPU->SP = memoria::readWord(xPC); CPU->PC += 2; break; case 0x02: /* LD (BC),A */ memoria::writeByte(CPU->BC.w, A); break; case 0x0A: /* LD A,(BC) */ A = memoria::readByte(CPU->BC.w); break; case 0x12: /* LD (DE),A */ memoria::writeByte(CPU->BC.w, A); break; case 0x1A: /* LD A,(DE) */ A = memoria::readByte(CPU->DE.w); break; case 0x22: /* LDI (HL),A */ memoria::writeByte(xHL, A); CPU->HL.w++; break; case 0x2A: /* LDI A,(HL) */ A = memoria::readByte(xHL); CPU->HL.w++; break; case 0x32: /* LDD (HL),A */ memoria::writeByte(xHL, A); CPU->HL.w--; break; case 0x3A: /* LDD A,(HL) */ A = memoria::readByte(xHL); CPU->HL.w--; break; case 0x06: /* LD B,imm */ B = FETCH; break; case 0x0E: /* LD C,imm */ C = FETCH; break; case 0x16: /* LD D,imm */ D = FETCH; break; case 0x1E: /* LD E,imm */ E = FETCH; break; case 0x26: /* LD H,imm */ H = FETCH; break; case 0x2E: /* LD L,imm */ L = FETCH; break; case 0x36: /* LD (HL),imm */ b = FETCH; memoria::writeByte(xHL, b); break; case 0x3E: /* LD A,imm */ A = FETCH; break; case 0x08: /* LD (imm),CPU->SP */ memoria::writeWord(memoria::readWord(xPC), CPU->SP); CPU->PC += 2; break; case 0xEA: /* LD (imm),A */ memoria::writeByte(memoria::readWord(xPC), A); CPU->PC += 2; break; case 0xF8: /* LD HL,CPU->SP+imm */ b = FETCH; LDHLSP(b); break; case 0xF9: /* LD CPU->SP,HL */ CPU->SP = CPU->HL.w; break; case 0xFA: /* LD A,(imm) */ A = memoria::readByte(memoria::readWord(xPC)); CPU->PC += 2; break; ALU_CASES(0x80, 0xC6, ADD, __ADD) ALU_CASES(0x88, 0xCE, ADC, __ADC) ALU_CASES(0x90, 0xD6, SUB, __SUB) ALU_CASES(0x98, 0xDE, SBC, __SBC) ALU_CASES(0xA0, 0xE6, AND, __AND) ALU_CASES(0xA8, 0xEE, XOR, __XOR) ALU_CASES(0xB0, 0xF6, OR, __OR) ALU_CASES(0xB8, 0xFE, CP, __CP) case 0x09: /* ADD HL,BC */ w = CPU->BC.w; goto __ADDW; case 0x19: /* ADD HL,DE */ w = CPU->DE.w; goto __ADDW; case 0x39: /* ADD HL,CPU->SP */ w = CPU->SP; goto __ADDW; case 0x29: /* ADD HL,HL */ w = CPU->HL.w; __ADDW: ADDW(w); break; case 0x04: /* INC B */ INC(B); break; case 0x0C: /* INC C */ INC(C); break; case 0x14: /* INC D */ INC(D); break; case 0x1C: /* INC E */ INC(E); break; case 0x24: /* INC H */ INC(H); break; case 0x2C: /* INC L */ INC(L); break; case 0x34: /* INC (HL) */ b = memoria::readByte(xHL); INC(b); memoria::writeByte(xHL, b); break; case 0x3C: /* INC A */ INC(A); break; case 0x03: /* INC BC */ INCW(CPU->BC.w); break; case 0x13: /* INC DE */ INCW(CPU->DE.w); break; case 0x23: /* INC HL */ INCW(CPU->HL.w); break; case 0x33: /* INC CPU->SP */ INCW(CPU->SP); break; case 0x05: /* DEC B */ DEC(B); break; case 0x0D: /* DEC C */ DEC(C); break; case 0x15: /* DEC D */ DEC(D); break; case 0x1D: /* DEC E */ DEC(E); break; case 0x25: /* DEC H */ DEC(H); break; case 0x2D: /* DEC L */ DEC(L); break; case 0x35: /* DEC (HL) */ b = memoria::readByte(xHL); DEC(b); memoria::writeByte(xHL, b); break; case 0x3D: /* DEC A */ DEC(A); break; case 0x0B: /* DEC BC */ DECW(CPU->BC.w); break; case 0x1B: /* DEC DE */ DECW(CPU->DE.w); break; case 0x2B: /* DEC HL */ DECW(CPU->HL.w); break; case 0x3B: /* DEC CPU->SP */ DECW(CPU->SP); break; case 0x07: /* RLCA */ RLCA(A); break; case 0x0F: /* RRCA */ RRCA(A); break; case 0x17: /* RLA */ RLA(A); break; case 0x1F: /* RRA */ RRA(A); break; case 0x27: /* DAA */ DAA; break; case 0x2F: /* CPL */ CPL(A); break; case 0x18: /* JR */ __JR: JR; break; case 0x20: /* JR NZ */ if (!(F&FZ)) goto __JR; NOJR; break; case 0x28: /* JR Z */ if (F&FZ) goto __JR; NOJR; break; case 0x30: /* JR NC */ if (!(F&FC)) goto __JR; NOJR; break; case 0x38: /* JR C */ if (F&FC) goto __JR; NOJR; break; case 0xC3: /* JP */ __JP: JP; break; case 0xC2: /* JP NZ */ if (!(F&FZ)) goto __JP; NOJP; break; case 0xCA: /* JP Z */ if (F&FZ) goto __JP; NOJP; break; case 0xD2: /* JP NC */ if (!(F&FC)) goto __JP; NOJP; break; case 0xDA: /* JP C */ if (F&FC) goto __JP; NOJP; break; case 0xE9: /* JP HL */ CPU->PC = CPU->HL.w; break; case 0xC9: /* RET */ __RET: RET; break; case 0xC0: /* RET NZ */ if (!(F&FZ)) goto __RET; NORET; break; case 0xC8: /* RET Z */ if (F&FZ) goto __RET; NORET; break; case 0xD0: /* RET NC */ if (!(F&FC)) goto __RET; NORET; break; case 0xD8: /* RET C */ if (F&FC) goto __RET; NORET; break; case 0xD9: /* RETI */ CPU->IME = CPU->IMA = 1; goto __RET; case 0xCD: /* CALL */ __CALL: CALL; break; case 0xC4: /* CALL NZ */ if (!(F&FZ)) goto __CALL; NOCALL; break; case 0xCC: /* CALL Z */ if (F&FZ) goto __CALL; NOCALL; break; case 0xD4: /* CALL NC */ if (!(F&FC)) goto __CALL; NOCALL; break; case 0xDC: /* CALL C */ if (F&FC) goto __CALL; NOCALL; break; case 0xC7: /* RST 0 */ b = 0x00; goto __RST; case 0xCF: /* RST 8 */ b = 0x08; goto __RST; case 0xD7: /* RST 10 */ b = 0x10; goto __RST; case 0xDF: /* RST 18 */ b = 0x18; goto __RST; case 0xE7: /* RST 20 */ b = 0x20; goto __RST; case 0xEF: /* RST 28 */ b = 0x28; goto __RST; case 0xF7: /* RST 30 */ b = 0x30; goto __RST; case 0xFF: /* RST 38 */ b = 0x38; __RST: RST(b); break; case 0xC1: /* POP BC */ POP(CPU->BC.w); break; case 0xC5: /* PUSH BC */ PUSH(CPU->BC.w); break; case 0xD1: /* POP DE */ POP(CPU->DE.w); break; case 0xD5: /* PUSH DE */ PUSH(CPU->DE.w); break; case 0xE1: /* POP HL */ POP(CPU->HL.w); break; case 0xE5: /* PUSH HL */ PUSH(CPU->HL.w); break; case 0xF1: /* POP AF */ POP(CPU->AF.w); break; case 0xF5: /* PUSH AF */ PUSH(CPU->AF.w); break; case 0xE8: /* ADD CPU->SP,imm */ b = FETCH; ADDSP(b); break; case 0xF3: /* DI */ DI; break; case 0xFB: /* EI */ EI; break; case 0x37: /* SCF */ SCF; break; case 0x3F: /* CCF */ CCF; break; case 0x10: /* STOP */ break; //to do// case 0x76: /* HALT */ CPU->halt = 1; break; case 0xCB: /* CB prefix */ cbop = FETCH; clen = cb_cycles_table[cbop]; switch (cbop) { CB_REG_CASES(B, 0); CB_REG_CASES(C, 1); CB_REG_CASES(D, 2); CB_REG_CASES(E, 3); CB_REG_CASES(H, 4); CB_REG_CASES(L, 5); CB_REG_CASES(A, 7); default: b = memoria::readByte(xHL); switch(cbop) { CB_REG_CASES(b, 6); } if ((cbop & 0xC0) != 0x40) /* exclude BIT */ memoria::writeByte(xHL, b); break; } break; default: printf("erro"); break; } clen <<= 1; i -= clen; emit onEndProcess((UINT32)op); mt.unlock(); //msleep(600); } //if(i >0) goto next; wt.wait(&mt); return ciclos-i; }
// // 柦椷幚峴 // INT CPU::EXEC( INT request_cycles ) { BYTE opcode; // 僆儁僐乕僪 INT OLD_cycles = TOTAL_cycles; INT exec_cycles; BYTE nmi_request, irq_request; BOOL bClockProcess = m_bClockProcess; // TEMP register WORD EA; register WORD ET; register WORD WT; register BYTE DT; while( request_cycles > 0 ) { exec_cycles = 0; if( DMA_cycles ) { if( request_cycles <= DMA_cycles ) { DMA_cycles -= request_cycles; TOTAL_cycles += request_cycles; // 僋儘僢僋摨婜張棟 mapper->Clock( request_cycles ); #if DPCM_SYNCCLOCK apu->SyncDPCM( request_cycles ); #endif if( bClockProcess ) { nes->Clock( request_cycles ); } // nes->Clock( request_cycles ); goto _execute_exit; } else { exec_cycles += DMA_cycles; // request_cycles -= DMA_cycles; DMA_cycles = 0; } } nmi_request = irq_request = 0; opcode = OP6502( R.PC++ ); if( R.INT_pending ) { if( R.INT_pending & NMI_FLAG ) { nmi_request = 0xFF; R.INT_pending &= ~NMI_FLAG; } else if( R.INT_pending & IRQ_MASK ) { R.INT_pending &= ~IRQ_TRIGGER2; if( !(R.P & I_FLAG) && opcode != 0x40 ) { irq_request = 0xFF; R.INT_pending &= ~IRQ_TRIGGER; } } } //增加指令预测忽略功能 //opcode BYTE iInstructionLen =1; switch (TraceAddrMode[opcode]) { case IND: case ADR: case ABS: case ABX: case ABY: iInstructionLen = 3; break; case IMM: case ZPG: case ZPX: case ZPY: case INX: case INY: iInstructionLen = 2; break; case IMP:case ACC:case ERR: break; case REL:iInstructionLen = 2;break; } if( ((TraceArr[opcode][0]=='*') || (TraceArr[opcode][1]=='?'))&& (!Config.emulator.bIllegalOp) ) { //这里可以优化输出信息 //char str[111]; //DecodeInstruction (R.PC-1, str); //DEBUGOUT( "Bad Instruction:%s\n",str); R.PC=(R.PC-1)+iInstructionLen; ADD_CYCLE(iInstructionLen*2); goto end_is; } // switch( opcode ) { case 0x69: // ADC #$?? MR_IM(); ADC(); ADD_CYCLE(2); break; case 0x65: // ADC $?? MR_ZP(); ADC(); ADD_CYCLE(3); break; case 0x75: // ADC $??,X MR_ZX(); ADC(); ADD_CYCLE(4); break; case 0x6D: // ADC $???? MR_AB(); ADC(); ADD_CYCLE(4); break; case 0x7D: // ADC $????,X MR_AX(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0x79: // ADC $????,Y MR_AY(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0x61: // ADC ($??,X) MR_IX(); ADC(); ADD_CYCLE(6); break; case 0x71: // ADC ($??),Y MR_IY(); ADC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xE9: // SBC #$?? MR_IM(); SBC(); ADD_CYCLE(2); break; case 0xE5: // SBC $?? MR_ZP(); SBC(); ADD_CYCLE(3); break; case 0xF5: // SBC $??,X MR_ZX(); SBC(); ADD_CYCLE(4); break; case 0xED: // SBC $???? MR_AB(); SBC(); ADD_CYCLE(4); break; case 0xFD: // SBC $????,X MR_AX(); SBC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xF9: // SBC $????,Y MR_AY(); SBC(); CHECK_EA(); ADD_CYCLE(4); break; case 0xE1: // SBC ($??,X) MR_IX(); SBC(); ADD_CYCLE(6); break; case 0xF1: // SBC ($??),Y MR_IY(); SBC(); CHECK_EA(); ADD_CYCLE(5); break; case 0xC6: // DEC $?? MR_ZP(); DEC(); MW_ZP(); ADD_CYCLE(5); break; case 0xD6: // DEC $??,X MR_ZX(); DEC(); MW_ZP(); ADD_CYCLE(6); break; case 0xCE: // DEC $???? MR_AB(); DEC(); MW_EA(); ADD_CYCLE(6); break; case 0xDE: // DEC $????,X MR_AX(); DEC(); MW_EA(); ADD_CYCLE(7); break; case 0xCA: // DEX DEX(); ADD_CYCLE(2); break; case 0x88: // DEY DEY(); ADD_CYCLE(2); break; case 0xE6: // INC $?? MR_ZP(); INC(); MW_ZP(); ADD_CYCLE(5); break; case 0xF6: // INC $??,X MR_ZX(); INC(); MW_ZP(); ADD_CYCLE(6); break; case 0xEE: // INC $???? MR_AB(); INC(); MW_EA(); ADD_CYCLE(6); break; case 0xFE: // INC $????,X MR_AX(); INC(); MW_EA(); ADD_CYCLE(7); break; case 0xE8: // INX INX(); ADD_CYCLE(2); break; case 0xC8: // INY INY(); ADD_CYCLE(2); break; case 0x29: // AND #$?? MR_IM(); AND(); ADD_CYCLE(2); break; case 0x25: // AND $?? MR_ZP(); AND(); ADD_CYCLE(3); break; case 0x35: // AND $??,X MR_ZX(); AND(); ADD_CYCLE(4); break; case 0x2D: // AND $???? MR_AB(); AND(); ADD_CYCLE(4); break; case 0x3D: // AND $????,X MR_AX(); AND(); CHECK_EA(); ADD_CYCLE(4); break; case 0x39: // AND $????,Y MR_AY(); AND(); CHECK_EA(); ADD_CYCLE(4); break; case 0x21: // AND ($??,X) MR_IX(); AND(); ADD_CYCLE(6); break; case 0x31: // AND ($??),Y MR_IY(); AND(); CHECK_EA(); ADD_CYCLE(5); break; case 0x0A: // ASL A ASL_A(); ADD_CYCLE(2); break; case 0x06: // ASL $?? MR_ZP(); ASL(); MW_ZP(); ADD_CYCLE(5); break; case 0x16: // ASL $??,X MR_ZX(); ASL(); MW_ZP(); ADD_CYCLE(6); break; case 0x0E: // ASL $???? MR_AB(); ASL(); MW_EA(); ADD_CYCLE(6); break; case 0x1E: // ASL $????,X MR_AX(); ASL(); MW_EA(); ADD_CYCLE(7); break; case 0x24: // BIT $?? MR_ZP(); BIT(); ADD_CYCLE(3); break; case 0x2C: // BIT $???? MR_AB(); BIT(); ADD_CYCLE(4); break; case 0x49: // EOR #$?? MR_IM(); EOR(); ADD_CYCLE(2); break; case 0x45: // EOR $?? MR_ZP(); EOR(); ADD_CYCLE(3); break; case 0x55: // EOR $??,X MR_ZX(); EOR(); ADD_CYCLE(4); break; case 0x4D: // EOR $???? MR_AB(); EOR(); ADD_CYCLE(4); break; case 0x5D: // EOR $????,X MR_AX(); EOR(); CHECK_EA(); ADD_CYCLE(4); break; case 0x59: // EOR $????,Y MR_AY(); EOR(); CHECK_EA(); ADD_CYCLE(4); break; case 0x41: // EOR ($??,X) MR_IX(); EOR(); ADD_CYCLE(6); break; case 0x51: // EOR ($??),Y MR_IY(); EOR(); CHECK_EA(); ADD_CYCLE(5); break; case 0x4A: // LSR A LSR_A(); ADD_CYCLE(2); break; case 0x46: // LSR $?? MR_ZP(); LSR(); MW_ZP(); ADD_CYCLE(5); break; case 0x56: // LSR $??,X MR_ZX(); LSR(); MW_ZP(); ADD_CYCLE(6); break; case 0x4E: // LSR $???? MR_AB(); LSR(); MW_EA(); ADD_CYCLE(6); break; case 0x5E: // LSR $????,X MR_AX(); LSR(); MW_EA(); ADD_CYCLE(7); break; case 0x09: // ORA #$?? MR_IM(); ORA(); ADD_CYCLE(2); break; case 0x05: // ORA $?? MR_ZP(); ORA(); ADD_CYCLE(3); break; case 0x15: // ORA $??,X MR_ZX(); ORA(); ADD_CYCLE(4); break; case 0x0D: // ORA $???? MR_AB(); ORA(); ADD_CYCLE(4); break; case 0x1D: // ORA $????,X MR_AX(); ORA(); CHECK_EA(); ADD_CYCLE(4); break; case 0x19: // ORA $????,Y MR_AY(); ORA(); CHECK_EA(); ADD_CYCLE(4); break; case 0x01: // ORA ($??,X) MR_IX(); ORA(); ADD_CYCLE(6); break; case 0x11: // ORA ($??),Y MR_IY(); ORA(); CHECK_EA(); ADD_CYCLE(5); break; case 0x2A: // ROL A ROL_A(); ADD_CYCLE(2); break; case 0x26: // ROL $?? MR_ZP(); ROL(); MW_ZP(); ADD_CYCLE(5); break; case 0x36: // ROL $??,X MR_ZX(); ROL(); MW_ZP(); ADD_CYCLE(6); break; case 0x2E: // ROL $???? MR_AB(); ROL(); MW_EA(); ADD_CYCLE(6); break; case 0x3E: // ROL $????,X MR_AX(); ROL(); MW_EA(); ADD_CYCLE(7); break; case 0x6A: // ROR A ROR_A(); ADD_CYCLE(2); break; case 0x66: // ROR $?? MR_ZP(); ROR(); MW_ZP(); ADD_CYCLE(5); break; case 0x76: // ROR $??,X MR_ZX(); ROR(); MW_ZP(); ADD_CYCLE(6); break; case 0x6E: // ROR $???? MR_AB(); ROR(); MW_EA(); ADD_CYCLE(6); break; case 0x7E: // ROR $????,X MR_AX(); ROR(); MW_EA(); ADD_CYCLE(7); break; case 0xA9: // LDA #$?? MR_IM(); LDA(); ADD_CYCLE(2); break; case 0xA5: // LDA $?? MR_ZP(); LDA(); ADD_CYCLE(3); break; case 0xB5: // LDA $??,X MR_ZX(); LDA(); ADD_CYCLE(4); break; case 0xAD: // LDA $???? MR_AB(); LDA(); ADD_CYCLE(4); break; case 0xBD: // LDA $????,X MR_AX(); LDA(); CHECK_EA(); ADD_CYCLE(4); break; case 0xB9: // LDA $????,Y MR_AY(); LDA(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA1: // LDA ($??,X) MR_IX(); LDA(); ADD_CYCLE(6); break; case 0xB1: // LDA ($??),Y MR_IY(); LDA(); CHECK_EA(); ADD_CYCLE(5); break; case 0xA2: // LDX #$?? MR_IM(); LDX(); ADD_CYCLE(2); break; case 0xA6: // LDX $?? MR_ZP(); LDX(); ADD_CYCLE(3); break; case 0xB6: // LDX $??,Y MR_ZY(); LDX(); ADD_CYCLE(4); break; case 0xAE: // LDX $???? MR_AB(); LDX(); ADD_CYCLE(4); break; case 0xBE: // LDX $????,Y MR_AY(); LDX(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA0: // LDY #$?? MR_IM(); LDY(); ADD_CYCLE(2); break; case 0xA4: // LDY $?? MR_ZP(); LDY(); ADD_CYCLE(3); break; case 0xB4: // LDY $??,X MR_ZX(); LDY(); ADD_CYCLE(4); break; case 0xAC: // LDY $???? MR_AB(); LDY(); ADD_CYCLE(4); break; case 0xBC: // LDY $????,X MR_AX(); LDY(); CHECK_EA(); ADD_CYCLE(4); break; case 0x85: // STA $?? EA_ZP(); STA(); MW_ZP(); ADD_CYCLE(3); break; case 0x95: // STA $??,X EA_ZX(); STA(); MW_ZP(); ADD_CYCLE(4); break; case 0x8D: // STA $???? EA_AB(); STA(); MW_EA(); ADD_CYCLE(4); break; case 0x9D: // STA $????,X EA_AX(); STA(); MW_EA(); ADD_CYCLE(5); break; case 0x99: // STA $????,Y EA_AY(); STA(); MW_EA(); ADD_CYCLE(5); break; case 0x81: // STA ($??,X) EA_IX(); STA(); MW_EA(); ADD_CYCLE(6); break; case 0x91: // STA ($??),Y EA_IY(); STA(); MW_EA(); ADD_CYCLE(6); break; case 0x86: // STX $?? EA_ZP(); STX(); MW_ZP(); ADD_CYCLE(3); break; case 0x96: // STX $??,Y EA_ZY(); STX(); MW_ZP(); ADD_CYCLE(4); break; case 0x8E: // STX $???? EA_AB(); STX(); MW_EA(); ADD_CYCLE(4); break; case 0x84: // STY $?? EA_ZP(); STY(); MW_ZP(); ADD_CYCLE(3); break; case 0x94: // STY $??,X EA_ZX(); STY(); MW_ZP(); ADD_CYCLE(4); break; case 0x8C: // STY $???? EA_AB(); STY(); MW_EA(); ADD_CYCLE(4); break; case 0xAA: // TAX TAX(); ADD_CYCLE(2); break; case 0x8A: // TXA TXA(); ADD_CYCLE(2); break; case 0xA8: // TAY TAY(); ADD_CYCLE(2); break; case 0x98: // TYA TYA(); ADD_CYCLE(2); break; case 0xBA: // TSX TSX(); ADD_CYCLE(2); break; case 0x9A: // TXS TXS(); ADD_CYCLE(2); break; case 0xC9: // CMP #$?? MR_IM(); CMP_(); ADD_CYCLE(2); break; case 0xC5: // CMP $?? MR_ZP(); CMP_(); ADD_CYCLE(3); break; case 0xD5: // CMP $??,X MR_ZX(); CMP_(); ADD_CYCLE(4); break; case 0xCD: // CMP $???? MR_AB(); CMP_(); ADD_CYCLE(4); break; case 0xDD: // CMP $????,X MR_AX(); CMP_(); CHECK_EA(); ADD_CYCLE(4); break; case 0xD9: // CMP $????,Y MR_AY(); CMP_(); CHECK_EA(); ADD_CYCLE(4); break; case 0xC1: // CMP ($??,X) MR_IX(); CMP_(); ADD_CYCLE(6); break; case 0xD1: // CMP ($??),Y MR_IY(); CMP_(); CHECK_EA(); ADD_CYCLE(5); break; case 0xE0: // CPX #$?? MR_IM(); CPX(); ADD_CYCLE(2); break; case 0xE4: // CPX $?? MR_ZP(); CPX(); ADD_CYCLE(3); break; case 0xEC: // CPX $???? MR_AB(); CPX(); ADD_CYCLE(4); break; case 0xC0: // CPY #$?? MR_IM(); CPY(); ADD_CYCLE(2); break; case 0xC4: // CPY $?? MR_ZP(); CPY(); ADD_CYCLE(3); break; case 0xCC: // CPY $???? MR_AB(); CPY(); ADD_CYCLE(4); break; case 0x90: // BCC MR_IM(); BCC(); ADD_CYCLE(2); break; case 0xB0: // BCS MR_IM(); BCS(); ADD_CYCLE(2); break; case 0xF0: // BEQ MR_IM(); BEQ(); ADD_CYCLE(2); break; case 0x30: // BMI MR_IM(); BMI(); ADD_CYCLE(2); break; case 0xD0: // BNE MR_IM(); BNE(); ADD_CYCLE(2); break; case 0x10: // BPL MR_IM(); BPL(); ADD_CYCLE(2); break; case 0x50: // BVC MR_IM(); BVC(); ADD_CYCLE(2); break; case 0x70: // BVS MR_IM(); BVS(); ADD_CYCLE(2); break; case 0x4C: // JMP $???? JMP(); ADD_CYCLE(3); break; case 0x6C: // JMP ($????) JMP_ID(); ADD_CYCLE(5); break; case 0x20: // JSR JSR(); ADD_CYCLE(6); break; case 0x40: // RTI RTI(); ADD_CYCLE(6); break; case 0x60: // RTS RTS(); ADD_CYCLE(6); break; // 僼儔僌惂屼宯 case 0x18: // CLC CLC(); ADD_CYCLE(2); break; case 0xD8: // CLD CLD(); ADD_CYCLE(2); break; case 0x58: // CLI CLI(); ADD_CYCLE(2); break; case 0xB8: // CLV CLV(); ADD_CYCLE(2); break; case 0x38: // SEC SEC(); ADD_CYCLE(2); break; case 0xF8: // SED SED(); ADD_CYCLE(2); break; case 0x78: // SEI SEI(); ADD_CYCLE(2); break; // 僗僞僢僋宯 case 0x48: // PHA PUSH( R.A ); ADD_CYCLE(3); break; case 0x08: // PHP PUSH( R.P | B_FLAG ); ADD_CYCLE(3); break; case 0x68: // PLA (N-----Z-) R.A = POP(); SET_ZN_FLAG(R.A); ADD_CYCLE(4); break; case 0x28: // PLP R.P = POP() | R_FLAG; ADD_CYCLE(4); break; // 偦偺懠 case 0x00: // BRK BRK(); ADD_CYCLE(7); break; case 0xEA: // NOP ADD_CYCLE(2); break; // 枹岞奐柦椷孮 case 0x0B: // ANC #$?? case 0x2B: // ANC #$?? MR_IM(); ANC(); ADD_CYCLE(2); break; case 0x8B: // ANE #$?? MR_IM(); ANE(); ADD_CYCLE(2); break; case 0x6B: // ARR #$?? MR_IM(); ARR(); ADD_CYCLE(2); break; case 0x4B: // ASR #$?? MR_IM(); ASR(); ADD_CYCLE(2); break; case 0xC7: // DCP $?? MR_ZP(); DCP(); MW_ZP(); ADD_CYCLE(5); break; case 0xD7: // DCP $??,X MR_ZX(); DCP(); MW_ZP(); ADD_CYCLE(6); break; case 0xCF: // DCP $???? MR_AB(); DCP(); MW_EA(); ADD_CYCLE(6); break; case 0xDF: // DCP $????,X MR_AX(); DCP(); MW_EA(); ADD_CYCLE(7); break; case 0xDB: // DCP $????,Y MR_AY(); DCP(); MW_EA(); ADD_CYCLE(7); break; case 0xC3: // DCP ($??,X) MR_IX(); DCP(); MW_EA(); ADD_CYCLE(8); break; case 0xD3: // DCP ($??),Y MR_IY(); DCP(); MW_EA(); ADD_CYCLE(8); break; case 0xE7: // ISB $?? MR_ZP(); ISB(); MW_ZP(); ADD_CYCLE(5); break; case 0xF7: // ISB $??,X MR_ZX(); ISB(); MW_ZP(); ADD_CYCLE(5); break; case 0xEF: // ISB $???? MR_AB(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xFF: // ISB $????,X MR_AX(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xFB: // ISB $????,Y MR_AY(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xE3: // ISB ($??,X) MR_IX(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xF3: // ISB ($??),Y MR_IY(); ISB(); MW_EA(); ADD_CYCLE(5); break; case 0xBB: // LAS $????,Y MR_AY(); LAS(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA7: // LAX $?? MR_ZP(); LAX(); ADD_CYCLE(3); break; case 0xB7: // LAX $??,Y MR_ZY(); LAX(); ADD_CYCLE(4); break; case 0xAF: // LAX $???? MR_AB(); LAX(); ADD_CYCLE(4); break; case 0xBF: // LAX $????,Y MR_AY(); LAX(); CHECK_EA(); ADD_CYCLE(4); break; case 0xA3: // LAX ($??,X) MR_IX(); LAX(); ADD_CYCLE(6); break; case 0xB3: // LAX ($??),Y MR_IY(); LAX(); CHECK_EA(); ADD_CYCLE(5); break; case 0xAB: // LXA #$?? MR_IM(); LXA(); ADD_CYCLE(2); break; case 0x27: // RLA $?? MR_ZP(); RLA(); MW_ZP(); ADD_CYCLE(5); break; case 0x37: // RLA $??,X MR_ZX(); RLA(); MW_ZP(); ADD_CYCLE(6); break; case 0x2F: // RLA $???? MR_AB(); RLA(); MW_EA(); ADD_CYCLE(6); break; case 0x3F: // RLA $????,X MR_AX(); RLA(); MW_EA(); ADD_CYCLE(7); break; case 0x3B: // RLA $????,Y MR_AY(); RLA(); MW_EA(); ADD_CYCLE(7); break; case 0x23: // RLA ($??,X) MR_IX(); RLA(); MW_EA(); ADD_CYCLE(8); break; case 0x33: // RLA ($??),Y MR_IY(); RLA(); MW_EA(); ADD_CYCLE(8); break; case 0x67: // RRA $?? MR_ZP(); RRA(); MW_ZP(); ADD_CYCLE(5); break; case 0x77: // RRA $??,X MR_ZX(); RRA(); MW_ZP(); ADD_CYCLE(6); break; case 0x6F: // RRA $???? MR_AB(); RRA(); MW_EA(); ADD_CYCLE(6); break; case 0x7F: // RRA $????,X MR_AX(); RRA(); MW_EA(); ADD_CYCLE(7); break; case 0x7B: // RRA $????,Y MR_AY(); RRA(); MW_EA(); ADD_CYCLE(7); break; case 0x63: // RRA ($??,X) MR_IX(); RRA(); MW_EA(); ADD_CYCLE(8); break; case 0x73: // RRA ($??),Y MR_IY(); RRA(); MW_EA(); ADD_CYCLE(8); break; case 0x87: // SAX $?? MR_ZP(); SAX(); MW_ZP(); ADD_CYCLE(3); break; case 0x97: // SAX $??,Y MR_ZY(); SAX(); MW_ZP(); ADD_CYCLE(4); break; case 0x8F: // SAX $???? MR_AB(); SAX(); MW_EA(); ADD_CYCLE(4); break; case 0x83: // SAX ($??,X) MR_IX(); SAX(); MW_EA(); ADD_CYCLE(6); break; case 0xCB: // SBX #$?? MR_IM(); SBX(); ADD_CYCLE(2); break; case 0x9F: // SHA $????,Y MR_AY(); SHA(); MW_EA(); ADD_CYCLE(5); break; case 0x93: // SHA ($??),Y MR_IY(); SHA(); MW_EA(); ADD_CYCLE(6); break; case 0x9B: // SHS $????,Y MR_AY(); SHS(); MW_EA(); ADD_CYCLE(5); break; case 0x9E: // SHX $????,Y MR_AY(); SHX(); MW_EA(); ADD_CYCLE(5); break; case 0x9C: // SHY $????,X MR_AX(); SHY(); MW_EA(); ADD_CYCLE(5); break; case 0x07: // SLO $?? MR_ZP(); SLO(); MW_ZP(); ADD_CYCLE(5); break; case 0x17: // SLO $??,X MR_ZX(); SLO(); MW_ZP(); ADD_CYCLE(6); break; case 0x0F: // SLO $???? MR_AB(); SLO(); MW_EA(); ADD_CYCLE(6); break; case 0x1F: // SLO $????,X MR_AX(); SLO(); MW_EA(); ADD_CYCLE(7); break; case 0x1B: // SLO $????,Y MR_AY(); SLO(); MW_EA(); ADD_CYCLE(7); break; case 0x03: // SLO ($??,X) MR_IX(); SLO(); MW_EA(); ADD_CYCLE(8); break; case 0x13: // SLO ($??),Y MR_IY(); SLO(); MW_EA(); ADD_CYCLE(8); break; case 0x47: // SRE $?? MR_ZP(); SRE(); MW_ZP(); ADD_CYCLE(5); break; case 0x57: // SRE $??,X MR_ZX(); SRE(); MW_ZP(); ADD_CYCLE(6); break; case 0x4F: // SRE $???? MR_AB(); SRE(); MW_EA(); ADD_CYCLE(6); break; case 0x5F: // SRE $????,X MR_AX(); SRE(); MW_EA(); ADD_CYCLE(7); break; case 0x5B: // SRE $????,Y MR_AY(); SRE(); MW_EA(); ADD_CYCLE(7); break; case 0x43: // SRE ($??,X) MR_IX(); SRE(); MW_EA(); ADD_CYCLE(8); break; case 0x53: // SRE ($??),Y MR_IY(); SRE(); MW_EA(); ADD_CYCLE(8); break; case 0xEB: // SBC #$?? (Unofficial) MR_IM(); SBC(); ADD_CYCLE(2); break; case 0x1A: // NOP (Unofficial) case 0x3A: // NOP (Unofficial) case 0x5A: // NOP (Unofficial) case 0x7A: // NOP (Unofficial) case 0xDA: // NOP (Unofficial) case 0xFA: // NOP (Unofficial) ADD_CYCLE(2); break; case 0x80: // DOP (CYCLES 2) case 0x82: // DOP (CYCLES 2) case 0x89: // DOP (CYCLES 2) case 0xC2: // DOP (CYCLES 2) case 0xE2: // DOP (CYCLES 2) R.PC++; ADD_CYCLE(2); break; case 0x04: // DOP (CYCLES 3) case 0x44: // DOP (CYCLES 3) case 0x64: // DOP (CYCLES 3) R.PC++; ADD_CYCLE(3); break; case 0x14: // DOP (CYCLES 4) case 0x34: // DOP (CYCLES 4) case 0x54: // DOP (CYCLES 4) case 0x74: // DOP (CYCLES 4) case 0xD4: // DOP (CYCLES 4) case 0xF4: // DOP (CYCLES 4) R.PC++; ADD_CYCLE(4); break; case 0x0C: // TOP case 0x1C: // TOP case 0x3C: // TOP case 0x5C: // TOP case 0x7C: // TOP case 0xDC: // TOP case 0xFC: // TOP R.PC+=2; ADD_CYCLE(4); break; case 0x02: /* JAM */ case 0x12: /* JAM */ case 0x22: /* JAM */ case 0x32: /* JAM */ case 0x42: /* JAM */ case 0x52: /* JAM */ case 0x62: /* JAM */ case 0x72: /* JAM */ case 0x92: /* JAM */ case 0xB2: /* JAM */ case 0xD2: /* JAM */ case 0xF2: /* JAM */ default: if( !Config.emulator.bIllegalOp ) { throw CApp::GetErrorString( IDS_ERROR_ILLEGALOPCODE ); goto _execute_exit; } else { R.PC--; ADD_CYCLE(4); } break; // default: // __assume(0); } end_is: __asm nop; if( nmi_request ) { _NMI(); } else if( irq_request ) { _IRQ(); } request_cycles -= exec_cycles; TOTAL_cycles += exec_cycles; // 僋儘僢僋摨婜張棟 mapper->Clock( exec_cycles ); #if DPCM_SYNCCLOCK apu->SyncDPCM( exec_cycles ); #endif if( bClockProcess ) { nes->Clock( exec_cycles ); } // nes->Clock( exec_cycles ); } _execute_exit: #if !DPCM_SYNCCLOCK apu->SyncDPCM( TOTAL_cycles - OLD_cycles ); #endif return TOTAL_cycles - OLD_cycles; }
/* * This is used by both syslog_r and syslog. The latter supplies * a non-NULL gettime callback for filling in the date, but we also * use the presence of that callback to decide whether it's safe * to call strerror and what the name of the caller is */ void __vsyslog_r(int pri, struct syslog_data *data, size_t (*gettime)(char *, size_t), const char *fmt, va_list ap) { int cnt; char ch, *p, *t; int fd, saved_errno, error; #define TBUF_LEN 2048 #define FMT_LEN 1024 char *stdp, tbuf[TBUF_LEN], fmt_cpy[FMT_LEN]; int tbuf_left, fmt_left, prlen; #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog_r(INTERNALLOG, data, "syslog%s: unknown facility/priority: %x", gettime != NULL ? "" : "_r", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask)) return; saved_errno = errno; /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= data->log_fac; p = tbuf; tbuf_left = TBUF_LEN; #define DEC() \ do { \ if (prlen < 0) \ prlen = 0; \ if (prlen >= tbuf_left) \ prlen = tbuf_left - 1; \ p += prlen; \ tbuf_left -= prlen; \ } while (0) prlen = snprintf(p, tbuf_left, "<%d>", pri); DEC(); /* * syslogd will expand time automagically for reentrant case, and * for normal case, invoke the callback to do it just do like before */ if (gettime != NULL) { prlen = gettime(p, tbuf_left); DEC(); } if (data->log_stat & LOG_PERROR) stdp = p; if (data->log_tag == NULL) data->log_tag = __progname; if (data->log_tag != NULL) { prlen = snprintf(p, tbuf_left, "%s", data->log_tag); DEC(); } if (data->log_stat & LOG_PID) { prlen = snprintf(p, tbuf_left, "[%ld]", (long)getpid()); DEC(); } if (data->log_tag != NULL) { if (tbuf_left > 1) { *p++ = ':'; tbuf_left--; } if (tbuf_left > 1) { *p++ = ' '; tbuf_left--; } } /* strerror() is not reentrant */ for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; if (gettime != NULL) { prlen = snprintf(t, fmt_left, "%s", strerror(saved_errno)); } else { prlen = snprintf(t, fmt_left, "Error %d", saved_errno); } if (prlen < 0) prlen = 0; if (prlen >= fmt_left) prlen = fmt_left - 1; t += prlen; fmt_left -= prlen; } else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) { *t++ = '%'; *t++ = '%'; fmt++; fmt_left -= 2; } else { if (fmt_left > 1) { *t++ = ch; fmt_left--; } } } *t = '\0'; prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); DEC(); cnt = p - tbuf; /* Output to stderr if requested. */ if (data->log_stat & LOG_PERROR) { struct iovec iov[2]; iov[0].iov_base = stdp; iov[0].iov_len = cnt - (stdp - tbuf); iov[1].iov_base = "\n"; iov[1].iov_len = 1; (void)writev(STDERR_FILENO, iov, 2); } /* Get connected, output the message to the local logger. */ if (!data->opened) openlog_r(data->log_tag, data->log_stat, 0, data); connectlog_r(data); /* * If the send() failed, there are two likely scenarios: * 1) syslogd was restarted * 2) /dev/log is out of socket buffer space * We attempt to reconnect to /dev/log to take care of * case #1 and keep send()ing data to cover case #2 * to give syslogd a chance to empty its socket buffer. */ if ((error = send(data->log_file, tbuf, cnt, 0)) < 0) { if (errno != ENOBUFS) { disconnectlog_r(data); connectlog_r(data); } do { struct timespec rqt = { 0, 1000 }; nanosleep(&rqt, NULL); if ((error = send(data->log_file, tbuf, cnt, 0)) >= 0) break; } while (errno == ENOBUFS); } /* * Output the message to the console; try not to block * as a blocking console should not stop other processes. * Make sure the error reported is the one from the syslogd failure. */ if (error == -1 && (data->log_stat & LOG_CONS) && (fd = open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK, 0)) >= 0) { struct iovec iov[2]; p = strchr(tbuf, '>') + 1; iov[0].iov_base = p; iov[0].iov_len = cnt - (p - tbuf); iov[1].iov_base = "\r\n"; iov[1].iov_len = 2; (void)writev(fd, iov, 2); (void)close(fd); } }
/*===================================================================*/ void K6502_Step( WORD wClocks ) { /* * Only the specified number of the clocks execute Op. * * Parameters * WORD wClocks (Read) * The number of the clocks */ BYTE byCode; WORD wA0; BYTE byD0; BYTE byD1; WORD wD0; // Dispose of it if there is an interrupt requirement if ( NMI_State != NMI_Wiring ) { // NMI Interrupt NMI_State = NMI_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_NMI ); } else if ( IRQ_State != IRQ_Wiring ) { // IRQ Interrupt // Execute IRQ if an I flag isn't being set if ( !( F & FLAG_I ) ) { IRQ_State = IRQ_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_IRQ ); } } // It has a loop until a constant clock passes while ( g_wPassedClocks < wClocks ) { // Read an instruction byCode = K6502_Read( PC++ ); // Execute an instruction. switch ( byCode ) { case 0x00: // BRK ++PC; PUSHW( PC ); SETF( FLAG_B ); PUSH( F ); SETF( FLAG_I ); RSTF( FLAG_D ); PC = K6502_ReadW( VECTOR_IRQ ); CLK( 7 ); break; case 0x01: // ORA (Zpg,X) ORA( A_IX ); CLK( 6 ); break; case 0x05: // ORA Zpg ORA( A_ZP ); CLK( 3 ); break; case 0x06: // ASL Zpg ASL( AA_ZP ); CLK( 5 ); break; case 0x08: // PHP SETF( FLAG_B ); PUSH( F ); CLK( 3 ); break; case 0x09: // ORA #Oper ORA( A_IMM ); CLK( 2 ); break; case 0x0A: // ASL A ASLA; CLK( 2 ); break; case 0x0D: // ORA Abs ORA( A_ABS ); CLK( 4 ); break; case 0x0e: // ASL Abs ASL( AA_ABS ); CLK( 6 ); break; case 0x10: // BPL Oper BRA( !( F & FLAG_N ) ); break; case 0x11: // ORA (Zpg),Y ORA( A_IY ); CLK( 5 ); break; case 0x15: // ORA Zpg,X ORA( A_ZPX ); CLK( 4 ); break; case 0x16: // ASL Zpg,X ASL( AA_ZPX ); CLK( 6 ); break; case 0x18: // CLC RSTF( FLAG_C ); CLK( 2 ); break; case 0x19: // ORA Abs,Y ORA( A_ABSY ); CLK( 4 ); break; case 0x1D: // ORA Abs,X ORA( A_ABSX ); CLK( 4 ); break; case 0x1E: // ASL Abs,X ASL( AA_ABSX ); CLK( 7 ); break; case 0x20: // JSR Abs JSR; CLK( 6 ); break; case 0x21: // AND (Zpg,X) AND( A_IX ); CLK( 6 ); break; case 0x24: // BIT Zpg BIT( A_ZP ); CLK( 3 ); break; case 0x25: // AND Zpg AND( A_ZP ); CLK( 3 ); break; case 0x26: // ROL Zpg ROL( AA_ZP ); CLK( 5 ); break; case 0x28: // PLP POP( F ); SETF( FLAG_R ); CLK( 4 ); break; case 0x29: // AND #Oper AND( A_IMM ); CLK( 2 ); break; case 0x2A: // ROL A ROLA; CLK( 2 ); break; case 0x2C: // BIT Abs BIT( A_ABS ); CLK( 4 ); break; case 0x2D: // AND Abs AND( A_ABS ); CLK( 4 ); break; case 0x2E: // ROL Abs ROL( AA_ABS ); CLK( 6 ); break; case 0x30: // BMI Oper BRA( F & FLAG_N ); break; case 0x31: // AND (Zpg),Y AND( A_IY ); CLK( 5 ); break; case 0x35: // AND Zpg,X AND( A_ZPX ); CLK( 4 ); break; case 0x36: // ROL Zpg,X ROL( AA_ZPX ); CLK( 6 ); break; case 0x38: // SEC SETF( FLAG_C ); CLK( 2 ); break; case 0x39: // AND Abs,Y AND( A_ABSY ); CLK( 4 ); break; case 0x3D: // AND Abs,X AND( A_ABSX ); CLK( 4 ); break; case 0x3E: // ROL Abs,X ROL( AA_ABSX ); CLK( 7 ); break; case 0x40: // RTI POP( F ); SETF( FLAG_R ); POPW( PC ); CLK( 6 ); break; case 0x41: // EOR (Zpg,X) EOR( A_IX ); CLK( 6 ); break; case 0x45: // EOR Zpg EOR( A_ZP ); CLK( 3 ); break; case 0x46: // LSR Zpg LSR( AA_ZP ); CLK( 5 ); break; case 0x48: // PHA PUSH( A ); CLK( 3 ); break; case 0x49: // EOR #Oper EOR( A_IMM ); CLK( 2 ); break; case 0x4A: // LSR A LSRA; CLK( 2 ); break; case 0x4C: // JMP Abs JMP( AA_ABS ); CLK( 3 ); break; case 0x4D: // EOR Abs EOR( A_ABS ); CLK( 4 ); break; case 0x4E: // LSR Abs LSR( AA_ABS ); CLK( 6 ); break; case 0x50: // BVC BRA( !( F & FLAG_V ) ); break; case 0x51: // EOR (Zpg),Y EOR( A_IY ); CLK( 5 ); break; case 0x55: // EOR Zpg,X EOR( A_ZPX ); CLK( 4 ); break; case 0x56: // LSR Zpg,X LSR( AA_ZPX ); CLK( 6 ); break; case 0x58: // CLI byD0 = F; RSTF( FLAG_I ); CLK( 2 ); if ( ( byD0 & FLAG_I ) && IRQ_State != IRQ_Wiring ) { IRQ_State = IRQ_Wiring; CLK( 7 ); PUSHW( PC ); PUSH( F & ~FLAG_B ); RSTF( FLAG_D ); SETF( FLAG_I ); PC = K6502_ReadW( VECTOR_IRQ ); } break; case 0x59: // EOR Abs,Y EOR( A_ABSY ); CLK( 4 ); break; case 0x5D: // EOR Abs,X EOR( A_ABSX ); CLK( 4 ); break; case 0x5E: // LSR Abs,X LSR( AA_ABSX ); CLK( 7 ); break; case 0x60: // RTS POPW( PC ); ++PC; CLK( 6 ); break; case 0x61: // ADC (Zpg,X) ADC( A_IX ); CLK( 6 ); break; case 0x65: // ADC Zpg ADC( A_ZP ); CLK( 3 ); break; case 0x66: // ROR Zpg ROR( AA_ZP ); CLK( 5 ); break; case 0x68: // PLA POP( A ); TEST( A ); CLK( 4 ); break; case 0x69: // ADC #Oper ADC( A_IMM ); CLK( 2 ); break; case 0x6A: // ROR A RORA; CLK( 2 ); break; case 0x6C: // JMP (Abs) JMP( K6502_ReadW2( AA_ABS ) ); CLK( 5 ); break; case 0x6D: // ADC Abs ADC( A_ABS ); CLK( 4 ); break; case 0x6E: // ROR Abs ROR( AA_ABS ); CLK( 6 ); break; case 0x70: // BVS BRA( F & FLAG_V ); break; case 0x71: // ADC (Zpg),Y ADC( A_IY ); CLK( 5 ); break; case 0x75: // ADC Zpg,X ADC( A_ZPX ); CLK( 4 ); break; case 0x76: // ROR Zpg,X ROR( AA_ZPX ); CLK( 6 ); break; case 0x78: // SEI SETF( FLAG_I ); CLK( 2 ); break; case 0x79: // ADC Abs,Y ADC( A_ABSY ); CLK( 4 ); break; case 0x7D: // ADC Abs,X ADC( A_ABSX ); CLK( 4 ); break; case 0x7E: // ROR Abs,X ROR( AA_ABSX ); CLK( 7 ); break; case 0x81: // STA (Zpg,X) STA( AA_IX ); CLK( 6 ); break; case 0x84: // STY Zpg STY( AA_ZP ); CLK( 3 ); break; case 0x85: // STA Zpg STA( AA_ZP ); CLK( 3 ); break; case 0x86: // STX Zpg STX( AA_ZP ); CLK( 3 ); break; case 0x88: // DEY --Y; TEST( Y ); CLK( 2 ); break; case 0x8A: // TXA A = X; TEST( A ); CLK( 2 ); break; case 0x8C: // STY Abs STY( AA_ABS ); CLK( 4 ); break; case 0x8D: // STA Abs STA( AA_ABS ); CLK( 4 ); break; case 0x8E: // STX Abs STX( AA_ABS ); CLK( 4 ); break; case 0x90: // BCC BRA( !( F & FLAG_C ) ); break; case 0x91: // STA (Zpg),Y STA( AA_IY ); CLK( 6 ); break; case 0x94: // STY Zpg,X STY( AA_ZPX ); CLK( 4 ); break; case 0x95: // STA Zpg,X STA( AA_ZPX ); CLK( 4 ); break; case 0x96: // STX Zpg,Y STX( AA_ZPY ); CLK( 4 ); break; case 0x98: // TYA A = Y; TEST( A ); CLK( 2 ); break; case 0x99: // STA Abs,Y STA( AA_ABSY ); CLK( 5 ); break; case 0x9A: // TXS SP = X; CLK( 2 ); break; case 0x9D: // STA Abs,X STA( AA_ABSX ); CLK( 5 ); break; case 0xA0: // LDY #Oper LDY( A_IMM ); CLK( 2 ); break; case 0xA1: // LDA (Zpg,X) LDA( A_IX ); CLK( 6 ); break; case 0xA2: // LDX #Oper LDX( A_IMM ); CLK( 2 ); break; case 0xA4: // LDY Zpg LDY( A_ZP ); CLK( 3 ); break; case 0xA5: // LDA Zpg LDA( A_ZP ); CLK( 3 ); break; case 0xA6: // LDX Zpg LDX( A_ZP ); CLK( 3 ); break; case 0xA8: // TAY Y = A; TEST( A ); CLK( 2 ); break; case 0xA9: // LDA #Oper LDA( A_IMM ); CLK( 2 ); break; case 0xAA: // TAX X = A; TEST( A ); CLK( 2 ); break; case 0xAC: // LDY Abs LDY( A_ABS ); CLK( 4 ); break; case 0xAD: // LDA Abs LDA( A_ABS ); CLK( 4 ); break; case 0xAE: // LDX Abs LDX( A_ABS ); CLK( 4 ); break; case 0xB0: // BCS BRA( F & FLAG_C ); break; case 0xB1: // LDA (Zpg),Y LDA( A_IY ); CLK( 5 ); break; case 0xB4: // LDY Zpg,X LDY( A_ZPX ); CLK( 4 ); break; case 0xB5: // LDA Zpg,X LDA( A_ZPX ); CLK( 4 ); break; case 0xB6: // LDX Zpg,Y LDX( A_ZPY ); CLK( 4 ); break; case 0xB8: // CLV RSTF( FLAG_V ); CLK( 2 ); break; case 0xB9: // LDA Abs,Y LDA( A_ABSY ); CLK( 4 ); break; case 0xBA: // TSX X = SP; TEST( X ); CLK( 2 ); break; case 0xBC: // LDY Abs,X LDY( A_ABSX ); CLK( 4 ); break; case 0xBD: // LDA Abs,X LDA( A_ABSX ); CLK( 4 ); break; case 0xBE: // LDX Abs,Y LDX( A_ABSY ); CLK( 4 ); break; case 0xC0: // CPY #Oper CPY( A_IMM ); CLK( 2 ); break; case 0xC1: // CMP (Zpg,X) CMP( A_IX ); CLK( 6 ); break; case 0xC4: // CPY Zpg CPY( A_ZP ); CLK( 3 ); break; case 0xC5: // CMP Zpg CMP( A_ZP ); CLK( 3 ); break; case 0xC6: // DEC Zpg DEC( AA_ZP ); CLK( 5 ); break; case 0xC8: // INY ++Y; TEST( Y ); CLK( 2 ); break; case 0xC9: // CMP #Oper CMP( A_IMM ); CLK( 2 ); break; case 0xCA: // DEX --X; TEST( X ); CLK( 2 ); break; case 0xCC: // CPY Abs CPY( A_ABS ); CLK( 4 ); break; case 0xCD: // CMP Abs CMP( A_ABS ); CLK( 4 ); break; case 0xCE: // DEC Abs DEC( AA_ABS ); CLK( 6 ); break; case 0xD0: // BNE BRA( !( F & FLAG_Z ) ); break; case 0xD1: // CMP (Zpg),Y CMP( A_IY ); CLK( 5 ); break; case 0xD5: // CMP Zpg,X CMP( A_ZPX ); CLK( 4 ); break; case 0xD6: // DEC Zpg,X DEC( AA_ZPX ); CLK( 6 ); break; case 0xD8: // CLD RSTF( FLAG_D ); CLK( 2 ); break; case 0xD9: // CMP Abs,Y CMP( A_ABSY ); CLK( 4 ); break; case 0xDD: // CMP Abs,X CMP( A_ABSX ); CLK( 4 ); break; case 0xDE: // DEC Abs,X DEC( AA_ABSX ); CLK( 7 ); break; case 0xE0: // CPX #Oper CPX( A_IMM ); CLK( 2 ); break; case 0xE1: // SBC (Zpg,X) SBC( A_IX ); CLK( 6 ); break; case 0xE4: // CPX Zpg CPX( A_ZP ); CLK( 3 ); break; case 0xE5: // SBC Zpg SBC( A_ZP ); CLK( 3 ); break; case 0xE6: // INC Zpg INC( AA_ZP ); CLK( 5 ); break; case 0xE8: // INX ++X; TEST( X ); CLK( 2 ); break; case 0xE9: // SBC #Oper SBC( A_IMM ); CLK( 2 ); break; case 0xEA: // NOP CLK( 2 ); break; case 0xEC: // CPX Abs CPX( A_ABS ); CLK( 4 ); break; case 0xED: // SBC Abs SBC( A_ABS ); CLK( 4 ); break; case 0xEE: // INC Abs INC( AA_ABS ); CLK( 6 ); break; case 0xF0: // BEQ BRA( F & FLAG_Z ); break; case 0xF1: // SBC (Zpg),Y SBC( A_IY ); CLK( 5 ); break; case 0xF5: // SBC Zpg,X SBC( A_ZPX ); CLK( 4 ); break; case 0xF6: // INC Zpg,X INC( AA_ZPX ); CLK( 6 ); break; case 0xF8: // SED SETF( FLAG_D ); CLK( 2 ); break; case 0xF9: // SBC Abs,Y SBC( A_ABSY ); CLK( 4 ); break; case 0xFD: // SBC Abs,X SBC( A_ABSX ); CLK( 4 ); break; case 0xFE: // INC Abs,X INC( AA_ABSX ); CLK( 7 ); break; /*-----------------------------------------------------------*/ /* Unlisted Instructions ( thanks to virtualnes ) */ /*-----------------------------------------------------------*/ case 0x1A: // NOP (Unofficial) case 0x3A: // NOP (Unofficial) case 0x5A: // NOP (Unofficial) case 0x7A: // NOP (Unofficial) case 0xDA: // NOP (Unofficial) case 0xFA: // NOP (Unofficial) CLK( 2 ); break; case 0x80: // DOP (CYCLES 2) case 0x82: // DOP (CYCLES 2) case 0x89: // DOP (CYCLES 2) case 0xC2: // DOP (CYCLES 2) case 0xE2: // DOP (CYCLES 2) PC++; CLK( 2 ); break; case 0x04: // DOP (CYCLES 3) case 0x44: // DOP (CYCLES 3) case 0x64: // DOP (CYCLES 3) PC++; CLK( 3 ); break; case 0x14: // DOP (CYCLES 4) case 0x34: // DOP (CYCLES 4) case 0x54: // DOP (CYCLES 4) case 0x74: // DOP (CYCLES 4) case 0xD4: // DOP (CYCLES 4) case 0xF4: // DOP (CYCLES 4) PC++; CLK( 4 ); break; case 0x0C: // TOP case 0x1C: // TOP case 0x3C: // TOP case 0x5C: // TOP case 0x7C: // TOP case 0xDC: // TOP case 0xFC: // TOP PC+=2; CLK( 4 ); break; default: // Unknown Instruction CLK( 2 ); #if 0 InfoNES_MessageBox( "0x%02x is unknown instruction.\n", byCode ) ; #endif break; } /* end of switch ( byCode ) */ } /* end of while ... */ // Correct the number of the clocks g_wPassedClocks -= wClocks; }
bool check(check_event_t event, uint8_t curr, const MenuFuncP *menuTab, uint8_t menuTabSize, const pm_uint8_t *horTab, uint8_t horTabMax, vertpos_t maxrow) { vertpos_t l_posVert = m_posVert; horzpos_t l_posHorz = m_posHorz; uint8_t maxcol = MAXCOL(l_posVert); #if defined(NAVIGATION_POT1) // check pot 1 - if changed -> scroll values static int16_t p1val; static int16_t p1valprev; p1valdiff = (p1val-calibratedStick[6]) / SCROLL_POT1_TH; if (p1valdiff) { p1valdiff = (p1valprev-calibratedStick[6]) / 2; p1val = calibratedStick[6]; } p1valprev = calibratedStick[6]; #endif #if defined(NAVIGATION_POT2) // check pot 2 - if changed -> scroll menu static int16_t p2valprev; p2valdiff = (p2valprev-calibratedStick[4]) / SCROLL_TH; if (p2valdiff) p2valprev = calibratedStick[4]; #endif #if defined(NAVIGATION_POT3) // check pot 3 if changed -> cursor down/up static int16_t p3valprev; int8_t scrollUD = (p3valprev-calibratedStick[5]) / SCROLL_TH; if (scrollUD) p3valprev = calibratedStick[5]; #else #define scrollUD 0 #endif if (p2valdiff || scrollUD || p1valdiff) backlightOn(); // on keypress turn the light on if (menuTab) { uint8_t attr = 0; if (l_posVert==0 && !calibrationState) { attr = INVERS; int8_t cc = curr; if (p2valdiff) { cc = limit((int8_t)0, (int8_t)(cc - p2valdiff), (int8_t)(menuTabSize-1)); } switch(event) { #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ROTARY_BREAK: if (s_editMode < 0 && maxrow > 0) { s_editMode = 0; // TODO ? l_posVert = (horTab && horTab[1]==0xff) ? 2 : 1; l_posHorz = 0; } else { s_editMode = -1; } event = 0; break; #endif #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ROTARY_LEFT: if (s_editMode >= 0) break; #endif case EVT_KEY_FIRST(KEY_LEFT): if (curr > 0) cc = curr - 1; else cc = menuTabSize-1; break; #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ROTARY_RIGHT: if (s_editMode >= 0) break; #endif case EVT_KEY_FIRST(KEY_RIGHT): if (curr < (menuTabSize-1)) cc = curr + 1; else cc = 0; break; } if (cc != curr) { chainMenu((MenuFuncP)pgm_read_adr(&menuTab[cc])); return false; } #if defined(ROTARY_ENCODER_NAVIGATION) if (IS_RE_NAVIGATION_ENABLE() && s_editMode < 0) attr = INVERS|BLINK; #endif } calibrationState = 0; displayScreenIndex(curr, menuTabSize, attr); } DISPLAY_PROGRESS_BAR(menuTab ? lcdLastPos-2*FW-((curr+1)/10*FWNUM)-2 : 20*FW+1); if (s_editMode<=0) { if (scrollUD) { l_posVert = limit((int8_t)0, (int8_t)(l_posVert - scrollUD), (int8_t)maxrow); l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); } if (p2valdiff && l_posVert>0) { l_posHorz = limit((int8_t)0, (int8_t)((uint8_t)l_posHorz - p2valdiff), (int8_t)maxcol); } } switch(event) { case EVT_ENTRY: #if defined(CPUARM) menuEntryTime = get_tmr10ms(); #endif l_posVert = POS_VERT_INIT; l_posHorz = POS_HORZ_INIT(l_posVert); SET_SCROLLBAR_X(LCD_W-1); #if defined(ROTARY_ENCODER_NAVIGATION) if (menuTab) { s_editMode = EDIT_MODE_INIT; break; } // no break #else s_editMode = EDIT_MODE_INIT; break; #endif #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ENTRY_UP: s_editMode = 0; SET_SCROLLBAR_X(LCD_W-1); break; case EVT_ROTARY_BREAK: if (s_editMode > 1) break; #endif case EVT_KEY_FIRST(KEY_ENTER): if (!menuTab || l_posVert>0) { if (READ_ONLY_UNLOCKED()) { s_editMode = (s_editMode<=0); } } break; #if defined(ROTARY_ENCODER_NAVIGATION) case EVT_ROTARY_LONG: if (s_editMode > 1) break; killEvents(event); if (l_posVert != POS_VERT_INIT) { l_posVert = POS_VERT_INIT; s_editMode = EDIT_MODE_INIT; break; } // no break #endif case EVT_KEY_LONG(KEY_EXIT): s_editMode = 0; // TODO needed? we call ENTRY_UP after which does the same popMenu(); return false; case EVT_KEY_BREAK(KEY_EXIT): #if defined(ROTARY_ENCODER_NAVIGATION) if (s_editMode == 0) s_editMode = EDIT_MODE_INIT; else #endif if (s_editMode>0) { s_editMode = 0; break; } if (l_posVert==0 || !menuTab) { popMenu(); // beeps itself return false; } else { AUDIO_MENUS(); l_posVert = 0; l_posHorz = 0; } break; case EVT_KEY_REPT(KEY_RIGHT): //inc if (l_posHorz==maxcol) break; // no break case EVT_KEY_FIRST(KEY_RIGHT)://inc if (!horTab || s_editMode>0) break; #if defined(ROTARY_ENCODER_NAVIGATION) CASE_EVT_ROTARY_MOVE_RIGHT if (s_editMode != 0) break; if (l_posHorz < maxcol) { l_posHorz++; break; } else { l_posHorz = 0; if (!IS_ROTARY_MOVE_RIGHT(event)) break; } #else INC(l_posHorz, 0, maxcol); break; #endif case EVT_KEY_REPT(KEY_DOWN): //inc if (!IS_ROTARY_RIGHT(event) && l_posVert==maxrow) break; // no break case EVT_KEY_FIRST(KEY_DOWN): //inc if (s_editMode>0) break; do { INC(l_posVert, POS_VERT_INIT, maxrow); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); #if defined(ROTARY_ENCODER_NAVIGATION) s_editMode = 0; // if we go down, we must be in this mode #endif l_posHorz = min(l_posHorz, MAXCOL(l_posVert)); break; case EVT_KEY_REPT(KEY_LEFT): //dec if (l_posHorz==0) break; // no break case EVT_KEY_FIRST(KEY_LEFT)://dec if (!horTab || s_editMode>0) break; #if defined(ROTARY_ENCODER_NAVIGATION) CASE_EVT_ROTARY_MOVE_LEFT if (s_editMode != 0) break; if (l_posHorz > 0) { l_posHorz--; break; } else if (IS_ROTARY_MOVE_LEFT(event) && s_editMode == 0) { l_posHorz = 0xff; } else { l_posHorz = maxcol; break; } #else DEC(l_posHorz, 0, maxcol); break; #endif case EVT_KEY_REPT(KEY_UP): //dec if (!IS_ROTARY_LEFT(event) && l_posVert==0) break; // no break case EVT_KEY_FIRST(KEY_UP): //dec if (s_editMode>0) break; do { DEC(l_posVert, POS_VERT_INIT, maxrow); } while (CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)); #if defined(ROTARY_ENCODER_NAVIGATION) || defined(PCBTARANIS) s_editMode = 0; // if we go up, we must be in this mode #endif l_posHorz = min((uint8_t)l_posHorz, MAXCOL(l_posVert)); break; } #if defined(CPUARM) if (l_posVert<1) s_pgOfs=0; else if (menuTab && horTab) { vertpos_t realPosVert = l_posVert; vertpos_t realPgOfs = s_pgOfs; vertpos_t realMaxrow = maxrow; for (vertpos_t i=1; i<=maxrow; i++) { if (MAXCOL(i) == HIDDEN_ROW) { realMaxrow--; if (i < l_posVert) realPosVert--; if (i < s_pgOfs) realPgOfs--; } } if (realPosVert>(LCD_LINES-1)+realPgOfs) realPgOfs = realPosVert-(LCD_LINES-1); else if (realPosVert<1+realPgOfs) realPgOfs = realPosVert-1; s_pgOfs = realPgOfs; for (vertpos_t i=1; i<=realPgOfs; i++) { if (MAXCOL(i) == HIDDEN_ROW) { s_pgOfs++; } } maxrow = realMaxrow; } else { uint8_t max = menuTab ? LCD_LINES-1 : LCD_LINES-2; if (l_posVert>max+s_pgOfs) s_pgOfs = l_posVert-max; else if (l_posVert<1+s_pgOfs) s_pgOfs = l_posVert-1; } #if LCD_W >= 212 if (maxrow > LCD_LINES-1 && scrollbar_X) displayScrollbar(scrollbar_X, FH, LCD_H-FH, s_pgOfs, menuTab ? maxrow : maxrow+1, LCD_LINES-1); #endif #else uint8_t max = menuTab ? LCD_LINES-1 : LCD_LINES-2; if (l_posVert<1) s_pgOfs=0; else if (l_posVert>max+s_pgOfs) s_pgOfs = l_posVert-max; else if (l_posVert<1+s_pgOfs) s_pgOfs = l_posVert-1; #endif m_posVert = l_posVert; m_posHorz = l_posHorz; #if !defined(CPUM64) // cosmetics on 9x if (s_pgOfs > 0) { l_posVert--; if (l_posVert == s_pgOfs && CURSOR_NOT_ALLOWED_IN_ROW(l_posVert)) { s_pgOfs = l_posVert-1; } } #endif return true; }
static void klog_format(E_MODULE eModule, E_SEVERITY eSeverity, char alrm_log, const char *fmt) { char *p; int cnt; int tbuf_left, prlen = 0; int pri = (int) eSeverity; const char * log_tag = NULL; #define TBUF_LEN 1024 char tbuf[TBUF_LEN] = { 0 }; if (!(eModule > M_MOD_UNKNOWN && eModule < M_MOD_MAX && eSeverity >= E_EMERGENCY && eSeverity <= E_DEBUG) || NULL == fmt) { return; } #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK | LOG_FACMASK)) { pri &= LOG_PRIMASK | LOG_FACMASK; } if (!LOG_MASK(LOG_PRI(pri))) { return; } p = tbuf; tbuf_left = TBUF_LEN; #define DEC() \ { \ if (prlen < 0) \ { \ prlen = 0; \ } \ if (prlen >= tbuf_left) \ { \ prlen = tbuf_left - 1; \ } \ p += prlen; \ tbuf_left -= prlen; \ } prlen = snprintf(p, tbuf_left, "<%d>", pri); DEC(); log_tag = (const char *) gModuleNameArr[eModule].pszName; if (log_tag != NULL ) { prlen = snprintf(p, tbuf_left, "%s: ", log_tag); DEC(); } if (strlen(fmt) > 0) { prlen = snprintf(p, tbuf_left, fmt); DEC(); } /* add alarm log prefix */ if (1 == alrm_log) { prlen = snprintf(p, tbuf_left, ALRM_LOG_PREFIX); DEC(); } prlen = snprintf(p, tbuf_left, "\n"); DEC(); cnt = p - tbuf; printk(tbuf); }