Add dependencies/vendor (whatsapp)

1 files changed, 1337 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/operand.go b/vendor/modernc.org/cc/v3/operand.go
new file mode 100644
index 00000000..24c46616
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/operand.go
@@ -0,0 +1,1337 @@
+// Copyright 2019 The CC Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cc // import "modernc.org/cc/v3"
+
+import (
+	"fmt"
+	"math"
+	"math/big"
+)
+
+var (
+	_ Value = (*Float128Value)(nil)
+	_ Value = (*InitializerValue)(nil)
+	_ Value = Complex128Value(0)
+	_ Value = Complex256Value{}
+	_ Value = Complex64Value(0)
+	_ Value = Float32Value(0)
+	_ Value = Float64Value(0)
+	_ Value = Int64Value(0)
+	_ Value = StringValue(0)
+	_ Value = Uint64Value(0)
+	_ Value = WideStringValue(0)
+
+	_ Operand = (*funcDesignator)(nil)
+	_ Operand = (*lvalue)(nil)
+	_ Operand = (*operand)(nil)
+	_ Operand = noOperand
+
+	noOperand = &operand{typ: noType}
+)
+
+type Operand interface {
+	// IsAssingmentCompatible reports whether the operand can be
+	// assigned to lhs. [0], 6.5.16.1.
+	IsAssingmentCompatible(lhs Type) bool
+	ConvertTo(Type) Operand
+	Declarator() *Declarator
+	IsConst() bool
+	IsLValue() bool
+	IsNonZero() bool
+	IsZero() bool
+	Offset() uintptr // Valid only for non nil Declarator() value
+	Type() Type
+	Value() Value
+	convertFromInt(*context, Node, Type) Operand
+	convertTo(*context, Node, Type) Operand
+	convertToInt(*context, Node, Type) Operand
+	getABI() *ABI
+	integerPromotion(*context, Node) Operand
+	normalize(*context, Node) Operand
+}
+
+type Value interface {
+	IsConst() bool
+	IsNonZero() bool
+	IsZero() bool
+	add(b Value) Value
+	and(b Value) Value
+	cpl() Value
+	div(b Value) Value
+	eq(b Value) Value
+	ge(b Value) Value
+	gt(b Value) Value
+	le(b Value) Value
+	lsh(b Value) Value
+	lt(b Value) Value
+	mod(b Value) Value
+	mul(b Value) Value
+	neg() Value
+	neq(b Value) Value
+	or(b Value) Value
+	rsh(b Value) Value
+	sub(b Value) Value
+	xor(b Value) Value
+}
+
+type WideStringValue StringID
+
+func (v WideStringValue) add(b Value) Value { panic(todo("")) }
+func (v WideStringValue) and(b Value) Value { panic(todo("")) }
+func (v WideStringValue) cpl() Value        { panic(todo("")) }
+func (v WideStringValue) div(b Value) Value { panic(todo("")) }
+func (v WideStringValue) eq(b Value) Value  { return boolValue(v == b.(WideStringValue)) }
+func (v WideStringValue) IsConst() bool     { return true }
+func (v WideStringValue) IsNonZero() bool   { return true }
+func (v WideStringValue) IsZero() bool      { return false }
+func (v WideStringValue) lsh(b Value) Value { panic(todo("")) }
+func (v WideStringValue) mod(b Value) Value { panic(todo("")) }
+func (v WideStringValue) mul(b Value) Value { panic(todo("")) }
+func (v WideStringValue) neg() Value        { panic(todo("")) }
+func (v WideStringValue) neq(b Value) Value { return boolValue(v != b.(WideStringValue)) }
+func (v WideStringValue) or(b Value) Value  { panic(todo("")) }
+func (v WideStringValue) rsh(b Value) Value { panic(todo("")) }
+func (v WideStringValue) sub(b Value) Value { panic(todo("")) }
+func (v WideStringValue) xor(b Value) Value { panic(todo("")) }
+
+func (v WideStringValue) le(b Value) Value {
+	return boolValue(StringID(v).String() <= StringID(b.(WideStringValue)).String())
+}
+
+func (v WideStringValue) ge(b Value) Value {
+	return boolValue(StringID(v).String() >= StringID(b.(WideStringValue)).String())
+}
+
+func (v WideStringValue) gt(b Value) Value {
+	return boolValue(StringID(v).String() > StringID(b.(WideStringValue)).String())
+}
+
+func (v WideStringValue) lt(b Value) Value {
+	return boolValue(StringID(v).String() < StringID(b.(WideStringValue)).String())
+}
+
+type StringValue StringID
+
+func (v StringValue) add(b Value) Value { panic(todo("")) }
+func (v StringValue) and(b Value) Value { panic(todo("")) }
+func (v StringValue) cpl() Value        { panic(todo("")) }
+func (v StringValue) div(b Value) Value { panic(todo("")) }
+func (v StringValue) eq(b Value) Value  { return boolValue(v == b.(StringValue)) }
+func (v StringValue) IsConst() bool     { return true }
+func (v StringValue) IsNonZero() bool   { return true }
+func (v StringValue) IsZero() bool      { return false }
+func (v StringValue) lsh(b Value) Value { panic(todo("")) }
+func (v StringValue) mod(b Value) Value { panic(todo("")) }
+func (v StringValue) mul(b Value) Value { panic(todo("")) }
+func (v StringValue) neg() Value        { panic(todo("")) }
+func (v StringValue) neq(b Value) Value { return boolValue(v != b.(StringValue)) }
+func (v StringValue) or(b Value) Value  { panic(todo("")) }
+func (v StringValue) rsh(b Value) Value { panic(todo("")) }
+func (v StringValue) sub(b Value) Value { panic(todo("")) }
+func (v StringValue) xor(b Value) Value { panic(todo("")) }
+
+func (v StringValue) le(b Value) Value {
+	return boolValue(StringID(v).String() <= StringID(b.(StringValue)).String())
+}
+
+func (v StringValue) ge(b Value) Value {
+	return boolValue(StringID(v).String() >= StringID(b.(StringValue)).String())
+}
+
+func (v StringValue) gt(b Value) Value {
+	return boolValue(StringID(v).String() > StringID(b.(StringValue)).String())
+}
+
+func (v StringValue) lt(b Value) Value {
+	return boolValue(StringID(v).String() < StringID(b.(StringValue)).String())
+}
+
+type Int64Value int64
+
+func (v Int64Value) add(b Value) Value { return v + b.(Int64Value) }
+func (v Int64Value) and(b Value) Value { return v & b.(Int64Value) }
+func (v Int64Value) cpl() Value        { return ^v }
+func (v Int64Value) eq(b Value) Value  { return boolValue(v == b.(Int64Value)) }
+func (v Int64Value) ge(b Value) Value  { return boolValue(v >= b.(Int64Value)) }
+func (v Int64Value) gt(b Value) Value  { return boolValue(v > b.(Int64Value)) }
+func (v Int64Value) IsConst() bool     { return true }
+func (v Int64Value) IsNonZero() bool   { return v != 0 }
+func (v Int64Value) IsZero() bool      { return v == 0 }
+func (v Int64Value) le(b Value) Value  { return boolValue(v <= b.(Int64Value)) }
+func (v Int64Value) lt(b Value) Value  { return boolValue(v < b.(Int64Value)) }
+func (v Int64Value) mul(b Value) Value { return v * b.(Int64Value) }
+func (v Int64Value) neg() Value        { return -v }
+func (v Int64Value) neq(b Value) Value { return boolValue(v != b.(Int64Value)) }
+func (v Int64Value) or(b Value) Value  { return v | b.(Int64Value) }
+func (v Int64Value) sub(b Value) Value { return v - b.(Int64Value) }
+func (v Int64Value) xor(b Value) Value { return v ^ b.(Int64Value) }
+
+func (v Int64Value) div(b Value) Value {
+	if b.IsZero() {
+		return nil
+	}
+
+	return v / b.(Int64Value)
+}
+
+func (v Int64Value) lsh(b Value) Value {
+	switch y := b.(type) {
+	case Int64Value:
+		return v << uint64(y)
+	case Uint64Value:
+		return v << y
+	default:
+		panic(todo(""))
+	}
+}
+
+func (v Int64Value) rsh(b Value) Value {
+	switch y := b.(type) {
+	case Int64Value:
+		return v >> uint64(y)
+	case Uint64Value:
+		return v >> y
+	default:
+		panic(todo(""))
+	}
+}
+
+func (v Int64Value) mod(b Value) Value {
+	if b.IsZero() {
+		return nil
+	}
+
+	return v % b.(Int64Value)
+}
+
+type Uint64Value uint64
+
+func (v Uint64Value) add(b Value) Value { return v + b.(Uint64Value) }
+func (v Uint64Value) and(b Value) Value { return v & b.(Uint64Value) }
+func (v Uint64Value) cpl() Value        { return ^v }
+func (v Uint64Value) eq(b Value) Value  { return boolValue(v == b.(Uint64Value)) }
+func (v Uint64Value) ge(b Value) Value  { return boolValue(v >= b.(Uint64Value)) }
+func (v Uint64Value) gt(b Value) Value  { return boolValue(v > b.(Uint64Value)) }
+func (v Uint64Value) IsConst() bool     { return true }
+func (v Uint64Value) IsNonZero() bool   { return v != 0 }
+func (v Uint64Value) IsZero() bool      { return v == 0 }
+func (v Uint64Value) le(b Value) Value  { return boolValue(v <= b.(Uint64Value)) }
+func (v Uint64Value) lt(b Value) Value  { return boolValue(v < b.(Uint64Value)) }
+func (v Uint64Value) mul(b Value) Value { return v * b.(Uint64Value) }
+func (v Uint64Value) neg() Value        { return -v }
+func (v Uint64Value) neq(b Value) Value { return boolValue(v != b.(Uint64Value)) }
+func (v Uint64Value) or(b Value) Value  { return v | b.(Uint64Value) }
+func (v Uint64Value) sub(b Value) Value { return v - b.(Uint64Value) }
+func (v Uint64Value) xor(b Value) Value { return v ^ b.(Uint64Value) }
+
+func (v Uint64Value) div(b Value) Value {
+	if b.IsZero() {
+		return nil
+	}
+
+	return v / b.(Uint64Value)
+}
+
+func (v Uint64Value) lsh(b Value) Value {
+	switch y := b.(type) {
+	case Int64Value:
+		return v << uint64(y)
+	case Uint64Value:
+		return v << y
+	default:
+		panic(todo(""))
+	}
+}
+
+func (v Uint64Value) rsh(b Value) Value {
+	switch y := b.(type) {
+	case Int64Value:
+		return v >> uint64(y)
+	case Uint64Value:
+		return v >> y
+	default:
+		panic(todo(""))
+	}
+}
+
+func (v Uint64Value) mod(b Value) Value {
+	if b.IsZero() {
+		return nil
+	}
+
+	return v % b.(Uint64Value)
+}
+
+type Float32Value float32
+
+func (v Float32Value) add(b Value) Value { return v + b.(Float32Value) }
+func (v Float32Value) and(b Value) Value { panic(todo("")) }
+func (v Float32Value) cpl() Value        { panic(todo("")) }
+func (v Float32Value) div(b Value) Value { return v / b.(Float32Value) }
+func (v Float32Value) eq(b Value) Value  { return boolValue(v == b.(Float32Value)) }
+func (v Float32Value) ge(b Value) Value  { return boolValue(v >= b.(Float32Value)) }
+func (v Float32Value) gt(b Value) Value  { return boolValue(v > b.(Float32Value)) }
+func (v Float32Value) IsConst() bool     { return true }
+func (v Float32Value) IsNonZero() bool   { return v != 0 }
+func (v Float32Value) IsZero() bool      { return !math.Signbit(float64(v)) && v == 0 }
+func (v Float32Value) le(b Value) Value  { return boolValue(v <= b.(Float32Value)) }
+func (v Float32Value) lsh(b Value) Value { panic(todo("")) }
+func (v Float32Value) lt(b Value) Value  { return boolValue(v < b.(Float32Value)) }
+func (v Float32Value) mod(b Value) Value { panic(todo("")) }
+func (v Float32Value) mul(b Value) Value { return v * b.(Float32Value) }
+func (v Float32Value) neg() Value        { return -v }
+func (v Float32Value) neq(b Value) Value { return boolValue(v != b.(Float32Value)) }
+func (v Float32Value) or(b Value) Value  { panic(todo("")) }
+func (v Float32Value) rsh(b Value) Value { panic(todo("")) }
+func (v Float32Value) sub(b Value) Value { return v - b.(Float32Value) }
+func (v Float32Value) xor(b Value) Value { panic(todo("")) }
+
+type Float64Value float64
+
+func (v Float64Value) add(b Value) Value { return v + b.(Float64Value) }
+func (v Float64Value) and(b Value) Value { panic(todo("")) }
+func (v Float64Value) cpl() Value        { panic(todo("")) }
+func (v Float64Value) div(b Value) Value { return v / b.(Float64Value) }
+func (v Float64Value) eq(b Value) Value  { return boolValue(v == b.(Float64Value)) }
+func (v Float64Value) ge(b Value) Value  { return boolValue(v >= b.(Float64Value)) }
+func (v Float64Value) gt(b Value) Value  { return boolValue(v > b.(Float64Value)) }
+func (v Float64Value) IsConst() bool     { return true }
+func (v Float64Value) IsNonZero() bool   { return v != 0 }
+func (v Float64Value) IsZero() bool      { return !math.Signbit(float64(v)) && v == 0 }
+func (v Float64Value) le(b Value) Value  { return boolValue(v <= b.(Float64Value)) }
+func (v Float64Value) lsh(b Value) Value { panic(todo("")) }
+func (v Float64Value) lt(b Value) Value  { return boolValue(v < b.(Float64Value)) }
+func (v Float64Value) mod(b Value) Value { panic(todo("")) }
+func (v Float64Value) mul(b Value) Value { return v * b.(Float64Value) }
+func (v Float64Value) neg() Value        { return -v }
+func (v Float64Value) neq(b Value) Value { return boolValue(v != b.(Float64Value)) }
+func (v Float64Value) or(b Value) Value  { panic(todo("")) }
+func (v Float64Value) rsh(b Value) Value { panic(todo("")) }
+func (v Float64Value) sub(b Value) Value { return v - b.(Float64Value) }
+func (v Float64Value) xor(b Value) Value { panic(todo("")) }
+
+var float128Zero = &Float128Value{N: big.NewFloat(0)}
+
+type Float128Value struct {
+	N   *big.Float
+	NaN bool
+}
+
+func (v *Float128Value) add(b Value) Value { return v.safe(b, func(x, y *big.Float) { x.Add(x, y) }) }
+func (v *Float128Value) and(b Value) Value { panic(todo("")) }
+func (v *Float128Value) cpl() Value        { panic(todo("")) }
+func (v *Float128Value) div(b Value) Value { return v.safe(b, func(x, y *big.Float) { x.Quo(x, y) }) }
+func (v *Float128Value) eq(b Value) Value  { panic(todo("")) }
+func (v *Float128Value) ge(b Value) Value  { panic(todo("")) }
+func (v *Float128Value) gt(b Value) Value  { return boolValue(v.cmp(b, -1, 0)) }
+func (v *Float128Value) IsNonZero() bool   { panic(todo("")) }
+func (v *Float128Value) IsConst() bool     { return true }
+func (v *Float128Value) IsZero() bool      { return !v.NaN && !v.N.Signbit() && v.cmp(float128Zero, 0) }
+func (v *Float128Value) le(b Value) Value  { panic(todo("")) }
+func (v *Float128Value) lsh(b Value) Value { panic(todo("")) }
+func (v *Float128Value) lt(b Value) Value  { panic(todo("")) }
+func (v *Float128Value) mod(b Value) Value { panic(todo("")) }
+func (v *Float128Value) mul(b Value) Value { return v.safe(b, func(x, y *big.Float) { x.Mul(x, y) }) }
+func (v *Float128Value) neg() Value        { return v.safe(nil, func(x, y *big.Float) { x.Neg(x) }) }
+func (v *Float128Value) neq(b Value) Value { panic(todo("")) }
+func (v *Float128Value) or(b Value) Value  { panic(todo("")) }
+func (v *Float128Value) rsh(b Value) Value { panic(todo("")) }
+func (v *Float128Value) sub(b Value) Value { return v.safe(b, func(x, y *big.Float) { x.Sub(x, y) }) }
+func (v *Float128Value) xor(b Value) Value { panic(todo("")) }
+
+func (v *Float128Value) cmp(b Value, accept ...int) bool {
+	w := b.(*Float128Value)
+	if v.NaN || w.NaN {
+		return false
+	}
+
+	x := v.N.Cmp(w.N)
+	for _, v := range accept {
+		if v == x {
+			return true
+		}
+	}
+	return false
+}
+
+func (v *Float128Value) String() string {
+	switch {
+	case v == nil:
+		return "<nil>"
+	case v.NaN:
+		return "NaN"
+	default:
+		return fmt.Sprint(v.N)
+	}
+}
+
+func (v *Float128Value) safe(b Value, f func(*big.Float, *big.Float)) (ret Value) {
+	var w *Float128Value
+	if b != nil {
+		w = b.(*Float128Value)
+	}
+	if v.NaN || w != nil && w.NaN {
+		return &Float128Value{NaN: true}
+	}
+
+	r := &Float128Value{}
+
+	defer func() {
+		switch x := recover().(type) {
+		case big.ErrNaN:
+			r.N = nil
+			r.NaN = true
+			ret = r
+		case nil:
+			// ok
+		default:
+			panic(x)
+		}
+	}()
+
+	r.N = big.NewFloat(0).SetPrec(0).Set(v.N)
+	var wn *big.Float
+	if w != nil {
+		wn = w.N
+	}
+	f(r.N, wn)
+	return r
+}
+
+type Complex64Value complex64
+
+func (v Complex64Value) add(b Value) Value { return v + b.(Complex64Value) }
+func (v Complex64Value) and(b Value) Value { panic(todo("")) }
+func (v Complex64Value) cpl() Value        { panic(todo("")) }
+func (v Complex64Value) div(b Value) Value { return v / b.(Complex64Value) }
+func (v Complex64Value) eq(b Value) Value  { return boolValue(v == b.(Complex64Value)) }
+func (v Complex64Value) ge(b Value) Value  { panic(todo("")) }
+func (v Complex64Value) gt(b Value) Value  { panic(todo("")) }
+func (v Complex64Value) IsConst() bool     { return true }
+func (v Complex64Value) IsNonZero() bool   { return v != 0 }
+func (v Complex64Value) IsZero() bool      { return v == 0 }
+func (v Complex64Value) le(b Value) Value  { panic(todo("")) }
+func (v Complex64Value) lsh(b Value) Value { panic(todo("")) }
+func (v Complex64Value) lt(b Value) Value  { panic(todo("")) }
+func (v Complex64Value) mod(b Value) Value { panic(todo("")) }
+func (v Complex64Value) mul(b Value) Value { return v * b.(Complex64Value) }
+func (v Complex64Value) neg() Value        { return -v }
+func (v Complex64Value) neq(b Value) Value { return boolValue(v != b.(Complex64Value)) }
+func (v Complex64Value) or(b Value) Value  { panic(todo("")) }
+func (v Complex64Value) rsh(b Value) Value { panic(todo("")) }
+func (v Complex64Value) sub(b Value) Value { return v - b.(Complex64Value) }
+func (v Complex64Value) xor(b Value) Value { panic(todo("")) }
+
+type Complex128Value complex128
+
+func (v Complex128Value) add(b Value) Value { return v + b.(Complex128Value) }
+func (v Complex128Value) and(b Value) Value { panic(todo("")) }
+func (v Complex128Value) cpl() Value        { panic(todo("")) }
+func (v Complex128Value) div(b Value) Value { return v / b.(Complex128Value) }
+func (v Complex128Value) eq(b Value) Value  { return boolValue(v == b.(Complex128Value)) }
+func (v Complex128Value) ge(b Value) Value  { panic(todo("")) }
+func (v Complex128Value) gt(b Value) Value  { panic(todo("")) }
+func (v Complex128Value) IsConst() bool     { return true }
+func (v Complex128Value) IsNonZero() bool   { return v != 0 }
+func (v Complex128Value) IsZero() bool      { return v == 0 }
+func (v Complex128Value) le(b Value) Value  { panic(todo("")) }
+func (v Complex128Value) lsh(b Value) Value { panic(todo("")) }
+func (v Complex128Value) lt(b Value) Value  { panic(todo("")) }
+func (v Complex128Value) mod(b Value) Value { panic(todo("")) }
+func (v Complex128Value) mul(b Value) Value { return v * b.(Complex128Value) }
+func (v Complex128Value) neg() Value        { return -v }
+func (v Complex128Value) neq(b Value) Value { return boolValue(v != b.(Complex128Value)) }
+func (v Complex128Value) or(b Value) Value  { panic(todo("")) }
+func (v Complex128Value) rsh(b Value) Value { panic(todo("")) }
+func (v Complex128Value) sub(b Value) Value { return v - b.(Complex128Value) }
+func (v Complex128Value) xor(b Value) Value { panic(todo("")) }
+
+type Complex256Value struct {
+	Re, Im *Float128Value
+}
+
+func (v Complex256Value) add(b Value) Value {
+	w := b.(Complex256Value)
+	return Complex256Value{v.Re.add(w.Re).(*Float128Value), v.Im.add(w.Im).(*Float128Value)}
+}
+
+func (v Complex256Value) and(b Value) Value { panic(todo("")) }
+func (v Complex256Value) cpl() Value        { panic(todo("")) }
+func (v Complex256Value) div(b Value) Value { panic(todo("")) }
+func (v Complex256Value) eq(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) ge(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) gt(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) IsConst() bool     { return true }
+func (v Complex256Value) IsNonZero() bool   { panic(todo("")) }
+func (v Complex256Value) IsZero() bool      { return v.Re.IsZero() && v.Im.IsZero() }
+func (v Complex256Value) le(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) lsh(b Value) Value { panic(todo("")) }
+func (v Complex256Value) lt(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) mod(b Value) Value { panic(todo("")) }
+func (v Complex256Value) mul(b Value) Value { panic(todo("")) }
+func (v Complex256Value) neg() Value        { panic(todo("")) }
+func (v Complex256Value) neq(b Value) Value { panic(todo("")) }
+func (v Complex256Value) or(b Value) Value  { panic(todo("")) }
+func (v Complex256Value) rsh(b Value) Value { panic(todo("")) }
+func (v Complex256Value) sub(b Value) Value { panic(todo("")) }
+func (v Complex256Value) xor(b Value) Value { panic(todo("")) }
+
+type lvalue struct {
+	Operand
+	declarator *Declarator
+}
+
+func (o *lvalue) ConvertTo(to Type) (r Operand) { return o.convertTo(nil, nil, to) }
+func (o *lvalue) Declarator() *Declarator       { return o.declarator }
+func (o *lvalue) IsLValue() bool                { return true }
+
+func (o *lvalue) IsConst() bool {
+	if v := o.Value(); v != nil {
+		return v.IsConst()
+	}
+
+	d := o.Declarator()
+	return d != nil && (d.Linkage != None || d.IsStatic())
+}
+
+func (o *lvalue) convertTo(ctx *context, n Node, to Type) (r Operand) {
+	return &lvalue{Operand: o.Operand.convertTo(ctx, n, to), declarator: o.declarator}
+}
+
+type funcDesignator struct {
+	Operand
+	declarator *Declarator
+}
+
+func (o *funcDesignator) ConvertTo(to Type) (r Operand) { return o.convertTo(nil, nil, to) }
+func (o *funcDesignator) Declarator() *Declarator       { return o.declarator }
+func (o *funcDesignator) IsLValue() bool                { return false }
+func (o *funcDesignator) IsConst() bool                 { return true }
+
+func (o *funcDesignator) convertTo(ctx *context, n Node, to Type) (r Operand) {
+	return &lvalue{Operand: o.Operand.convertTo(ctx, n, to), declarator: o.declarator}
+}
+
+type operand struct {
+	abi    *ABI
+	typ    Type
+	value  Value
+	offset uintptr
+}
+
+func (o *operand) ConvertTo(to Type) (r Operand) { return o.convertTo(nil, nil, to) }
+func (o *operand) Declarator() *Declarator       { return nil }
+func (o *operand) Offset() uintptr               { return o.offset }
+func (o *operand) IsLValue() bool                { return false }
+func (o *operand) IsNonZero() bool               { return o.value != nil && o.value.IsNonZero() }
+func (o *operand) IsZero() bool                  { return o.value != nil && o.value.IsZero() }
+func (o *operand) Type() Type                    { return o.typ }
+func (o *operand) Value() Value                  { return o.value }
+func (o *operand) getABI() *ABI                  { return o.abi }
+
+// IsAssingmentCompatible implements Operand.
+func (o *operand) IsAssingmentCompatible(lhs Type) bool { return lhs.isAssingmentCompatibleOperand(o) }
+
+func (o *operand) IsConst() bool {
+	if v := o.Value(); v != nil {
+		return v.IsConst()
+	}
+
+	d := o.Declarator()
+	return d != nil && (d.Linkage != None || d.IsStatic())
+}
+
+// [0]6.3.1.8
+//
+// Many operators that expect operands of arithmetic type cause conversions and
+// yield result types in a similar way. The purpose is to determine a common
+// real type for the operands and result. For the specified operands, each
+// operand is converted, without change of type domain, to a type whose
+// corresponding real type is the common real type. Unless explicitly stated
+// otherwise, the common real type is also the corresponding real type of the
+// result, whose type domain is the type domain of the operands if they are the
+// same, and complex otherwise. This pattern is called the usual arithmetic
+// conversions:
+func usualArithmeticConversions(ctx *context, n Node, a, b Operand, normalize bool) (Operand, Operand) {
+	if a.Type().Kind() == Invalid || b.Type().Kind() == Invalid {
+		return noOperand, noOperand
+	}
+
+	abi := a.getABI()
+	if !a.Type().IsArithmeticType() {
+		if ctx != nil {
+			ctx.errNode(n, "not an arithmetic type: %s", a.Type())
+		}
+		return noOperand, noOperand
+	}
+
+	if !b.Type().IsArithmeticType() {
+		if ctx != nil {
+			ctx.errNode(n, "not an arithmetic type: %s", b.Type())
+		}
+		return noOperand, noOperand
+	}
+
+	if a.Type() == nil || b.Type() == nil {
+		return a, b
+	}
+
+	if normalize {
+		a = a.normalize(ctx, n)
+		b = b.normalize(ctx, n)
+	}
+	if a == noOperand || b == noOperand {
+		return noOperand, noOperand
+	}
+
+	at := a.Type()
+	bt := b.Type()
+	cplx := at.IsComplexType() || bt.IsComplexType()
+
+	// First, if the corresponding real type of either operand is long
+	// double, the other operand is converted, without change of type
+	// domain, to a type whose corresponding real type is long double.
+	if at.Kind() == ComplexLongDouble || bt.Kind() == ComplexLongDouble || at.Kind() == LongDouble || bt.Kind() == LongDouble {
+		switch {
+		case cplx:
+			return a.convertTo(ctx, n, abi.Type(ComplexLongDouble)), b.convertTo(ctx, n, abi.Type(ComplexLongDouble))
+		default:
+			return a.convertTo(ctx, n, abi.Type(LongDouble)), b.convertTo(ctx, n, abi.Type(LongDouble))
+		}
+	}
+
+	// Otherwise, if the corresponding real type of either operand is
+	// double, the other operand is converted, without change of type
+	// domain, to a type whose corresponding real type is double.
+	if at.Kind() == ComplexDouble || bt.Kind() == ComplexDouble || at.Kind() == Double || bt.Kind() == Double {
+		switch {
+		case cplx:
+			return a.convertTo(ctx, n, abi.Type(ComplexDouble)), b.convertTo(ctx, n, abi.Type(ComplexDouble))
+		default:
+			return a.convertTo(ctx, n, abi.Type(Double)), b.convertTo(ctx, n, abi.Type(Double))
+		}
+	}
+
+	// Otherwise, if the corresponding real type of either operand is
+	// float, the other operand is converted, without change of type
+	// domain, to a type whose corresponding real type is float.
+	if at.Kind() == ComplexFloat || bt.Kind() == ComplexFloat || at.Kind() == Float || bt.Kind() == Float {
+		switch {
+		case cplx:
+			return a.convertTo(ctx, n, abi.Type(ComplexFloat)), b.convertTo(ctx, n, abi.Type(ComplexFloat))
+		default:
+			return a.convertTo(ctx, n, abi.Type(Float)), b.convertTo(ctx, n, abi.Type(Float))
+		}
+	}
+
+	if cplx {
+		panic(internalErrorf("TODO %v, %v", at, bt))
+	}
+
+	if !a.Type().IsIntegerType() || !b.Type().IsIntegerType() {
+		panic(todo(""))
+	}
+
+	// Otherwise, the integer promotions are performed on both operands.
+	a = a.integerPromotion(ctx, n)
+	b = b.integerPromotion(ctx, n)
+	at = a.Type()
+	bt = b.Type()
+
+	// Then the following rules are applied to the promoted operands:
+
+	// If both operands have the same type, then no further conversion is
+	// needed.
+	if at.Kind() == bt.Kind() {
+		return a, b
+	}
+
+	// Otherwise, if both operands have signed integer types or both have
+	// unsigned integer types, the operand with the type of lesser integer
+	// conversion rank is converted to the type of the operand with greater
+	// rank.
+	if abi.isSignedInteger(at.Kind()) == abi.isSignedInteger(bt.Kind()) {
+		t := a.Type()
+		if intConvRank[bt.Kind()] > intConvRank[at.Kind()] {
+			t = b.Type()
+		}
+		return a.convertTo(ctx, n, t), b.convertTo(ctx, n, t)
+
+	}
+
+	// Otherwise, if the operand that has unsigned integer type has rank
+	// greater or equal to the rank of the type of the other operand, then
+	// the operand with signed integer type is converted to the type of the
+	// operand with unsigned integer type.
+	switch {
+	case a.Type().IsSignedType(): // b is unsigned
+		if intConvRank[bt.Kind()] >= intConvRank[a.Type().Kind()] {
+			return a.convertTo(ctx, n, b.Type()), b
+		}
+	case b.Type().IsSignedType(): // a is unsigned
+		if intConvRank[at.Kind()] >= intConvRank[b.Type().Kind()] {
+			return a, b.convertTo(ctx, n, a.Type())
+		}
+	default:
+		panic(fmt.Errorf("TODO %v %v", a.Type(), b.Type()))
+	}
+
+	// Otherwise, if the type of the operand with signed integer type can
+	// represent all of the values of the type of the operand with unsigned
+	// integer type, then the operand with unsigned integer type is
+	// converted to the type of the operand with signed integer type.
+	var signed Type
+	switch {
+	case abi.isSignedInteger(at.Kind()): // b is unsigned
+		signed = a.Type()
+		if at.Size() > bt.Size() {
+			return a, b.convertTo(ctx, n, a.Type())
+		}
+	case abi.isSignedInteger(bt.Kind()): // a is unsigned
+		signed = b.Type()
+		if bt.Size() > at.Size() {
+			return a.convertTo(ctx, n, b.Type()), b
+		}
+
+	}
+
+	// Otherwise, both operands are converted to the unsigned integer type
+	// corresponding to the type of the operand with signed integer type.
+	var typ Type
+	switch signed.Kind() {
+	case Int:
+		//TODO if a.IsEnumConst || b.IsEnumConst {
+		//TODO 	return a, b
+		//TODO }
+
+		typ = abi.Type(UInt)
+	case Long:
+		typ = abi.Type(ULong)
+	case LongLong:
+		typ = abi.Type(ULongLong)
+	default:
+		panic(todo(""))
+	}
+	return a.convertTo(ctx, n, typ), b.convertTo(ctx, n, typ)
+}
+
+// [0]6.3.1.1-2
+//
+// If an int can represent all values of the original type, the value is
+// converted to an int; otherwise, it is converted to an unsigned int. These
+// are called the integer promotions. All other types are unchanged by the
+// integer promotions.
+func (o *operand) integerPromotion(ctx *context, n Node) Operand {
+	t := o.Type()
+	if t2 := integerPromotion(o.abi, t); t2.Kind() != t.Kind() {
+		return o.convertTo(ctx, n, t2)
+	}
+
+	return o
+}
+
+// [0]6.3.1.1-2
+//
+// If an int can represent all values of the original type, the value is
+// converted to an int; otherwise, it is converted to an unsigned int. These
+// are called the integer promotions. All other types are unchanged by the
+// integer promotions.
+func integerPromotion(abi *ABI, t Type) Type {
+	// github.com/gcc-mirror/gcc/gcc/testsuite/gcc.c-torture/execute/bf-sign-2.c
+	//
+	// This test checks promotion of bitfields.  Bitfields
+	// should be promoted very much like chars and shorts:
+	//
+	// Bitfields (signed or unsigned) should be promoted to
+	// signed int if their value will fit in a signed int,
+	// otherwise to an unsigned int if their value will fit
+	// in an unsigned int, otherwise we don't promote them
+	// (ANSI/ISO does not specify the behavior of bitfields
+	// larger than an unsigned int).
+	if t.IsBitFieldType() {
+		f := t.BitField()
+		intBits := int(abi.Types[Int].Size) * 8
+		switch {
+		case t.IsSignedType():
+			if f.BitFieldWidth() < intBits-1 {
+				return abi.Type(Int)
+			}
+		default:
+			if f.BitFieldWidth() < intBits {
+				return abi.Type(Int)
+			}
+		}
+		return t
+	}
+
+	switch t.Kind() {
+	case Invalid:
+		return t
+	case Char, SChar, UChar, Short, UShort:
+		return abi.Type(Int)
+	default:
+		return t
+	}
+}
+
+func (o *operand) convertTo(ctx *context, n Node, to Type) Operand {
+	if o.Type().Kind() == Invalid {
+		return o
+	}
+
+	v := o.Value()
+	r := &operand{abi: o.abi, typ: to, offset: o.offset, value: v}
+	switch v.(type) {
+	case nil, *InitializerValue:
+		return r
+	}
+
+	if o.Type().Kind() == to.Kind() {
+		return r.normalize(ctx, n)
+	}
+
+	if o.Type().IsIntegerType() {
+		return o.convertFromInt(ctx, n, to)
+	}
+
+	if to.IsIntegerType() {
+		return o.convertToInt(ctx, n, to)
+	}
+
+	switch o.Type().Kind() {
+	case Array:
+		switch to.Kind() {
+		case Ptr:
+			return r
+		default:
+			panic(todo("", n.Position()))
+		}
+	case ComplexFloat:
+		v := v.(Complex64Value)
+		switch to.Kind() {
+		case ComplexDouble:
+			r.value = Complex128Value(v)
+		case Float:
+			r.value = Float32Value(real(v))
+		case Double:
+			r.value = Float64Value(real(v))
+		case ComplexLongDouble:
+			panic(todo("", n.Position()))
+		default:
+			panic(todo("", n.Position()))
+		}
+	case ComplexDouble:
+		v := v.(Complex128Value)
+		switch to.Kind() {
+		case ComplexFloat:
+			r.value = Complex64Value(v)
+		case ComplexLongDouble:
+			//TODO panic(todo("", n.Position()))
+			r.value = nil
+		case Float:
+			r.value = Float32Value(real(v))
+		case Double:
+			r.value = Float64Value(real(v))
+		default:
+			//TODO panic(todo("", n.Position(), o.Type(), to))
+			r.value = nil
+		}
+	case Float:
+		v := v.(Float32Value)
+		switch to.Kind() {
+		case ComplexFloat:
+			r.value = Complex64Value(complex(v, 0))
+		case ComplexDouble:
+			r.value = Complex128Value(complex(v, 0))
+		case Double:
+			r.value = Float64Value(v)
+		case ComplexLongDouble:
+			panic(todo("", n.Position()))
+		case LongDouble:
+			r.value = &Float128Value{N: big.NewFloat(float64(v))}
+		case Decimal32, Decimal64, Decimal128:
+			// ok
+		default:
+			panic(todo("695 %s", to.Kind()))
+		}
+	case Double:
+		v := v.(Float64Value)
+		switch to.Kind() {
+		case ComplexFloat:
+			r.value = Complex64Value(complex(v, 0))
+		case ComplexDouble:
+			r.value = Complex128Value(complex(v, 0))
+		case LongDouble:
+			f := float64(v)
+			switch {
+			case math.IsNaN(f):
+				r.value = &Float128Value{NaN: true}
+			default:
+				r.value = &Float128Value{N: big.NewFloat(f)}
+			}
+		case Float:
+			r.value = Float32Value(v)
+		case ComplexLongDouble:
+			panic(todo("", n.Position()))
+		case Vector:
+			r.value = nil
+		case Decimal32, Decimal64, Decimal128:
+			// ok
+		default:
+			panic(todo("", to.Kind()))
+		}
+	case LongDouble:
+		v := v.(*Float128Value)
+		switch to.Kind() {
+		case Double:
+			if v.NaN {
+				r.value = Float64Value(math.NaN())
+				break
+			}
+
+			d, _ := v.N.Float64()
+			r.value = Float64Value(d)
+		case Float:
+			if v.NaN {
+				r.value = Float32Value(math.NaN())
+				break
+			}
+
+			d, _ := v.N.Float64()
+			r.value = Float32Value(d)
+		case ComplexLongDouble:
+			if v.NaN {
+				r.value = Complex256Value{v, &Float128Value{NaN: true}}
+				break
+			}
+
+			r.value = Complex256Value{v, &Float128Value{N: big.NewFloat(0)}}
+		case Decimal32, Decimal64, Decimal128:
+			// ok
+		default:
+			panic(todo("813 %v", to.Kind()))
+		}
+	case Ptr:
+		switch to.Kind() {
+		case Void:
+			return noOperand
+		default:
+			panic(internalErrorf("%v: %v y-> %v %v", n.Position(), o.Type(), to, to.Kind()))
+		}
+	default:
+		panic(internalErrorf("%v: %v -> %v %v", n.Position(), o.Type(), to, to.Kind()))
+	}
+	return r.normalize(ctx, n)
+}
+
+type signedSaturationLimit struct {
+	fmin, fmax float64
+	min, max   int64
+}
+
+type unsignedSaturationLimit struct {
+	fmax float64
+	max  uint64
+}
+
+var (
+	signedSaturationLimits = [...]signedSaturationLimit{
+		1: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
+		2: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
+		4: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
+		8: {math.Nextafter(math.MinInt64, 0), math.Nextafter(math.MaxInt64, 0), math.MinInt64, math.MaxInt64},
+	}
+
+	unsignedSaturationLimits = [...]unsignedSaturationLimit{
+		1: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
+		2: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
+		4: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
+		8: {math.Nextafter(math.MaxUint64, 0), math.MaxUint64},
+	}
+)
+
+func (o *operand) convertToInt(ctx *context, n Node, to Type) (r Operand) {
+	v := o.Value()
+	switch o.Type().Kind() {
+	case Float:
+		v := float64(v.(Float32Value))
+		switch {
+		case to.IsSignedType():
+			limits := &signedSaturationLimits[to.Size()]
+			if v > limits.fmax {
+				return (&operand{abi: o.abi, typ: to, value: Int64Value(limits.max)}).normalize(ctx, n)
+			}
+
+			if v < limits.fmin {
+				return (&operand{abi: o.abi, typ: to, value: Int64Value(limits.min)}).normalize(ctx, n)
+			}
+
+			return (&operand{abi: o.abi, typ: to, value: Int64Value(v)}).normalize(ctx, n)
+		default:
+			limits := &unsignedSaturationLimits[to.Size()]
+			if v > limits.fmax {
+				return (&operand{abi: o.abi, typ: to, value: Uint64Value(limits.max)}).normalize(ctx, n)
+			}
+
+			return (&operand{abi: o.abi, typ: to, value: Uint64Value(v)}).normalize(ctx, n)
+		}
+	case Double:
+		v := float64(v.(Float64Value))
+		switch {
+		case to.IsSignedType():
+			limits := &signedSaturationLimits[to.Size()]
+			if v > limits.fmax {
+				return (&operand{abi: o.abi, typ: to, value: Int64Value(limits.max)}).normalize(ctx, n)
+			}
+
+			if v < limits.fmin {
+				return (&operand{abi: o.abi, typ: to, value: Int64Value(limits.min)}).normalize(ctx, n)
+			}
+
+			return (&operand{abi: o.abi, typ: to, value: Int64Value(v)}).normalize(ctx, n)
+		default:
+			limits := &unsignedSaturationLimits[to.Size()]
+			if v > limits.fmax {
+				return (&operand{abi: o.abi, typ: to, value: Uint64Value(limits.max)}).normalize(ctx, n)
+			}
+
+			return (&operand{abi: o.abi, typ: to, value: Uint64Value(v)}).normalize(ctx, n)
+		}
+	case LongDouble:
+		panic(todo("", n.Position()))
+	case Ptr:
+		var v uint64
+		switch x := o.Value().(type) {
+		case Int64Value:
+			v = uint64(x)
+		case Uint64Value:
+			v = uint64(x)
+		case *InitializerValue:
+			return (&operand{abi: o.abi, typ: to})
+		default:
+			panic(internalErrorf("%v: %T", n.Position(), x))
+		}
+		switch {
+		case to.IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Int64Value(v)}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Uint64Value(v)}).normalize(ctx, n)
+		}
+	case Array:
+		return &operand{abi: o.abi, typ: to}
+	case Vector:
+		if o.Type().Size() == to.Size() {
+			return &operand{abi: o.abi, typ: to}
+		}
+	}
+	if ctx != nil {
+		ctx.errNode(n, "cannot convert %s to %s", o.Type(), to)
+	}
+	return &operand{abi: o.abi, typ: to}
+}
+
+func (o *operand) convertFromInt(ctx *context, n Node, to Type) (r Operand) {
+	var v uint64
+	switch x := o.Value().(type) {
+	case Int64Value:
+		v = uint64(x)
+	case Uint64Value:
+		v = uint64(x)
+	default:
+		if ctx != nil {
+			ctx.errNode(n, "conversion to integer: invalid value")
+		}
+		return &operand{abi: o.abi, typ: to}
+	}
+
+	if to.IsIntegerType() {
+		switch {
+		case to.IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Int64Value(v)}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Uint64Value(v)}).normalize(ctx, n)
+		}
+	}
+
+	switch to.Kind() {
+	case ComplexFloat:
+		switch {
+		case o.Type().IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Complex64Value(complex(float64(int64(v)), 0))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Complex64Value(complex(float64(v), 0))}).normalize(ctx, n)
+		}
+	case ComplexDouble:
+		switch {
+		case o.Type().IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Complex128Value(complex(float64(int64(v)), 0))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Complex128Value(complex(float64(v), 0))}).normalize(ctx, n)
+		}
+	case Float:
+		switch {
+		case o.Type().IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Float32Value(float64(int64(v)))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Float32Value(float64(v))}).normalize(ctx, n)
+		}
+	case ComplexLongDouble:
+		panic(todo("", n.Position()))
+	case Double:
+		switch {
+		case o.Type().IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: Float64Value(int64(v))}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: Float64Value(v)}).normalize(ctx, n)
+		}
+	case LongDouble:
+		switch {
+		case o.Type().IsSignedType():
+			return (&operand{abi: o.abi, typ: to, value: &Float128Value{N: big.NewFloat(0).SetInt64(int64(v))}}).normalize(ctx, n)
+		default:
+			return (&operand{abi: o.abi, typ: to, value: &Float128Value{N: big.NewFloat(0).SetUint64(v)}}).normalize(ctx, n)
+		}
+	case Ptr:
+		return (&operand{abi: o.abi, typ: to, value: Uint64Value(v)}).normalize(ctx, n)
+	case Struct, Union, Array, Void, Int128, UInt128:
+		return &operand{abi: o.abi, typ: to}
+	case Vector:
+		if o.Type().Size() == to.Size() {
+			return &operand{abi: o.abi, typ: to}
+		}
+	}
+	if ctx != nil {
+		ctx.errNode(n, "cannot convert %s to %s", o.Type(), to)
+	}
+	return &operand{abi: o.abi, typ: to}
+}
+
+func (o *operand) normalize(ctx *context, n Node) (r Operand) {
+	if o.Type() == nil {
+		ctx.errNode(n, "operand has unsupported, invalid or incomplete type")
+		return noOperand
+	}
+
+	if o.Type().IsIntegerType() {
+		switch {
+		case o.Type().IsSignedType():
+			if x, ok := o.value.(Uint64Value); ok {
+				o.value = Int64Value(x)
+			}
+		default:
+			if x, ok := o.value.(Int64Value); ok {
+				o.value = Uint64Value(x)
+			}
+		}
+		switch x := o.Value().(type) {
+		case Int64Value:
+			if v := convertInt64(int64(x), o.Type(), o.abi); v != int64(x) {
+				o.value = Int64Value(v)
+			}
+		case Uint64Value:
+			v := uint64(x)
+			switch o.Type().Size() {
+			case 1:
+				v &= 0xff
+			case 2:
+				v &= 0xffff
+			case 4:
+				v &= 0xffffffff
+			}
+			if v != uint64(x) {
+				o.value = Uint64Value(v)
+			}
+		case *InitializerValue, nil:
+			// ok
+		default:
+			panic(internalErrorf("%T %v", x, x))
+		}
+		return o
+	}
+
+	switch o.Type().Kind() {
+	case ComplexFloat:
+		switch o.Value().(type) {
+		case Complex64Value, nil:
+			return o
+		default:
+			panic(todo(""))
+		}
+	case ComplexDouble:
+		switch o.Value().(type) {
+		case Complex128Value, nil:
+			return o
+		default:
+			panic(todo(""))
+		}
+	case ComplexLongDouble:
+		switch o.Value().(type) {
+		case Complex256Value, nil:
+			return o
+		default:
+			panic(todo("934 %v", o.Type().Kind()))
+		}
+	case Float:
+		switch o.Value().(type) {
+		case Float32Value, *InitializerValue, nil:
+			return o
+		default:
+			panic(todo(""))
+		}
+	case Double:
+		switch x := o.Value().(type) {
+		case Float64Value, *InitializerValue, nil:
+			return o
+		default:
+			panic(internalErrorf("%T %v", x, x))
+		}
+	case LongDouble:
+		switch x := o.Value().(type) {
+		case *Float128Value, nil:
+			return o
+		default:
+			panic(internalErrorf("%T %v TODO980 %v", x, x, n.Position()))
+		}
+	case Ptr:
+		switch o.Value().(type) {
+		case Int64Value, Uint64Value, *InitializerValue, StringValue, WideStringValue, nil:
+			return o
+		default:
+			panic(todo(""))
+		}
+	case Array, Void, Function, Struct, Union, Vector, Decimal32, Decimal64, Decimal128:
+		return o
+	case ComplexChar, ComplexInt, ComplexLong, ComplexLongLong, ComplexShort, ComplexUInt, ComplexUShort:
+		//TOD
+		if ctx != nil {
+			ctx.errNode(n, "unsupported type: %s", o.Type())
+		}
+		return noOperand
+	}
+	panic(internalErrorf("%v, %v", o.Type(), o.Type().Kind()))
+}
+
+func convertInt64(n int64, t Type, abi *ABI) int64 {
+	k := t.Kind()
+	if k == Enum {
+		//TODO
+	}
+	signed := abi.isSignedInteger(k)
+	switch sz := abi.size(k); sz {
+	case 1:
+		switch {
+		case signed:
+			switch {
+			case int8(n) < 0:
+				return n | ^math.MaxUint8
+			default:
+				return n & math.MaxUint8
+			}
+		default:
+			return n & math.MaxUint8
+		}
+	case 2:
+		switch {
+		case signed:
+			switch {
+			case int16(n) < 0:
+				return n | ^math.MaxUint16
+			default:
+				return n & math.MaxUint16
+			}
+		default:
+			return n & math.MaxUint16
+		}
+	case 4:
+		switch {
+		case signed:
+			switch {
+			case int32(n) < 0:
+				return n | ^math.MaxUint32
+			default:
+				return n & math.MaxUint32
+			}
+		default:
+			return n & math.MaxUint32
+		}
+	default:
+		return n
+	}
+}
+
+func boolValue(b bool) Value {
+	if b {
+		return Int64Value(1)
+	}
+
+	return Int64Value(0)
+}
+
+type initializer interface {
+	List() []*Initializer
+	IsConst() bool
+}
+
+type InitializerValue struct {
+	typ         Type
+	initializer initializer
+}
+
+func (v *InitializerValue) List() []*Initializer {
+	if v == nil || v.initializer == nil {
+		return nil
+	}
+
+	return v.initializer.List()
+}
+
+func (v *InitializerValue) IsConst() bool {
+	return v != nil && v.initializer != nil && v.initializer.IsConst()
+}
+func (v *InitializerValue) Type() Type        { return v.typ }
+func (v *InitializerValue) add(b Value) Value { return nil }
+func (v *InitializerValue) and(b Value) Value { return nil }
+func (v *InitializerValue) cpl() Value        { return nil }
+func (v *InitializerValue) div(b Value) Value { return nil }
+func (v *InitializerValue) eq(b Value) Value  { return nil }
+func (v *InitializerValue) ge(b Value) Value  { return nil }
+func (v *InitializerValue) gt(b Value) Value  { return nil }
+func (v *InitializerValue) le(b Value) Value  { return nil }
+func (v *InitializerValue) lsh(b Value) Value { return nil }
+func (v *InitializerValue) lt(b Value) Value  { return nil }
+func (v *InitializerValue) mod(b Value) Value { return nil }
+func (v *InitializerValue) mul(b Value) Value { return nil }
+func (v *InitializerValue) neg() Value        { return nil }
+func (v *InitializerValue) neq(b Value) Value { return nil }
+func (v *InitializerValue) or(b Value) Value  { return nil }
+func (v *InitializerValue) rsh(b Value) Value { return nil }
+func (v *InitializerValue) sub(b Value) Value { return nil }
+func (v *InitializerValue) xor(b Value) Value { return nil }
+
+func (v *InitializerValue) IsNonZero() bool {
+	if v == nil {
+		return false
+	}
+
+	for _, v := range v.List() {
+		if !v.AssignmentExpression.Operand.IsZero() {
+			return true
+		}
+	}
+	return false
+}
+
+func (v *InitializerValue) IsZero() bool {
+	if v == nil {
+		return false
+	}
+
+	for _, v := range v.List() {
+		if !v.AssignmentExpression.Operand.IsZero() {
+			return false
+		}
+	}
+	return true
+}