lang: Write 64-bit limits as integer literals

a4b828fcbe047d790f1ac0ce402953be0adb4ac4e8bd2f174a5e5d6cc1a67e55
The compiler now parses 64-bit literals, so define `U64_MAX`, `I64_MIN`
and `I64_MAX` as constants instead of computing them at run time, and
remove `u64Max`, `i64Min` and `i64Max`.
Alexis Sellier committed ago 1 parent 8b7c02ca
lib/std/lang/parser.rad +4 -12
9 9
use std::lang::strings;
10 10
use std::lang::scanner;
11 11
12 12
/// Maximum `u32` value.
13 13
pub const U32_MAX: u32 = 0xFFFFFFFF;
14 -
/// Maximum representable `u64` value, `0xFFFFFFFFFFFFFFFF`.
15 -
///
16 -
/// Built from 32-bit halves at run time.
17 -
pub fn u64Max() -> u64 {
18 -
    let lo: u32 = 0xFFFFFFFF;
19 -
    let lo64 = lo as u64;
20 -
21 -
    return (lo64 << 32) | lo64;
22 -
}
14 +
/// Maximum representable `u64` value.
15 +
pub const U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;
23 16
/// Maximum number of fields in a record.
24 17
pub const MAX_RECORD_FIELDS: u32 = 32;
25 18
26 19
/// Maximum number of parser errors before aborting.
27 20
const MAX_ERRORS: u32 = 8;
227 220
            throw failParsing(p, "integer literal prefix must be followed by digits");
228 221
        }
229 222
    }
230 223
    let mut value: u64 = 0;
231 224
    let radix64: u64 = radix as u64;
232 -
    let max = u64Max();
233 225
    for i in start..text.len {
234 226
        let ch = text[i];
235 227
        let digit = digitFromAscii(ch, radix) else {
236 228
            throw failParsing(p, "invalid digit in integer literal");
237 229
        };
238 -
        if value > (max / radix64) {
230 +
        if value > (U64_MAX / radix64) {
239 231
            throw failParsing(p, "integer literal overflow");
240 232
        }
241 233
        value = value * radix64;
242 234
243 -
        if value > max - (digit as u64) {
235 +
        if value > U64_MAX - (digit as u64) {
244 236
            throw failParsing(p, "integer literal overflow");
245 237
        }
246 238
        value = value + (digit as u64);
247 239
    }
248 240
    return ast::IntLiteral {
lib/std/lang/resolver.rad +6 -14
65 65
66 66
/// Minimum `i32` value.
67 67
const I32_MIN: i32 = -2147483648;
68 68
/// Maximum `i32` value.
69 69
const I32_MAX: i32 = 2147483647;
70 -
71 70
/// Minimum `i64` value: -(2^63).
72 -
///
73 -
/// Built from 32-bit halves at run time.
74 -
fn i64Min() -> i64 {
75 -
    return 0 - i64Max() - 1;
76 -
}
77 -
71 +
const I64_MIN: i64 = -9223372036854775808;
78 72
/// Maximum `i64` value: 2^63 - 1.
79 -
fn i64Max() -> i64 {
80 -
    return (parser::u64Max() >> 1) as i64;
81 -
}
73 +
const I64_MAX: i64 = 9223372036854775807;
82 74
83 75
/// Size of a pointer in bytes.
84 76
pub const PTR_SIZE: u32 = 8;
85 77
86 78
/// Information about a record or tuple field.
1416 1408
            max: I32_MAX as i64,
1417 1409
            lim: (I32_MAX as u64) + 1,
1418 1410
        },
1419 1411
        case Type::I64 => return IntegerRange::Signed {
1420 1412
            bits: 64,
1421 -
            min: i64Min(),
1422 -
            max: i64Max(),
1423 -
            lim: (i64Max() as u64) + 1,
1413 +
            min: I64_MIN,
1414 +
            max: I64_MAX,
1415 +
            lim: (I64_MAX as u64) + 1,
1424 1416
        },
1425 1417
        case Type::Int => return IntegerRange::Signed {
1426 1418
            bits: 32,
1427 1419
            min: I32_MIN as i64,
1428 1420
            max: I32_MAX as i64,
1429 1421
            lim: (I32_MAX as u64) + 1,
1430 1422
        },
1431 1423
        case Type::U8 => return IntegerRange::Unsigned { bits: 8, max: U8_MAX as u64 },
1432 1424
        case Type::U16 => return IntegerRange::Unsigned { bits: 16, max: U16_MAX as u64 },
1433 1425
        case Type::U32 => return IntegerRange::Unsigned { bits: 32, max: parser::U32_MAX as u64 },
1434 -
        case Type::U64 => return IntegerRange::Unsigned { bits: 64, max: parser::u64Max() },
1426 +
        case Type::U64 => return IntegerRange::Unsigned { bits: 64, max: parser::U64_MAX },
1435 1427
        else => return nil,
1436 1428
    }
1437 1429
}
1438 1430
1439 1431
/// Validate that an integer constant fits within the target type's range.