zig/std/endian.zig

const mem = @import("mem.zig");
const builtin = @import("builtin");

pub fn swapIfLe(comptime T: type, x: T) -> T {
    return swapIf(false, T, x);
}

pub fn swapIfBe(comptime T: type, x: T) -> T {
    return swapIf(true, T, x);
}

pub fn swapIf(endian: builtin.Endian, comptime T: type, x: T) -> T {
    return if (builtin.endian == endian) swap(T, x) else x;
}

pub fn swap(comptime T: type, x: T) -> T {
    var buf: [@sizeOf(T)]u8 = undefined;
    mem.writeInt(buf[0..], x, false);
    return mem.readInt(buf, T, true);
}
slice and array re-work plus some misc. changes * `@truncate` builtin allows casting to the same size integer. It also performs two's complement casting between signed and unsigned integers. * The idiomatic way to convert between bytes and numbers is now `mem.readInt` and `mem.writeInt` instead of an unsafe cast. It works at compile time, is safer, and looks cleaner. * Implicitly casting an array to a slice is allowed only if the slice is const. * Constant pointer values know if their memory is from a compile- time constant value or a compile-time variable. * Cast from [N]u8 to []T no longer allowed, but [N]u8 to []const T still allowed. * Fix inability to pass a mutable pointer to comptime variable at compile-time to a function and have the function modify the memory pointed to by the pointer. * Add the `comptime T: type` parameter back to mem.eql. Prevents accidentally creating instantiations for arrays. 2017-02-13 06:22:35 +08:00			`const mem = @import("mem.zig");`
`@import("builtin")` instead of `@compileVar` See #226 Closes #220 2017-05-02 01:12:38 +08:00			`const builtin = @import("builtin");`
slice and array re-work plus some misc. changes * `@truncate` builtin allows casting to the same size integer. It also performs two's complement casting between signed and unsigned integers. * The idiomatic way to convert between bytes and numbers is now `mem.readInt` and `mem.writeInt` instead of an unsafe cast. It works at compile time, is safer, and looks cleaner. * Implicitly casting an array to a slice is allowed only if the slice is const. * Constant pointer values know if their memory is from a compile- time constant value or a compile-time variable. * Cast from [N]u8 to []T no longer allowed, but [N]u8 to []const T still allowed. * Fix inability to pass a mutable pointer to comptime variable at compile-time to a function and have the function modify the memory pointed to by the pointer. * Add the `comptime T: type` parameter back to mem.eql. Prevents accidentally creating instantiations for arrays. 2017-02-13 06:22:35 +08:00
			`pub fn swapIfLe(comptime T: type, x: T) -> T {`
explicitly return from blocks instead of last statement being expression value closes #629 2017-12-22 13:50:30 +08:00			`return swapIf(false, T, x);`
progress toward stack trace printing 2016-08-18 11:11:04 +08:00			`}`

slice and array re-work plus some misc. changes * `@truncate` builtin allows casting to the same size integer. It also performs two's complement casting between signed and unsigned integers. * The idiomatic way to convert between bytes and numbers is now `mem.readInt` and `mem.writeInt` instead of an unsafe cast. It works at compile time, is safer, and looks cleaner. * Implicitly casting an array to a slice is allowed only if the slice is const. * Constant pointer values know if their memory is from a compile- time constant value or a compile-time variable. * Cast from [N]u8 to []T no longer allowed, but [N]u8 to []const T still allowed. * Fix inability to pass a mutable pointer to comptime variable at compile-time to a function and have the function modify the memory pointed to by the pointer. * Add the `comptime T: type` parameter back to mem.eql. Prevents accidentally creating instantiations for arrays. 2017-02-13 06:22:35 +08:00			`pub fn swapIfBe(comptime T: type, x: T) -> T {`
explicitly return from blocks instead of last statement being expression value closes #629 2017-12-22 13:50:30 +08:00			`return swapIf(true, T, x);`
progress toward stack trace printing 2016-08-18 11:11:04 +08:00			`}`

rename builtin.is_big_endian to builtin.endian See #307 2017-12-04 23:35:55 +08:00			`pub fn swapIf(endian: builtin.Endian, comptime T: type, x: T) -> T {`
explicitly return from blocks instead of last statement being expression value closes #629 2017-12-22 13:50:30 +08:00			`return if (builtin.endian == endian) swap(T, x) else x;`
progress toward stack trace printing 2016-08-18 11:11:04 +08:00			`}`

use comptime instead of inline for var and params See #221 2017-01-23 08:51:37 +08:00			`pub fn swap(comptime T: type, x: T) -> T {`
slice and array re-work plus some misc. changes * `@truncate` builtin allows casting to the same size integer. It also performs two's complement casting between signed and unsigned integers. * The idiomatic way to convert between bytes and numbers is now `mem.readInt` and `mem.writeInt` instead of an unsafe cast. It works at compile time, is safer, and looks cleaner. * Implicitly casting an array to a slice is allowed only if the slice is const. * Constant pointer values know if their memory is from a compile- time constant value or a compile-time variable. * Cast from [N]u8 to []T no longer allowed, but [N]u8 to []const T still allowed. * Fix inability to pass a mutable pointer to comptime variable at compile-time to a function and have the function modify the memory pointed to by the pointer. * Add the `comptime T: type` parameter back to mem.eql. Prevents accidentally creating instantiations for arrays. 2017-02-13 06:22:35 +08:00			`var buf: [@sizeOf(T)]u8 = undefined;`
change slicing syntax from ... to .. See #359 2017-05-19 22:39:59 +08:00			`mem.writeInt(buf[0..], x, false);`
slice and array re-work plus some misc. changes * `@truncate` builtin allows casting to the same size integer. It also performs two's complement casting between signed and unsigned integers. * The idiomatic way to convert between bytes and numbers is now `mem.readInt` and `mem.writeInt` instead of an unsafe cast. It works at compile time, is safer, and looks cleaner. * Implicitly casting an array to a slice is allowed only if the slice is const. * Constant pointer values know if their memory is from a compile- time constant value or a compile-time variable. * Cast from [N]u8 to []T no longer allowed, but [N]u8 to []const T still allowed. * Fix inability to pass a mutable pointer to comptime variable at compile-time to a function and have the function modify the memory pointed to by the pointer. * Add the `comptime T: type` parameter back to mem.eql. Prevents accidentally creating instantiations for arrays. 2017-02-13 06:22:35 +08:00			`return mem.readInt(buf, T, true);`
progress toward stack trace printing 2016-08-18 11:11:04 +08:00			`}`