diff options
Diffstat (limited to 'src/emu/validity.cpp')
-rw-r--r-- | src/emu/validity.cpp | 504 |
1 files changed, 252 insertions, 252 deletions
diff --git a/src/emu/validity.cpp b/src/emu/validity.cpp index f98e5b8ed5f..740a9c6c6dd 100644 --- a/src/emu/validity.cpp +++ b/src/emu/validity.cpp @@ -30,7 +30,7 @@ // string from the I/O port system //------------------------------------------------- -inline const char *validity_checker::ioport_string_from_index(UINT32 index) +inline const char *validity_checker::ioport_string_from_index(uint32_t index) { return ioport_configurer::string_from_token((const char *)(uintptr_t)index); } @@ -59,10 +59,10 @@ inline int validity_checker::get_defstr_index(const char *string, bool suppress_ // random_s32 //------------------------------------------------- #undef rand -inline INT32 validity_checker::random_i32() { return INT32(random_u32()); } -inline UINT32 validity_checker::random_u32() { return rand() ^ (rand() << 15); } -inline INT64 validity_checker::random_i64() { return INT64(random_u64()); } -inline UINT64 validity_checker::random_u64() { return UINT64(random_u32()) ^ (UINT64(random_u32()) << 30); } +inline int32_t validity_checker::random_i32() { return int32_t(random_u32()); } +inline uint32_t validity_checker::random_u32() { return rand() ^ (rand() << 15); } +inline int64_t validity_checker::random_i64() { return int64_t(random_u64()); } +inline uint64_t validity_checker::random_u64() { return uint64_t(random_u32()) ^ (uint64_t(random_u32()) << 30); } @@ -82,7 +82,7 @@ void validity_checker::validate_tag(const char *tag) for (const char *p = tag; *p != 0; p++) { // only lower-case permitted - if (*p != tolower((UINT8)*p)) + if (*p != tolower((uint8_t)*p)) { osd_printf_error("Tag '%s' contains upper-case characters\n", tag); break; @@ -336,29 +336,29 @@ void validity_checker::validate_core() // basic system checks if (~0 != -1) osd_printf_error("Machine must be two's complement\n"); - UINT8 a = 0xff; - UINT8 b = a + 1; - if (b > a) osd_printf_error("UINT8 must be 8 bits\n"); + uint8_t a = 0xff; + uint8_t b = a + 1; + if (b > a) osd_printf_error("uint8_t must be 8 bits\n"); // check size of core integer types - if (sizeof(INT8) != 1) osd_printf_error("INT8 must be 8 bits\n"); - if (sizeof(UINT8) != 1) osd_printf_error("UINT8 must be 8 bits\n"); - if (sizeof(INT16) != 2) osd_printf_error("INT16 must be 16 bits\n"); - if (sizeof(UINT16) != 2) osd_printf_error("UINT16 must be 16 bits\n"); - if (sizeof(INT32) != 4) osd_printf_error("INT32 must be 32 bits\n"); - if (sizeof(UINT32) != 4) osd_printf_error("UINT32 must be 32 bits\n"); - if (sizeof(INT64) != 8) osd_printf_error("INT64 must be 64 bits\n"); - if (sizeof(UINT64) != 8) osd_printf_error("UINT64 must be 64 bits\n"); + if (sizeof(int8_t) != 1) osd_printf_error("int8_t must be 8 bits\n"); + if (sizeof(uint8_t) != 1) osd_printf_error("uint8_t must be 8 bits\n"); + if (sizeof(int16_t) != 2) osd_printf_error("int16_t must be 16 bits\n"); + if (sizeof(uint16_t) != 2) osd_printf_error("uint16_t must be 16 bits\n"); + if (sizeof(int32_t) != 4) osd_printf_error("int32_t must be 32 bits\n"); + if (sizeof(uint32_t) != 4) osd_printf_error("uint32_t must be 32 bits\n"); + if (sizeof(int64_t) != 8) osd_printf_error("int64_t must be 64 bits\n"); + if (sizeof(uint64_t) != 8) osd_printf_error("uint64_t must be 64 bits\n"); // check signed right shift - INT8 a8 = -3; - INT16 a16 = -3; - INT32 a32 = -3; - INT64 a64 = -3; - if (a8 >> 1 != -2) osd_printf_error("INT8 right shift must be arithmetic\n"); - if (a16 >> 1 != -2) osd_printf_error("INT16 right shift must be arithmetic\n"); - if (a32 >> 1 != -2) osd_printf_error("INT32 right shift must be arithmetic\n"); - if (a64 >> 1 != -2) osd_printf_error("INT64 right shift must be arithmetic\n"); + int8_t a8 = -3; + int16_t a16 = -3; + int32_t a32 = -3; + int64_t a64 = -3; + if (a8 >> 1 != -2) osd_printf_error("int8_t right shift must be arithmetic\n"); + if (a16 >> 1 != -2) osd_printf_error("int16_t right shift must be arithmetic\n"); + if (a32 >> 1 != -2) osd_printf_error("int32_t right shift must be arithmetic\n"); + if (a64 >> 1 != -2) osd_printf_error("int64_t right shift must be arithmetic\n"); // check pointer size #ifdef PTR64 @@ -369,8 +369,8 @@ void validity_checker::validate_core() // TODO: check if this is actually working // check endianness definition - UINT16 lsbtest = 0; - *(UINT8 *)&lsbtest = 0xff; + uint16_t lsbtest = 0; + *(uint8_t *)&lsbtest = 0xff; #ifdef LSB_FIRST if (lsbtest == 0xff00) osd_printf_error("LSB_FIRST specified, but running on a big-endian machine\n"); #else @@ -386,18 +386,18 @@ void validity_checker::validate_core() void validity_checker::validate_inlines() { - volatile UINT64 testu64a = random_u64(); - volatile INT64 testi64a = random_i64(); - volatile UINT32 testu32a = random_u32(); - volatile UINT32 testu32b = random_u32(); - volatile INT32 testi32a = random_i32(); - volatile INT32 testi32b = random_i32(); - INT32 resulti32, expectedi32; - UINT32 resultu32, expectedu32; - INT64 resulti64, expectedi64; - UINT64 resultu64, expectedu64; - INT32 remainder, expremainder; - UINT32 uremainder, expuremainder, bigu32 = 0xffffffff; + volatile uint64_t testu64a = random_u64(); + volatile int64_t testi64a = random_i64(); + volatile uint32_t testu32a = random_u32(); + volatile uint32_t testu32b = random_u32(); + volatile int32_t testi32a = random_i32(); + volatile int32_t testi32b = random_i32(); + int32_t resulti32, expectedi32; + uint32_t resultu32, expectedu32; + int64_t resulti64, expectedi64; + uint64_t resultu64, expectedu64; + int32_t remainder, expremainder; + uint32_t uremainder, expuremainder, bigu32 = 0xffffffff; // use only non-zero, positive numbers if (testu64a == 0) testu64a++; @@ -411,86 +411,86 @@ void validity_checker::validate_inlines() else if (testi32b < 0) testi32b = -testi32b; resulti64 = mul_32x32(testi32a, testi32b); - expectedi64 = (INT64)testi32a * (INT64)testi32b; + expectedi64 = (int64_t)testi32a * (int64_t)testi32b; if (resulti64 != expectedi64) - osd_printf_error("Error testing mul_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testi32a, testi32b, (UINT32)(resulti64 >> 32), (UINT32)resulti64, (UINT32)(expectedi64 >> 32), (UINT32)expectedi64); + osd_printf_error("Error testing mul_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testi32a, testi32b, (uint32_t)(resulti64 >> 32), (uint32_t)resulti64, (uint32_t)(expectedi64 >> 32), (uint32_t)expectedi64); resultu64 = mulu_32x32(testu32a, testu32b); - expectedu64 = (UINT64)testu32a * (UINT64)testu32b; + expectedu64 = (uint64_t)testu32a * (uint64_t)testu32b; if (resultu64 != expectedu64) - osd_printf_error("Error testing mulu_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testu32a, testu32b, (UINT32)(resultu64 >> 32), (UINT32)resultu64, (UINT32)(expectedu64 >> 32), (UINT32)expectedu64); + osd_printf_error("Error testing mulu_32x32 (%08X x %08X) = %08X%08X (expected %08X%08X)\n", testu32a, testu32b, (uint32_t)(resultu64 >> 32), (uint32_t)resultu64, (uint32_t)(expectedu64 >> 32), (uint32_t)expectedu64); resulti32 = mul_32x32_hi(testi32a, testi32b); - expectedi32 = ((INT64)testi32a * (INT64)testi32b) >> 32; + expectedi32 = ((int64_t)testi32a * (int64_t)testi32b) >> 32; if (resulti32 != expectedi32) osd_printf_error("Error testing mul_32x32_hi (%08X x %08X) = %08X (expected %08X)\n", testi32a, testi32b, resulti32, expectedi32); resultu32 = mulu_32x32_hi(testu32a, testu32b); - expectedu32 = ((INT64)testu32a * (INT64)testu32b) >> 32; + expectedu32 = ((int64_t)testu32a * (int64_t)testu32b) >> 32; if (resultu32 != expectedu32) osd_printf_error("Error testing mulu_32x32_hi (%08X x %08X) = %08X (expected %08X)\n", testu32a, testu32b, resultu32, expectedu32); resulti32 = mul_32x32_shift(testi32a, testi32b, 7); - expectedi32 = ((INT64)testi32a * (INT64)testi32b) >> 7; + expectedi32 = ((int64_t)testi32a * (int64_t)testi32b) >> 7; if (resulti32 != expectedi32) osd_printf_error("Error testing mul_32x32_shift (%08X x %08X) >> 7 = %08X (expected %08X)\n", testi32a, testi32b, resulti32, expectedi32); resultu32 = mulu_32x32_shift(testu32a, testu32b, 7); - expectedu32 = ((INT64)testu32a * (INT64)testu32b) >> 7; + expectedu32 = ((int64_t)testu32a * (int64_t)testu32b) >> 7; if (resultu32 != expectedu32) osd_printf_error("Error testing mulu_32x32_shift (%08X x %08X) >> 7 = %08X (expected %08X)\n", testu32a, testu32b, resultu32, expectedu32); - while ((INT64)testi32a * (INT64)0x7fffffff < testi64a) + while ((int64_t)testi32a * (int64_t)0x7fffffff < testi64a) testi64a /= 2; - while ((UINT64)testu32a * (UINT64)bigu32 < testu64a) + while ((uint64_t)testu32a * (uint64_t)bigu32 < testu64a) testu64a /= 2; resulti32 = div_64x32(testi64a, testi32a); - expectedi32 = testi64a / (INT64)testi32a; + expectedi32 = testi64a / (int64_t)testi32a; if (resulti32 != expectedi32) - osd_printf_error("Error testing div_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, expectedi32); + osd_printf_error("Error testing div_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (uint32_t)(testi64a >> 32), (uint32_t)testi64a, testi32a, resulti32, expectedi32); resultu32 = divu_64x32(testu64a, testu32a); - expectedu32 = testu64a / (UINT64)testu32a; + expectedu32 = testu64a / (uint64_t)testu32a; if (resultu32 != expectedu32) - osd_printf_error("Error testing divu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, expectedu32); + osd_printf_error("Error testing divu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (uint32_t)(testu64a >> 32), (uint32_t)testu64a, testu32a, resultu32, expectedu32); resulti32 = div_64x32_rem(testi64a, testi32a, &remainder); - expectedi32 = testi64a / (INT64)testi32a; - expremainder = testi64a % (INT64)testi32a; + expectedi32 = testi64a / (int64_t)testi32a; + expremainder = testi64a % (int64_t)testi32a; if (resulti32 != expectedi32 || remainder != expremainder) - osd_printf_error("Error testing div_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, remainder, expectedi32, expremainder); + osd_printf_error("Error testing div_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (uint32_t)(testi64a >> 32), (uint32_t)testi64a, testi32a, resulti32, remainder, expectedi32, expremainder); resultu32 = divu_64x32_rem(testu64a, testu32a, &uremainder); - expectedu32 = testu64a / (UINT64)testu32a; - expuremainder = testu64a % (UINT64)testu32a; + expectedu32 = testu64a / (uint64_t)testu32a; + expuremainder = testu64a % (uint64_t)testu32a; if (resultu32 != expectedu32 || uremainder != expuremainder) - osd_printf_error("Error testing divu_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, uremainder, expectedu32, expuremainder); + osd_printf_error("Error testing divu_64x32_rem (%08X%08X / %08X) = %08X,%08X (expected %08X,%08X)\n", (uint32_t)(testu64a >> 32), (uint32_t)testu64a, testu32a, resultu32, uremainder, expectedu32, expuremainder); resulti32 = mod_64x32(testi64a, testi32a); - expectedi32 = testi64a % (INT64)testi32a; + expectedi32 = testi64a % (int64_t)testi32a; if (resulti32 != expectedi32) - osd_printf_error("Error testing mod_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testi64a >> 32), (UINT32)testi64a, testi32a, resulti32, expectedi32); + osd_printf_error("Error testing mod_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (uint32_t)(testi64a >> 32), (uint32_t)testi64a, testi32a, resulti32, expectedi32); resultu32 = modu_64x32(testu64a, testu32a); - expectedu32 = testu64a % (UINT64)testu32a; + expectedu32 = testu64a % (uint64_t)testu32a; if (resultu32 != expectedu32) - osd_printf_error("Error testing modu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (UINT32)(testu64a >> 32), (UINT32)testu64a, testu32a, resultu32, expectedu32); + osd_printf_error("Error testing modu_64x32 (%08X%08X / %08X) = %08X (expected %08X)\n", (uint32_t)(testu64a >> 32), (uint32_t)testu64a, testu32a, resultu32, expectedu32); - while ((INT64)testi32a * (INT64)0x7fffffff < ((INT32)testi64a << 3)) + while ((int64_t)testi32a * (int64_t)0x7fffffff < ((int32_t)testi64a << 3)) testi64a /= 2; - while ((UINT64)testu32a * (UINT64)0xffffffff < ((UINT32)testu64a << 3)) + while ((uint64_t)testu32a * (uint64_t)0xffffffff < ((uint32_t)testu64a << 3)) testu64a /= 2; - resulti32 = div_32x32_shift((INT32)testi64a, testi32a, 3); - expectedi32 = ((INT64)(INT32)testi64a << 3) / (INT64)testi32a; + resulti32 = div_32x32_shift((int32_t)testi64a, testi32a, 3); + expectedi32 = ((int64_t)(int32_t)testi64a << 3) / (int64_t)testi32a; if (resulti32 != expectedi32) - osd_printf_error("Error testing div_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (INT32)testi64a, testi32a, resulti32, expectedi32); + osd_printf_error("Error testing div_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (int32_t)testi64a, testi32a, resulti32, expectedi32); - resultu32 = divu_32x32_shift((UINT32)testu64a, testu32a, 3); - expectedu32 = ((UINT64)(UINT32)testu64a << 3) / (UINT64)testu32a; + resultu32 = divu_32x32_shift((uint32_t)testu64a, testu32a, 3); + expectedu32 = ((uint64_t)(uint32_t)testu64a << 3) / (uint64_t)testu32a; if (resultu32 != expectedu32) - osd_printf_error("Error testing divu_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (UINT32)testu64a, testu32a, resultu32, expectedu32); + osd_printf_error("Error testing divu_32x32_shift (%08X << 3) / %08X = %08X (expected %08X)\n", (uint32_t)testu64a, testu32a, resultu32, expectedu32); if (fabsf(recip_approx(100.0f) - 0.01f) > 0.0001f) osd_printf_error("Error testing recip_approx\n"); @@ -527,38 +527,38 @@ void validity_checker::validate_rgb() The following functions are not tested yet: rgbaint_t() - clamp_and_clear(const UINT32) - sign_extend(const UINT32, const UINT32) - min(const INT32) - max(const INT32) - blend(const rgbaint_t&, UINT8) + clamp_and_clear(const uint32_t) + sign_extend(const uint32_t, const uint32_t) + min(const int32_t) + max(const int32_t) + blend(const rgbaint_t&, uint8_t) scale_and_clamp(const rgbaint_t&) - scale_imm_and_clamp(const INT32) + scale_imm_and_clamp(const int32_t) scale2_add_and_clamp(const rgbaint_t&, const rgbaint_t&, const rgbaint_t&) scale_add_and_clamp(const rgbaint_t&, const rgbaint_t&); - scale_imm_add_and_clamp(const INT32, const rgbaint_t&); - static bilinear_filter(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8) - bilinear_filter_rgbaint(UINT32, UINT32, UINT32, UINT32, UINT8, UINT8) + scale_imm_add_and_clamp(const int32_t, const rgbaint_t&); + static bilinear_filter(uint32_t, uint32_t, uint32_t, uint32_t, uint8_t, uint8_t) + bilinear_filter_rgbaint(uint32_t, uint32_t, uint32_t, uint32_t, uint8_t, uint8_t) */ auto random_i32_nolimit = [this] { - INT32 result; - do { result = random_i32(); } while ((result == std::numeric_limits<INT32>::min()) || (result == std::numeric_limits<INT32>::max())); + int32_t result; + do { result = random_i32(); } while ((result == std::numeric_limits<int32_t>::min()) || (result == std::numeric_limits<int32_t>::max())); return result; }; - volatile INT32 expected_a, expected_r, expected_g, expected_b; - volatile INT32 actual_a, actual_r, actual_g, actual_b; - volatile INT32 imm; + volatile int32_t expected_a, expected_r, expected_g, expected_b; + volatile int32_t actual_a, actual_r, actual_g, actual_b; + volatile int32_t imm; rgbaint_t rgb, other; rgb_t packed; auto check_expected = [&] (const char *desc) { - const volatile INT32 a = rgb.get_a32(); - const volatile INT32 r = rgb.get_r32(); - const volatile INT32 g = rgb.get_g32(); - const volatile INT32 b = rgb.get_b32(); + const volatile int32_t a = rgb.get_a32(); + const volatile int32_t r = rgb.get_r32(); + const volatile int32_t g = rgb.get_g32(); + const volatile int32_t b = rgb.get_b32(); if (a != expected_a) osd_printf_error("Error testing %s get_a32() = %d (expected %d)\n", desc, a, expected_a); if (r != expected_r) osd_printf_error("Error testing %s get_r32() = %d (expected %d)\n", desc, r, expected_r); if (g != expected_g) osd_printf_error("Error testing %s get_g32() = %d (expected %d)\n", desc, g, expected_g); @@ -830,14 +830,14 @@ void validity_checker::validate_rgb() check_expected("rgbaint_t::xor_imm_rgba"); // test 8-bit get - expected_a = INT32(UINT32(expected_a) & 0x00ff); - expected_r = INT32(UINT32(expected_r) & 0x00ff); - expected_g = INT32(UINT32(expected_g) & 0x00ff); - expected_b = INT32(UINT32(expected_b) & 0x00ff); - actual_a = INT32(UINT32(rgb.get_a())); - actual_r = INT32(UINT32(rgb.get_r())); - actual_g = INT32(UINT32(rgb.get_g())); - actual_b = INT32(UINT32(rgb.get_b())); + expected_a = int32_t(uint32_t(expected_a) & 0x00ff); + expected_r = int32_t(uint32_t(expected_r) & 0x00ff); + expected_g = int32_t(uint32_t(expected_g) & 0x00ff); + expected_b = int32_t(uint32_t(expected_b) & 0x00ff); + actual_a = int32_t(uint32_t(rgb.get_a())); + actual_r = int32_t(uint32_t(rgb.get_r())); + actual_g = int32_t(uint32_t(rgb.get_g())); + actual_b = int32_t(uint32_t(rgb.get_b())); if (actual_a != expected_a) osd_printf_error("Error testing rgbaint_t::get_a() = %d (expected %d)\n", actual_a, expected_a); if (actual_r != expected_r) osd_printf_error("Error testing rgbaint_t::get_r() = %d (expected %d)\n", actual_r, expected_r); if (actual_g != expected_g) osd_printf_error("Error testing rgbaint_t::get_g() = %d (expected %d)\n", actual_g, expected_g); @@ -845,88 +845,88 @@ void validity_checker::validate_rgb() // test set from packed RGBA imm = random_i32(); - expected_a = INT32((UINT32(imm) >> 24) & 0x00ff); - expected_r = INT32((UINT32(imm) >> 16) & 0x00ff); - expected_g = INT32((UINT32(imm) >> 8) & 0x00ff); - expected_b = INT32((UINT32(imm) >> 0) & 0x00ff); - rgb.set(UINT32(imm)); - check_expected("rgbaint_t::set(UINT32)"); + expected_a = int32_t((uint32_t(imm) >> 24) & 0x00ff); + expected_r = int32_t((uint32_t(imm) >> 16) & 0x00ff); + expected_g = int32_t((uint32_t(imm) >> 8) & 0x00ff); + expected_b = int32_t((uint32_t(imm) >> 0) & 0x00ff); + rgb.set(uint32_t(imm)); + check_expected("rgbaint_t::set(uint32_t)"); // while we have a value loaded that we know doesn't exceed 8-bit range, check the non-clamping convert-to-rgba packed = rgb.to_rgba(); - if (UINT32(imm) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba() = %08x (expected %08x)\n", UINT32(packed), UINT32(imm)); + if (uint32_t(imm) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba() = %08x (expected %08x)\n", uint32_t(packed), uint32_t(imm)); // test construct from packed RGBA and assign imm = random_i32(); - expected_a = INT32((UINT32(imm) >> 24) & 0x00ff); - expected_r = INT32((UINT32(imm) >> 16) & 0x00ff); - expected_g = INT32((UINT32(imm) >> 8) & 0x00ff); - expected_b = INT32((UINT32(imm) >> 0) & 0x00ff); - rgb = rgbaint_t(UINT32(imm)); - check_expected("rgbaint_t(UINT32)"); + expected_a = int32_t((uint32_t(imm) >> 24) & 0x00ff); + expected_r = int32_t((uint32_t(imm) >> 16) & 0x00ff); + expected_g = int32_t((uint32_t(imm) >> 8) & 0x00ff); + expected_b = int32_t((uint32_t(imm) >> 0) & 0x00ff); + rgb = rgbaint_t(uint32_t(imm)); + check_expected("rgbaint_t(uint32_t)"); // while we have a value loaded that we know doesn't exceed 8-bit range, check the non-clamping convert-to-rgba packed = rgb.to_rgba(); - if (UINT32(imm) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba() = %08x (expected %08x)\n", UINT32(packed), UINT32(imm)); + if (uint32_t(imm) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba() = %08x (expected %08x)\n", uint32_t(packed), uint32_t(imm)); // test set with rgb_t packed = random_u32(); - expected_a = INT32(UINT32(packed.a())); - expected_r = INT32(UINT32(packed.r())); - expected_g = INT32(UINT32(packed.g())); - expected_b = INT32(UINT32(packed.b())); + expected_a = int32_t(uint32_t(packed.a())); + expected_r = int32_t(uint32_t(packed.r())); + expected_g = int32_t(uint32_t(packed.g())); + expected_b = int32_t(uint32_t(packed.b())); rgb.set(packed); check_expected("rgbaint_t::set(rgba_t)"); // test construct with rgb_t packed = random_u32(); - expected_a = INT32(UINT32(packed.a())); - expected_r = INT32(UINT32(packed.r())); - expected_g = INT32(UINT32(packed.g())); - expected_b = INT32(UINT32(packed.b())); + expected_a = int32_t(uint32_t(packed.a())); + expected_r = int32_t(uint32_t(packed.r())); + expected_g = int32_t(uint32_t(packed.g())); + expected_b = int32_t(uint32_t(packed.b())); rgb = rgbaint_t(packed); check_expected("rgbaint_t::set(rgba_t)"); // test clamping convert-to-rgba with hand-crafted values to catch edge cases - rgb.set(std::numeric_limits<INT32>::min(), -1, 0, 1); + rgb.set(std::numeric_limits<int32_t>::min(), -1, 0, 1); packed = rgb.to_rgba_clamp(); - if (UINT32(0x00000001) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0x00000001)\n", UINT32(packed)); - rgb.set(254, 255, 256, std::numeric_limits<INT32>::max()); + if (uint32_t(0x00000001) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0x00000001)\n", uint32_t(packed)); + rgb.set(254, 255, 256, std::numeric_limits<int32_t>::max()); packed = rgb.to_rgba_clamp(); - if (UINT32(0xfeffffff) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0xfeffffff)\n", UINT32(packed)); - rgb.set(std::numeric_limits<INT32>::max(), std::numeric_limits<INT32>::min(), 256, -1); + if (uint32_t(0xfeffffff) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0xfeffffff)\n", uint32_t(packed)); + rgb.set(std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::min(), 256, -1); packed = rgb.to_rgba_clamp(); - if (UINT32(0xff00ff00) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0xff00ff00)\n", UINT32(packed)); + if (uint32_t(0xff00ff00) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0xff00ff00)\n", uint32_t(packed)); rgb.set(0, 255, 1, 254); packed = rgb.to_rgba_clamp(); - if (UINT32(0x00ff01fe) != UINT32(packed)) - osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0x00ff01fe)\n", UINT32(packed)); + if (uint32_t(0x00ff01fe) != uint32_t(packed)) + osd_printf_error("Error testing rgbaint_t::to_rgba_clamp() = %08x (expected 0x00ff01fe)\n", uint32_t(packed)); // test in-place clamping with hand-crafted values to catch edge cases expected_a = 0; expected_r = 0; expected_g = 0; expected_b = 1; - rgb.set(std::numeric_limits<INT32>::min(), -1, 0, 1); + rgb.set(std::numeric_limits<int32_t>::min(), -1, 0, 1); rgb.clamp_to_uint8(); check_expected("rgbaint_t::clamp_to_uint8"); expected_a = 254; expected_r = 255; expected_g = 255; expected_b = 255; - rgb.set(254, 255, 256, std::numeric_limits<INT32>::max()); + rgb.set(254, 255, 256, std::numeric_limits<int32_t>::max()); rgb.clamp_to_uint8(); check_expected("rgbaint_t::clamp_to_uint8"); expected_a = 255; expected_r = 0; expected_g = 255; expected_b = 0; - rgb.set(std::numeric_limits<INT32>::max(), std::numeric_limits<INT32>::min(), 256, -1); + rgb.set(std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::min(), 256, -1); rgb.clamp_to_uint8(); check_expected("rgbaint_t::clamp_to_uint8"); expected_a = 0; @@ -956,37 +956,37 @@ void validity_checker::validate_rgb() check_expected("rgbaint_t::shl_imm"); // test logical shift right - expected_a = INT32(UINT32(actual_a = random_i32()) >> 8); - expected_r = INT32(UINT32(actual_r = random_i32()) >> 18); - expected_g = INT32(UINT32(actual_g = random_i32()) >> 26); - expected_b = INT32(UINT32(actual_b = random_i32()) >> 4); + expected_a = int32_t(uint32_t(actual_a = random_i32()) >> 8); + expected_r = int32_t(uint32_t(actual_r = random_i32()) >> 18); + expected_g = int32_t(uint32_t(actual_g = random_i32()) >> 26); + expected_b = int32_t(uint32_t(actual_b = random_i32()) >> 4); rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.shr(rgbaint_t(8, 18, 26, 4)); check_expected("rgbaint_t::shr"); // test logical shift right with opposite signs - expected_a = INT32(UINT32(actual_a = -actual_a) >> 21); - expected_r = INT32(UINT32(actual_r = -actual_r) >> 13); - expected_g = INT32(UINT32(actual_g = -actual_g) >> 11); - expected_b = INT32(UINT32(actual_b = -actual_b) >> 17); + expected_a = int32_t(uint32_t(actual_a = -actual_a) >> 21); + expected_r = int32_t(uint32_t(actual_r = -actual_r) >> 13); + expected_g = int32_t(uint32_t(actual_g = -actual_g) >> 11); + expected_b = int32_t(uint32_t(actual_b = -actual_b) >> 17); rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.shr(rgbaint_t(21, 13, 11, 17)); check_expected("rgbaint_t::shr"); // test logical shift right immediate - expected_a = INT32(UINT32(actual_a = random_i32()) >> 5); - expected_r = INT32(UINT32(actual_r = random_i32()) >> 5); - expected_g = INT32(UINT32(actual_g = random_i32()) >> 5); - expected_b = INT32(UINT32(actual_b = random_i32()) >> 5); + expected_a = int32_t(uint32_t(actual_a = random_i32()) >> 5); + expected_r = int32_t(uint32_t(actual_r = random_i32()) >> 5); + expected_g = int32_t(uint32_t(actual_g = random_i32()) >> 5); + expected_b = int32_t(uint32_t(actual_b = random_i32()) >> 5); rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.shr_imm(5); check_expected("rgbaint_t::shr_imm"); // test logical shift right immediate with opposite signs - expected_a = INT32(UINT32(actual_a = -actual_a) >> 15); - expected_r = INT32(UINT32(actual_r = -actual_r) >> 15); - expected_g = INT32(UINT32(actual_g = -actual_g) >> 15); - expected_b = INT32(UINT32(actual_b = -actual_b) >> 15); + expected_a = int32_t(uint32_t(actual_a = -actual_a) >> 15); + expected_r = int32_t(uint32_t(actual_r = -actual_r) >> 15); + expected_g = int32_t(uint32_t(actual_g = -actual_g) >> 15); + expected_b = int32_t(uint32_t(actual_b = -actual_b) >> 15); rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.shr_imm(15); check_expected("rgbaint_t::shr_imm"); @@ -1050,19 +1050,19 @@ void validity_checker::validate_rgb() actual_r = random_i32_nolimit(); actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); - expected_a = ~INT32(0); + expected_a = ~int32_t(0); expected_r = 0; expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min())); + rgb.cmpeq(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<int32_t>::min())); check_expected("rgbaint_t::cmpeq"); expected_a = 0; - expected_r = ~INT32(0); + expected_r = ~int32_t(0); expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1)); + rgb.cmpeq(rgbaint_t(std::numeric_limits<int32_t>::max(), actual_r, actual_g - 1, actual_b + 1)); check_expected("rgbaint_t::cmpeq"); // test immediate equality comparison @@ -1070,31 +1070,31 @@ void validity_checker::validate_rgb() actual_r = random_i32_nolimit(); actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); - expected_a = ~INT32(0); - expected_r = (actual_r == actual_a) ? ~INT32(0) : 0; - expected_g = (actual_g == actual_a) ? ~INT32(0) : 0; - expected_b = (actual_b == actual_a) ? ~INT32(0) : 0; + expected_a = ~int32_t(0); + expected_r = (actual_r == actual_a) ? ~int32_t(0) : 0; + expected_g = (actual_g == actual_a) ? ~int32_t(0) : 0; + expected_b = (actual_b == actual_a) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpeq_imm(actual_a); check_expected("rgbaint_t::cmpeq_imm"); - expected_a = (actual_a == actual_r) ? ~INT32(0) : 0; - expected_r = ~INT32(0); - expected_g = (actual_g == actual_r) ? ~INT32(0) : 0; - expected_b = (actual_b == actual_r) ? ~INT32(0) : 0; + expected_a = (actual_a == actual_r) ? ~int32_t(0) : 0; + expected_r = ~int32_t(0); + expected_g = (actual_g == actual_r) ? ~int32_t(0) : 0; + expected_b = (actual_b == actual_r) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpeq_imm(actual_r); check_expected("rgbaint_t::cmpeq_imm"); - expected_a = (actual_a == actual_g) ? ~INT32(0) : 0; - expected_r = (actual_r == actual_g) ? ~INT32(0) : 0; - expected_g = ~INT32(0); - expected_b = (actual_b == actual_g) ? ~INT32(0) : 0; + expected_a = (actual_a == actual_g) ? ~int32_t(0) : 0; + expected_r = (actual_r == actual_g) ? ~int32_t(0) : 0; + expected_g = ~int32_t(0); + expected_b = (actual_b == actual_g) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpeq_imm(actual_g); check_expected("rgbaint_t::cmpeq_imm"); - expected_a = (actual_a == actual_b) ? ~INT32(0) : 0; - expected_r = (actual_r == actual_b) ? ~INT32(0) : 0; - expected_g = (actual_g == actual_b) ? ~INT32(0) : 0; - expected_b = ~INT32(0); + expected_a = (actual_a == actual_b) ? ~int32_t(0) : 0; + expected_r = (actual_r == actual_b) ? ~int32_t(0) : 0; + expected_g = (actual_g == actual_b) ? ~int32_t(0) : 0; + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpeq_imm(actual_b); check_expected("rgbaint_t::cmpeq_imm"); @@ -1103,12 +1103,12 @@ void validity_checker::validate_rgb() expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq_imm(std::numeric_limits<INT32>::min()); + rgb.cmpeq_imm(std::numeric_limits<int32_t>::min()); check_expected("rgbaint_t::cmpeq_imm"); - expected_a = !actual_a ? ~INT32(0) : 0; - expected_r = !actual_r ? ~INT32(0) : 0; - expected_g = !actual_g ? ~INT32(0) : 0; - expected_b = !actual_b ? ~INT32(0) : 0; + expected_a = !actual_a ? ~int32_t(0) : 0; + expected_r = !actual_r ? ~int32_t(0) : 0; + expected_g = !actual_g ? ~int32_t(0) : 0; + expected_b = !actual_b ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpeq_imm(0); check_expected("rgbaint_t::cmpeq_imm"); @@ -1117,7 +1117,7 @@ void validity_checker::validate_rgb() expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq_imm(std::numeric_limits<INT32>::max()); + rgb.cmpeq_imm(std::numeric_limits<int32_t>::max()); check_expected("rgbaint_t::cmpeq_imm"); // test immediate RGB equality comparison @@ -1127,17 +1127,17 @@ void validity_checker::validate_rgb() actual_b = random_i32_nolimit(); expected_a = 0; expected_r = 0; - expected_g = ~INT32(0); + expected_g = ~int32_t(0); expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1); + rgb.cmpeq_imm_rgba(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_g, actual_b - 1); check_expected("rgbaint_t::cmpeq_imm_rgba"); expected_a = 0; expected_r = 0; expected_g = 0; - expected_b = ~INT32(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpeq_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b); + rgb.cmpeq_imm_rgba(actual_a + 1, std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_b); check_expected("rgbaint_t::cmpeq_imm_rgba"); // test RGB greater than comparison @@ -1146,18 +1146,18 @@ void validity_checker::validate_rgb() actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); expected_a = 0; - expected_r = ~INT32(0); + expected_r = ~int32_t(0); expected_g = 0; - expected_b = ~INT32(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min())); + rgb.cmpgt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<int32_t>::min())); check_expected("rgbaint_t::cmpgt"); expected_a = 0; expected_r = 0; - expected_g = ~INT32(0); + expected_g = ~int32_t(0); expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1)); + rgb.cmpgt(rgbaint_t(std::numeric_limits<int32_t>::max(), actual_r, actual_g - 1, actual_b + 1)); check_expected("rgbaint_t::cmpgt"); // test immediate greater than comparison @@ -1166,44 +1166,44 @@ void validity_checker::validate_rgb() actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); expected_a = 0; - expected_r = (actual_r > actual_a) ? ~INT32(0) : 0; - expected_g = (actual_g > actual_a) ? ~INT32(0) : 0; - expected_b = (actual_b > actual_a) ? ~INT32(0) : 0; + expected_r = (actual_r > actual_a) ? ~int32_t(0) : 0; + expected_g = (actual_g > actual_a) ? ~int32_t(0) : 0; + expected_b = (actual_b > actual_a) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpgt_imm(actual_a); check_expected("rgbaint_t::cmpgt_imm"); - expected_a = (actual_a > actual_r) ? ~INT32(0) : 0; + expected_a = (actual_a > actual_r) ? ~int32_t(0) : 0; expected_r = 0; - expected_g = (actual_g > actual_r) ? ~INT32(0) : 0; - expected_b = (actual_b > actual_r) ? ~INT32(0) : 0; + expected_g = (actual_g > actual_r) ? ~int32_t(0) : 0; + expected_b = (actual_b > actual_r) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpgt_imm(actual_r); check_expected("rgbaint_t::cmpgt_imm"); - expected_a = (actual_a > actual_g) ? ~INT32(0) : 0; - expected_r = (actual_r > actual_g) ? ~INT32(0) : 0; + expected_a = (actual_a > actual_g) ? ~int32_t(0) : 0; + expected_r = (actual_r > actual_g) ? ~int32_t(0) : 0; expected_g =0; - expected_b = (actual_b > actual_g) ? ~INT32(0) : 0; + expected_b = (actual_b > actual_g) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpgt_imm(actual_g); check_expected("rgbaint_t::cmpgt_imm"); - expected_a = (actual_a > actual_b) ? ~INT32(0) : 0; - expected_r = (actual_r > actual_b) ? ~INT32(0) : 0; - expected_g = (actual_g > actual_b) ? ~INT32(0) : 0; + expected_a = (actual_a > actual_b) ? ~int32_t(0) : 0; + expected_r = (actual_r > actual_b) ? ~int32_t(0) : 0; + expected_g = (actual_g > actual_b) ? ~int32_t(0) : 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpgt_imm(actual_b); check_expected("rgbaint_t::cmpgt_imm"); - expected_a = ~INT32(0); - expected_r = ~INT32(0); - expected_g = ~INT32(0); - expected_b = ~INT32(0); + expected_a = ~int32_t(0); + expected_r = ~int32_t(0); + expected_g = ~int32_t(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt_imm(std::numeric_limits<INT32>::min()); + rgb.cmpgt_imm(std::numeric_limits<int32_t>::min()); check_expected("rgbaint_t::cmpgt_imm"); - expected_a = (actual_a > 0) ? ~INT32(0) : 0; - expected_r = (actual_r > 0) ? ~INT32(0) : 0; - expected_g = (actual_g > 0) ? ~INT32(0) : 0; - expected_b = (actual_b > 0) ? ~INT32(0) : 0; + expected_a = (actual_a > 0) ? ~int32_t(0) : 0; + expected_r = (actual_r > 0) ? ~int32_t(0) : 0; + expected_g = (actual_g > 0) ? ~int32_t(0) : 0; + expected_b = (actual_b > 0) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmpgt_imm(0); check_expected("rgbaint_t::cmpgt_imm"); @@ -1212,7 +1212,7 @@ void validity_checker::validate_rgb() expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt_imm(std::numeric_limits<INT32>::max()); + rgb.cmpgt_imm(std::numeric_limits<int32_t>::max()); check_expected("rgbaint_t::cmpgt_imm"); // test immediate RGB greater than comparison @@ -1220,19 +1220,19 @@ void validity_checker::validate_rgb() actual_r = random_i32_nolimit(); actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); - expected_a = ~INT32(0); + expected_a = ~int32_t(0); expected_r = 0; expected_g = 0; - expected_b = ~INT32(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1); + rgb.cmpgt_imm_rgba(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_g, actual_b - 1); check_expected("rgbaint_t::cmpgt_imm_rgba"); expected_a = 0; - expected_r = ~INT32(0); + expected_r = ~int32_t(0); expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmpgt_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b); + rgb.cmpgt_imm_rgba(actual_a + 1, std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_b); check_expected("rgbaint_t::cmpgt_imm_rgba"); // test RGB less than comparison @@ -1242,17 +1242,17 @@ void validity_checker::validate_rgb() actual_b = random_i32_nolimit(); expected_a = 0; expected_r = 0; - expected_g = ~INT32(0); + expected_g = ~int32_t(0); expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<INT32>::min())); + rgb.cmplt(rgbaint_t(actual_a, actual_r - 1, actual_g + 1, std::numeric_limits<int32_t>::min())); check_expected("rgbaint_t::cmplt"); - expected_a = ~INT32(0); + expected_a = ~int32_t(0); expected_r = 0; expected_g = 0; - expected_b = ~INT32(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt(rgbaint_t(std::numeric_limits<INT32>::max(), actual_r, actual_g - 1, actual_b + 1)); + rgb.cmplt(rgbaint_t(std::numeric_limits<int32_t>::max(), actual_r, actual_g - 1, actual_b + 1)); check_expected("rgbaint_t::cmplt"); // test immediate less than comparison @@ -1261,29 +1261,29 @@ void validity_checker::validate_rgb() actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); expected_a = 0; - expected_r = (actual_r < actual_a) ? ~INT32(0) : 0; - expected_g = (actual_g < actual_a) ? ~INT32(0) : 0; - expected_b = (actual_b < actual_a) ? ~INT32(0) : 0; + expected_r = (actual_r < actual_a) ? ~int32_t(0) : 0; + expected_g = (actual_g < actual_a) ? ~int32_t(0) : 0; + expected_b = (actual_b < actual_a) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmplt_imm(actual_a); check_expected("rgbaint_t::cmplt_imm"); - expected_a = (actual_a < actual_r) ? ~INT32(0) : 0; + expected_a = (actual_a < actual_r) ? ~int32_t(0) : 0; expected_r = 0; - expected_g = (actual_g < actual_r) ? ~INT32(0) : 0; - expected_b = (actual_b < actual_r) ? ~INT32(0) : 0; + expected_g = (actual_g < actual_r) ? ~int32_t(0) : 0; + expected_b = (actual_b < actual_r) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmplt_imm(actual_r); check_expected("rgbaint_t::cmplt_imm"); - expected_a = (actual_a < actual_g) ? ~INT32(0) : 0; - expected_r = (actual_r < actual_g) ? ~INT32(0) : 0; + expected_a = (actual_a < actual_g) ? ~int32_t(0) : 0; + expected_r = (actual_r < actual_g) ? ~int32_t(0) : 0; expected_g =0; - expected_b = (actual_b < actual_g) ? ~INT32(0) : 0; + expected_b = (actual_b < actual_g) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmplt_imm(actual_g); check_expected("rgbaint_t::cmplt_imm"); - expected_a = (actual_a < actual_b) ? ~INT32(0) : 0; - expected_r = (actual_r < actual_b) ? ~INT32(0) : 0; - expected_g = (actual_g < actual_b) ? ~INT32(0) : 0; + expected_a = (actual_a < actual_b) ? ~int32_t(0) : 0; + expected_r = (actual_r < actual_b) ? ~int32_t(0) : 0; + expected_g = (actual_g < actual_b) ? ~int32_t(0) : 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmplt_imm(actual_b); @@ -1293,21 +1293,21 @@ void validity_checker::validate_rgb() expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt_imm(std::numeric_limits<INT32>::min()); + rgb.cmplt_imm(std::numeric_limits<int32_t>::min()); check_expected("rgbaint_t::cmplt_imm"); - expected_a = (actual_a < 0) ? ~INT32(0) : 0; - expected_r = (actual_r < 0) ? ~INT32(0) : 0; - expected_g = (actual_g < 0) ? ~INT32(0) : 0; - expected_b = (actual_b < 0) ? ~INT32(0) : 0; + expected_a = (actual_a < 0) ? ~int32_t(0) : 0; + expected_r = (actual_r < 0) ? ~int32_t(0) : 0; + expected_g = (actual_g < 0) ? ~int32_t(0) : 0; + expected_b = (actual_b < 0) ? ~int32_t(0) : 0; rgb.set(actual_a, actual_r, actual_g, actual_b); rgb.cmplt_imm(0); check_expected("rgbaint_t::cmplt_imm"); - expected_a = ~INT32(0); - expected_r = ~INT32(0); - expected_g = ~INT32(0); - expected_b = ~INT32(0); + expected_a = ~int32_t(0); + expected_r = ~int32_t(0); + expected_g = ~int32_t(0); + expected_b = ~int32_t(0); rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt_imm(std::numeric_limits<INT32>::max()); + rgb.cmplt_imm(std::numeric_limits<int32_t>::max()); check_expected("rgbaint_t::cmplt_imm"); // test immediate RGB less than comparison @@ -1316,18 +1316,18 @@ void validity_checker::validate_rgb() actual_g = random_i32_nolimit(); actual_b = random_i32_nolimit(); expected_a = 0; - expected_r = ~INT32(0); + expected_r = ~int32_t(0); expected_g = 0; expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt_imm_rgba(std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_g, actual_b - 1); + rgb.cmplt_imm_rgba(std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_g, actual_b - 1); check_expected("rgbaint_t::cmplt_imm_rgba"); - expected_a = ~INT32(0); + expected_a = ~int32_t(0); expected_r = 0; - expected_g = ~INT32(0); + expected_g = ~int32_t(0); expected_b = 0; rgb.set(actual_a, actual_r, actual_g, actual_b); - rgb.cmplt_imm_rgba(actual_a + 1, std::numeric_limits<INT32>::min(), std::numeric_limits<INT32>::max(), actual_b); + rgb.cmplt_imm_rgba(actual_a + 1, std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(), actual_b); check_expected("rgbaint_t::cmplt_imm_rgba"); } @@ -1388,7 +1388,7 @@ void validity_checker::validate_driver() // make sure the year is only digits, '?' or '+' for (const char *s = m_current_driver->year; *s != 0; s++) - if (!isdigit((UINT8)*s) && *s != '?' && *s != '+') + if (!isdigit((uint8_t)*s) && *s != '?' && *s != '+') { osd_printf_error("Driver has an invalid year '%s'\n", m_current_driver->year); break; @@ -1437,7 +1437,7 @@ void validity_checker::validate_roms() // scan the ROM entries for this device const char *last_region_name = "???"; const char *last_name = "???"; - UINT32 current_length = 0; + uint32_t current_length = 0; int items_since_region = 1; int last_bios = 0; int total_files = 0; @@ -1538,7 +1538,7 @@ void validity_checker::validate_analog_input_field(ioport_field &field) for (shift = 0; shift <= 31 && (~field.mask() & (1 << shift)) != 0; shift++) { } // convert the positional max value to be in the bitmask for testing - //INT32 analog_max = field.maxval(); + //int32_t analog_max = field.maxval(); //analog_max = (analog_max - 1) << shift; // positional port size must fit in bits used @@ -1550,9 +1550,9 @@ void validity_checker::validate_analog_input_field(ioport_field &field) else if (field.type() > IPT_ANALOG_ABSOLUTE_FIRST && field.type() < IPT_ANALOG_ABSOLUTE_LAST) { // adjust for signed values - INT32 default_value = field.defvalue(); - INT32 analog_min = field.minval(); - INT32 analog_max = field.maxval(); + int32_t default_value = field.defvalue(); + int32_t analog_min = field.minval(); + int32_t analog_max = field.maxval(); if (analog_min > analog_max) { analog_min = -analog_min; @@ -1606,7 +1606,7 @@ void validity_checker::validate_dip_settings(ioport_field &field) { const char *demo_sounds = ioport_string_from_index(INPUT_STRING_Demo_Sounds); const char *flipscreen = ioport_string_from_index(INPUT_STRING_Flip_Screen); - UINT8 coin_list[__input_string_coinage_end + 1 - __input_string_coinage_start] = { 0 }; + uint8_t coin_list[__input_string_coinage_end + 1 - __input_string_coinage_start] = { 0 }; bool coin_error = false; // iterate through the settings |