mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-11-28 20:41:35 +00:00
1338 lines
42 KiB
Go
1338 lines
42 KiB
Go
// 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
|
|
}
|