mirror of
https://github.com/ziglang/zig.git
synced 2025-01-26 20:06:39 +00:00
remove @minValue,@maxValue; add std.math.minInt,maxInt
closes #1466 closes #1476
This commit is contained in:
Andrew Kelley
parent
40b7652a6d
commit
2b395d4ede
@ -827,7 +827,7 @@ a +%= b{#endsyntax#}</pre></td>
|
||||
</ul>
|
||||
</td>
|
||||
<td>
|
||||
<pre>{#syntax#}u32(@maxValue(u32)) +% 1 == 0{#endsyntax#}</pre>
|
||||
<pre>{#syntax#}u32(std.math.maxInt(u32)) +% 1 == 0{#endsyntax#}</pre>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -866,7 +866,7 @@ a -%= b{#endsyntax#}</pre></td>
|
||||
</ul>
|
||||
</td>
|
||||
<td>
|
||||
<pre>{#syntax#}u32(0) -% 1 == @maxValue(u32){#endsyntax#}</pre>
|
||||
<pre>{#syntax#}u32(0) -% 1 == std.math.maxInt(u32){#endsyntax#}</pre>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -901,7 +901,7 @@ a -%= b{#endsyntax#}</pre></td>
|
||||
</ul>
|
||||
</td>
|
||||
<td>
|
||||
<pre>{#syntax#}-%i32(@minValue(i32)) == @minValue(i32){#endsyntax#}</pre>
|
||||
<pre>{#syntax#}-%i32(std.math.minInt(i32)) == std.math.minInt(i32){#endsyntax#}</pre>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -3298,6 +3298,9 @@ const err = (error.{FileNotFound}).FileNotFound;
|
||||
Here is a function to parse a string into a 64-bit integer:
|
||||
</p>
|
||||
{#code_begin|test#}
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn parseU64(buf: []const u8, radix: u8) !u64 {
|
||||
var x: u64 = 0;
|
||||
|
||||
@ -3327,13 +3330,13 @@ fn charToDigit(c: u8) u8 {
|
||||
'0' ... '9' => c - '0',
|
||||
'A' ... 'Z' => c - 'A' + 10,
|
||||
'a' ... 'z' => c - 'a' + 10,
|
||||
else => @maxValue(u8),
|
||||
else => maxInt(u8),
|
||||
};
|
||||
}
|
||||
|
||||
test "parse u64" {
|
||||
const result = try parseU64("1234", 10);
|
||||
@import("std").debug.assert(result == 1234);
|
||||
std.debug.assert(result == 1234);
|
||||
}
|
||||
{#code_end#}
|
||||
<p>
|
||||
@ -5539,7 +5542,7 @@ test "main" {
|
||||
<p>
|
||||
Floored division. Rounds toward negative infinity. For unsigned integers it is
|
||||
the same as {#syntax#}numerator / denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator != 0{#endsyntax#} and
|
||||
{#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1){#endsyntax#}.
|
||||
{#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1){#endsyntax#}.
|
||||
</p>
|
||||
<ul>
|
||||
<li>{#syntax#}@divFloor(-5, 3) == -2{#endsyntax#}</li>
|
||||
@ -5553,7 +5556,7 @@ test "main" {
|
||||
<p>
|
||||
Truncated division. Rounds toward zero. For unsigned integers it is
|
||||
the same as {#syntax#}numerator / denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator != 0{#endsyntax#} and
|
||||
{#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1){#endsyntax#}.
|
||||
{#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1){#endsyntax#}.
|
||||
</p>
|
||||
<ul>
|
||||
<li>{#syntax#}@divTrunc(-5, 3) == -1{#endsyntax#}</li>
|
||||
@ -5816,15 +5819,6 @@ fn add(a: i32, b: i32) i32 { return a + b; }
|
||||
This function returns an integer type with the given signness and bit count.
|
||||
</p>
|
||||
{#header_close#}
|
||||
{#header_open|@maxValue#}
|
||||
<pre>{#syntax#}@maxValue(comptime T: type) comptime_int{#endsyntax#}</pre>
|
||||
<p>
|
||||
This function returns the maximum value of the integer type {#syntax#}T{#endsyntax#}.
|
||||
</p>
|
||||
<p>
|
||||
The result is a compile time constant.
|
||||
</p>
|
||||
{#header_close#}
|
||||
{#header_open|@memberCount#}
|
||||
<pre>{#syntax#}@memberCount(comptime T: type) comptime_int{#endsyntax#}</pre>
|
||||
<p>
|
||||
@ -5885,15 +5879,6 @@ mem.copy(u8, dest[0...byte_count], source[0...byte_count]);{#endsyntax#}</pre>
|
||||
<p>There is also a standard library function for this:</p>
|
||||
<pre>{#syntax#}const mem = @import("std").mem;
|
||||
mem.set(u8, dest, c);{#endsyntax#}</pre>
|
||||
{#header_close#}
|
||||
{#header_open|@minValue#}
|
||||
<pre>{#syntax#}@minValue(comptime T: type) comptime_int{#endsyntax#}</pre>
|
||||
<p>
|
||||
This function returns the minimum value of the integer type T.
|
||||
</p>
|
||||
<p>
|
||||
The result is a compile time constant.
|
||||
</p>
|
||||
{#header_close#}
|
||||
{#header_open|@mod#}
|
||||
<pre>{#syntax#}@mod(numerator: T, denominator: T) T{#endsyntax#}</pre>
|
||||
@ -6688,7 +6673,7 @@ pub fn main() void {
|
||||
}
|
||||
{#code_end#}
|
||||
<p>
|
||||
To obtain the maximum value of an unsigned integer, use {#link|@maxValue#}.
|
||||
To obtain the maximum value of an unsigned integer, use {#syntax#}std.math.maxInt{#endsyntax#}.
|
||||
</p>
|
||||
{#header_close#}
|
||||
{#header_open|Cast Truncates Data#}
|
||||
@ -6810,14 +6795,17 @@ pub fn main() void {
|
||||
<li>{#syntax#}*%{#endsyntax#} (wraparound multiplication)</li>
|
||||
</ul>
|
||||
{#code_begin|test#}
|
||||
const assert = @import("std").debug.assert;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const minInt = std.math.minInt;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
test "wraparound addition and subtraction" {
|
||||
const x: i32 = @maxValue(i32);
|
||||
const x: i32 = maxInt(i32);
|
||||
const min_val = x +% 1;
|
||||
assert(min_val == @minValue(i32));
|
||||
assert(min_val == minInt(i32));
|
||||
const max_val = min_val -% 1;
|
||||
assert(max_val == @maxValue(i32));
|
||||
assert(max_val == maxInt(i32));
|
||||
}
|
||||
{#code_end#}
|
||||
{#header_close#}
|
||||
|
||||
@ -10,6 +10,7 @@ const Scope = @import("scope.zig").Scope;
|
||||
const event = std.event;
|
||||
const assert = std.debug.assert;
|
||||
const DW = std.dwarf;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code) !void {
|
||||
fn_val.base.ref();
|
||||
@ -362,15 +363,15 @@ fn addLLVMAttrInt(
|
||||
}
|
||||
|
||||
fn addLLVMFnAttr(ofile: *ObjectFile, fn_val: llvm.ValueRef, attr_name: []const u8) !void {
|
||||
return addLLVMAttr(ofile, fn_val, @maxValue(llvm.AttributeIndex), attr_name);
|
||||
return addLLVMAttr(ofile, fn_val, maxInt(llvm.AttributeIndex), attr_name);
|
||||
}
|
||||
|
||||
fn addLLVMFnAttrStr(ofile: *ObjectFile, fn_val: llvm.ValueRef, attr_name: []const u8, attr_val: []const u8) !void {
|
||||
return addLLVMAttrStr(ofile, fn_val, @maxValue(llvm.AttributeIndex), attr_name, attr_val);
|
||||
return addLLVMAttrStr(ofile, fn_val, maxInt(llvm.AttributeIndex), attr_name, attr_val);
|
||||
}
|
||||
|
||||
fn addLLVMFnAttrInt(ofile: *ObjectFile, fn_val: llvm.ValueRef, attr_name: []const u8, attr_val: u64) !void {
|
||||
return addLLVMAttrInt(ofile, fn_val, @maxValue(llvm.AttributeIndex), attr_name, attr_val);
|
||||
return addLLVMAttrInt(ofile, fn_val, maxInt(llvm.AttributeIndex), attr_name, attr_val);
|
||||
}
|
||||
|
||||
fn renderLoadUntyped(
|
||||
|
||||
@ -1343,8 +1343,6 @@ enum BuiltinFnId {
|
||||
BuiltinFnIdMemset,
|
||||
BuiltinFnIdSizeof,
|
||||
BuiltinFnIdAlignOf,
|
||||
BuiltinFnIdMaxValue,
|
||||
BuiltinFnIdMinValue,
|
||||
BuiltinFnIdMemberCount,
|
||||
BuiltinFnIdMemberType,
|
||||
BuiltinFnIdMemberName,
|
||||
@ -2081,8 +2079,6 @@ enum IrInstructionId {
|
||||
IrInstructionIdCUndef,
|
||||
IrInstructionIdArrayLen,
|
||||
IrInstructionIdRef,
|
||||
IrInstructionIdMinValue,
|
||||
IrInstructionIdMaxValue,
|
||||
IrInstructionIdCompileErr,
|
||||
IrInstructionIdCompileLog,
|
||||
IrInstructionIdErrName,
|
||||
@ -2609,18 +2605,6 @@ struct IrInstructionRef {
|
||||
bool is_volatile;
|
||||
};
|
||||
|
||||
struct IrInstructionMinValue {
|
||||
IrInstruction base;
|
||||
|
||||
IrInstruction *value;
|
||||
};
|
||||
|
||||
struct IrInstructionMaxValue {
|
||||
IrInstruction base;
|
||||
|
||||
IrInstruction *value;
|
||||
};
|
||||
|
||||
struct IrInstructionCompileErr {
|
||||
IrInstruction base;
|
||||
|
||||
|
||||
@ -5100,8 +5100,6 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
|
||||
case IrInstructionIdSizeOf:
|
||||
case IrInstructionIdSwitchTarget:
|
||||
case IrInstructionIdContainerInitFields:
|
||||
case IrInstructionIdMinValue:
|
||||
case IrInstructionIdMaxValue:
|
||||
case IrInstructionIdCompileErr:
|
||||
case IrInstructionIdCompileLog:
|
||||
case IrInstructionIdArrayLen:
|
||||
@ -6651,8 +6649,6 @@ static void define_builtin_fns(CodeGen *g) {
|
||||
create_builtin_fn(g, BuiltinFnIdMemset, "memset", 3);
|
||||
create_builtin_fn(g, BuiltinFnIdSizeof, "sizeOf", 1);
|
||||
create_builtin_fn(g, BuiltinFnIdAlignOf, "alignOf", 1);
|
||||
create_builtin_fn(g, BuiltinFnIdMaxValue, "maxValue", 1);
|
||||
create_builtin_fn(g, BuiltinFnIdMinValue, "minValue", 1);
|
||||
create_builtin_fn(g, BuiltinFnIdMemberCount, "memberCount", 1);
|
||||
create_builtin_fn(g, BuiltinFnIdMemberType, "memberType", 2);
|
||||
create_builtin_fn(g, BuiltinFnIdMemberName, "memberName", 2);
|
||||
|
||||
120
src/ir.cpp
120
src/ir.cpp
@ -495,14 +495,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionInit *) {
|
||||
return IrInstructionIdUnionInit;
|
||||
}
|
||||
|
||||
static constexpr IrInstructionId ir_instruction_id(IrInstructionMinValue *) {
|
||||
return IrInstructionIdMinValue;
|
||||
}
|
||||
|
||||
static constexpr IrInstructionId ir_instruction_id(IrInstructionMaxValue *) {
|
||||
return IrInstructionIdMaxValue;
|
||||
}
|
||||
|
||||
static constexpr IrInstructionId ir_instruction_id(IrInstructionCompileErr *) {
|
||||
return IrInstructionIdCompileErr;
|
||||
}
|
||||
@ -1693,24 +1685,6 @@ static IrInstruction *ir_build_ref(IrBuilder *irb, Scope *scope, AstNode *source
|
||||
return &instruction->base;
|
||||
}
|
||||
|
||||
static IrInstruction *ir_build_min_value(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
|
||||
IrInstructionMinValue *instruction = ir_build_instruction<IrInstructionMinValue>(irb, scope, source_node);
|
||||
instruction->value = value;
|
||||
|
||||
ir_ref_instruction(value, irb->current_basic_block);
|
||||
|
||||
return &instruction->base;
|
||||
}
|
||||
|
||||
static IrInstruction *ir_build_max_value(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
|
||||
IrInstructionMaxValue *instruction = ir_build_instruction<IrInstructionMaxValue>(irb, scope, source_node);
|
||||
instruction->value = value;
|
||||
|
||||
ir_ref_instruction(value, irb->current_basic_block);
|
||||
|
||||
return &instruction->base;
|
||||
}
|
||||
|
||||
static IrInstruction *ir_build_compile_err(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *msg) {
|
||||
IrInstructionCompileErr *instruction = ir_build_instruction<IrInstructionCompileErr>(irb, scope, source_node);
|
||||
instruction->msg = msg;
|
||||
@ -3813,26 +3787,6 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
|
||||
IrInstruction *c_undef = ir_build_c_undef(irb, scope, node, arg0_value);
|
||||
return ir_lval_wrap(irb, scope, c_undef, lval);
|
||||
}
|
||||
case BuiltinFnIdMaxValue:
|
||||
{
|
||||
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
|
||||
IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
|
||||
if (arg0_value == irb->codegen->invalid_instruction)
|
||||
return arg0_value;
|
||||
|
||||
IrInstruction *max_value = ir_build_max_value(irb, scope, node, arg0_value);
|
||||
return ir_lval_wrap(irb, scope, max_value, lval);
|
||||
}
|
||||
case BuiltinFnIdMinValue:
|
||||
{
|
||||
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
|
||||
IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
|
||||
if (arg0_value == irb->codegen->invalid_instruction)
|
||||
return arg0_value;
|
||||
|
||||
IrInstruction *min_value = ir_build_min_value(irb, scope, node, arg0_value);
|
||||
return ir_lval_wrap(irb, scope, min_value, lval);
|
||||
}
|
||||
case BuiltinFnIdCompileErr:
|
||||
{
|
||||
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
|
||||
@ -16407,74 +16361,6 @@ static IrInstruction *ir_analyze_instruction_container_init_fields(IrAnalyze *ir
|
||||
instruction->field_count, instruction->fields);
|
||||
}
|
||||
|
||||
static IrInstruction *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_instruction,
|
||||
IrInstruction *target_type_value, bool is_max)
|
||||
{
|
||||
ZigType *target_type = ir_resolve_type(ira, target_type_value);
|
||||
if (type_is_invalid(target_type))
|
||||
return ira->codegen->invalid_instruction;
|
||||
switch (target_type->id) {
|
||||
case ZigTypeIdInvalid:
|
||||
zig_unreachable();
|
||||
case ZigTypeIdInt:
|
||||
{
|
||||
IrInstruction *result = ir_const(ira, source_instruction,
|
||||
ira->codegen->builtin_types.entry_num_lit_int);
|
||||
eval_min_max_value(ira->codegen, target_type, &result->value, is_max);
|
||||
return result;
|
||||
}
|
||||
case ZigTypeIdBool:
|
||||
case ZigTypeIdVoid:
|
||||
{
|
||||
IrInstruction *result = ir_const(ira, source_instruction, target_type);
|
||||
eval_min_max_value(ira->codegen, target_type, &result->value, is_max);
|
||||
return result;
|
||||
}
|
||||
case ZigTypeIdEnum:
|
||||
case ZigTypeIdFloat:
|
||||
case ZigTypeIdMetaType:
|
||||
case ZigTypeIdUnreachable:
|
||||
case ZigTypeIdPointer:
|
||||
case ZigTypeIdPromise:
|
||||
case ZigTypeIdArray:
|
||||
case ZigTypeIdStruct:
|
||||
case ZigTypeIdComptimeFloat:
|
||||
case ZigTypeIdComptimeInt:
|
||||
case ZigTypeIdUndefined:
|
||||
case ZigTypeIdNull:
|
||||
case ZigTypeIdOptional:
|
||||
case ZigTypeIdErrorUnion:
|
||||
case ZigTypeIdErrorSet:
|
||||
case ZigTypeIdUnion:
|
||||
case ZigTypeIdFn:
|
||||
case ZigTypeIdNamespace:
|
||||
case ZigTypeIdBoundFn:
|
||||
case ZigTypeIdArgTuple:
|
||||
case ZigTypeIdOpaque:
|
||||
{
|
||||
const char *err_format = is_max ?
|
||||
"no max value available for type '%s'" :
|
||||
"no min value available for type '%s'";
|
||||
ir_add_error(ira, source_instruction,
|
||||
buf_sprintf(err_format, buf_ptr(&target_type->name)));
|
||||
return ira->codegen->invalid_instruction;
|
||||
}
|
||||
}
|
||||
zig_unreachable();
|
||||
}
|
||||
|
||||
static IrInstruction *ir_analyze_instruction_min_value(IrAnalyze *ira,
|
||||
IrInstructionMinValue *instruction)
|
||||
{
|
||||
return ir_analyze_min_max(ira, &instruction->base, instruction->value->child, false);
|
||||
}
|
||||
|
||||
static IrInstruction *ir_analyze_instruction_max_value(IrAnalyze *ira,
|
||||
IrInstructionMaxValue *instruction)
|
||||
{
|
||||
return ir_analyze_min_max(ira, &instruction->base, instruction->value->child, true);
|
||||
}
|
||||
|
||||
static IrInstruction *ir_analyze_instruction_compile_err(IrAnalyze *ira,
|
||||
IrInstructionCompileErr *instruction)
|
||||
{
|
||||
@ -21052,10 +20938,6 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio
|
||||
return ir_analyze_instruction_container_init_list(ira, (IrInstructionContainerInitList *)instruction);
|
||||
case IrInstructionIdContainerInitFields:
|
||||
return ir_analyze_instruction_container_init_fields(ira, (IrInstructionContainerInitFields *)instruction);
|
||||
case IrInstructionIdMinValue:
|
||||
return ir_analyze_instruction_min_value(ira, (IrInstructionMinValue *)instruction);
|
||||
case IrInstructionIdMaxValue:
|
||||
return ir_analyze_instruction_max_value(ira, (IrInstructionMaxValue *)instruction);
|
||||
case IrInstructionIdCompileErr:
|
||||
return ir_analyze_instruction_compile_err(ira, (IrInstructionCompileErr *)instruction);
|
||||
case IrInstructionIdCompileLog:
|
||||
@ -21399,8 +21281,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
|
||||
case IrInstructionIdSwitchTarget:
|
||||
case IrInstructionIdUnionTag:
|
||||
case IrInstructionIdRef:
|
||||
case IrInstructionIdMinValue:
|
||||
case IrInstructionIdMaxValue:
|
||||
case IrInstructionIdEmbedFile:
|
||||
case IrInstructionIdTruncate:
|
||||
case IrInstructionIdIntType:
|
||||
|
||||
@ -565,18 +565,6 @@ static void ir_print_ref(IrPrint *irp, IrInstructionRef *instruction) {
|
||||
ir_print_other_instruction(irp, instruction->value);
|
||||
}
|
||||
|
||||
static void ir_print_min_value(IrPrint *irp, IrInstructionMinValue *instruction) {
|
||||
fprintf(irp->f, "@minValue(");
|
||||
ir_print_other_instruction(irp, instruction->value);
|
||||
fprintf(irp->f, ")");
|
||||
}
|
||||
|
||||
static void ir_print_max_value(IrPrint *irp, IrInstructionMaxValue *instruction) {
|
||||
fprintf(irp->f, "@maxValue(");
|
||||
ir_print_other_instruction(irp, instruction->value);
|
||||
fprintf(irp->f, ")");
|
||||
}
|
||||
|
||||
static void ir_print_compile_err(IrPrint *irp, IrInstructionCompileErr *instruction) {
|
||||
fprintf(irp->f, "@compileError(");
|
||||
ir_print_other_instruction(irp, instruction->msg);
|
||||
@ -1480,12 +1468,6 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
|
||||
case IrInstructionIdRef:
|
||||
ir_print_ref(irp, (IrInstructionRef *)instruction);
|
||||
break;
|
||||
case IrInstructionIdMinValue:
|
||||
ir_print_min_value(irp, (IrInstructionMinValue *)instruction);
|
||||
break;
|
||||
case IrInstructionIdMaxValue:
|
||||
ir_print_max_value(irp, (IrInstructionMaxValue *)instruction);
|
||||
break;
|
||||
case IrInstructionIdCompileErr:
|
||||
ir_print_compile_err(irp, (IrInstructionCompileErr *)instruction);
|
||||
break;
|
||||
|
||||
@ -5,6 +5,7 @@ const mem = std.mem;
|
||||
const endian = std.endian;
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const QuarterRound = struct.{
|
||||
a: usize,
|
||||
@ -111,7 +112,7 @@ fn chaCha20_internal(out: []u8, in: []const u8, key: [8]u32, counter: [4]u32) vo
|
||||
/// counter, nonce, and key.
|
||||
pub fn chaCha20IETF(out: []u8, in: []const u8, counter: u32, key: [32]u8, nonce: [12]u8) void {
|
||||
assert(in.len >= out.len);
|
||||
assert((in.len >> 6) + counter <= @maxValue(u32));
|
||||
assert((in.len >> 6) + counter <= maxInt(u32));
|
||||
|
||||
var k: [8]u32 = undefined;
|
||||
var c: [4]u32 = undefined;
|
||||
@ -161,7 +162,7 @@ pub fn chaCha20With64BitNonce(out: []u8, in: []const u8, counter: u64, key: [32]
|
||||
const big_block = (block_size << 32);
|
||||
|
||||
// first partial big block
|
||||
if (((@intCast(u64, @maxValue(u32) - @truncate(u32, counter)) + 1) << 6) < in.len) {
|
||||
if (((@intCast(u64, maxInt(u32) - @truncate(u32, counter)) + 1) << 6) < in.len) {
|
||||
chaCha20_internal(out[cursor..big_block], in[cursor..big_block], k, c);
|
||||
cursor = big_block - cursor;
|
||||
c[1] += 1;
|
||||
|
||||
@ -11,6 +11,7 @@ const pdb = std.pdb;
|
||||
const windows = os.windows;
|
||||
const ArrayList = std.ArrayList;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub const FailingAllocator = @import("failing_allocator.zig").FailingAllocator;
|
||||
pub const failing_allocator = &FailingAllocator.init(global_allocator, 0).allocator;
|
||||
@ -842,7 +843,7 @@ fn readSparseBitVector(stream: var, allocator: *mem.Allocator) ![]usize {
|
||||
if (word & (u32(1) << bit_i) != 0) {
|
||||
try list.append(word_i * 32 + bit_i);
|
||||
}
|
||||
if (bit_i == @maxValue(u5)) break;
|
||||
if (bit_i == maxInt(u5)) break;
|
||||
}
|
||||
}
|
||||
return list.toOwnedSlice();
|
||||
@ -1939,7 +1940,7 @@ fn findCompileUnit(st: *DebugInfo, target_address: u64) !*const CompileUnit {
|
||||
if (begin_addr == 0 and end_addr == 0) {
|
||||
break;
|
||||
}
|
||||
if (begin_addr == @maxValue(usize)) {
|
||||
if (begin_addr == maxInt(usize)) {
|
||||
base_address = begin_addr;
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -10,6 +10,7 @@ const elf = std.elf;
|
||||
const linux = os.linux;
|
||||
const windows = os.windows;
|
||||
const win_util = @import("os/windows/util.zig");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub const DynLib = switch (builtin.os) {
|
||||
Os.linux => LinuxDynLib,
|
||||
@ -80,7 +81,7 @@ pub const ElfLib = struct.{
|
||||
const elf_addr = @ptrToInt(bytes.ptr);
|
||||
var ph_addr: usize = elf_addr + eh.e_phoff;
|
||||
|
||||
var base: usize = @maxValue(usize);
|
||||
var base: usize = maxInt(usize);
|
||||
var maybe_dynv: ?[*]usize = null;
|
||||
{
|
||||
var i: usize = 0;
|
||||
@ -97,7 +98,7 @@ pub const ElfLib = struct.{
|
||||
}
|
||||
}
|
||||
const dynv = maybe_dynv orelse return error.MissingDynamicLinkingInformation;
|
||||
if (base == @maxValue(usize)) return error.BaseNotFound;
|
||||
if (base == maxInt(usize)) return error.BaseNotFound;
|
||||
|
||||
var maybe_strings: ?[*]u8 = null;
|
||||
var maybe_syms: ?[*]elf.Sym = null;
|
||||
|
||||
@ -8,6 +8,7 @@ const fs = std.event.fs;
|
||||
const os = std.os;
|
||||
const posix = os.posix;
|
||||
const windows = os.windows;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub const Loop = struct.{
|
||||
allocator: *mem.Allocator,
|
||||
@ -317,7 +318,7 @@ pub const Loop = struct.{
|
||||
windows.INVALID_HANDLE_VALUE,
|
||||
null,
|
||||
undefined,
|
||||
@maxValue(windows.DWORD),
|
||||
maxInt(windows.DWORD),
|
||||
);
|
||||
errdefer os.close(self.os_data.io_port);
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@ const os = std.os;
|
||||
const builtin = @import("builtin");
|
||||
const Os = builtin.Os;
|
||||
const c = std.c;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const Allocator = mem.Allocator;
|
||||
|
||||
@ -567,7 +568,7 @@ fn testAllocatorAligned(allocator: *mem.Allocator, comptime alignment: u29) !voi
|
||||
fn testAllocatorLargeAlignment(allocator: *mem.Allocator) mem.Allocator.Error!void {
|
||||
//Maybe a platform's page_size is actually the same as or
|
||||
// very near usize?
|
||||
if (os.page_size << 2 > @maxValue(usize)) return;
|
||||
if (os.page_size << 2 > maxInt(usize)) return;
|
||||
|
||||
const USizeShift = @IntType(false, std.math.log2(usize.bit_count));
|
||||
const large_align = u29(os.page_size << 2);
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
const std = @import("index.zig");
|
||||
const debug = std.debug;
|
||||
const mem = std.mem;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
// A single token slice into the parent string.
|
||||
//
|
||||
@ -107,7 +108,7 @@ pub const StreamingParser = struct.{
|
||||
|
||||
const object_bit = 0;
|
||||
const array_bit = 1;
|
||||
const max_stack_size = @maxValue(u8);
|
||||
const max_stack_size = maxInt(u8);
|
||||
|
||||
pub fn init() StreamingParser {
|
||||
var p: StreamingParser = undefined;
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn asinh(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -55,7 +56,7 @@ fn asinh64(x: f64) f64 {
|
||||
const e = (u >> 52) & 0x7FF;
|
||||
const s = u >> 63;
|
||||
|
||||
var rx = @bitCast(f64, u & (@maxValue(u64) >> 1)); // |x|
|
||||
var rx = @bitCast(f64, u & (maxInt(u64) >> 1)); // |x|
|
||||
|
||||
if (math.isNegativeInf(x)) {
|
||||
return x;
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn atanh(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -52,7 +53,7 @@ fn atanh_64(x: f64) f64 {
|
||||
const e = (u >> 52) & 0x7FF;
|
||||
const s = u >> 63;
|
||||
|
||||
var y = @bitCast(f64, u & (@maxValue(u64) >> 1)); // |x|
|
||||
var y = @bitCast(f64, u & (maxInt(u64) >> 1)); // |x|
|
||||
|
||||
if (y == 1.0) {
|
||||
return math.copysign(f64, math.inf(f64), x);
|
||||
|
||||
@ -5,6 +5,8 @@ const math = std.math;
|
||||
const mem = std.mem;
|
||||
const Allocator = mem.Allocator;
|
||||
const ArrayList = std.ArrayList;
|
||||
const maxInt = std.math.maxInt;
|
||||
const minInt = std.math.minInt;
|
||||
|
||||
const TypeId = builtin.TypeId;
|
||||
|
||||
@ -212,7 +214,7 @@ pub const Int = struct.{
|
||||
self.positive = value >= 0;
|
||||
self.len = req_limbs;
|
||||
|
||||
if (w_value <= @maxValue(Limb)) {
|
||||
if (w_value <= maxInt(Limb)) {
|
||||
self.limbs[0] = w_value;
|
||||
} else {
|
||||
const mask = (1 << Limb.bit_count) - 1;
|
||||
@ -267,7 +269,7 @@ pub const Int = struct.{
|
||||
if (math.cast(T, r)) |ok| {
|
||||
return -ok;
|
||||
} else |_| {
|
||||
return @minValue(T);
|
||||
return minInt(T);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -371,7 +373,7 @@ pub const Int = struct.{
|
||||
}
|
||||
} // Non power-of-two: batch divisions per word size.
|
||||
else {
|
||||
const digits_per_limb = math.log(Limb, base, @maxValue(Limb));
|
||||
const digits_per_limb = math.log(Limb, base, maxInt(Limb));
|
||||
var limb_base: Limb = 1;
|
||||
var j: usize = 0;
|
||||
while (j < digits_per_limb) : (j += 1) {
|
||||
@ -717,7 +719,7 @@ pub const Int = struct.{
|
||||
const c3: Limb = @boolToInt(@addWithOverflow(Limb, r1, r2, &r1));
|
||||
|
||||
// This never overflows, c1, c3 are either 0 or 1 and if both are 1 then
|
||||
// c2 is at least <= @maxValue(Limb) - 2.
|
||||
// c2 is at least <= maxInt(Limb) - 2.
|
||||
carry.* = c1 + c2 + c3;
|
||||
|
||||
return r1;
|
||||
@ -873,11 +875,11 @@ pub const Int = struct.{
|
||||
while (i > t) : (i -= 1) {
|
||||
// 3.1
|
||||
if (x.limbs[i] == y.limbs[t]) {
|
||||
q.limbs[i - t - 1] = @maxValue(Limb);
|
||||
q.limbs[i - t - 1] = maxInt(Limb);
|
||||
} else {
|
||||
const num = (DoubleLimb(x.limbs[i]) << Limb.bit_count) | DoubleLimb(x.limbs[i - 1]);
|
||||
const z = @intCast(Limb, num / DoubleLimb(y.limbs[t]));
|
||||
q.limbs[i - t - 1] = if (z > @maxValue(Limb)) @maxValue(Limb) else Limb(z);
|
||||
q.limbs[i - t - 1] = if (z > maxInt(Limb)) maxInt(Limb) else Limb(z);
|
||||
}
|
||||
|
||||
// 3.2
|
||||
@ -1081,7 +1083,7 @@ test "big.int comptime_int set" {
|
||||
|
||||
comptime var i: usize = 0;
|
||||
inline while (i < s_limb_count) : (i += 1) {
|
||||
const result = Limb(s & @maxValue(Limb));
|
||||
const result = Limb(s & maxInt(Limb));
|
||||
s >>= Limb.bit_count / 2;
|
||||
s >>= Limb.bit_count / 2;
|
||||
debug.assert(a.limbs[i] == result);
|
||||
@ -1403,7 +1405,7 @@ test "big.int compare similar" {
|
||||
}
|
||||
|
||||
test "big.int compare different limb size" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, 1);
|
||||
|
||||
debug.assert(a.cmpAbs(b) == 1);
|
||||
@ -1457,16 +1459,16 @@ test "big.int add single-single" {
|
||||
}
|
||||
|
||||
test "big.int add multi-single" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, 1);
|
||||
|
||||
var c = try Int.init(al);
|
||||
|
||||
try c.add(a, b);
|
||||
debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
|
||||
debug.assert((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
|
||||
|
||||
try c.add(b, a);
|
||||
debug.assert((try c.to(DoubleLimb)) == @maxValue(Limb) + 2);
|
||||
debug.assert((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
|
||||
}
|
||||
|
||||
test "big.int add multi-multi" {
|
||||
@ -1533,13 +1535,13 @@ test "big.int sub single-single" {
|
||||
}
|
||||
|
||||
test "big.int sub multi-single" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, 1);
|
||||
|
||||
var c = try Int.init(al);
|
||||
try c.sub(a, b);
|
||||
|
||||
debug.assert((try c.to(Limb)) == @maxValue(Limb));
|
||||
debug.assert((try c.to(Limb)) == maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int sub multi-multi" {
|
||||
@ -1600,13 +1602,13 @@ test "big.int mul single-single" {
|
||||
}
|
||||
|
||||
test "big.int mul multi-single" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb));
|
||||
var b = try Int.initSet(al, 2);
|
||||
|
||||
var c = try Int.init(al);
|
||||
try c.mul(a, b);
|
||||
|
||||
debug.assert((try c.to(DoubleLimb)) == 2 * @maxValue(Limb));
|
||||
debug.assert((try c.to(DoubleLimb)) == 2 * maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int mul multi-multi" {
|
||||
@ -1622,29 +1624,29 @@ test "big.int mul multi-multi" {
|
||||
}
|
||||
|
||||
test "big.int mul alias r with a" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb));
|
||||
var b = try Int.initSet(al, 2);
|
||||
|
||||
try a.mul(a, b);
|
||||
|
||||
debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
|
||||
debug.assert((try a.to(DoubleLimb)) == 2 * maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int mul alias r with b" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb));
|
||||
var b = try Int.initSet(al, 2);
|
||||
|
||||
try a.mul(b, a);
|
||||
|
||||
debug.assert((try a.to(DoubleLimb)) == 2 * @maxValue(Limb));
|
||||
debug.assert((try a.to(DoubleLimb)) == 2 * maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int mul alias r with a and b" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb));
|
||||
|
||||
try a.mul(a, a);
|
||||
|
||||
debug.assert((try a.to(DoubleLimb)) == @maxValue(Limb) * @maxValue(Limb));
|
||||
debug.assert((try a.to(DoubleLimb)) == maxInt(Limb) * maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int mul a*0" {
|
||||
@ -2047,8 +2049,8 @@ test "big.int bitwise and simple" {
|
||||
}
|
||||
|
||||
test "big.int bitwise and multi-limb" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var b = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, maxInt(Limb));
|
||||
|
||||
try a.bitAnd(a, b);
|
||||
|
||||
@ -2065,12 +2067,12 @@ test "big.int bitwise xor simple" {
|
||||
}
|
||||
|
||||
test "big.int bitwise xor multi-limb" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var b = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, maxInt(Limb));
|
||||
|
||||
try a.bitXor(a, b);
|
||||
|
||||
debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) ^ @maxValue(Limb));
|
||||
debug.assert((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) ^ maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int bitwise or simple" {
|
||||
@ -2083,13 +2085,13 @@ test "big.int bitwise or simple" {
|
||||
}
|
||||
|
||||
test "big.int bitwise or multi-limb" {
|
||||
var a = try Int.initSet(al, @maxValue(Limb) + 1);
|
||||
var b = try Int.initSet(al, @maxValue(Limb));
|
||||
var a = try Int.initSet(al, maxInt(Limb) + 1);
|
||||
var b = try Int.initSet(al, maxInt(Limb));
|
||||
|
||||
try a.bitOr(a, b);
|
||||
|
||||
// TODO: big.int.cpp or is wrong on multi-limb.
|
||||
debug.assert((try a.to(DoubleLimb)) == (@maxValue(Limb) + 1) + @maxValue(Limb));
|
||||
debug.assert((try a.to(DoubleLimb)) == (maxInt(Limb) + 1) + maxInt(Limb));
|
||||
}
|
||||
|
||||
test "big.int var args" {
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn copysign(comptime T: type, x: T, y: T) T {
|
||||
return switch (T) {
|
||||
@ -15,7 +16,7 @@ fn copysign16(x: f16, y: f16) f16 {
|
||||
const ux = @bitCast(u16, x);
|
||||
const uy = @bitCast(u16, y);
|
||||
|
||||
const h1 = ux & (@maxValue(u16) / 2);
|
||||
const h1 = ux & (maxInt(u16) / 2);
|
||||
const h2 = uy & (u16(1) << 15);
|
||||
return @bitCast(f16, h1 | h2);
|
||||
}
|
||||
@ -24,7 +25,7 @@ fn copysign32(x: f32, y: f32) f32 {
|
||||
const ux = @bitCast(u32, x);
|
||||
const uy = @bitCast(u32, y);
|
||||
|
||||
const h1 = ux & (@maxValue(u32) / 2);
|
||||
const h1 = ux & (maxInt(u32) / 2);
|
||||
const h2 = uy & (u32(1) << 31);
|
||||
return @bitCast(f32, h1 | h2);
|
||||
}
|
||||
@ -33,7 +34,7 @@ fn copysign64(x: f64, y: f64) f64 {
|
||||
const ux = @bitCast(u64, x);
|
||||
const uy = @bitCast(u64, y);
|
||||
|
||||
const h1 = ux & (@maxValue(u64) / 2);
|
||||
const h1 = ux & (maxInt(u64) / 2);
|
||||
const h2 = uy & (u64(1) << 63);
|
||||
return @bitCast(f64, h1 | h2);
|
||||
}
|
||||
|
||||
@ -9,6 +9,7 @@ const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const expo2 = @import("expo2.zig").expo2;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn cosh(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -50,7 +51,7 @@ fn cosh32(x: f32) f32 {
|
||||
fn cosh64(x: f64) f64 {
|
||||
const u = @bitCast(u64, x);
|
||||
const w = @intCast(u32, u >> 32);
|
||||
const ax = @bitCast(f64, u & (@maxValue(u64) >> 1));
|
||||
const ax = @bitCast(f64, u & (maxInt(u64) >> 1));
|
||||
|
||||
// TODO: Shouldn't need this explicit check.
|
||||
if (x == 0.0) {
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn fabs(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -31,7 +32,7 @@ fn fabs32(x: f32) f32 {
|
||||
|
||||
fn fabs64(x: f64) f64 {
|
||||
var u = @bitCast(u64, x);
|
||||
u &= @maxValue(u64) >> 1;
|
||||
u &= maxInt(u64) >> 1;
|
||||
return @bitCast(f64, u);
|
||||
}
|
||||
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn hypot(comptime T: type, x: T, y: T) T {
|
||||
return switch (T) {
|
||||
@ -21,8 +22,8 @@ fn hypot32(x: f32, y: f32) f32 {
|
||||
var ux = @bitCast(u32, x);
|
||||
var uy = @bitCast(u32, y);
|
||||
|
||||
ux &= @maxValue(u32) >> 1;
|
||||
uy &= @maxValue(u32) >> 1;
|
||||
ux &= maxInt(u32) >> 1;
|
||||
uy &= maxInt(u32) >> 1;
|
||||
if (ux < uy) {
|
||||
const tmp = ux;
|
||||
ux = uy;
|
||||
@ -65,8 +66,8 @@ fn hypot64(x: f64, y: f64) f64 {
|
||||
var ux = @bitCast(u64, x);
|
||||
var uy = @bitCast(u64, y);
|
||||
|
||||
ux &= @maxValue(u64) >> 1;
|
||||
uy &= @maxValue(u64) >> 1;
|
||||
ux &= maxInt(u64) >> 1;
|
||||
uy &= maxInt(u64) >> 1;
|
||||
if (ux < uy) {
|
||||
const tmp = ux;
|
||||
ux = uy;
|
||||
|
||||
@ -1,12 +1,14 @@
|
||||
// Special Cases:
|
||||
//
|
||||
// - ilogb(+-inf) = @maxValue(i32)
|
||||
// - ilogb(0) = @maxValue(i32)
|
||||
// - ilogb(nan) = @maxValue(i32)
|
||||
// - ilogb(+-inf) = maxInt(i32)
|
||||
// - ilogb(0) = maxInt(i32)
|
||||
// - ilogb(nan) = maxInt(i32)
|
||||
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
const minInt = std.math.minInt;
|
||||
|
||||
pub fn ilogb(x: var) i32 {
|
||||
const T = @typeOf(x);
|
||||
@ -18,7 +20,7 @@ pub fn ilogb(x: var) i32 {
|
||||
}
|
||||
|
||||
// NOTE: Should these be exposed publically?
|
||||
const fp_ilogbnan = -1 - i32(@maxValue(u32) >> 1);
|
||||
const fp_ilogbnan = -1 - i32(maxInt(u32) >> 1);
|
||||
const fp_ilogb0 = fp_ilogbnan;
|
||||
|
||||
fn ilogb32(x: f32) i32 {
|
||||
@ -27,7 +29,7 @@ fn ilogb32(x: f32) i32 {
|
||||
|
||||
// TODO: We should be able to merge this with the lower check.
|
||||
if (math.isNan(x)) {
|
||||
return @maxValue(i32);
|
||||
return maxInt(i32);
|
||||
}
|
||||
|
||||
if (e == 0) {
|
||||
@ -50,7 +52,7 @@ fn ilogb32(x: f32) i32 {
|
||||
if (u << 9 != 0) {
|
||||
return fp_ilogbnan;
|
||||
} else {
|
||||
return @maxValue(i32);
|
||||
return maxInt(i32);
|
||||
}
|
||||
}
|
||||
|
||||
@ -62,7 +64,7 @@ fn ilogb64(x: f64) i32 {
|
||||
var e = @intCast(i32, (u >> 52) & 0x7FF);
|
||||
|
||||
if (math.isNan(x)) {
|
||||
return @maxValue(i32);
|
||||
return maxInt(i32);
|
||||
}
|
||||
|
||||
if (e == 0) {
|
||||
@ -85,7 +87,7 @@ fn ilogb64(x: f64) i32 {
|
||||
if (u << 12 != 0) {
|
||||
return fp_ilogbnan;
|
||||
} else {
|
||||
return @maxValue(i32);
|
||||
return maxInt(i32);
|
||||
}
|
||||
}
|
||||
|
||||
@ -116,15 +118,15 @@ test "math.ilogb64" {
|
||||
}
|
||||
|
||||
test "math.ilogb32.special" {
|
||||
assert(ilogb32(math.inf(f32)) == @maxValue(i32));
|
||||
assert(ilogb32(-math.inf(f32)) == @maxValue(i32));
|
||||
assert(ilogb32(0.0) == @minValue(i32));
|
||||
assert(ilogb32(math.nan(f32)) == @maxValue(i32));
|
||||
assert(ilogb32(math.inf(f32)) == maxInt(i32));
|
||||
assert(ilogb32(-math.inf(f32)) == maxInt(i32));
|
||||
assert(ilogb32(0.0) == minInt(i32));
|
||||
assert(ilogb32(math.nan(f32)) == maxInt(i32));
|
||||
}
|
||||
|
||||
test "math.ilogb64.special" {
|
||||
assert(ilogb64(math.inf(f64)) == @maxValue(i32));
|
||||
assert(ilogb64(-math.inf(f64)) == @maxValue(i32));
|
||||
assert(ilogb64(0.0) == @minValue(i32));
|
||||
assert(ilogb64(math.nan(f64)) == @maxValue(i32));
|
||||
assert(ilogb64(math.inf(f64)) == maxInt(i32));
|
||||
assert(ilogb64(-math.inf(f64)) == maxInt(i32));
|
||||
assert(ilogb64(0.0) == minInt(i32));
|
||||
assert(ilogb64(math.nan(f64)) == maxInt(i32));
|
||||
}
|
||||
|
||||
@ -382,7 +382,7 @@ pub fn absInt(x: var) !@typeOf(x) {
|
||||
comptime assert(@typeId(T) == builtin.TypeId.Int); // must pass an integer to absInt
|
||||
comptime assert(T.is_signed); // must pass a signed integer to absInt
|
||||
|
||||
if (x == @minValue(@typeOf(x))) {
|
||||
if (x == minInt(@typeOf(x))) {
|
||||
return error.Overflow;
|
||||
} else {
|
||||
@setRuntimeSafety(false);
|
||||
@ -404,7 +404,7 @@ pub const absFloat = @import("fabs.zig").fabs;
|
||||
pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
|
||||
@setRuntimeSafety(false);
|
||||
if (denominator == 0) return error.DivisionByZero;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1) return error.Overflow;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
|
||||
return @divTrunc(numerator, denominator);
|
||||
}
|
||||
|
||||
@ -425,7 +425,7 @@ fn testDivTrunc() void {
|
||||
pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
|
||||
@setRuntimeSafety(false);
|
||||
if (denominator == 0) return error.DivisionByZero;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1) return error.Overflow;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
|
||||
return @divFloor(numerator, denominator);
|
||||
}
|
||||
|
||||
@ -446,7 +446,7 @@ fn testDivFloor() void {
|
||||
pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
|
||||
@setRuntimeSafety(false);
|
||||
if (denominator == 0) return error.DivisionByZero;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1) return error.Overflow;
|
||||
if (@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
|
||||
const result = @divTrunc(numerator, denominator);
|
||||
if (result * denominator != numerator) return error.UnexpectedRemainder;
|
||||
return result;
|
||||
@ -530,8 +530,8 @@ test "math.absCast" {
|
||||
assert(absCast(i32(999)) == 999);
|
||||
assert(@typeOf(absCast(i32(999))) == u32);
|
||||
|
||||
assert(absCast(i32(@minValue(i32))) == -@minValue(i32));
|
||||
assert(@typeOf(absCast(i32(@minValue(i32)))) == u32);
|
||||
assert(absCast(i32(minInt(i32))) == -minInt(i32));
|
||||
assert(@typeOf(absCast(i32(minInt(i32)))) == u32);
|
||||
}
|
||||
|
||||
/// Returns the negation of the integer parameter.
|
||||
@ -540,9 +540,9 @@ pub fn negateCast(x: var) !@IntType(true, @typeOf(x).bit_count) {
|
||||
if (@typeOf(x).is_signed) return negate(x);
|
||||
|
||||
const int = @IntType(true, @typeOf(x).bit_count);
|
||||
if (x > -@minValue(int)) return error.Overflow;
|
||||
if (x > -minInt(int)) return error.Overflow;
|
||||
|
||||
if (x == -@minValue(int)) return @minValue(int);
|
||||
if (x == -minInt(int)) return minInt(int);
|
||||
|
||||
return -@intCast(int, x);
|
||||
}
|
||||
@ -551,10 +551,10 @@ test "math.negateCast" {
|
||||
assert((negateCast(u32(999)) catch unreachable) == -999);
|
||||
assert(@typeOf(negateCast(u32(999)) catch unreachable) == i32);
|
||||
|
||||
assert((negateCast(u32(-@minValue(i32))) catch unreachable) == @minValue(i32));
|
||||
assert(@typeOf(negateCast(u32(-@minValue(i32))) catch unreachable) == i32);
|
||||
assert((negateCast(u32(-minInt(i32))) catch unreachable) == minInt(i32));
|
||||
assert(@typeOf(negateCast(u32(-minInt(i32))) catch unreachable) == i32);
|
||||
|
||||
if (negateCast(u32(@maxValue(i32) + 10))) |_| unreachable else |err| assert(err == error.Overflow);
|
||||
if (negateCast(u32(maxInt(i32) + 10))) |_| unreachable else |err| assert(err == error.Overflow);
|
||||
}
|
||||
|
||||
/// Cast an integer to a different integer type. If the value doesn't fit,
|
||||
@ -562,9 +562,9 @@ test "math.negateCast" {
|
||||
pub fn cast(comptime T: type, x: var) (error.{Overflow}!T) {
|
||||
comptime assert(@typeId(T) == builtin.TypeId.Int); // must pass an integer
|
||||
comptime assert(@typeId(@typeOf(x)) == builtin.TypeId.Int); // must pass an integer
|
||||
if (@maxValue(@typeOf(x)) > @maxValue(T) and x > @maxValue(T)) {
|
||||
if (maxInt(@typeOf(x)) > maxInt(T) and x > maxInt(T)) {
|
||||
return error.Overflow;
|
||||
} else if (@minValue(@typeOf(x)) < @minValue(T) and x < @minValue(T)) {
|
||||
} else if (minInt(@typeOf(x)) < minInt(T) and x < minInt(T)) {
|
||||
return error.Overflow;
|
||||
} else {
|
||||
return @intCast(T, x);
|
||||
@ -658,3 +658,59 @@ test "math.f64_min" {
|
||||
const fmin: f64 = f64_min;
|
||||
assert(@bitCast(u64, fmin) == f64_min_u64);
|
||||
}
|
||||
|
||||
pub fn maxInt(comptime T: type) comptime_int {
|
||||
const info = @typeInfo(T);
|
||||
const bit_count = comptime_int(info.Int.bits); // TODO #1683
|
||||
if (bit_count == 0) return 0;
|
||||
return (1 << (bit_count - @boolToInt(info.Int.is_signed))) - 1;
|
||||
}
|
||||
|
||||
pub fn minInt(comptime T: type) comptime_int {
|
||||
const info = @typeInfo(T);
|
||||
const bit_count = comptime_int(info.Int.bits); // TODO #1683
|
||||
if (!info.Int.is_signed) return 0;
|
||||
if (bit_count == 0) return 0;
|
||||
return -(1 << (bit_count - 1));
|
||||
}
|
||||
|
||||
test "minInt and maxInt" {
|
||||
assert(maxInt(u0) == 0);
|
||||
assert(maxInt(u1) == 1);
|
||||
assert(maxInt(u8) == 255);
|
||||
assert(maxInt(u16) == 65535);
|
||||
assert(maxInt(u32) == 4294967295);
|
||||
assert(maxInt(u64) == 18446744073709551615);
|
||||
|
||||
assert(maxInt(i0) == 0);
|
||||
assert(maxInt(i1) == 0);
|
||||
assert(maxInt(i8) == 127);
|
||||
assert(maxInt(i16) == 32767);
|
||||
assert(maxInt(i32) == 2147483647);
|
||||
assert(maxInt(i63) == 4611686018427387903);
|
||||
assert(maxInt(i64) == 9223372036854775807);
|
||||
|
||||
assert(minInt(u0) == 0);
|
||||
assert(minInt(u1) == 0);
|
||||
assert(minInt(u8) == 0);
|
||||
assert(minInt(u16) == 0);
|
||||
assert(minInt(u32) == 0);
|
||||
assert(minInt(u63) == 0);
|
||||
assert(minInt(u64) == 0);
|
||||
|
||||
assert(minInt(i0) == 0);
|
||||
assert(minInt(i1) == -1);
|
||||
assert(minInt(i8) == -128);
|
||||
assert(minInt(i16) == -32768);
|
||||
assert(minInt(i32) == -2147483648);
|
||||
assert(minInt(i63) == -4611686018427387904);
|
||||
assert(minInt(i64) == -9223372036854775808);
|
||||
}
|
||||
|
||||
test "max value type" {
|
||||
// If the type of maxInt(i32) was i32 then this implicit cast to
|
||||
// u32 would not work. But since the value is a number literal,
|
||||
// it works fine.
|
||||
const x: u32 = maxInt(i32);
|
||||
assert(x == 2147483647);
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn isFinite(x: var) bool {
|
||||
const T = @typeOf(x);
|
||||
@ -15,7 +16,7 @@ pub fn isFinite(x: var) bool {
|
||||
},
|
||||
f64 => {
|
||||
const bits = @bitCast(u64, x);
|
||||
return bits & (@maxValue(u64) >> 1) < (0x7FF << 52);
|
||||
return bits & (maxInt(u64) >> 1) < (0x7FF << 52);
|
||||
},
|
||||
else => {
|
||||
@compileError("isFinite not implemented for " ++ @typeName(T));
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn isInf(x: var) bool {
|
||||
const T = @typeOf(x);
|
||||
@ -15,7 +16,7 @@ pub fn isInf(x: var) bool {
|
||||
},
|
||||
f64 => {
|
||||
const bits = @bitCast(u64, x);
|
||||
return bits & (@maxValue(u64) >> 1) == (0x7FF << 52);
|
||||
return bits & (maxInt(u64) >> 1) == (0x7FF << 52);
|
||||
},
|
||||
else => {
|
||||
@compileError("isInf not implemented for " ++ @typeName(T));
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn isNan(x: var) bool {
|
||||
const T = @typeOf(x);
|
||||
@ -15,7 +16,7 @@ pub fn isNan(x: var) bool {
|
||||
},
|
||||
f64 => {
|
||||
const bits = @bitCast(u64, x);
|
||||
return (bits & (@maxValue(u64) >> 1)) > (u64(0x7FF) << 52);
|
||||
return (bits & (maxInt(u64) >> 1)) > (u64(0x7FF) << 52);
|
||||
},
|
||||
else => {
|
||||
@compileError("isNan not implemented for " ++ @typeName(T));
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn isNormal(x: var) bool {
|
||||
const T = @typeOf(x);
|
||||
@ -15,7 +16,7 @@ pub fn isNormal(x: var) bool {
|
||||
},
|
||||
f64 => {
|
||||
const bits = @bitCast(u64, x);
|
||||
return (bits + (1 << 52)) & (@maxValue(u64) >> 1) >= (1 << 53);
|
||||
return (bits + (1 << 52)) & (maxInt(u64) >> 1) >= (1 << 53);
|
||||
},
|
||||
else => {
|
||||
@compileError("isNormal not implemented for " ++ @typeName(T));
|
||||
|
||||
@ -10,6 +10,7 @@ const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const TypeId = builtin.TypeId;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn log10(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -151,7 +152,7 @@ pub fn log10_64(x_: f64) f64 {
|
||||
// hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
|
||||
var hi = f - hfsq;
|
||||
var hii = @bitCast(u64, hi);
|
||||
hii &= u64(@maxValue(u64)) << 32;
|
||||
hii &= u64(maxInt(u64)) << 32;
|
||||
hi = @bitCast(f64, hii);
|
||||
const lo = f - hi - hfsq + s * (hfsq + R);
|
||||
|
||||
|
||||
@ -10,6 +10,7 @@ const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const TypeId = builtin.TypeId;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn log2(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -151,7 +152,7 @@ pub fn log2_64(x_: f64) f64 {
|
||||
// hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
|
||||
var hi = f - hfsq;
|
||||
var hii = @bitCast(u64, hi);
|
||||
hii &= u64(@maxValue(u64)) << 32;
|
||||
hii &= u64(maxInt(u64)) << 32;
|
||||
hi = @bitCast(f64, hii);
|
||||
const lo = f - hi - hfsq + s * (hfsq + R);
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
fn modf_result(comptime T: type) type {
|
||||
return struct.{
|
||||
@ -101,7 +102,7 @@ fn modf64(x: f64) modf64_result {
|
||||
return result;
|
||||
}
|
||||
|
||||
const mask = u64(@maxValue(u64) >> 12) >> @intCast(u6, e);
|
||||
const mask = u64(maxInt(u64) >> 12) >> @intCast(u6, e);
|
||||
if (u & mask == 0) {
|
||||
result.ipart = x;
|
||||
result.fpart = @bitCast(f64, us);
|
||||
|
||||
@ -9,6 +9,7 @@ const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const expo2 = @import("expo2.zig").expo2;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn sinh(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -56,7 +57,7 @@ fn sinh32(x: f32) f32 {
|
||||
fn sinh64(x: f64) f64 {
|
||||
const u = @bitCast(u64, x);
|
||||
const w = @intCast(u32, u >> 32);
|
||||
const ax = @bitCast(f64, u & (@maxValue(u64) >> 1));
|
||||
const ax = @bitCast(f64, u & (maxInt(u64) >> 1));
|
||||
|
||||
if (x == 0.0 or math.isNan(x)) {
|
||||
return x;
|
||||
|
||||
@ -10,6 +10,7 @@ const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const TypeId = builtin.TypeId;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typeOf(x).bit_count / 2) else @typeOf(x)) {
|
||||
const T = @typeOf(x);
|
||||
@ -17,7 +18,7 @@ pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typ
|
||||
TypeId.ComptimeFloat => return T(@sqrt(f64, x)), // TODO upgrade to f128
|
||||
TypeId.Float => return @sqrt(T, x),
|
||||
TypeId.ComptimeInt => comptime {
|
||||
if (x > @maxValue(u128)) {
|
||||
if (x > maxInt(u128)) {
|
||||
@compileError("sqrt not implemented for comptime_int greater than 128 bits");
|
||||
}
|
||||
if (x < 0) {
|
||||
|
||||
@ -9,6 +9,7 @@ const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const expo2 = @import("expo2.zig").expo2;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn tanh(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -69,7 +70,7 @@ fn tanh32(x: f32) f32 {
|
||||
fn tanh64(x: f64) f64 {
|
||||
const u = @bitCast(u64, x);
|
||||
const w = @intCast(u32, u >> 32);
|
||||
const ax = @bitCast(f64, u & (@maxValue(u64) >> 1));
|
||||
const ax = @bitCast(f64, u & (maxInt(u64) >> 1));
|
||||
|
||||
var t: f64 = undefined;
|
||||
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const math = std.math;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn trunc(x: var) @typeOf(x) {
|
||||
const T = @typeOf(x);
|
||||
@ -29,7 +30,7 @@ fn trunc32(x: f32) f32 {
|
||||
e = 1;
|
||||
}
|
||||
|
||||
m = u32(@maxValue(u32)) >> @intCast(u5, e);
|
||||
m = u32(maxInt(u32)) >> @intCast(u5, e);
|
||||
if (u & m == 0) {
|
||||
return x;
|
||||
} else {
|
||||
@ -50,7 +51,7 @@ fn trunc64(x: f64) f64 {
|
||||
e = 1;
|
||||
}
|
||||
|
||||
m = u64(@maxValue(u64)) >> @intCast(u6, e);
|
||||
m = u64(maxInt(u64)) >> @intCast(u6, e);
|
||||
if (u & m == 0) {
|
||||
return x;
|
||||
} else {
|
||||
|
||||
@ -14,6 +14,7 @@ const builtin = @import("builtin");
|
||||
const Os = builtin.Os;
|
||||
const LinkedList = std.LinkedList;
|
||||
const windows_util = @import("windows/util.zig");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const is_windows = builtin.os == Os.windows;
|
||||
|
||||
@ -307,16 +308,16 @@ pub const ChildProcess = struct.{
|
||||
os.close(self.err_pipe[1]);
|
||||
}
|
||||
|
||||
// Write @maxValue(ErrInt) to the write end of the err_pipe. This is after
|
||||
// Write maxInt(ErrInt) to the write end of the err_pipe. This is after
|
||||
// waitpid, so this write is guaranteed to be after the child
|
||||
// pid potentially wrote an error. This way we can do a blocking
|
||||
// read on the error pipe and either get @maxValue(ErrInt) (no error) or
|
||||
// read on the error pipe and either get maxInt(ErrInt) (no error) or
|
||||
// an error code.
|
||||
try writeIntFd(self.err_pipe[1], @maxValue(ErrInt));
|
||||
try writeIntFd(self.err_pipe[1], maxInt(ErrInt));
|
||||
const err_int = try readIntFd(self.err_pipe[0]);
|
||||
// Here we potentially return the fork child's error
|
||||
// from the parent pid.
|
||||
if (err_int != @maxValue(ErrInt)) {
|
||||
if (err_int != maxInt(ErrInt)) {
|
||||
return @errSetCast(SpawnError, @intToError(err_int));
|
||||
}
|
||||
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../index.zig");
|
||||
const c = std.c;
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub use @import("darwin/errno.zig");
|
||||
|
||||
@ -45,7 +46,7 @@ pub const MAP_NOCACHE = 0x0400;
|
||||
|
||||
/// don't reserve needed swap area
|
||||
pub const MAP_NORESERVE = 0x0040;
|
||||
pub const MAP_FAILED = @maxValue(usize);
|
||||
pub const MAP_FAILED = maxInt(usize);
|
||||
|
||||
/// [XSI] no hang in wait/no child to reap
|
||||
pub const WNOHANG = 0x00000001;
|
||||
|
||||
@ -9,6 +9,7 @@ const posix = os.posix;
|
||||
const windows = os.windows;
|
||||
const Os = builtin.Os;
|
||||
const windows_util = @import("windows/util.zig");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const is_posix = builtin.os != builtin.Os.windows;
|
||||
const is_windows = builtin.os == builtin.Os.windows;
|
||||
@ -385,7 +386,7 @@ pub const File = struct.{
|
||||
} else if (is_windows) {
|
||||
var index: usize = 0;
|
||||
while (index < buffer.len) {
|
||||
const want_read_count = @intCast(windows.DWORD, math.min(windows.DWORD(@maxValue(windows.DWORD)), buffer.len - index));
|
||||
const want_read_count = @intCast(windows.DWORD, math.min(windows.DWORD(maxInt(windows.DWORD)), buffer.len - index));
|
||||
var amt_read: windows.DWORD = undefined;
|
||||
if (windows.ReadFile(self.handle, buffer.ptr + index, want_read_count, &amt_read, null) == 0) {
|
||||
const err = windows.GetLastError();
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("../../index.zig");
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
const vdso = @import("vdso.zig");
|
||||
pub use switch (builtin.arch) {
|
||||
builtin.Arch.x86_64 => @import("x86_64.zig"),
|
||||
@ -38,7 +39,7 @@ pub const PROT_EXEC = 4;
|
||||
pub const PROT_GROWSDOWN = 0x01000000;
|
||||
pub const PROT_GROWSUP = 0x02000000;
|
||||
|
||||
pub const MAP_FAILED = @maxValue(usize);
|
||||
pub const MAP_FAILED = maxInt(usize);
|
||||
pub const MAP_SHARED = 0x01;
|
||||
pub const MAP_PRIVATE = 0x02;
|
||||
pub const MAP_TYPE = 0x0f;
|
||||
@ -1094,7 +1095,7 @@ pub fn sigaction(sig: u6, noalias act: *const Sigaction, noalias oact: ?*Sigacti
|
||||
|
||||
const NSIG = 65;
|
||||
const sigset_t = [128 / @sizeOf(usize)]usize;
|
||||
const all_mask = []usize.{@maxValue(usize)};
|
||||
const all_mask = []usize.{maxInt(usize)};
|
||||
const app_mask = []usize.{0xfffffffc7fffffff};
|
||||
|
||||
const k_sigaction = extern struct.{
|
||||
@ -1111,7 +1112,7 @@ pub const Sigaction = struct.{
|
||||
flags: u32,
|
||||
};
|
||||
|
||||
pub const SIG_ERR = @intToPtr(extern fn (i32) void, @maxValue(usize));
|
||||
pub const SIG_ERR = @intToPtr(extern fn (i32) void, maxInt(usize));
|
||||
pub const SIG_DFL = @intToPtr(extern fn (i32) void, 0);
|
||||
pub const SIG_IGN = @intToPtr(extern fn (i32) void, 1);
|
||||
pub const empty_sigset = []usize.{0} ** sigset_t.len;
|
||||
|
||||
@ -3,6 +3,7 @@ const elf = std.elf;
|
||||
const linux = std.os.linux;
|
||||
const cstr = std.cstr;
|
||||
const mem = std.mem;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub fn lookup(vername: []const u8, name: []const u8) usize {
|
||||
const vdso_addr = std.os.linuxGetAuxVal(std.elf.AT_SYSINFO_EHDR);
|
||||
@ -13,7 +14,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
|
||||
const ph = @intToPtr(*elf.Phdr, ph_addr);
|
||||
|
||||
var maybe_dynv: ?[*]usize = null;
|
||||
var base: usize = @maxValue(usize);
|
||||
var base: usize = maxInt(usize);
|
||||
{
|
||||
var i: usize = 0;
|
||||
while (i < eh.e_phnum) : ({
|
||||
@ -29,7 +30,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
|
||||
}
|
||||
}
|
||||
const dynv = maybe_dynv orelse return 0;
|
||||
if (base == @maxValue(usize)) return 0;
|
||||
if (base == maxInt(usize)) return 0;
|
||||
|
||||
var maybe_strings: ?[*]u8 = null;
|
||||
var maybe_syms: ?[*]elf.Sym = null;
|
||||
|
||||
@ -1,5 +1,6 @@
|
||||
const std = @import("../../index.zig");
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
pub use @import("advapi32.zig");
|
||||
pub use @import("kernel32.zig");
|
||||
@ -53,17 +54,17 @@ pub const TRUE = 1;
|
||||
pub const FALSE = 0;
|
||||
|
||||
/// The standard input device. Initially, this is the console input buffer, CONIN$.
|
||||
pub const STD_INPUT_HANDLE = @maxValue(DWORD) - 10 + 1;
|
||||
pub const STD_INPUT_HANDLE = maxInt(DWORD) - 10 + 1;
|
||||
|
||||
/// The standard output device. Initially, this is the active console screen buffer, CONOUT$.
|
||||
pub const STD_OUTPUT_HANDLE = @maxValue(DWORD) - 11 + 1;
|
||||
pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
|
||||
|
||||
/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
|
||||
pub const STD_ERROR_HANDLE = @maxValue(DWORD) - 12 + 1;
|
||||
pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
|
||||
|
||||
pub const INVALID_HANDLE_VALUE = @intToPtr(HANDLE, @maxValue(usize));
|
||||
pub const INVALID_HANDLE_VALUE = @intToPtr(HANDLE, maxInt(usize));
|
||||
|
||||
pub const INVALID_FILE_ATTRIBUTES = DWORD(@maxValue(DWORD));
|
||||
pub const INVALID_FILE_ATTRIBUTES = DWORD(maxInt(DWORD));
|
||||
|
||||
pub const OVERLAPPED = extern struct.{
|
||||
Internal: ULONG_PTR,
|
||||
|
||||
@ -20,6 +20,7 @@ const assert = std.debug.assert;
|
||||
const mem = std.mem;
|
||||
const math = std.math;
|
||||
const ziggurat = @import("ziggurat.zig");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
// When you need fast unbiased random numbers
|
||||
pub const DefaultPrng = Xoroshiro128;
|
||||
@ -39,7 +40,7 @@ pub const Random = struct.{
|
||||
return r.int(u1) != 0;
|
||||
}
|
||||
|
||||
/// Returns a random int `i` such that `0 <= i <= @maxValue(T)`.
|
||||
/// Returns a random int `i` such that `0 <= i <= maxInt(T)`.
|
||||
/// `i` is evenly distributed.
|
||||
pub fn int(r: *Random, comptime T: type) T {
|
||||
const UnsignedT = @IntType(false, T.bit_count);
|
||||
@ -69,14 +70,14 @@ pub const Random = struct.{
|
||||
assert(T.is_signed == false);
|
||||
assert(0 < less_than);
|
||||
|
||||
const last_group_size_minus_one: T = @maxValue(T) % less_than;
|
||||
const last_group_size_minus_one: T = maxInt(T) % less_than;
|
||||
if (last_group_size_minus_one == less_than - 1) {
|
||||
// less_than is a power of two.
|
||||
assert(math.floorPowerOfTwo(T, less_than) == less_than);
|
||||
// There is no retry zone. The optimal retry_zone_start would be @maxValue(T) + 1.
|
||||
// There is no retry zone. The optimal retry_zone_start would be maxInt(T) + 1.
|
||||
return r.int(T) % less_than;
|
||||
}
|
||||
const retry_zone_start = @maxValue(T) - last_group_size_minus_one;
|
||||
const retry_zone_start = maxInt(T) - last_group_size_minus_one;
|
||||
|
||||
while (true) {
|
||||
const rand_val = r.int(T);
|
||||
@ -91,7 +92,7 @@ pub const Random = struct.{
|
||||
/// for commentary on the runtime of this function.
|
||||
pub fn uintAtMost(r: *Random, comptime T: type, at_most: T) T {
|
||||
assert(T.is_signed == false);
|
||||
if (at_most == @maxValue(T)) {
|
||||
if (at_most == maxInt(T)) {
|
||||
// have the full range
|
||||
return r.int(T);
|
||||
}
|
||||
|
||||
@ -1,14 +1,16 @@
|
||||
// These functions are provided when not linking against libc because LLVM
|
||||
// sometimes generates code that calls them.
|
||||
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
// Avoid dragging in the runtime safety mechanisms into this .o file,
|
||||
// unless we're trying to test this file.
|
||||
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
|
||||
if (builtin.is_test) {
|
||||
@setCold(true);
|
||||
@import("std").debug.panic("{}", msg);
|
||||
std.debug.panic("{}", msg);
|
||||
} else {
|
||||
unreachable;
|
||||
}
|
||||
@ -190,7 +192,7 @@ fn generic_fmod(comptime T: type, x: T, y: T) T {
|
||||
}) {}
|
||||
ux <<= @intCast(log2uint, @bitCast(u32, -ex + 1));
|
||||
} else {
|
||||
ux &= @maxValue(uint) >> exp_bits;
|
||||
ux &= maxInt(uint) >> exp_bits;
|
||||
ux |= 1 << digits;
|
||||
}
|
||||
if (ey == 0) {
|
||||
@ -201,7 +203,7 @@ fn generic_fmod(comptime T: type, x: T, y: T) T {
|
||||
}) {}
|
||||
uy <<= @intCast(log2uint, @bitCast(u32, -ey + 1));
|
||||
} else {
|
||||
uy &= @maxValue(uint) >> exp_bits;
|
||||
uy &= maxInt(uint) >> exp_bits;
|
||||
uy |= 1 << digits;
|
||||
}
|
||||
|
||||
@ -247,7 +249,7 @@ fn isNan(comptime T: type, bits: T) bool {
|
||||
} else if (T == u32) {
|
||||
return (bits & 0x7fffffff) > 0x7f800000;
|
||||
} else if (T == u64) {
|
||||
return (bits & (@maxValue(u64) >> 1)) > (u64(0x7ff) << 52);
|
||||
return (bits & (maxInt(u64) >> 1)) > (u64(0x7ff) << 52);
|
||||
} else {
|
||||
unreachable;
|
||||
}
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const DBL_MANT_DIG = 53;
|
||||
|
||||
@ -37,7 +39,7 @@ pub extern fn __floattidf(arg: i128) f64 {
|
||||
const shift2_amt = @intCast(i32, N + (DBL_MANT_DIG + 2)) - sd;
|
||||
const shift2_amt_u7 = @intCast(u7, shift2_amt);
|
||||
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, @maxValue(u128)) >> shift2_amt_u7)) != 0);
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const FLT_MANT_DIG = 24;
|
||||
|
||||
@ -38,7 +40,7 @@ pub extern fn __floattisf(arg: i128) f32 {
|
||||
const shift2_amt = @intCast(i32, N + (FLT_MANT_DIG + 2)) - sd;
|
||||
const shift2_amt_u7 = @intCast(u7, shift2_amt);
|
||||
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, @maxValue(u128)) >> shift2_amt_u7)) != 0);
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const LDBL_MANT_DIG = 113;
|
||||
|
||||
@ -37,7 +39,7 @@ pub extern fn __floattitf(arg: i128) f128 {
|
||||
const shift2_amt = @intCast(i32, N + (LDBL_MANT_DIG + 2)) - sd;
|
||||
const shift2_amt_u7 = @intCast(u7, shift2_amt);
|
||||
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, @maxValue(u128)) >> shift2_amt_u7)) != 0);
|
||||
a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const DBL_MANT_DIG = 53;
|
||||
|
||||
@ -30,7 +32,7 @@ pub extern fn __floatuntidf(arg: u128) f64 {
|
||||
const shift_amt = @bitCast(i32, N + (DBL_MANT_DIG + 2)) - sd;
|
||||
const shift_amt_u7 = @intCast(u7, shift_amt);
|
||||
a = (a >> @intCast(u7, sd - (DBL_MANT_DIG + 2))) |
|
||||
@boolToInt((a & (u128(@maxValue(u128)) >> shift_amt_u7)) != 0);
|
||||
@boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const FLT_MANT_DIG = 24;
|
||||
|
||||
@ -30,7 +32,7 @@ pub extern fn __floatuntisf(arg: u128) f32 {
|
||||
const shift_amt = @bitCast(i32, N + (FLT_MANT_DIG + 2)) - sd;
|
||||
const shift_amt_u7 = @intCast(u7, shift_amt);
|
||||
a = (a >> @intCast(u7, sd - (FLT_MANT_DIG + 2))) |
|
||||
@boolToInt((a & (u128(@maxValue(u128)) >> shift_amt_u7)) != 0);
|
||||
@boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
const std = @import("std");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const LDBL_MANT_DIG = 113;
|
||||
|
||||
@ -30,7 +32,7 @@ pub extern fn __floatuntitf(arg: u128) f128 {
|
||||
const shift_amt = @bitCast(i32, N + (LDBL_MANT_DIG + 2)) - sd;
|
||||
const shift_amt_u7 = @intCast(u7, shift_amt);
|
||||
a = (a >> @intCast(u7, sd - (LDBL_MANT_DIG + 2))) |
|
||||
@boolToInt((a & (u128(@maxValue(u128)) >> shift_amt_u7)) != 0);
|
||||
@boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
|
||||
},
|
||||
}
|
||||
// finish
|
||||
|
||||
@ -1868,6 +1868,7 @@ const std = @import("std");
|
||||
const mem = std.mem;
|
||||
const warn = std.debug.warn;
|
||||
const io = std.io;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
var fixed_buffer_mem: [100 * 1024]u8 = undefined;
|
||||
|
||||
@ -1916,7 +1917,7 @@ fn testTransform(source: []const u8, expected_source: []const u8) !void {
|
||||
const needed_alloc_count = x: {
|
||||
// Try it once with unlimited memory, make sure it works
|
||||
var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
|
||||
var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
|
||||
var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, maxInt(usize));
|
||||
var anything_changed: bool = undefined;
|
||||
const result_source = try testParse(source, &failing_allocator.allocator, &anything_changed);
|
||||
if (!mem.eql(u8, result_source, expected_source)) {
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const assert = @import("std").debug.assert;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const Foo = struct.{
|
||||
x: u32,
|
||||
@ -8,7 +10,7 @@ const Foo = struct.{
|
||||
};
|
||||
|
||||
test "@alignOf(T) before referencing T" {
|
||||
comptime assert(@alignOf(Foo) != @maxValue(usize));
|
||||
comptime assert(@alignOf(Foo) != maxInt(usize));
|
||||
if (builtin.arch == builtin.Arch.x86_64) {
|
||||
comptime assert(@alignOf(Foo) == 4);
|
||||
}
|
||||
|
||||
@ -1,4 +1,6 @@
|
||||
const assert = @import("std").debug.assert;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
test "@bitCast i32 -> u32" {
|
||||
testBitCast_i32_u32();
|
||||
@ -6,8 +8,8 @@ test "@bitCast i32 -> u32" {
|
||||
}
|
||||
|
||||
fn testBitCast_i32_u32() void {
|
||||
assert(conv(-1) == @maxValue(u32));
|
||||
assert(conv2(@maxValue(u32)) == -1);
|
||||
assert(conv(-1) == maxInt(u32));
|
||||
assert(conv2(maxInt(u32)) == -1);
|
||||
}
|
||||
|
||||
fn conv(x: i32) u32 {
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const mem = std.mem;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
test "int to ptr cast" {
|
||||
const x = usize(13);
|
||||
@ -368,7 +369,7 @@ test "@bytesToSlice keeps pointer alignment" {
|
||||
}
|
||||
|
||||
test "@intCast i32 to u7" {
|
||||
var x: u128 = @maxValue(u128);
|
||||
var x: u128 = maxInt(u128);
|
||||
var y: i32 = 120;
|
||||
var z = x >> @intCast(u7, y);
|
||||
assert(z == 0xff);
|
||||
@ -435,11 +436,11 @@ test "compile time int to ptr of function" {
|
||||
foobar(FUNCTION_CONSTANT);
|
||||
}
|
||||
|
||||
pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, @maxValue(usize));
|
||||
pub const FUNCTION_CONSTANT = @intToPtr(PFN_void, maxInt(usize));
|
||||
pub const PFN_void = extern fn (*c_void) void;
|
||||
|
||||
fn foobar(func: PFN_void) void {
|
||||
std.debug.assert(@ptrToInt(func) == @maxValue(usize));
|
||||
std.debug.assert(@ptrToInt(func) == maxInt(usize));
|
||||
}
|
||||
|
||||
test "implicit ptr to *c_void" {
|
||||
|
||||
@ -1,4 +1,7 @@
|
||||
const assert = @import("std").debug.assert;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const maxInt = std.math.maxInt;
|
||||
const minInt = std.math.minInt;
|
||||
|
||||
test "division" {
|
||||
testDivision();
|
||||
@ -179,30 +182,30 @@ test "const number literal" {
|
||||
const ten = 10;
|
||||
|
||||
test "unsigned wrapping" {
|
||||
testUnsignedWrappingEval(@maxValue(u32));
|
||||
comptime testUnsignedWrappingEval(@maxValue(u32));
|
||||
testUnsignedWrappingEval(maxInt(u32));
|
||||
comptime testUnsignedWrappingEval(maxInt(u32));
|
||||
}
|
||||
fn testUnsignedWrappingEval(x: u32) void {
|
||||
const zero = x +% 1;
|
||||
assert(zero == 0);
|
||||
const orig = zero -% 1;
|
||||
assert(orig == @maxValue(u32));
|
||||
assert(orig == maxInt(u32));
|
||||
}
|
||||
|
||||
test "signed wrapping" {
|
||||
testSignedWrappingEval(@maxValue(i32));
|
||||
comptime testSignedWrappingEval(@maxValue(i32));
|
||||
testSignedWrappingEval(maxInt(i32));
|
||||
comptime testSignedWrappingEval(maxInt(i32));
|
||||
}
|
||||
fn testSignedWrappingEval(x: i32) void {
|
||||
const min_val = x +% 1;
|
||||
assert(min_val == @minValue(i32));
|
||||
assert(min_val == minInt(i32));
|
||||
const max_val = min_val -% 1;
|
||||
assert(max_val == @maxValue(i32));
|
||||
assert(max_val == maxInt(i32));
|
||||
}
|
||||
|
||||
test "negation wrapping" {
|
||||
testNegationWrappingEval(@minValue(i16));
|
||||
comptime testNegationWrappingEval(@minValue(i16));
|
||||
testNegationWrappingEval(minInt(i16));
|
||||
comptime testNegationWrappingEval(minInt(i16));
|
||||
}
|
||||
fn testNegationWrappingEval(x: i16) void {
|
||||
assert(x == -32768);
|
||||
@ -311,8 +314,8 @@ test "hex float literal within range" {
|
||||
}
|
||||
|
||||
test "truncating shift left" {
|
||||
testShlTrunc(@maxValue(u16));
|
||||
comptime testShlTrunc(@maxValue(u16));
|
||||
testShlTrunc(maxInt(u16));
|
||||
comptime testShlTrunc(maxInt(u16));
|
||||
}
|
||||
fn testShlTrunc(x: u16) void {
|
||||
const shifted = x << 1;
|
||||
@ -320,8 +323,8 @@ fn testShlTrunc(x: u16) void {
|
||||
}
|
||||
|
||||
test "truncating shift right" {
|
||||
testShrTrunc(@maxValue(u16));
|
||||
comptime testShrTrunc(@maxValue(u16));
|
||||
testShrTrunc(maxInt(u16));
|
||||
comptime testShrTrunc(maxInt(u16));
|
||||
}
|
||||
fn testShrTrunc(x: u16) void {
|
||||
const shifted = x >> 1;
|
||||
|
||||
@ -1,7 +1,9 @@
|
||||
const assert = @import("std").debug.assert;
|
||||
const mem = @import("std").mem;
|
||||
const cstr = @import("std").cstr;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const mem = std.mem;
|
||||
const cstr = std.cstr;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
// normal comment
|
||||
|
||||
@ -58,43 +60,6 @@ test "floating point primitive bit counts" {
|
||||
assert(f64.bit_count == 64);
|
||||
}
|
||||
|
||||
test "@minValue and @maxValue" {
|
||||
assert(@maxValue(u1) == 1);
|
||||
assert(@maxValue(u8) == 255);
|
||||
assert(@maxValue(u16) == 65535);
|
||||
assert(@maxValue(u32) == 4294967295);
|
||||
assert(@maxValue(u64) == 18446744073709551615);
|
||||
|
||||
assert(@maxValue(i1) == 0);
|
||||
assert(@maxValue(i8) == 127);
|
||||
assert(@maxValue(i16) == 32767);
|
||||
assert(@maxValue(i32) == 2147483647);
|
||||
assert(@maxValue(i63) == 4611686018427387903);
|
||||
assert(@maxValue(i64) == 9223372036854775807);
|
||||
|
||||
assert(@minValue(u1) == 0);
|
||||
assert(@minValue(u8) == 0);
|
||||
assert(@minValue(u16) == 0);
|
||||
assert(@minValue(u32) == 0);
|
||||
assert(@minValue(u63) == 0);
|
||||
assert(@minValue(u64) == 0);
|
||||
|
||||
assert(@minValue(i1) == -1);
|
||||
assert(@minValue(i8) == -128);
|
||||
assert(@minValue(i16) == -32768);
|
||||
assert(@minValue(i32) == -2147483648);
|
||||
assert(@minValue(i63) == -4611686018427387904);
|
||||
assert(@minValue(i64) == -9223372036854775808);
|
||||
}
|
||||
|
||||
test "max value type" {
|
||||
// If the type of @maxValue(i32) was i32 then this implicit cast to
|
||||
// u32 would not work. But since the value is a number literal,
|
||||
// it works fine.
|
||||
const x: u32 = @maxValue(i32);
|
||||
assert(x == 2147483647);
|
||||
}
|
||||
|
||||
test "short circuit" {
|
||||
testShortCircuit(false, true);
|
||||
comptime testShortCircuit(false, true);
|
||||
@ -428,10 +393,10 @@ test "cast slice to u8 slice" {
|
||||
const big_thing_again = @bytesToSlice(i32, bytes);
|
||||
assert(big_thing_again[2] == 3);
|
||||
big_thing_again[2] = -1;
|
||||
assert(bytes[8] == @maxValue(u8));
|
||||
assert(bytes[9] == @maxValue(u8));
|
||||
assert(bytes[10] == @maxValue(u8));
|
||||
assert(bytes[11] == @maxValue(u8));
|
||||
assert(bytes[8] == maxInt(u8));
|
||||
assert(bytes[9] == maxInt(u8));
|
||||
assert(bytes[10] == maxInt(u8));
|
||||
assert(bytes[11] == maxInt(u8));
|
||||
}
|
||||
|
||||
test "pointer to void return type" {
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
const assert = @import("std").debug.assert;
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const builtin = @import("builtin");
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const StructWithNoFields = struct.{
|
||||
fn add(a: i32, b: i32) i32 {
|
||||
@ -307,29 +309,29 @@ test "packed array 24bits" {
|
||||
assert(ptr.b[1].field == 0);
|
||||
assert(ptr.c == 0);
|
||||
|
||||
ptr.a = @maxValue(u16);
|
||||
assert(ptr.a == @maxValue(u16));
|
||||
ptr.a = maxInt(u16);
|
||||
assert(ptr.a == maxInt(u16));
|
||||
assert(ptr.b[0].field == 0);
|
||||
assert(ptr.b[1].field == 0);
|
||||
assert(ptr.c == 0);
|
||||
|
||||
ptr.b[0].field = @maxValue(u24);
|
||||
assert(ptr.a == @maxValue(u16));
|
||||
assert(ptr.b[0].field == @maxValue(u24));
|
||||
ptr.b[0].field = maxInt(u24);
|
||||
assert(ptr.a == maxInt(u16));
|
||||
assert(ptr.b[0].field == maxInt(u24));
|
||||
assert(ptr.b[1].field == 0);
|
||||
assert(ptr.c == 0);
|
||||
|
||||
ptr.b[1].field = @maxValue(u24);
|
||||
assert(ptr.a == @maxValue(u16));
|
||||
assert(ptr.b[0].field == @maxValue(u24));
|
||||
assert(ptr.b[1].field == @maxValue(u24));
|
||||
ptr.b[1].field = maxInt(u24);
|
||||
assert(ptr.a == maxInt(u16));
|
||||
assert(ptr.b[0].field == maxInt(u24));
|
||||
assert(ptr.b[1].field == maxInt(u24));
|
||||
assert(ptr.c == 0);
|
||||
|
||||
ptr.c = @maxValue(u16);
|
||||
assert(ptr.a == @maxValue(u16));
|
||||
assert(ptr.b[0].field == @maxValue(u24));
|
||||
assert(ptr.b[1].field == @maxValue(u24));
|
||||
assert(ptr.c == @maxValue(u16));
|
||||
ptr.c = maxInt(u16);
|
||||
assert(ptr.a == maxInt(u16));
|
||||
assert(ptr.b[0].field == maxInt(u24));
|
||||
assert(ptr.b[1].field == maxInt(u24));
|
||||
assert(ptr.c == maxInt(u16));
|
||||
|
||||
assert(bytes[bytes.len - 1] == 0xaa);
|
||||
}
|
||||
|
||||
@ -535,12 +535,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
|
||||
);
|
||||
|
||||
cases.add(
|
||||
"optional pointer to void in extern struct",
|
||||
"bit count of @IntType too large",
|
||||
\\comptime {
|
||||
\\ _ = @IntType(false, @maxValue(u32) + 1);
|
||||
\\ _ = @IntType(false, @import("std").math.maxInt(u32) + 1);
|
||||
\\}
|
||||
,
|
||||
".tmp_source.zig:2:40: error: integer value 4294967296 cannot be implicitly casted to type 'u32'",
|
||||
".tmp_source.zig:2:57: error: integer value 4294967296 cannot be implicitly casted to type 'u32'",
|
||||
);
|
||||
|
||||
cases.add(
|
||||
|
||||
@ -5,6 +5,7 @@ const debug = std.debug;
|
||||
const assert = debug.assert;
|
||||
const Buffer = std.Buffer;
|
||||
const ArrayList = std.ArrayList;
|
||||
const maxInt = std.math.maxInt;
|
||||
|
||||
const Token = union(enum).{
|
||||
Word: []const u8,
|
||||
@ -192,7 +193,7 @@ pub fn main() !void {
|
||||
defer stdin_buf.deinit();
|
||||
|
||||
var stdin_adapter = stdin_file.inStream();
|
||||
try stdin_adapter.stream.readAllBuffer(&stdin_buf, @maxValue(usize));
|
||||
try stdin_adapter.stream.readAllBuffer(&stdin_buf, maxInt(usize));
|
||||
|
||||
var result_buf = try Buffer.initSize(global_allocator, 0);
|
||||
defer result_buf.deinit();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user