Nixyri/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-15 16:45:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
d972d1c942
zig/lib/std/fmt.zig

1700 lines
59 KiB
Zig
Raw Normal View History

rename std lib files to new convention
2019-03-02 21:46:04 +00:00
const std = @import("std.zig");
move std/debug.zig to a subdirectory self hosted compiler parser tests do some fuzz testing
2017-12-24 03:08:53 +00:00
const math = std.math;
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
const assert = std.debug.assert;
move std/debug.zig to a subdirectory self hosted compiler parser tests do some fuzz testing
2017-12-24 03:08:53 +00:00
const mem = std.mem;
typeId builtin instead of isInteger, isFloat, etc closes #373
2017-05-17 16:26:35 +00:00
const builtin = @import("builtin");
rename std lib files to new convention
2019-03-02 21:46:04 +00:00
const errol = @import("fmt/errol.zig");
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const lossyCast = std.math.lossyCast;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
pub const default_max_depth = 3;
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
pub const Alignment = enum {
Left,
Center,
Right,
};
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
pub const FormatOptions = struct {
precision: ?usize = null,
width: ?usize = null,
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
alignment: ?Alignment = null,
fill: u8 = ' ',
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
};
fn nextArg(comptime used_pos_args: *u32, comptime maybe_pos_arg: ?comptime_int, comptime next_arg: *comptime_int) comptime_int {
if (maybe_pos_arg) |pos_arg| {
used_pos_args.* |= 1 << pos_arg;
return pos_arg;
} else {
const arg = next_arg.*;
next_arg.* += 1;
return arg;
}
}
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
fn peekIsAlign(comptime fmt: []const u8) bool {
// Should only be called during a state transition to the format segment.
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
comptime assert(fmt[0] == ':');
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
inline for (([_]u8{ 1, 2 })[0..]) |i| {
if (fmt.len > i and (fmt[i] == '<' or fmt[i] == '^' or fmt[i] == '>')) {
return true;
}
}
return false;
}
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
/// Renders fmt string with args, calling output with slices of bytes.
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 08:47:55 +00:00
/// If `output` returns an error, the error is returned from `format` and
/// `output` is not called again.
Adds documentation for std.fmt.format grammar and customization. (#3474)
2019-10-22 18:58:27 +00:00
///
/// The format string must be comptime known and may contain placeholders following
/// this format:
/// `{[position][specifier]:[fill][alignment][width].[precision]}`
std lib networking improvements, especially non-blocking I/O * delete the std/event/net directory * `std.event.Loop.waitUntilFdReadable` and related functions no longer have possibility of failure. On Linux, they fall back to poll() and then fall back to sleep(). * add some missing `noasync` decorations in `std.event.Loop` * redo the `std.net.Server` API. it's quite nice now, but shutdown does not work cleanly. There is a race condition with close() that I am actively working on. * move `std.io.OutStream` to its own file to match `std.io.InStream`. I started working on making `write` integrated with evented I/O, but it got tricky so I backed off and filed #3557. However I did integrate `std.os.writev` and `std.os.pwritev` with evented I/O. * add `std.Target.stack_align` * move networking tests to `lib/std/net/test.zig` * add `std.net.tcpConnectToHost` and `std.net.tcpConnectToAddress`. * rename `error.UnknownName` to `error.UnknownHostName` within the context of DNS resolution. * add `std.os.readv`, which is integrated with evented I/O. * `std.os.preadv`, is now integrated with evented I/O. * `std.os.accept4` now asserts that ENOTSOCK and EOPNOTSUPP never occur (misuse of API), instead of returning errors. * `std.os.connect` is now integrated with evented I/O. `std.os.connect_async` is gone. Just use `std.os.connect`. * fix false positive dependency loop regarding async function frames * add more compile notes to help when dependency loops occur in determining whether a function is async. * ir: change an assert to ir_assert to make it easier to find workarounds for when such an assert is triggered. In this case it was trying to parse an IPv4 address at comptime.
2019-10-30 02:59:30 +00:00
///
Adds documentation for std.fmt.format grammar and customization. (#3474)
2019-10-22 18:58:27 +00:00
/// Each word between `[` and `]` is a parameter you have to replace with something:
///
/// - *position* is the index of the argument that should be inserted
/// - *specifier* is a type-dependent formatting option that determines how a type should formatted (see below)
/// - *fill* is a single character which is used to pad the formatted text
/// - *alignment* is one of the three characters `<`, `^` or `>`. they define if the text is *left*, *center*, or *right* aligned
/// - *width* is the total width of the field in characters
/// - *precision* specifies how many decimals a formatted number should have
///
/// Note that most of the parameters are optional and may be omitted. Also you can leave out separators like `:` and `.` when
/// all parameters after the separator are omitted.
/// Only exception is the *fill* parameter. If *fill* is required, one has to specify *alignment* as well, as otherwise
/// the digits after `:` is interpreted as *width*, not *fill*.
///
/// The *specifier* has several options for types:
/// - `x` and `X`:
/// - format the non-numeric value as a string of bytes in hexadecimal notation ("binary dump") in either lower case or upper case
/// - output numeric value in hexadecimal notation
/// - `s`: print a pointer-to-many as a c-string, use zero-termination
/// - `B` and `Bi`: output a memory size in either metric (1000) or power-of-two (1024) based notation. works for both float and integer values.
/// - `e`: output floating point value in scientific notation
/// - `d`: output numeric value in decimal notation
/// - `b`: output integer value in binary notation
/// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max.
std lib networking improvements, especially non-blocking I/O * delete the std/event/net directory * `std.event.Loop.waitUntilFdReadable` and related functions no longer have possibility of failure. On Linux, they fall back to poll() and then fall back to sleep(). * add some missing `noasync` decorations in `std.event.Loop` * redo the `std.net.Server` API. it's quite nice now, but shutdown does not work cleanly. There is a race condition with close() that I am actively working on. * move `std.io.OutStream` to its own file to match `std.io.InStream`. I started working on making `write` integrated with evented I/O, but it got tricky so I backed off and filed #3557. However I did integrate `std.os.writev` and `std.os.pwritev` with evented I/O. * add `std.Target.stack_align` * move networking tests to `lib/std/net/test.zig` * add `std.net.tcpConnectToHost` and `std.net.tcpConnectToAddress`. * rename `error.UnknownName` to `error.UnknownHostName` within the context of DNS resolution. * add `std.os.readv`, which is integrated with evented I/O. * `std.os.preadv`, is now integrated with evented I/O. * `std.os.accept4` now asserts that ENOTSOCK and EOPNOTSUPP never occur (misuse of API), instead of returning errors. * `std.os.connect` is now integrated with evented I/O. `std.os.connect_async` is gone. Just use `std.os.connect`. * fix false positive dependency loop regarding async function frames * add more compile notes to help when dependency loops occur in determining whether a function is async. * ir: change an assert to ir_assert to make it easier to find workarounds for when such an assert is triggered. In this case it was trying to parse an IPv4 address at comptime.
2019-10-30 02:59:30 +00:00
/// - `*`: output the address of the value instead of the value itself.
Adds documentation for std.fmt.format grammar and customization. (#3474)
2019-10-22 18:58:27 +00:00
///
/// If a formatted user type contains a function of the type
/// ```
Additional replacements of @typeOf with @TypeOf
2019-12-09 20:59:12 +00:00
/// fn format(value: ?, comptime fmt: []const u8, options: std.fmt.FormatOptions, context: var, comptime Errors: type, output: fn (@TypeOf(context), []const u8) Errors!void) Errors!void
Adds documentation for std.fmt.format grammar and customization. (#3474)
2019-10-22 18:58:27 +00:00
/// ```
/// with `?` being the type formatted, this function will be called instead of the default implementation.
/// This allows user types to be formatted in a logical manner instead of dumping all fields of the type.
///
/// A user type may be a `struct`, `union` or `enum` type.
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
pub fn format(
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
comptime fmt: []const u8,
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
args: var,
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
const ArgSetType = @IntType(false, 32);
remove var args from the language closes #208
2019-12-09 19:55:51 +00:00
if (args.len > ArgSetType.bit_count) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
@compileError("32 arguments max are supported per format call");
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const State = enum {
add std.os.createThread this adds kernel thread support to the standard library for linux. See #174
2018-04-14 06:12:19 +00:00
Start,
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
Positional,
add std.os.createThread this adds kernel thread support to the standard library for linux. See #174
2018-04-14 06:12:19 +00:00
CloseBrace,
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
Specifier,
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
FormatFillAndAlign,
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
FormatWidth,
FormatPrecision,
add std.os.createThread this adds kernel thread support to the standard library for linux. See #174
2018-04-14 06:12:19 +00:00
};
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
comptime var start_index = 0;
comptime var state = State.Start;
comptime var next_arg = 0;
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
comptime var maybe_pos_arg: ?comptime_int = null;
comptime var used_pos_args: ArgSetType = 0;
comptime var specifier_start = 0;
comptime var specifier_end = 0;
comptime var options = FormatOptions{};
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
inline for (fmt) |c, i| {
switch (state) {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Start => switch (c) {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
'{' => {
if (start_index < i) {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, fmt[start_index..i]);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
start_index = i;
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
specifier_start = i + 1;
specifier_end = i + 1;
maybe_pos_arg = null;
state = .Positional;
options = FormatOptions{};
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
},
'}' => {
if (start_index < i) {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, fmt[start_index..i]);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
state = .CloseBrace;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
},
else => {},
},
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
.Positional => switch (c) {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
'{' => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
state = .Start;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
start_index = i;
},
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
':' => {
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
state = if (comptime peekIsAlign(fmt[i..])) State.FormatFillAndAlign else State.FormatWidth;
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
specifier_end = i;
},
'0'...'9' => {
if (maybe_pos_arg == null) {
maybe_pos_arg = 0;
}
maybe_pos_arg.? *= 10;
maybe_pos_arg.? += c - '0';
specifier_start = i + 1;
remove var args from the language closes #208
2019-12-09 19:55:51 +00:00
if (maybe_pos_arg.? >= args.len) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
@compileError("Positional value refers to non-existent argument");
}
},
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
'}' => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
remove var args from the language closes #208
2019-12-09 19:55:51 +00:00
if (arg_to_print >= args.len) {
Add error when too few arguments are provided to std.fmt
2019-10-31 17:23:02 +00:00
@compileError("Too few arguments");
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType(
args[arg_to_print],
fmt[0..0],
options,
context,
Errors,
output,
default_max_depth,
);
state = .Start;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
start_index = i + 1;
},
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
else => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
state = .Specifier;
specifier_start = i;
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
},
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.CloseBrace => switch (c) {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
'}' => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
state = .Start;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
start_index = i;
},
else => @compileError("Single '}' encountered in format string"),
},
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
.Specifier => switch (c) {
':' => {
specifier_end = i;
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
state = if (comptime peekIsAlign(fmt[i..])) State.FormatFillAndAlign else State.FormatWidth;
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
},
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
'}' => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
try formatType(
args[arg_to_print],
fmt[specifier_start..i],
options,
context,
Errors,
output,
default_max_depth,
);
state = .Start;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
start_index = i + 1;
},
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
else => {},
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
},
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
// Only entered if the format string contains a fill/align segment.
.FormatFillAndAlign => switch (c) {
'<' => {
options.alignment = Alignment.Left;
state = .FormatWidth;
},
'^' => {
options.alignment = Alignment.Center;
state = .FormatWidth;
},
'>' => {
options.alignment = Alignment.Right;
state = .FormatWidth;
},
else => {
options.fill = c;
},
},
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
.FormatWidth => switch (c) {
'0'...'9' => {
if (options.width == null) {
options.width = 0;
}
options.width.? *= 10;
options.width.? += c - '0';
},
'.' => {
state = .FormatPrecision;
},
'}' => {
const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
try formatType(
args[arg_to_print],
fmt[specifier_start..specifier_end],
options,
context,
Errors,
output,
default_max_depth,
);
state = .Start;
start_index = i + 1;
},
else => {
@compileError("Unexpected character in width value: " ++ [_]u8{c});
},
},
.FormatPrecision => switch (c) {
'0'...'9' => {
if (options.precision == null) {
options.precision = 0;
}
options.precision.? *= 10;
options.precision.? += c - '0';
},
'}' => {
const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
try formatType(
args[arg_to_print],
fmt[specifier_start..specifier_end],
options,
context,
Errors,
output,
default_max_depth,
);
state = .Start;
start_index = i + 1;
},
else => {
@compileError("Unexpected character in precision value: " ++ [_]u8{c});
},
},
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
comptime {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
// All arguments must have been printed but we allow mixing positional and fixed to achieve this.
var i: usize = 0;
inline while (i < next_arg) : (i += 1) {
used_pos_args |= 1 << i;
}
remove var args from the language closes #208
2019-12-09 19:55:51 +00:00
if (@popCount(ArgSetType, used_pos_args) != args.len) {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
@compileError("Unused arguments");
}
if (state != State.Start) {
@compileError("Incomplete format string: " ++ fmt);
}
}
if (start_index < fmt.len) {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, fmt[start_index..]);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatType(
value: var,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
max_depth: usize,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
std/fmt: Move pointer parsing out of main state machine This allows us to format a pointer with alignment/padding as we would with any other format specifier. e.g. {*:5}
2019-08-05 07:07:31 +00:00
if (comptime std.mem.eql(u8, fmt, "*")) {
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try output(context, @typeName(@TypeOf(value).Child));
std/fmt: Move pointer parsing out of main state machine This allows us to format a pointer with alignment/padding as we would with any other format specifier. e.g. {*:5}
2019-08-05 07:07:31 +00:00
try output(context, "@");
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, context, Errors, output);
std/fmt: Move pointer parsing out of main state machine This allows us to format a pointer with alignment/padding as we would with any other format specifier. e.g. {*:5}
2019-08-05 07:07:31 +00:00
return;
}
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const T = @TypeOf(value);
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
switch (@typeInfo(T)) {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.ComptimeInt, .Int, .Float => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatValue(value, fmt, options, context, Errors, output);
typeId builtin instead of isInteger, isFloat, etc closes #373
2017-05-17 16:26:35 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Void => {
typeId builtin instead of isInteger, isFloat, etc closes #373
2017-05-17 16:26:35 +00:00
return output(context, "void");
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Bool => {
typeId builtin instead of isInteger, isFloat, etc closes #373
2017-05-17 16:26:35 +00:00
return output(context, if (value) "true" else "false");
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Optional => {
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
if (value) |payload| {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatType(payload, fmt, options, context, Errors, output, max_depth);
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
} else {
return output(context, "null");
}
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.ErrorUnion => {
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
if (value) |payload| {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatType(payload, fmt, options, context, Errors, output, max_depth);
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
} else |err| {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatType(err, fmt, options, context, Errors, output, max_depth);
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.ErrorSet => {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, "error.");
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
return output(context, @errorName(value));
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Enum => {
if (comptime std.meta.trait.hasFn("format")(T)) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return value.format(fmt, options, context, Errors, output);
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
Handle unions differently in std.fmt (#1432) * Handle unions differently in std.fmt Print the active tag's value in tagged unions. Untagged unions considered unsafe to print and treated like a pointer or an array.
2018-08-27 21:25:33 +00:00
std.fmt.format: handle non-pointer struct/union/enum Also adds support for printing structs via reflection. The case when structs have pointers to themselves is not handled yet. closes #1380
2018-08-20 20:04:03 +00:00
try output(context, @typeName(T));
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
try output(context, ".");
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatType(@tagName(value), "", options, context, Errors, output, max_depth);
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
},
.Union => {
if (comptime std.meta.trait.hasFn("format")(T)) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return value.format(fmt, options, context, Errors, output);
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
try output(context, @typeName(T));
if (max_depth == 0) {
return output(context, "{ ... }");
}
const info = @typeInfo(T).Union;
if (info.tag_type) |UnionTagType| {
try output(context, "{ .");
update more of the std lib to use `@as`
2019-11-07 23:52:09 +00:00
try output(context, @tagName(@as(UnionTagType, value)));
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
try output(context, " = ");
inline for (info.fields) |u_field| {
update more of the std lib to use `@as`
2019-11-07 23:52:09 +00:00
if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType(@field(value, u_field.name), "", options, context, Errors, output, max_depth - 1);
Handle unions differently in std.fmt (#1432) * Handle unions differently in std.fmt Print the active tag's value in tagged unions. Untagged unions considered unsafe to print and treated like a pointer or an array.
2018-08-27 21:25:33 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
try output(context, " }");
} else {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try format(context, Errors, output, "@{x}", .{@ptrToInt(&value)});
std.fmt.format: handle non-pointer struct/union/enum Also adds support for printing structs via reflection. The case when structs have pointers to themselves is not handled yet. closes #1380
2018-08-20 20:04:03 +00:00
}
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Struct => {
if (comptime std.meta.trait.hasFn("format")(T)) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return value.format(fmt, options, context, Errors, output);
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
try output(context, @typeName(T));
if (max_depth == 0) {
return output(context, "{ ... }");
}
comptime var field_i = 0;
support zero-sized structs in zig.fmt.format
2019-07-29 01:37:35 +00:00
try output(context, "{");
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
inline while (field_i < @memberCount(T)) : (field_i += 1) {
if (field_i == 0) {
support zero-sized structs in zig.fmt.format
2019-07-29 01:37:35 +00:00
try output(context, " .");
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
} else {
try output(context, ", .");
}
try output(context, @memberName(T, field_i));
try output(context, " = ");
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType(@field(value, @memberName(T, field_i)), "", options, context, Errors, output, max_depth - 1);
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
try output(context, " }");
},
.Pointer => |ptr_info| switch (ptr_info.size) {
.One => switch (@typeInfo(ptr_info.child)) {
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
builtin.TypeId.Array => |info| {
if (info.child == u8) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatText(value, fmt, options, context, Errors, output);
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
},
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
builtin.TypeId.Enum, builtin.TypeId.Union, builtin.TypeId.Struct => {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatType(value.*, fmt, options, context, Errors, output, max_depth);
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
},
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
else => return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Many => {
Added C string support to fmt by using "{s}". The format string requirement is for saftey. (#1092)
2018-06-10 16:57:21 +00:00
if (ptr_info.child == u8) {
fixed handling of [*]u8 when no format specifier is set If fmt was called on with a [*]u8 or [*]const u8 argument, but the fmt string did not specify 's' to treat it as a string, it produced a compile error due to accessing index 1 of a 0 length slice.
2018-08-14 17:56:41 +00:00
if (fmt.len > 0 and fmt[0] == 's') {
clean up references to os
2019-05-26 17:17:34 +00:00
const len = mem.len(u8, value);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatText(value[0..len], fmt, options, context, Errors, output);
Added C string support to fmt by using "{s}". The format string requirement is for saftey. (#1092)
2018-06-10 16:57:21 +00:00
}
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Slice => {
std/fmt/index.zig: support printing hex bytes on slices;
2018-11-14 16:12:10 +00:00
if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatText(value, fmt, options, context, Errors, output);
std/fmt/index.zig: support printing hex bytes on slices;
2018-11-14 16:12:10 +00:00
}
Fix fmt.zig handling of slices of slices Discovered while calling testing.expectError on an error union with payload [][]const u8. Even though the payload was not going to be printed, the current format handling caused a compile error anyway because it couldn't be casted to []const u8. The new handling treats a []u8 as a string but otherwise treats the slice as a pointer.
2019-05-29 15:23:21 +00:00
if (ptr_info.child == u8) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
return formatText(value, fmt, options, context, Errors, output);
Fix fmt.zig handling of slices of slices Discovered while calling testing.expectError on an error union with payload [][]const u8. Even though the payload was not going to be printed, the current format handling caused a compile error anyway because it couldn't be casted to []const u8. The new handling treats a []u8 as a string but otherwise treats the slice as a pointer.
2019-05-29 15:23:21 +00:00
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return format(context, Errors, output, "{}@{x}", .{ @typeName(ptr_info.child), @ptrToInt(value.ptr) });
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.C => {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
add C pointer type to @typeInfo See #1059
2019-02-11 21:07:40 +00:00
},
typeId builtin instead of isInteger, isFloat, etc closes #373
2017-05-17 16:26:35 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Array => |info| {
remove type coercion from array values to references * Implements #3768. This is a sweeping breaking change that requires many (trivial) edits to Zig source code. Array values no longer coerced to slices; however one may use `&` to obtain a reference to an array value, which may then be coerced to a slice. * Adds `IrInstruction::dump`, for debugging purposes. It's useful to call to inspect the instruction when debugging Zig IR. * Fixes bugs with result location semantics. See the new behavior test cases, and compile error test cases. * Fixes bugs with `@typeInfo` not properly resolving const values. * Behavior tests are passing but std lib tests are not yet. There is more work to do before merging this branch.
2019-11-27 08:30:39 +00:00
const Slice = @Type(builtin.TypeInfo{
.Pointer = .{
.size = .Slice,
.is_const = true,
.is_volatile = false,
.is_allowzero = false,
.alignment = @alignOf(info.child),
.child = info.child,
.sentinel = null,
},
});
return formatType(@as(Slice, &value), fmt, options, context, Errors, output, max_depth);
don't automatically take pointer when passing by non-copying value this commit does not have all tests passing
2018-06-15 17:49:39 +00:00
},
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
.Fn => {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return format(context, Errors, output, "{}@{x}", .{ @typeName(T), @ptrToInt(value) });
Added formatting of function pointers (#1843)
2018-12-19 15:07:35 +00:00
},
ability to give comptime and non-comptime types to same parameter
2019-12-09 18:30:53 +00:00
.Type => return output(context, @typeName(T)),
Pointer Reform: update @typeInfo * add assertion for trying to do @typeInfo on global error set * remove TypeInfo.Slice * add TypeInfo.Pointer.Size with possible values - One - Many - Slice See #770
2018-06-06 04:39:39 +00:00
else => @compileError("Unable to format type '" ++ @typeName(T) ++ "'"),
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
fn formatValue(
value: var,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (comptime std.mem.eql(u8, fmt, "B")) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatBytes(value, options, 1000, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else if (comptime std.mem.eql(u8, fmt, "Bi")) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatBytes(value, options, 1024, context, Errors, output);
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const T = @TypeOf(value);
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
switch (@typeId(T)) {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
.Float => return formatFloatValue(value, fmt, options, context, Errors, output),
.Int, .ComptimeInt => return formatIntValue(value, fmt, options, context, Errors, output),
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
else => comptime unreachable,
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatIntValue(
value: var,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
comptime var radix = 10;
comptime var uppercase = false;
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const int_value = if (@TypeOf(value) == comptime_int) blk: {
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
const Int = math.IntFittingRange(value, value);
update more of the std lib to use `@as`
2019-11-07 23:52:09 +00:00
break :blk @as(Int, value);
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
} else
value;
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "d")) {
radix = 10;
uppercase = false;
} else if (comptime std.mem.eql(u8, fmt, "c")) {
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
if (@TypeOf(int_value).bit_count <= 8) {
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
return formatAsciiChar(@as(u8, int_value), options, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else {
@compileError("Cannot print integer that is larger than 8 bits as a ascii");
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else if (comptime std.mem.eql(u8, fmt, "b")) {
radix = 2;
uppercase = false;
} else if (comptime std.mem.eql(u8, fmt, "x")) {
radix = 16;
uppercase = false;
} else if (comptime std.mem.eql(u8, fmt, "X")) {
radix = 16;
uppercase = true;
} else {
@compileError("Unknown format string: '" ++ fmt ++ "'");
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatInt(int_value, radix, uppercase, options, context, Errors, output);
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
fn formatFloatValue(
value: var,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "e")) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatFloatScientific(value, options, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else if (comptime std.mem.eql(u8, fmt, "d")) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatFloatDecimal(value, options, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else {
@compileError("Unknown format string: '" ++ fmt ++ "'");
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatText(
bytes: []const u8,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (fmt.len == 0) {
return output(context, bytes);
} else if (comptime std.mem.eql(u8, fmt, "s")) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatBuf(bytes, options, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else if (comptime (std.mem.eql(u8, fmt, "x") or std.mem.eql(u8, fmt, "X"))) {
for (bytes) |c| {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
try formatInt(c, 16, fmt[0] == 'X', FormatOptions{ .width = 2, .fill = '0' }, context, Errors, output);
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
}
return;
} else {
@compileError("Unknown format string: '" ++ fmt ++ "'");
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatAsciiChar(
c: u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
translate-c-2 character literals and more test fixes
2019-12-17 23:04:01 +00:00
if (std.ascii.isPrint(c))
return output(context, @as(*const [1]u8, &c)[0..]);
return format(context, Errors, output, "\\x{x:0<2}", .{c});
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatBuf(
buf: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, buf);
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
const width = options.width orelse 0;
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 08:47:55 +00:00
var leftover_padding = if (width > buf.len) (width - buf.len) else return;
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
const pad_byte: u8 = options.fill;
change while syntax Old: ``` while (condition; expression) {} ``` New: ``` while (condition) : (expression) {} ``` This is in preparation to allow nullable and error union types as the condition. See #357
2017-05-03 22:12:07 +00:00
while (leftover_padding > 0) : (leftover_padding -= 1) {
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
try output(context, @as(*const [1]u8, &pad_byte)[0..1]);
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
}
}
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// Print a float in scientific notation to the specified precision. Null uses full precision.
// It should be the case that every full precision, printed value can be re-parsed back to the
// same type unambiguously.
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatFloatScientific(
value: var,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
Alignment fix and allow rudimentary f128 float printing
2018-06-30 08:15:02 +00:00
var x = @floatCast(f64, value);
Print better floats
2017-10-23 20:40:49 +00:00
// Errol doesn't handle these special cases.
More corrections to float printing Testing suggests all f32s are now printed accurately.
2017-10-24 19:18:50 +00:00
if (math.signbit(x)) {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, "-");
More corrections to float printing Testing suggests all f32s are now printed accurately.
2017-10-24 19:18:50 +00:00
x = -x;
}
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
if (math.isNan(x)) {
return output(context, "nan");
}
Print better floats
2017-10-23 20:40:49 +00:00
if (math.isPositiveInf(x)) {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
return output(context, "inf");
Print better floats
2017-10-23 20:40:49 +00:00
}
if (x == 0.0) {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
try output(context, "0");
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
if (options.precision) |precision| {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
if (precision != 0) {
try output(context, ".");
var i: usize = 0;
while (i < precision) : (i += 1) {
try output(context, "0");
}
}
} else {
try output(context, ".0");
}
try output(context, "e+00");
return;
Print better floats
2017-10-23 20:40:49 +00:00
}
var buffer: [32]u8 = undefined;
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
var float_decimal = errol.errol3(x, buffer[0..]);
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
if (options.precision) |precision| {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Scientific);
try output(context, float_decimal.digits[0..1]);
// {e0} case prints no `.`
if (precision != 0) {
try output(context, ".");
var printed: usize = 0;
if (float_decimal.digits.len > 1) {
const num_digits = math.min(float_decimal.digits.len, precision + 1);
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[1..num_digits]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
printed += num_digits - 1;
}
while (printed < precision) : (printed += 1) {
try output(context, "0");
}
}
slightly nicer floating point printing
2017-08-18 21:54:42 +00:00
} else {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
try output(context, float_decimal.digits[0..1]);
try output(context, ".");
if (float_decimal.digits.len > 1) {
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const num_digits = if (@TypeOf(value) == f32) math.min(@as(usize, 9), float_decimal.digits.len) else float_decimal.digits.len;
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[1..num_digits]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
} else {
try output(context, "0");
}
slightly nicer floating point printing
2017-08-18 21:54:42 +00:00
}
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
try output(context, "e");
const exp = float_decimal.exp - 1;
if (exp >= 0) {
try output(context, "+");
if (exp > -10 and exp < 10) {
try output(context, "0");
}
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
try formatInt(exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
} else {
try output(context, "-");
if (exp > -10 and exp < 10) {
try output(context, "0");
}
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
try formatInt(-exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
slightly nicer floating point printing
2017-08-18 21:54:42 +00:00
}
partial implementation of printing floating point numbers with errol3 also add bitCast builtin function. closes #387
2017-06-08 02:56:57 +00:00
}
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// Print a float of the format x.yyyyy where the number of y is specified by the precision argument.
// By default floats are printed at full precision (no rounding).
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
pub fn formatFloatDecimal(
value: var,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
var x = @as(f64, value);
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
// Errol doesn't handle these special cases.
if (math.signbit(x)) {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
try output(context, "-");
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
x = -x;
}
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
if (math.isNan(x)) {
return output(context, "nan");
}
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
if (math.isPositiveInf(x)) {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
return output(context, "inf");
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
}
if (x == 0.0) {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
try output(context, "0");
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
if (options.precision) |precision| {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
if (precision != 0) {
try output(context, ".");
var i: usize = 0;
while (i < precision) : (i += 1) {
try output(context, "0");
}
} else {
try output(context, ".0");
}
} else {
try output(context, "0");
}
return;
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
}
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// non-special case, use errol3
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
var buffer: [32]u8 = undefined;
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
var float_decimal = errol.errol3(x, buffer[0..]);
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
if (options.precision) |precision| {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Decimal);
// exp < 0 means the leading is always 0 as errol result is normalized.
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
var num_digits_whole = if (float_decimal.exp > 0) @intCast(usize, float_decimal.exp) else 0;
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this.
var num_digits_whole_no_pad = math.min(num_digits_whole, float_decimal.digits.len);
if (num_digits_whole > 0) {
// We may have to zero pad, for instance 1e4 requires zero padding.
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[0..num_digits_whole_no_pad]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
var i = num_digits_whole_no_pad;
while (i < num_digits_whole) : (i += 1) {
try output(context, "0");
}
} else {
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, "0");
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
}
// {.0} special case doesn't want a trailing '.'
if (precision == 0) {
return;
}
try output(context, ".");
// Keep track of fractional count printed for case where we pre-pad then post-pad with 0's.
var printed: usize = 0;
// Zero-fill until we reach significant digits or run out of precision.
if (float_decimal.exp <= 0) {
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const zero_digit_count = @intCast(usize, -float_decimal.exp);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
const zeros_to_print = math.min(zero_digit_count, precision);
var i: usize = 0;
while (i < zeros_to_print) : (i += 1) {
try output(context, "0");
printed += 1;
}
if (printed >= precision) {
return;
}
}
// Remaining fractional portion, zero-padding if insufficient.
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 23:18:47 +00:00
assert(precision >= printed);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
if (num_digits_whole_no_pad + precision - printed < float_decimal.digits.len) {
run zig fmt on the codebase
2018-05-30 20:09:11 +00:00
try output(context, float_decimal.digits[num_digits_whole_no_pad .. num_digits_whole_no_pad + precision - printed]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
return;
} else {
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[num_digits_whole_no_pad..]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
printed += float_decimal.digits.len - num_digits_whole_no_pad;
while (printed < precision) : (printed += 1) {
try output(context, "0");
}
}
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
} else {
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// exp < 0 means the leading is always 0 as errol result is normalized.
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
var num_digits_whole = if (float_decimal.exp > 0) @intCast(usize, float_decimal.exp) else 0;
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
// the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this.
var num_digits_whole_no_pad = math.min(num_digits_whole, float_decimal.digits.len);
if (num_digits_whole > 0) {
// We may have to zero pad, for instance 1e4 requires zero padding.
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[0..num_digits_whole_no_pad]);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
var i = num_digits_whole_no_pad;
while (i < num_digits_whole) : (i += 1) {
try output(context, "0");
}
} else {
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, "0");
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
}
// Omit `.` if no fractional portion
if (float_decimal.exp >= 0 and num_digits_whole_no_pad == float_decimal.digits.len) {
return;
}
try output(context, ".");
// Zero-fill until we reach significant digits or run out of precision.
if (float_decimal.exp < 0) {
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const zero_digit_count = @intCast(usize, -float_decimal.exp);
Improve fmt float-printing - Fix errors printing very small numbers - Add explicit scientific output mode - Add rounding based on a specific precision for both decimal/exp modes. - Test and confirm exp/decimal against libc for all f32 values. Various changes to better match libc.
2018-04-17 10:58:10 +00:00
var i: usize = 0;
while (i < zero_digit_count) : (i += 1) {
try output(context, "0");
}
}
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
try output(context, float_decimal.digits[num_digits_whole_no_pad..]);
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
}
}
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
pub fn formatBytes(
value: var,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
comptime radix: usize,
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
) Errors!void {
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
if (value == 0) {
return output(context, "0B");
}
std/fmt: Use lowercase k for kilo in base 1000 (#1090)
2018-06-09 16:05:58 +00:00
const mags_si = " kMGTPEZY";
const mags_iec = " KMGTPEZY";
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
const magnitude = switch (radix) {
std/fmt: Use lowercase k for kilo in base 1000 (#1090)
2018-06-09 16:05:58 +00:00
1000 => math.min(math.log2(value) / comptime math.log2(1000), mags_si.len - 1),
1024 => math.min(math.log2(value) / 10, mags_iec.len - 1),
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
else => unreachable,
};
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const new_value = lossyCast(f64, value) / math.pow(f64, lossyCast(f64, radix), lossyCast(f64, magnitude));
std/fmt: Use lowercase k for kilo in base 1000 (#1090)
2018-06-09 16:05:58 +00:00
const suffix = switch (radix) {
1000 => mags_si[magnitude],
1024 => mags_iec[magnitude],
else => unreachable,
};
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
try formatFloatDecimal(new_value, options, context, Errors, output);
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
if (suffix == ' ') {
return output(context, "B");
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
}
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
const buf = switch (radix) {
remove type coercion from array values to references * Implements #3768. This is a sweeping breaking change that requires many (trivial) edits to Zig source code. Array values no longer coerced to slices; however one may use `&` to obtain a reference to an array value, which may then be coerced to a slice. * Adds `IrInstruction::dump`, for debugging purposes. It's useful to call to inspect the instruction when debugging Zig IR. * Fixes bugs with result location semantics. See the new behavior test cases, and compile error test cases. * Fixes bugs with `@typeInfo` not properly resolving const values. * Behavior tests are passing but std lib tests are not yet. There is more work to do before merging this branch.
2019-11-27 08:30:39 +00:00
1000 => &[_]u8{ suffix, 'B' },
1024 => &[_]u8{ suffix, 'i', 'B' },
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
else => unreachable,
};
return output(context, buf);
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
}
Added format for floating point numbers. {.x} where x is the number of decimals.
2017-12-30 23:27:58 +00:00
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
pub fn formatInt(
value: var,
base: u8,
uppercase: bool,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
) Errors!void {
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const int_value = if (@TypeOf(value) == comptime_int) blk: {
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
const Int = math.IntFittingRange(value, value);
Fix missing @as cast in std.fmt.formatInt (#3650)
2019-11-10 23:08:24 +00:00
break :blk @as(Int, value);
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
} else
value;
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
if (@TypeOf(int_value).is_signed) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatIntSigned(int_value, base, uppercase, options, context, Errors, output);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
} else {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatIntUnsigned(int_value, base, uppercase, options, context, Errors, output);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
fn formatIntSigned(
value: var,
base: u8,
uppercase: bool,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
const new_options = FormatOptions{
.width = if (options.width) |w| (if (w == 0) 0 else w - 1) else null,
.precision = options.precision,
.fill = options.fill,
};
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
const uint = @IntType(false, @TypeOf(value).bit_count);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
if (value < 0) {
const minus_sign: u8 = '-';
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
try output(context, @as(*const [1]u8, &minus_sign)[0..]);
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const new_value = @intCast(uint, -(value + 1)) + 1;
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
} else if (options.width == null or options.width.? == 0) {
return formatIntUnsigned(@intCast(uint, value), base, uppercase, options, context, Errors, output);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
} else {
const plus_sign: u8 = '+';
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
try output(context, @as(*const [1]u8, &plus_sign)[0..]);
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
const new_value = @intCast(uint, value);
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
fn formatIntUnsigned(
value: var,
base: u8,
uppercase: bool,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
) Errors!void {
better buffer length for formatIntUnsigned see #1358
2019-03-19 14:11:28 +00:00
assert(base >= 2);
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
var buf: [math.max(@TypeOf(value).bit_count, 1)]u8 = undefined;
const min_int_bits = comptime math.max(@TypeOf(value).bit_count, @TypeOf(base).bit_count);
const MinInt = @IntType(@TypeOf(value).is_signed, min_int_bits);
fix formatInt to handle upcasting to base int size
2018-09-20 17:46:20 +00:00
var a: MinInt = value;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
var index: usize = buf.len;
while (true) {
const digit = a % base;
index -= 1;
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 06:57:07 +00:00
buf[index] = digitToChar(@intCast(u8, digit), uppercase);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
a /= base;
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
if (a == 0) break;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
change slicing syntax from ... to .. See #359
2017-05-19 14:39:59 +00:00
const digits_buf = buf[index..];
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
const width = options.width orelse 0;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
const padding = if (width > digits_buf.len) (width - digits_buf.len) else 0;
if (padding > index) {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
const zero_byte: u8 = options.fill;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
var leftover_padding = padding - index;
while (true) {
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
try output(context, @as(*const [1]u8, &zero_byte)[0..]);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
leftover_padding -= 1;
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
if (leftover_padding == 0) break;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
mem.set(u8, buf[0..index], options.fill);
remove type coercion from array values to references * Implements #3768. This is a sweeping breaking change that requires many (trivial) edits to Zig source code. Array values no longer coerced to slices; however one may use `&` to obtain a reference to an array value, which may then be coerced to a slice. * Adds `IrInstruction::dump`, for debugging purposes. It's useful to call to inspect the instruction when debugging Zig IR. * Fixes bugs with result location semantics. See the new behavior test cases, and compile error test cases. * Fixes bugs with `@typeInfo` not properly resolving const values. * Behavior tests are passing but std lib tests are not yet. There is more work to do before merging this branch.
2019-11-27 08:30:39 +00:00
return output(context, &buf);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
} else {
run zig fmt on the codebase
2018-05-30 20:09:11 +00:00
const padded_buf = buf[index - padding ..];
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
mem.set(u8, padded_buf[0..padding], options.fill);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
return output(context, padded_buf);
}
}
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) usize {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
var context = FormatIntBuf{
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
.out_buf = out_buf,
.index = 0,
};
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
formatInt(value, base, uppercase, options, &context, error{}, formatIntCallback) catch unreachable;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
return context.index;
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const FormatIntBuf = struct {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
out_buf: []u8,
index: usize,
};
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
fn formatIntCallback(context: *FormatIntBuf, bytes: []const u8) (error{}!void) {
change slicing syntax from ... to .. See #359
2017-05-19 14:39:59 +00:00
mem.copy(u8, context.out_buf[context.index..], bytes);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
context.index += bytes.len;
}
*WIP* error sets converting std lib
2018-02-01 03:48:40 +00:00
pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) !T {
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
if (!T.is_signed) return parseUnsigned(T, buf, radix);
update more of the std lib to use `@as`
2019-11-07 23:52:09 +00:00
if (buf.len == 0) return @as(T, 0);
add fmt.parseInt
2017-09-26 23:40:51 +00:00
if (buf[0] == '-') {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
return math.negate(try parseUnsigned(T, buf[1..], radix));
add fmt.parseInt
2017-09-26 23:40:51 +00:00
} else if (buf[0] == '+') {
return parseUnsigned(T, buf[1..], radix);
} else {
return parseUnsigned(T, buf, radix);
}
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
test "parseInt" {
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((parseInt(i32, "-10", 10) catch unreachable) == -10);
std.testing.expect((parseInt(i32, "+10", 10) catch unreachable) == 10);
std.testing.expect(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidCharacter);
std.testing.expect(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidCharacter);
std.testing.expect(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidCharacter);
std.testing.expect((parseInt(u8, "255", 10) catch unreachable) == 255);
std.testing.expect(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
add fmt.parseInt
2017-09-26 23:40:51 +00:00
}
std.fmt.ParseUnsignedError is now public
2019-12-04 23:44:22 +00:00
pub const ParseUnsignedError = error{
*WI* error sets - basic support working
2018-02-02 19:26:14 +00:00
/// The result cannot fit in the type specified
Overflow,
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
*WI* error sets - basic support working
2018-02-02 19:26:14 +00:00
/// The input had a byte that was not a digit
InvalidCharacter,
};
pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseUnsignedError!T {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
var x: T = 0;
for (buf) |c| {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
const digit = try charToDigit(c, radix);
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
if (x != 0) x = try math.mul(T, x, try math.cast(T, radix));
x = try math.add(T, x, try math.cast(T, digit));
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
return x;
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
test "parseUnsigned" {
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u16, "050124", 10)) == 50124);
std.testing.expect((try parseUnsigned(u16, "65535", 10)) == 65535);
std.testing.expectError(error.Overflow, parseUnsigned(u16, "65536", 10));
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u64, "0ffffffffffffffff", 16)) == 0xffffffffffffffff);
std.testing.expectError(error.Overflow, parseUnsigned(u64, "10000000000000000", 16));
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u32, "DeadBeef", 16)) == 0xDEADBEEF);
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u7, "1", 10)) == 1);
std.testing.expect((try parseUnsigned(u7, "1000", 2)) == 8);
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expectError(error.InvalidCharacter, parseUnsigned(u32, "f", 10));
std.testing.expectError(error.InvalidCharacter, parseUnsigned(u8, "109", 8));
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u32, "NUMBER", 36)) == 1442151747);
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
// these numbers should fit even though the radix itself doesn't fit in the destination type
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(u1, "0", 10)) == 0);
std.testing.expect((try parseUnsigned(u1, "1", 10)) == 1);
std.testing.expectError(error.Overflow, parseUnsigned(u1, "2", 10));
std.testing.expect((try parseUnsigned(u1, "001", 16)) == 1);
std.testing.expect((try parseUnsigned(u2, "3", 16)) == 3);
std.testing.expectError(error.Overflow, parseUnsigned(u2, "4", 16));
make parseUnsigned handle types <8 bits wide
2018-11-28 05:17:45 +00:00
}
rename std lib files to new convention
2019-03-02 21:46:04 +00:00
pub const parseFloat = @import("fmt/parse_float.zig").parseFloat;
Add parseFloat to std.fmt This is not intended to be the long-term implementation as it doesn't provide various properties that we eventually will want (e.g. round-tripping, denormal support). It also uses f64 internally so the wider f128 will be inaccurate.
2019-02-13 11:06:32 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "parseFloat" {
rename std lib files to new convention
2019-03-02 21:46:04 +00:00
_ = @import("fmt/parse_float.zig");
Add parseFloat to std.fmt This is not intended to be the long-term implementation as it doesn't provide various properties that we eventually will want (e.g. round-tripping, denormal support). It also uses f64 internally so the wider f128 will be inaccurate.
2019-02-13 11:06:32 +00:00
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
const value = switch (c) {
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
'0'...'9' => c - '0',
'A'...'Z' => c - 'A' + 10,
'a'...'z' => c - 'a' + 10,
*WI* error sets - basic support working
2018-02-02 19:26:14 +00:00
else => return error.InvalidCharacter,
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
};
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
if (value >= radix) return error.InvalidCharacter;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
return value;
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 09:10:11 +00:00
fn digitToChar(digit: u8, uppercase: bool) u8 {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
return switch (digit) {
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
0...9 => digit + '0',
update the codebase to use `@as`
2019-11-07 04:25:57 +00:00
10...35 => digit + ((if (uppercase) @as(u8, 'A') else @as(u8, 'a')) - 10),
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 08:58:48 +00:00
else => unreachable,
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
};
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const BufPrintContext = struct {
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
remaining: []u8,
};
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 14:56:59 +00:00
fn bufPrintWrite(context: *BufPrintContext, bytes: []const u8) !void {
rework the progress module and integrate with stage1
2019-10-18 00:20:22 +00:00
if (context.remaining.len < bytes.len) {
mem.copy(u8, context.remaining, bytes[0..context.remaining.len]);
return error.BufferTooSmall;
}
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
mem.copy(u8, context.remaining, bytes);
change slicing syntax from ... to .. See #359
2017-05-19 14:39:59 +00:00
context.remaining = context.remaining[bytes.len..];
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
}
rework the progress module and integrate with stage1
2019-10-18 00:20:22 +00:00
pub const BufPrintError = error{
/// As much as possible was written to the buffer, but it was too small to fit all the printed bytes.
BufferTooSmall,
};
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: var) BufPrintError![]u8 {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
var context = BufPrintContext{ .remaining = buf };
rework the progress module and integrate with stage1
2019-10-18 00:20:22 +00:00
try format(&context, BufPrintError, bufPrintWrite, fmt, args);
run zig fmt on the codebase
2018-05-30 20:09:11 +00:00
return buf[0 .. buf.len - context.remaining.len];
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
pub const AllocPrintError = error{OutOfMemory};
self-hosted: find libc on linux
2018-07-17 22:36:47 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
pub fn allocPrint(allocator: *mem.Allocator, comptime fmt: []const u8, args: var) AllocPrintError![]u8 {
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
var size: usize = 0;
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
format(&size, error{}, countSize, fmt, args) catch |err| switch (err) {};
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 21:51:46 +00:00
const buf = try allocator.alloc(u8, size);
self-hosted: find libc on linux
2018-07-17 22:36:47 +00:00
return bufPrint(buf, fmt, args) catch |err| switch (err) {
error.BufferTooSmall => unreachable, // we just counted the size above
};
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
size.* += bytes.len;
Update zig build system to support user defined options * Fix assertion failure when switching on type. Closes #310 * Update zig build system to support user defined options. See #204 * fmt.format supports {sNNN} to set padding for a buffer arg. * add std.fmt.bufPrint and std.fmt.allocPrint * std.hash_map.HashMap.put returns the previous value * add std.mem.startsWith
2017-04-06 09:34:04 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
test "bufPrintInt" {
better buffer length for formatIntUnsigned see #1358
2019-03-19 14:11:28 +00:00
var buffer: [100]u8 = undefined;
change slicing syntax from ... to .. See #359
2017-05-19 14:39:59 +00:00
const buf = buffer[0..];
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 10, false, FormatOptions{}), "-12345678"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, false, FormatOptions{}), "-bc614e"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, true, FormatOptions{}), "-BC614E"));
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 12345678), 10, true, FormatOptions{}), "12345678"));
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 666), 10, false, FormatOptions{ .width = 6 }), " 666"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 6 }), " 1234"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, 42), 10, false, FormatOptions{ .width = 3 }), "+42"));
std.testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -42), 10, false, FormatOptions{ .width = 3 }), "-42"));
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) []u8 {
std/fmt.zig: Pass full options struct to all internal functions The fill specifier is now handled in some cases. The default fill of '0' is now ' ' for integers and non-byte sequences.
2019-08-17 23:17:16 +00:00
return buf[0..formatIntBuf(buf, value, base, uppercase, options)];
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
std.fmt.format prints bool values
2017-05-08 03:25:02 +00:00
test "parse u64 digit too big" {
replace `a %% b` with `a catch b` See #632 better fits the convention of using keywords for control flow
2018-01-07 22:28:20 +00:00
_ = parseUnsigned(u64, "123a", 10) catch |err| {
error sets - fix most std lib compile errors
2018-02-05 23:09:13 +00:00
if (err == error.InvalidCharacter) return;
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 08:58:48 +00:00
unreachable;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
};
new unreachable syntax * `noreturn` is the primitive type. * `unreachable` is a control flow keyword. * `@unreachable()` builtin function is deleted. closes #214
2017-03-26 08:58:48 +00:00
unreachable;
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
std.fmt.format prints bool values
2017-05-08 03:25:02 +00:00
test "parse unsigned comptime" {
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
comptime {
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect((try parseUnsigned(usize, "2", 10)) == 2);
break off some of std.io into std.fmt, generalize printf closes #250
2017-03-10 00:12:15 +00:00
}
}
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "optional" {
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
{
const value: ?i32 = 1234;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("optional: 1234\n", "optional: {}\n", .{value});
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
{
const value: ?i32 = null;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("optional: null\n", "optional: {}\n", .{value});
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "error" {
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
{
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const value: anyerror!i32 = 1234;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("error union: 1234\n", "error union: {}\n", .{value});
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
{
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const value: anyerror!i32 = error.InvalidChar;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("error union: error.InvalidChar\n", "error union: {}\n", .{value});
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "int.small" {
std.fmt.format supports ints smaller than u8 closes #546 thanks to @Dimenus for the fix
2017-10-21 17:03:08 +00:00
{
const value: u3 = 0b101;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("u3: 5\n", "u3: {}\n", .{value});
std.fmt.format: support {B} for human readable bytes
2018-05-16 02:11:03 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "int.specifier" {
Fixed character handling
2018-05-30 17:18:24 +00:00
{
const value: u8 = 'a';
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("u8: a\n", "u8: {c}\n", .{value});
Fixed character handling
2018-05-30 17:18:24 +00:00
}
Add integer binary output format (#1313)
2018-08-01 15:38:04 +00:00
{
const value: u8 = 0b1100;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("u8: 0b1100\n", "u8: 0b{b}\n", .{value});
Add integer binary output format (#1313)
2018-08-01 15:38:04 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "int.padded" {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("u8: ' 1'", "u8: '{:4}'", .{@as(u8, 1)});
try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", .{@as(u8, 1)});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
}
test "buffer" {
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
{
var buf1: [32]u8 = undefined;
var context = BufPrintContext{ .remaining = buf1[0..] };
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType(1234, "", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
var res = buf1[0 .. buf1.len - context.remaining.len];
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, res, "1234"));
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
context = BufPrintContext{ .remaining = buf1[0..] };
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType('a', "c", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
res = buf1[0 .. buf1.len - context.remaining.len];
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, res, "a"));
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
context = BufPrintContext{ .remaining = buf1[0..] };
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
try formatType(0b1100, "b", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
res = buf1[0 .. buf1.len - context.remaining.len];
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, res, "1100"));
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "array" {
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
{
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
const value: [3]u8 = "abc".*;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("array: abc\n", "array: {}\n", .{value});
try testFmt("array: abc\n", "array: {}\n", .{&value});
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
var buf: [100]u8 = undefined;
try testFmt(
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try bufPrint(buf[0..], "array: [3]u8@{x}\n", .{@ptrToInt(&value)}),
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
"array: {*}\n",
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
.{&value},
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
);
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "slice" {
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
{
const value: []const u8 = "abc";
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("slice: abc\n", "slice: {}\n", .{value});
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
}
Fix fmt.zig handling of slices of slices Discovered while calling testing.expectError on an error union with payload [][]const u8. Even though the payload was not going to be printed, the current format handling caused a compile error anyway because it couldn't be casted to []const u8. The new handling treats a []u8 as a string but otherwise treats the slice as a pointer.
2019-05-29 15:23:21 +00:00
{
Make sure the address is aligned for intToPtr ops Closes #773
2019-12-15 11:48:35 +00:00
const value = @intToPtr([*]align(1) const []const u8, 0xdeadbeef)[0..0];
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("slice: []const u8@deadbeef\n", "slice: {}\n", .{value});
Fix fmt.zig handling of slices of slices Discovered while calling testing.expectError on an error union with payload [][]const u8. Even though the payload was not going to be printed, the current format handling caused a compile error anyway because it couldn't be casted to []const u8. The new handling treats a []u8 as a string but otherwise treats the slice as a pointer.
2019-05-29 15:23:21 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("buf: Test \n", "buf: {s:5}\n", .{"Test"});
try testFmt("buf: Test\n Other text", "buf: {s}\n Other text", .{"Test"});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "pointer" {
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
{
Make sure the address is aligned for intToPtr ops Closes #773
2019-12-15 11:48:35 +00:00
const value = @intToPtr(*align(1) i32, 0xdeadbeef);
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("pointer: i32@deadbeef\n", "pointer: {}\n", .{value});
try testFmt("pointer: i32@deadbeef\n", "pointer: {*}\n", .{value});
std.fmt.format: add '*' for formatting things as pointers closes #1285
2018-07-31 15:34:42 +00:00
}
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
{
const value = @intToPtr(fn () void, 0xdeadbeef);
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});
formatType can now format comptime_int
2018-12-19 10:50:29 +00:00
}
Added formatting of function pointers (#1843)
2018-12-19 15:07:35 +00:00
{
const value = @intToPtr(fn () void, 0xdeadbeef);
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("pointer: fn() void@deadbeef\n", "pointer: {}\n", .{value});
Added formatting of function pointers (#1843)
2018-12-19 15:07:35 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "cstr" {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("cstr: Test C\n", "cstr: {s}\n", .{"Test C"});
try testFmt("cstr: Test C \n", "cstr: {s:10}\n", .{"Test C"});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "filesize" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("file size: 63MiB\n", "file size: {Bi}\n", .{@as(usize, 63 * 1024 * 1024)});
try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", .{@as(usize, 63 * 1024 * 1024)});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "struct" {
format struct pointers as "<typename>@<address>" (#752)
2018-02-07 21:18:48 +00:00
{
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const Struct = struct {
std.fmt.format: handle non-pointer struct/union/enum Also adds support for printing structs via reflection. The case when structs have pointers to themselves is not handled yet. closes #1380
2018-08-20 20:04:03 +00:00
field: u8,
name types inside functions after variable Before this commit: fn f() []const u8 { const S = struct {}; return @typeName(S); // "f()", unexpected. } And now: fn f() []const u8 { const S = struct {}; return @typeName(S); // "S", expected. } Fixes #675.
2018-02-22 16:53:58 +00:00
};
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const value = Struct{ .field = 42 };
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{value});
try testFmt("struct: Struct{ .field = 42 }\n", "struct: {}\n", .{&value});
format struct pointers as "<typename>@<address>" (#752)
2018-02-07 21:18:48 +00:00
}
fix formatInt to handle upcasting to base int size
2018-09-20 17:46:20 +00:00
{
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const Struct = struct {
fix formatInt to handle upcasting to base int size
2018-09-20 17:46:20 +00:00
a: u0,
b: u1,
};
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 13:08:37 +00:00
const value = Struct{ .a = 0, .b = 1 };
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("struct: Struct{ .a = 0, .b = 1 }\n", "struct: {}\n", .{value});
fix formatInt to handle upcasting to base int size
2018-09-20 17:46:20 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "enum" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const Enum = enum {
One,
Two,
};
const value = Enum.Two;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("enum: Enum.Two\n", "enum: {}\n", .{value});
try testFmt("enum: Enum.Two\n", "enum: {}\n", .{&value});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "float.scientific" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f32: 1.34000003e+00", "f32: {e}", .{@as(f32, 1.34)});
try testFmt("f32: 1.23400001e+01", "f32: {e}", .{@as(f32, 12.34)});
try testFmt("f64: -1.234e+11", "f64: {e}", .{@as(f64, -12.34e10)});
try testFmt("f64: 9.99996e-40", "f64: {e}", .{@as(f64, 9.999960e-40)});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "float.scientific.precision" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 1.40971e-42", "f64: {e:.5}", .{@as(f64, 1.409706e-42)});
try testFmt("f64: 1.00000e-09", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 814313563)))});
try testFmt("f64: 7.81250e-03", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1006632960)))});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
// libc rounds 1.000005e+05 to 1.00000e+05 but zig does 1.00001e+05.
// In fact, libc doesn't round a lot of 5 cases up when one past the precision point.
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 1.00001e+05", "f64: {e:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1203982400)))});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "float.special" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: nan", "f64: {}", .{math.nan_f64});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
// negative nan is not defined by IEE 754,
// and ARM thus normalizes it to positive nan
breaking changes to the way targets work in zig * CLI: `-target [name]` instead of `--target-*` args. This matches clang's API. * `builtin.Environ` renamed to `builtin.Abi` - likewise `builtin.environ` renamed to `builtin.abi` * stop hiding the concept of sub-arch. closes #1526 * `zig targets` only shows available targets. closes #438 * include all targets in readme, even those that don't print with `zig targets` but note they are Tier 4 * refactor target.cpp and make the naming conventions more consistent * introduce the concept of a "default C ABI" for a given OS/Arch combo. As a rule of thumb, if the system compiler is clang or gcc then the default C ABI is the gnu ABI.
2019-02-26 20:51:32 +00:00
if (builtin.arch != builtin.Arch.arm) {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: -nan", "f64: {}", .{-math.nan_f64});
Fix release float printing errors Fixes #564. Fixes #669. Fixes #928.
2018-04-23 05:18:05 +00:00
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: inf", "f64: {}", .{math.inf_f64});
try testFmt("f64: -inf", "f64: {}", .{-math.inf_f64});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "float.decimal" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 152314000000000000000000000000", "f64: {d}", .{@as(f64, 1.52314e+29)});
try testFmt("f32: 1.1", "f32: {d:.1}", .{@as(f32, 1.1234)});
try testFmt("f32: 1234.57", "f32: {d:.2}", .{@as(f32, 1234.567)});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
// -11.12339... is rounded back up to -11.1234
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f32: -11.1234", "f32: {d:.4}", .{@as(f32, -11.1234)});
try testFmt("f32: 91.12345", "f32: {d:.5}", .{@as(f32, 91.12345)});
try testFmt("f64: 91.1234567890", "f64: {d:.10}", .{@as(f64, 91.12345678901235)});
try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 0.0)});
try testFmt("f64: 6", "f64: {d:.0}", .{@as(f64, 5.700)});
try testFmt("f64: 10.0", "f64: {d:.1}", .{@as(f64, 9.999)});
try testFmt("f64: 1.000", "f64: {d:.3}", .{@as(f64, 1.0)});
try testFmt("f64: 0.00030000", "f64: {d:.8}", .{@as(f64, 0.0003)});
try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 1.40130e-45)});
try testFmt("f64: 0.00000", "f64: {d:.5}", .{@as(f64, 9.999960e-40)});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "float.libc.sanity" {
enable test coverage for armv8-linux-musleabihf * fix libc prototypes of offsets to have correct integer sizes and signedness. This gets all behavior tests to pass for armv8-linux-musleabihf * fix linux mmap syscall to have correct integer size and signedness for offset * disable failing armv8-linux-musleabihf std lib tests. See 3289. I suspect compiler-rt issue. Note these tests fail with this target triple regardless of whether musl is actually linked (-lc).
2019-09-25 19:57:13 +00:00
if (builtin.os == .linux and builtin.arch == .arm and builtin.abi == .musleabihf) {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 916964781)))});
try testFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 925353389)))});
try testFmt("f64: 0.10000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1036831278)))});
try testFmt("f64: 1.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1065353133)))});
try testFmt("f64: 10.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1092616192)))});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
Fix release float printing errors Fixes #564. Fixes #669. Fixes #928.
2018-04-23 05:18:05 +00:00
// libc differences
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
//
// This is 0.015625 exactly according to gdb. We thus round down,
// however glibc rounds up for some reason. This occurs for all
// floats of the form x.yyyy25 on a precision point.
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 0.01563", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1015021568)))});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
// errol3 rounds to ... 630 but libc rounds to ...632. Grisu3
// also rounds to 630 so I'm inclined to believe libc is not
// optimal here.
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("f64: 18014400656965630.00000", "f64: {d:.5}", .{@as(f64, @bitCast(f32, @as(u32, 1518338049)))});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "custom" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const Vec2 = struct {
const SelfType = @This();
x: f32,
y: f32,
pub fn format(
self: SelfType,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "p")) {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else if (comptime std.mem.eql(u8, fmt, "d")) {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return std.fmt.format(context, Errors, output, "{d:.3}x{d:.3}", .{ self.x, self.y });
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else {
@compileError("Unknown format character: '" ++ fmt ++ "'");
Added custom formatter support, refactored fmt.format
2018-05-30 15:18:11 +00:00
}
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
};
Merge branch 'zig-custom-format' of https://github.com/tgschultz/zig into tgschultz-zig-custom-format I removed the code that checks for type signature and type. A function named `format` is enough for zig to give it a try.
2018-06-04 15:06:55 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
var buf1: [32]u8 = undefined;
var value = Vec2{
.x = 10.2,
.y = 2.22,
};
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("point: (10.200,2.220)\n", "point: {}\n", .{&value});
try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", .{&value});
std.fmt.format: handle non-pointer struct/union/enum Also adds support for printing structs via reflection. The case when structs have pointers to themselves is not handled yet. closes #1380
2018-08-20 20:04:03 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
// same thing but not passing a pointer
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("point: (10.200,2.220)\n", "point: {}\n", .{value});
try testFmt("dim: 10.200x2.220\n", "dim: {d}\n", .{value});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
zig fmt
2018-08-27 23:25:18 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "struct" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const S = struct {
a: u32,
b: anyerror,
};
zig fmt
2018-08-27 23:25:18 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const inst = S{
.a = 456,
.b = error.Unused,
};
zig fmt
2018-08-27 23:25:18 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("S{ .a = 456, .b = error.Unused }", "{}", .{inst});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
zig fmt
2018-08-27 23:25:18 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "union" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const TU = union(enum) {
float: f32,
int: u32,
};
zig fmt
2018-08-27 23:25:18 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const UU = union {
float: f32,
int: u32,
};
zig fmt
2018-08-27 23:25:18 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const EU = extern union {
float: f32,
int: u32,
};
zig fmt
2018-08-27 23:25:18 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const tu_inst = TU{ .int = 123 };
const uu_inst = UU{ .int = 456 };
const eu_inst = EU{ .float = 321.123 };
zig fmt
2018-08-27 23:25:18 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("TU{ .int = 123 }", "{}", .{tu_inst});
zig fmt
2018-08-27 23:25:18 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
var buf: [100]u8 = undefined;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
const uu_result = try bufPrint(buf[0..], "{}", .{uu_inst});
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, uu_result[0..3], "UU@"));
zig fmt
2018-08-27 23:25:18 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
const eu_result = try bufPrint(buf[0..], "{}", .{eu_inst});
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, uu_result[0..3], "EU@"));
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "enum" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const E = enum {
One,
Two,
Three,
};
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const inst = E.Two;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("E.Two", "{}", .{inst});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "struct.self-referential" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const S = struct {
const SelfType = @This();
a: ?*SelfType,
};
var inst = S{
.a = null,
};
inst.a = &inst;
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("S{ .a = S{ .a = S{ .a = S{ ... } } } }", "{}", .{inst});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
}
support zero-sized structs in zig.fmt.format
2019-07-29 01:37:35 +00:00
test "struct.zero-size" {
const A = struct {
fn foo() void {}
};
const B = struct {
a: A,
c: i32,
};
const a = A{};
const b = B{ .a = a, .c = 0 };
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("B{ .a = A{ }, .c = 0 }", "{}", .{b});
support zero-sized structs in zig.fmt.format
2019-07-29 01:37:35 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "bytes.hex" {
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const some_bytes = "\xCA\xFE\xBA\xBE";
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("lowercase: cafebabe\n", "lowercase: {x}\n", .{some_bytes});
try testFmt("uppercase: CAFEBABE\n", "uppercase: {X}\n", .{some_bytes});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
//Test Slices
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("uppercase: CAFE\n", "uppercase: {X}\n", .{some_bytes[0..2]});
try testFmt("lowercase: babe\n", "lowercase: {x}\n", .{some_bytes[2..]});
Small cleanup of fmt.zig Use inferred enum literals and split the large test case up.
2019-06-17 10:03:56 +00:00
const bytes_with_zeros = "\x00\x0E\xBA\xBE";
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("lowercase: 000ebabe\n", "lowercase: {x}\n", .{bytes_with_zeros});
std.fmt can print nullables, errors, and error unions
2017-05-23 22:38:41 +00:00
}
add std.fmt.trim
2017-09-26 07:03:12 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
fn testFmt(expected: []const u8, comptime template: []const u8, args: var) !void {
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
var buf: [100]u8 = undefined;
const result = try bufPrint(buf[0..], template, args);
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
if (mem.eql(u8, result, expected)) return;
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
std.debug.warn("\n====== expected this output: =========\n", .{});
std.debug.warn("{}", .{expected});
std.debug.warn("\n======== instead found this: =========\n", .{});
std.debug.warn("{}", .{result});
std.debug.warn("\n======================================\n", .{});
std.fmt: use SI prefixes for printing bytes closes #1015
2018-05-16 22:22:39 +00:00
return error.TestFailed;
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 09:10:11 +00:00
pub fn trim(buf: []const u8) []const u8 {
add std.fmt.trim
2017-09-26 07:03:12 +00:00
var start: usize = 0;
behavior tests passing with new pointer deref syntax
2018-05-01 05:53:04 +00:00
while (start < buf.len and isWhiteSpace(buf[start])) : (start += 1) {}
add std.fmt.trim
2017-09-26 07:03:12 +00:00
var end: usize = buf.len;
while (true) {
if (end > start) {
const new_end = end - 1;
if (isWhiteSpace(buf[new_end])) {
end = new_end;
continue;
}
}
break;
}
return buf[start..end];
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "trim" {
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, "abc", trim("\n abc \t")));
std.testing.expect(mem.eql(u8, "", trim(" ")));
std.testing.expect(mem.eql(u8, "", trim("")));
std.testing.expect(mem.eql(u8, "abc", trim(" abc")));
std.testing.expect(mem.eql(u8, "abc", trim("abc ")));
add std.fmt.trim
2017-09-26 07:03:12 +00:00
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 09:10:11 +00:00
pub fn isWhiteSpace(byte: u8) bool {
add std.fmt.trim
2017-09-26 07:03:12 +00:00
return switch (byte) {
run zig fmt on the codebase See #1003
2018-05-29 00:23:55 +00:00
' ', '\t', '\n', '\r' => true,
add std.fmt.trim
2017-09-26 07:03:12 +00:00
else => false,
};
}
std/fmt/index.zig: add hexToBytes function under std.fmt; Depends on #1454 being implemented;
2018-09-02 09:02:24 +00:00
fixups * zig fmt * use canonical parameter order. memcpy has dest first and the base64 code follows the pattern. * pass correct radix to charToDigit
2018-09-02 23:23:30 +00:00
pub fn hexToBytes(out: []u8, input: []const u8) !void {
if (out.len * 2 < input.len)
return error.InvalidLength;
std/fmt/index.zig: add hexToBytes function under std.fmt; Depends on #1454 being implemented;
2018-09-02 09:02:24 +00:00
fixups * zig fmt * use canonical parameter order. memcpy has dest first and the base64 code follows the pattern. * pass correct radix to charToDigit
2018-09-02 23:23:30 +00:00
var in_i: usize = 0;
while (in_i != input.len) : (in_i += 2) {
const hi = try charToDigit(input[in_i], 16);
const lo = try charToDigit(input[in_i + 1], 16);
out[in_i / 2] = (hi << 4) | lo;
}
std/fmt/index.zig: add hexToBytes function under std.fmt; Depends on #1454 being implemented;
2018-09-02 09:02:24 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "hexToBytes" {
fixups * zig fmt * use canonical parameter order. memcpy has dest first and the base64 code follows the pattern. * pass correct radix to charToDigit
2018-09-02 23:23:30 +00:00
const test_hex_str = "909A312BB12ED1F819B3521AC4C1E896F2160507FFC1C8381E3B07BB16BD1706";
var pb: [32]u8 = undefined;
try hexToBytes(pb[0..], test_hex_str);
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt(test_hex_str, "{X}", .{pb});
std/fmt/index.zig: add hexToBytes function under std.fmt; Depends on #1454 being implemented;
2018-09-02 09:02:24 +00:00
}
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "formatIntValue with comptime_int" {
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
const value: comptime_int = 123456789123456789;
var buf = try std.Buffer.init(std.debug.global_allocator, "");
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try formatIntValue(value, "", FormatOptions{}, &buf, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append);
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, buf.toSlice(), "123456789123456789"));
support comptime_int in formatInt{,Value}
2019-04-05 01:36:31 +00:00
}
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "formatType max_depth" {
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
const Vec2 = struct {
const SelfType = @This();
x: f32,
y: f32,
pub fn format(
self: SelfType,
comptime fmt: []const u8,
std/fmt: Make FormatOptions arguments non-comptime No need and should help avoid exessive function monomorphizaton.
2019-08-19 10:28:13 +00:00
options: FormatOptions,
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
context: var,
comptime Errors: type,
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
output: fn (@TypeOf(context), []const u8) Errors!void,
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
) Errors!void {
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
if (fmt.len == 0) {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
} else {
@compileError("Unknown format string: '" ++ fmt ++ "'");
}
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
}
};
const E = enum {
One,
Two,
Three,
};
const TU = union(enum) {
const SelfType = @This();
float: f32,
int: u32,
ptr: ?*SelfType,
};
const S = struct {
const SelfType = @This();
a: ?*SelfType,
tu: TU,
e: E,
vec: Vec2,
};
var inst = S{
.a = null,
.tu = TU{ .ptr = null },
.e = E.Two,
.vec = Vec2{ .x = 10.2, .y = 2.22 },
};
inst.a = &inst;
inst.tu.ptr = &inst.tu;
var buf0 = try std.Buffer.init(std.debug.global_allocator, "");
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 0);
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
var buf1 = try std.Buffer.init(std.debug.global_allocator, "");
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 1);
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
var buf2 = try std.Buffer.init(std.debug.global_allocator, "");
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 2);
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
var buf3 = try std.Buffer.init(std.debug.global_allocator, "");
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 20:56:19 +00:00
try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.Buffer.append).ReturnType.ErrorSet, std.Buffer.append, 3);
string literals are now null terminated this also deletes C string literals from the language, and then makes the std lib changes and compiler changes necessary to get the behavior tests and std lib tests passing again.
2019-11-20 01:29:08 +00:00
std.testing.expect(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
std.fmt: add max_depth to avoid infinite recursion from self-references
2019-04-27 09:36:48 +00:00
}
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
test "positional" {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
try testFmt("2 1 0", "{2} {1} {}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
try testFmt("0 0", "{0} {0}", .{@as(usize, 0)});
try testFmt("0 1", "{} {1}", .{ @as(usize, 0), @as(usize, 1) });
try testFmt("1 0 0 1", "{1} {} {0} {}", .{ @as(usize, 0), @as(usize, 1) });
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
}
test "positional with specifier" {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("10.0", "{0d:.1}", .{@as(f64, 9.999)});
breaking: Add positional, precision and width support to std.fmt This removes the odd width and precision specifiers found and replacing them with the more consistent api described in #1358. Take the following example: {1:5.9} This refers to the first argument (0-indexed) in the argument list. It will be printed with a minimum width of 5 and will have a precision of 9 (if applicable). Not all types correctly use these parameters just yet. There are still some missing gaps to fill in. Fill characters and alignment have yet to be implemented.
2019-06-20 08:07:43 +00:00
}
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
test "positional/alignment/width/precision" {
std.fmt.format: tuple parameter instead of var args
2019-12-09 03:53:51 +00:00
try testFmt("10.0", "{0d: >3.1}", .{@as(f64, 9.999)});
Add parsing of fill and alignment in std.format These options are now available to use when printing, however nothing currently makes use of these.
2019-06-25 05:11:04 +00:00
}
Reference in New Issue Copy Permalink