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`.
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. |