Skip to content

Commit 5f38d6e

Browse files
andrewrkandrewrk
committedJun 21, 2018
add casting docs, __extenddftf2, and __extendsftf2
·
0.15.20.3.0
1 parent 47dd104 commit 5f38d6e

File tree

8 files changed

+384
-18
lines changed

8 files changed

+384
-18
lines changed
 

‎CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -558,6 +558,7 @@ set(ZIG_STD_FILES
558558
"special/compiler_rt/aullrem.zig"
559559
"special/compiler_rt/comparetf2.zig"
560560
"special/compiler_rt/divti3.zig"
561+
"special/compiler_rt/extendXfYf2.zig"
561562
"special/compiler_rt/fixuint.zig"
562563
"special/compiler_rt/fixunsdfdi.zig"
563564
"special/compiler_rt/fixunsdfsi.zig"

‎doc/langref.html.in‎

Lines changed: 156 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -3573,14 +3573,161 @@ const optional_value: ?i32 = null;
35733573
{#header_close#}
35743574
{#header_close#}
35753575
{#header_open|Casting#}
3576-
<p>TODO: explain implicit vs explicit casting</p>
3577-
<p>TODO: resolve peer types builtin</p>
3578-
<p>TODO: truncate builtin</p>
3579-
<p>TODO: bitcast builtin</p>
3580-
<p>TODO: int to ptr builtin</p>
3581-
<p>TODO: ptr to int builtin</p>
3582-
<p>TODO: ptrcast builtin</p>
3583-
<p>TODO: explain number literals vs concrete types</p>
3576+
<p>
3577+
A <strong>type cast</strong> converts a value of one type to another.
3578+
Zig has {#link|Implicit Casts#} for conversions that are known to be completely safe and unambiguous,
3579+
and {#link|Explicit Casts#} for conversions that one would not want to happen on accident.
3580+
There is also a third kind of type conversion called {#link|Peer Type Resolution#} for
3581+
the case when a result type must be decided given multiple operand types.
3582+
</p>
3583+
{#header_open|Implicit Casts#}
3584+
<p>
3585+
An implicit cast occurs when one type is expected, but different type is provided:
3586+
</p>
3587+
{#code_begin|test#}
3588+
test "implicit cast - variable declaration" {
3589+
var a: u8 = 1;
3590+
var b: u16 = a;
3591+
}
3592+
3593+
test "implicit cast - function call" {
3594+
var a: u8 = 1;
3595+
foo(a);
3596+
}
3597+
3598+
fn foo(b: u16) void {}
3599+
3600+
test "implicit cast - invoke a type as a function" {
3601+
var a: u8 = 1;
3602+
var b = u16(a);
3603+
}
3604+
{#code_end#}
3605+
{#header_open|Implicit Cast: Stricter Qualification#}
3606+
<p>
3607+
Values which have the same representation at runtime can be cast to increase the strictness
3608+
of the qualifiers, no matter how nested the qualifiers are:
3609+
</p>
3610+
<ul>
3611+
<li><code>const</code> - non-const to const is allowed</li>
3612+
<li><code>volatile</code> - non-volatile to volatile is allowed</li>
3613+
<li><code>align</code> - bigger to smaller alignment is allowed </li>
3614+
<li>{#link|error sets|Error Set Type#} to supersets is allowed</li>
3615+
</ul>
3616+
<p>
3617+
These casts are no-ops at runtime since the value representation does not change.
3618+
</p>
3619+
{#code_begin|test#}
3620+
test "implicit cast - const qualification" {
3621+
var a: i32 = 1;
3622+
var b: *i32 = &a;
3623+
foo(b);
3624+
}
3625+
3626+
fn foo(a: *const i32) void {}
3627+
{#code_end#}
3628+
<p>
3629+
In addition, pointers implicitly cast to const optional pointers:
3630+
</p>
3631+
{#code_begin|test#}
3632+
const std = @import("std");
3633+
const assert = std.debug.assert;
3634+
const mem = std.mem;
3635+
3636+
test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
3637+
const window_name = [1][*]const u8{c"window name"};
3638+
const x: [*]const ?[*]const u8 = &window_name;
3639+
assert(mem.eql(u8, std.cstr.toSliceConst(x[0].?), "window name"));
3640+
}
3641+
{#code_end#}
3642+
{#header_close#}
3643+
{#header_open|Implicit Cast: Integer and Float Widening#}
3644+
<p>
3645+
{#link|Integers#} implicitly cast to integer types which can represent every value of the old type, and likewise
3646+
{#link|Floats#} implicitly cast to float types which can represent every value of the old type.
3647+
</p>
3648+
{#code_begin|test#}
3649+
const std = @import("std");
3650+
const assert = std.debug.assert;
3651+
const mem = std.mem;
3652+
3653+
test "integer widening" {
3654+
var a: u8 = 250;
3655+
var b: u16 = a;
3656+
var c: u32 = b;
3657+
var d: u64 = c;
3658+
var e: u64 = d;
3659+
var f: u128 = e;
3660+
assert(f == a);
3661+
}
3662+
3663+
test "implicit unsigned integer to signed integer" {
3664+
var a: u8 = 250;
3665+
var b: i16 = a;
3666+
assert(b == 250);
3667+
}
3668+
3669+
test "float widening" {
3670+
var a: f32 = 12.34;
3671+
var b: f64 = a;
3672+
var c: f128 = b;
3673+
assert(c == a);
3674+
}
3675+
{#code_end#}
3676+
{#header_close#}
3677+
{#header_open|Implicit Cast: Arrays#}
3678+
<p>TODO: [N]T to []const T</p>
3679+
<p>TODO: *const [N]T to []const T</p>
3680+
<p>TODO: [N]T to *const []const T</p>
3681+
<p>TODO: [N]T to ?[]const T</p>
3682+
<p>TODO: *[N]T to []T</p>
3683+
<p>TODO: *[N]T to [*]T</p>
3684+
<p>TODO: *T to *[1]T</p>
3685+
<p>TODO: [N]T to E![]const T</p>
3686+
{#header_close#}
3687+
{#header_open|Implicit Cast: Optionals#}
3688+
<p>TODO: T to ?T</p>
3689+
<p>TODO: T to E!?T</p>
3690+
<p>TODO: null to ?T</p>
3691+
{#header_close#}
3692+
{#header_open|Implicit Cast: T to E!T#}
3693+
<p>TODO</p>
3694+
{#header_close#}
3695+
{#header_open|Implicit Cast: E to E!T#}
3696+
<p>TODO</p>
3697+
{#header_close#}
3698+
{#header_open|Implicit Cast: comptime_int to *const integer#}
3699+
<p>TODO</p>
3700+
{#header_close#}
3701+
{#header_open|Implicit Cast: comptime_float to *const float#}
3702+
<p>TODO</p>
3703+
{#header_close#}
3704+
{#header_open|Implicit Cast: compile-time known numbers#}
3705+
<p>TODO</p>
3706+
{#header_close#}
3707+
{#header_open|Implicit Cast: union to enum#}
3708+
<p>TODO</p>
3709+
{#header_close#}
3710+
{#header_open|Implicit Cast: enum to union#}
3711+
<p>TODO</p>
3712+
{#header_close#}
3713+
{#header_open|Implicit Cast: T to *T when @sizeOf(T) == 0#}
3714+
<p>TODO</p>
3715+
{#header_close#}
3716+
{#header_open|Implicit Cast: undefined#}
3717+
<p>TODO</p>
3718+
{#header_close#}
3719+
{#header_open|Implicit Cast: T to *const T#}
3720+
<p>TODO</p>
3721+
{#header_close#}
3722+
{#header_close#}
3723+
3724+
{#header_open|Explicit Casts#}
3725+
<p>TODO</p>
3726+
{#header_close#}
3727+
3728+
{#header_open|Peer Type Resolution#}
3729+
<p>TODO</p>
3730+
{#header_close#}
35843731
{#header_close#}
35853732

35863733
{#header_open|void#}
@@ -5522,12 +5669,6 @@ pub const FloatMode = enum {
55225669
</p>
55235670
{#see_also|Compile Variables#}
55245671
{#header_close#}
5525-
{#header_open|@setGlobalSection#}
5526-
<pre><code class="zig">@setGlobalSection(global_variable_name, comptime section_name: []const u8) bool</code></pre>
5527-
<p>
5528-
Puts the global variable in the specified section.
5529-
</p>
5530-
{#header_close#}
55315672
{#header_open|@shlExact#}
55325673
<pre><code class="zig">@shlExact(value: T, shift_amt: Log2T) T</code></pre>
55335674
<p>
@@ -6928,7 +7069,7 @@ hljs.registerLanguage("zig", function(t) {
69287069
a = t.IR + "\\s*\\(",
69297070
c = {
69307071
keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong resume cancel await async orelse",
6931-
built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic ptrCast intCast floatCast intToFloat floatToInt boolToInt bytesToSlice sliceToBytes errSetCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo typeName newStackCall errorToInt intToError enumToInt intToEnum",
7072+
built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage divTrunc divFloor enumTagName intToPtr ptrToInt panic ptrCast intCast floatCast intToFloat floatToInt boolToInt bytesToSlice sliceToBytes errSetCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo typeName newStackCall errorToInt intToError enumToInt intToEnum",
69327073
literal: "true false null undefined"
69337074
},
69347075
n = [e, t.CLCM, t.CBCM, s, r];

‎src/ir.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -10092,7 +10092,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1009210092
}
1009310093
}
1009410094

10095-
// cast from &const [N]T to []const T
10095+
// cast from *const [N]T to []const T
1009610096
if (is_slice(wanted_type) &&
1009710097
actual_type->id == TypeTableEntryIdPointer &&
1009810098
actual_type->data.pointer.is_const &&
@@ -10111,7 +10111,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1011110111
}
1011210112
}
1011310113

10114-
// cast from [N]T to &const []const T
10114+
// cast from [N]T to *const []const T
1011510115
if (wanted_type->id == TypeTableEntryIdPointer &&
1011610116
wanted_type->data.pointer.is_const &&
1011710117
is_slice(wanted_type->data.pointer.child_type) &&
@@ -10136,7 +10136,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1013610136
}
1013710137
}
1013810138

10139-
// cast from [N]T to ?[]const N
10139+
// cast from [N]T to ?[]const T
1014010140
if (wanted_type->id == TypeTableEntryIdOptional &&
1014110141
is_slice(wanted_type->data.maybe.child_type) &&
1014210142
actual_type->id == TypeTableEntryIdArray)

‎std/special/compiler_rt/extendXfYf2.zig‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
const std = @import("std");
2+
const builtin = @import("builtin");
3+
const is_test = builtin.is_test;
4+
5+
pub extern fn __extenddftf2(a: f64) f128 {
6+
return extendXfYf2(f128, f64, a);
7+
}
8+
9+
pub extern fn __extendsftf2(a: f32) f128 {
10+
return extendXfYf2(f128, f32, a);
11+
}
12+
13+
const CHAR_BIT = 8;
14+
15+
pub fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
16+
const src_rep_t = @IntType(false, @typeInfo(src_t).Float.bits);
17+
const dst_rep_t = @IntType(false, @typeInfo(dst_t).Float.bits);
18+
const srcSigBits = std.math.floatMantissaBits(src_t);
19+
const dstSigBits = std.math.floatMantissaBits(dst_t);
20+
const SrcShift = std.math.Log2Int(src_rep_t);
21+
const DstShift = std.math.Log2Int(dst_rep_t);
22+
23+
// Various constants whose values follow from the type parameters.
24+
// Any reasonable optimizer will fold and propagate all of these.
25+
const srcBits: i32 = @sizeOf(src_t) * CHAR_BIT;
26+
const srcExpBits: i32 = srcBits - srcSigBits - 1;
27+
const srcInfExp: i32 = (1 << srcExpBits) - 1;
28+
const srcExpBias: i32 = srcInfExp >> 1;
29+
30+
const srcMinNormal: src_rep_t = src_rep_t(1) << srcSigBits;
31+
const srcInfinity: src_rep_t = src_rep_t(@bitCast(u32, srcInfExp)) << srcSigBits;
32+
const srcSignMask: src_rep_t = src_rep_t(1) << @intCast(SrcShift, srcSigBits +% srcExpBits);
33+
const srcAbsMask: src_rep_t = srcSignMask -% 1;
34+
const srcQNaN: src_rep_t = src_rep_t(1) << @intCast(SrcShift, srcSigBits -% 1);
35+
const srcNaNCode: src_rep_t = srcQNaN -% 1;
36+
37+
const dstBits: i32 = @sizeOf(dst_t) * CHAR_BIT;
38+
const dstExpBits: i32 = dstBits - dstSigBits - 1;
39+
const dstInfExp: i32 = (1 << dstExpBits) - 1;
40+
const dstExpBias: i32 = dstInfExp >> 1;
41+
42+
const dstMinNormal: dst_rep_t = dst_rep_t(1) << dstSigBits;
43+
44+
// Break a into a sign and representation of the absolute value
45+
const aRep: src_rep_t = @bitCast(src_rep_t, a);
46+
const aAbs: src_rep_t = aRep & srcAbsMask;
47+
const sign: src_rep_t = aRep & srcSignMask;
48+
var absResult: dst_rep_t = undefined;
49+
50+
// If @sizeOf(src_rep_t) < @sizeOf(int), the subtraction result is promoted
51+
// to (signed) int. To avoid that, explicitly cast to src_rep_t.
52+
if ((src_rep_t)(aAbs -% srcMinNormal) < srcInfinity -% srcMinNormal) {
53+
// a is a normal number.
54+
// Extend to the destination type by shifting the significand and
55+
// exponent into the proper position and rebiasing the exponent.
56+
absResult = dst_rep_t(aAbs) << (dstSigBits -% srcSigBits);
57+
absResult += dst_rep_t(@bitCast(u32, dstExpBias -% srcExpBias)) << dstSigBits;
58+
} else if (aAbs >= srcInfinity) {
59+
// a is NaN or infinity.
60+
// Conjure the result by beginning with infinity, then setting the qNaN
61+
// bit (if needed) and right-aligning the rest of the trailing NaN
62+
// payload field.
63+
absResult = dst_rep_t(@bitCast(u32, dstInfExp)) << dstSigBits;
64+
absResult |= (dst_rep_t)(aAbs & srcQNaN) << (dstSigBits - srcSigBits);
65+
absResult |= (dst_rep_t)(aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
66+
} else if (aAbs != 0) {
67+
// a is denormal.
68+
// renormalize the significand and clear the leading bit, then insert
69+
// the correct adjusted exponent in the destination type.
70+
const scale: i32 = @clz(aAbs) - @clz(srcMinNormal);
71+
absResult = dst_rep_t(aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
72+
absResult ^= dstMinNormal;
73+
const resultExponent: i32 = dstExpBias - srcExpBias - scale + 1;
74+
absResult |= dst_rep_t(@bitCast(u32, resultExponent)) << @intCast(DstShift, dstSigBits);
75+
} else {
76+
// a is zero.
77+
absResult = 0;
78+
}
79+
80+
// Apply the signbit to (dst_t)abs(a).
81+
const result: dst_rep_t align(@alignOf(dst_t)) = absResult | dst_rep_t(sign) << @intCast(DstShift, dstBits - srcBits);
82+
return @bitCast(dst_t, result);
83+
}
84+
85+
test "import extendXfYf2" {
86+
_ = @import("extendXfYf2_test.zig");
87+
}

‎std/special/compiler_rt/extendXfYf2_test.zig‎

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2;
2+
const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2;
3+
const assert = @import("std").debug.assert;
4+
5+
fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {
6+
const x = __extenddftf2(a);
7+
8+
const rep = @bitCast(u128, x);
9+
const hi = @intCast(u64, rep >> 64);
10+
const lo = @truncate(u64, rep);
11+
12+
if (hi == expectedHi and lo == expectedLo)
13+
return;
14+
15+
// test other possible NaN representation(signal NaN)
16+
if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
17+
if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
18+
((hi & 0xffffffffffff) > 0 or lo > 0))
19+
{
20+
return;
21+
}
22+
}
23+
24+
@panic("__extenddftf2 test failure");
25+
}
26+
27+
fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {
28+
const x = __extendsftf2(a);
29+
30+
const rep = @bitCast(u128, x);
31+
const hi = @intCast(u64, rep >> 64);
32+
const lo = @truncate(u64, rep);
33+
34+
if (hi == expectedHi and lo == expectedLo)
35+
return;
36+
37+
// test other possible NaN representation(signal NaN)
38+
if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
39+
if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
40+
((hi & 0xffffffffffff) > 0 or lo > 0))
41+
{
42+
return;
43+
}
44+
}
45+
46+
@panic("__extendsftf2 test failure");
47+
}
48+
49+
test "extenddftf2" {
50+
// qNaN
51+
test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
52+
53+
// NaN
54+
test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
55+
56+
// inf
57+
test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
58+
59+
// zero
60+
test__extenddftf2(0.0, 0x0, 0x0);
61+
62+
test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
63+
64+
test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
65+
66+
test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
67+
68+
test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
69+
}
70+
71+
test "extendsftf2" {
72+
// qNaN
73+
test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
74+
// NaN
75+
test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
76+
// inf
77+
test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
78+
// zero
79+
test__extendsftf2(0.0, 0x0, 0x0);
80+
test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
81+
test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
82+
test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
83+
test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
84+
}
85+
86+
fn makeQNaN64() f64 {
87+
return @bitCast(f64, u64(0x7ff8000000000000));
88+
}
89+
90+
fn makeInf64() f64 {
91+
return @bitCast(f64, u64(0x7ff0000000000000));
92+
}
93+
94+
fn makeNaN64(rand: u64) f64 {
95+
return @bitCast(f64, 0x7ff0000000000000 | (rand & 0xfffffffffffff));
96+
}
97+
98+
fn makeQNaN32() f32 {
99+
return @bitCast(f32, u32(0x7fc00000));
100+
}
101+
102+
fn makeNaN32(rand: u32) f32 {
103+
return @bitCast(f32, 0x7f800000 | (rand & 0x7fffff));
104+
}
105+
106+
fn makeInf32() f32 {
107+
return @bitCast(f32, u32(0x7f800000));
108+
}

‎std/special/compiler_rt/index.zig‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,8 @@ comptime {
2020
@export("__unordtf2", @import("comparetf2.zig").__unordtf2, linkage);
2121

2222
@export("__floatuntidf", @import("floatuntidf.zig").__floatuntidf, linkage);
23+
@export("__extenddftf2", @import("extendXfYf2.zig").__extenddftf2, linkage);
24+
@export("__extendsftf2", @import("extendXfYf2.zig").__extendsftf2, linkage);
2325

2426
@export("__fixunssfsi", @import("fixunssfsi.zig").__fixunssfsi, linkage);
2527
@export("__fixunssfdi", @import("fixunssfdi.zig").__fixunssfdi, linkage);

‎test/behavior.zig‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,4 +59,5 @@ comptime {
5959
_ = @import("cases/var_args.zig");
6060
_ = @import("cases/void.zig");
6161
_ = @import("cases/while.zig");
62+
_ = @import("cases/widening.zig");
6263
}

‎test/cases/widening.zig‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
const std = @import("std");
2+
const assert = std.debug.assert;
3+
const mem = std.mem;
4+
5+
test "integer widening" {
6+
var a: u8 = 250;
7+
var b: u16 = a;
8+
var c: u32 = b;
9+
var d: u64 = c;
10+
var e: u64 = d;
11+
var f: u128 = e;
12+
assert(f == a);
13+
}
14+
15+
test "implicit unsigned integer to signed integer" {
16+
var a: u8 = 250;
17+
var b: i16 = a;
18+
assert(b == 250);
19+
}
20+
21+
test "float widening" {
22+
var a: f32 = 12.34;
23+
var b: f64 = a;
24+
var c: f128 = b;
25+
assert(c == a);
26+
}

0 commit comments

Comments
 (0)
Please sign in to comment.