mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
1455 lines
40 KiB
Swift
1455 lines
40 KiB
Swift
struct Int8 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int8
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> Int8 {
|
|
return Int8(Builtin.trunc_Int128_Int8(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = Int8
|
|
static func convertFromIntegerLiteral(value : Int8) -> Int8 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(Int64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : Int8 { get: return 0x7F }
|
|
// static var min : Int8 { get: return -0x7F-1 }
|
|
static func max() -> Int8 { return 0x7F }
|
|
static func min() -> Int8 { return -0x7F-1 }
|
|
}
|
|
|
|
extension Int8 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: Int8) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int8(value, rhs.value))
|
|
}
|
|
func __less__(rhs: Int8) -> Bool {
|
|
return _getBool(Builtin.cmp_slt_Int8(value, rhs.value))
|
|
}
|
|
func succ() -> Int8 {
|
|
return __add__(1)
|
|
}
|
|
func pred() -> Int8 {
|
|
return __sub__(1)
|
|
}
|
|
typealias DistanceType = Int8
|
|
func __sub__(rhs: Int8) -> DistanceType {
|
|
return Int8(Builtin.sub_Int8(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> Int8 {
|
|
return Int8(Builtin.add_Int8(value, offset.value))
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(this)
|
|
}
|
|
}
|
|
|
|
extension Int8 : SignedNumber {
|
|
func __negate__() -> Int8 { return 0 - this }
|
|
func isNegative() -> Bool { return this < 0 }
|
|
}
|
|
|
|
struct UInt8 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int8
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> UInt8 {
|
|
return UInt8(Builtin.trunc_Int128_Int8(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = UInt8
|
|
static func convertFromIntegerLiteral(value : UInt8) -> UInt8 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(UInt64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : UInt8 { get: return 0xFF }
|
|
// static var min : UInt8 { get: return 0 }
|
|
static func max() -> UInt8 { return 0xFF }
|
|
static func min() -> UInt8 { return 0 }
|
|
}
|
|
|
|
extension UInt8 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: UInt8) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int8(value, rhs.value))
|
|
}
|
|
func __less__(rhs: UInt8) -> Bool {
|
|
return _getBool(Builtin.cmp_ult_Int8(value, rhs.value))
|
|
}
|
|
func succ() -> UInt8 {
|
|
return this + 1
|
|
}
|
|
func pred() -> UInt8 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(UInt(this).value)
|
|
}
|
|
typealias DistanceType = UInt8
|
|
func __sub__(rhs: UInt8) -> DistanceType {
|
|
return UInt8(Builtin.sub_Int8(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> UInt8 {
|
|
return UInt8(Builtin.add_Int8(value, offset.value))
|
|
}
|
|
}
|
|
|
|
struct Int16 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int16
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> Int16 {
|
|
return Int16(Builtin.trunc_Int128_Int16(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = Int16
|
|
static func convertFromIntegerLiteral(value : Int16) -> Int16 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(Int64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : Int16 { get: return 0x7FFF }
|
|
// static var min : Int16 { get: return -0x7FFF-1 }
|
|
static func max() -> Int16 { return 0x7FFF }
|
|
static func min() -> Int16 { return -0x7FFF-1 }
|
|
}
|
|
|
|
extension Int16 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: Int16) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int16(value, rhs.value))
|
|
}
|
|
func __less__(rhs: Int16) -> Bool {
|
|
return _getBool(Builtin.cmp_slt_Int16(value, rhs.value))
|
|
}
|
|
func succ() -> Int16 {
|
|
return this + 1
|
|
}
|
|
func pred() -> Int16 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(this)
|
|
}
|
|
typealias DistanceType = Int16
|
|
func __sub__(rhs: Int16) -> DistanceType {
|
|
return Int16(Builtin.sub_Int16(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> Int16 {
|
|
return Int16(Builtin.add_Int16(value, offset.value))
|
|
}
|
|
}
|
|
|
|
extension Int16 : SignedNumber {
|
|
func __negate__() -> Int16 { return 0 - this }
|
|
func isNegative() -> Bool { return this < 0 }
|
|
}
|
|
|
|
struct UInt16 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int16
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> UInt16 {
|
|
return UInt16(Builtin.trunc_Int128_Int16(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = UInt16
|
|
static func convertFromIntegerLiteral(value : UInt16) -> UInt16 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(UInt64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : UInt16 { get: return 0xFFFF }
|
|
// static var min : UInt16 { get: return 0 }
|
|
static func max() -> UInt16 { return 0xFFFF }
|
|
static func min() -> UInt16 { return 0 }
|
|
}
|
|
|
|
extension UInt16 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: UInt16) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int16(value, rhs.value))
|
|
}
|
|
func __less__(rhs: UInt16) -> Bool {
|
|
return _getBool(Builtin.cmp_ult_Int16(value, rhs.value))
|
|
}
|
|
func succ() -> UInt16 {
|
|
return this + 1
|
|
}
|
|
func pred() -> UInt16 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(UInt(this).value)
|
|
}
|
|
typealias DistanceType = UInt16
|
|
func __sub__(rhs: UInt16) -> DistanceType {
|
|
return UInt16(Builtin.sub_Int16(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> UInt16 {
|
|
return UInt16(Builtin.add_Int16(value, offset.value))
|
|
}
|
|
}
|
|
|
|
struct Int32 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible, ArrayBound {
|
|
var value : Builtin.Int32
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> Int32 {
|
|
return Int32(Builtin.trunc_Int128_Int32(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = Int32
|
|
static func convertFromIntegerLiteral(value : Int32) -> Int32 {
|
|
return value
|
|
}
|
|
|
|
func _getBuiltinArrayBoundValue() -> Builtin.Int32 {
|
|
return value
|
|
}
|
|
|
|
typealias ArrayBoundType = Int32
|
|
func getArrayBoundValue() -> Int32 {
|
|
return this
|
|
}
|
|
|
|
func replPrint() {
|
|
print(Int64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : Int32 { get: return 0x7FFFFFFF }
|
|
// static var min : Int32 { get: return -0x7FFFFFFF-1 }
|
|
static func max() -> Int32 { return 0x7FFFFFFF }
|
|
static func min() -> Int32 { return -0x7FFFFFFF-1 }
|
|
}
|
|
|
|
extension Int32 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: Int32) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int32(value, rhs.value))
|
|
}
|
|
func __less__(rhs: Int32) -> Bool {
|
|
return _getBool(Builtin.cmp_slt_Int32(value, rhs.value))
|
|
}
|
|
func succ() -> Int32 {
|
|
return this + 1
|
|
}
|
|
func pred() -> Int32 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(this)
|
|
}
|
|
typealias DistanceType = Int32
|
|
func __sub__(rhs: Int32) -> DistanceType {
|
|
return Int32(Builtin.sub_Int32(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> Int32 {
|
|
return Int32(Builtin.add_Int32(value, offset.value))
|
|
}
|
|
}
|
|
|
|
extension Int32 : SignedNumber {
|
|
func __negate__() -> Int32 { return 0 - this }
|
|
func isNegative() -> Bool { return this < 0 }
|
|
}
|
|
|
|
struct UInt32 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int32
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> UInt32 {
|
|
return UInt32(Builtin.trunc_Int128_Int32(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = UInt32
|
|
static func convertFromIntegerLiteral(value : UInt32) -> UInt32 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(UInt64(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : UInt32 { get: return 0xFFFFFFFF }
|
|
// static var min : UInt32 { get: return 0 }
|
|
static func max() -> UInt32 { return 0xFFFFFFFF }
|
|
static func min() -> UInt32 { return 0 }
|
|
}
|
|
|
|
extension UInt32 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: UInt32) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int32(value, rhs.value))
|
|
}
|
|
func __less__(rhs: UInt32) -> Bool {
|
|
return _getBool(Builtin.cmp_ult_Int32(value, rhs.value))
|
|
}
|
|
func succ() -> UInt32 {
|
|
return this + 1
|
|
}
|
|
func pred() -> UInt32 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(UInt(this).value)
|
|
}
|
|
typealias DistanceType = UInt32
|
|
func __sub__(rhs: UInt32) -> DistanceType {
|
|
return UInt32(Builtin.sub_Int32(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> UInt32 {
|
|
return UInt32(Builtin.add_Int32(value, offset.value))
|
|
}
|
|
}
|
|
|
|
struct Int64 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible, ArrayBound {
|
|
var value : Builtin.Int64
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> Int64 {
|
|
return Int64(Builtin.trunc_Int128_Int64(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = Int64
|
|
static func convertFromIntegerLiteral(value : Int64) -> Int64 {
|
|
return value
|
|
}
|
|
|
|
func _getBuiltinArrayBoundValue() -> Builtin.Int64 {
|
|
return value
|
|
}
|
|
|
|
typealias ArrayBoundType = Int64
|
|
func getArrayBoundValue() -> Int64 {
|
|
return this
|
|
}
|
|
|
|
func replPrint() {
|
|
print(this)
|
|
}
|
|
// FIXME:
|
|
// static var max : Int64 { get: return 0x7FFFFFFFFFFFFFFF }
|
|
// static var min : Int64 { get: return -0x7FFFFFFFFFFFFFFF-1 }
|
|
static func max() -> Int64 { return 0x7FFFFFFFFFFFFFFF }
|
|
static func min() -> Int64 { return -0x7FFFFFFFFFFFFFFF-1 }
|
|
}
|
|
|
|
extension Int64 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: Int64) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int64(value, rhs.value))
|
|
}
|
|
func __less__(rhs: Int64) -> Bool {
|
|
return _getBool(Builtin.cmp_slt_Int64(value, rhs.value))
|
|
}
|
|
func succ() -> Int64 {
|
|
return __add__(1)
|
|
}
|
|
func pred() -> Int64 {
|
|
return __sub__(1)
|
|
}
|
|
typealias DistanceType = Int64
|
|
func __sub__(rhs: Int64) -> DistanceType {
|
|
return Int64(Builtin.sub_Int64(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> Int64 {
|
|
return Int64(Builtin.add_Int64(value, offset.value))
|
|
}
|
|
func hashValue() -> Int {
|
|
return this
|
|
}
|
|
}
|
|
|
|
extension Int64 : SignedNumber {
|
|
func __negate__() -> Int64 { return 0 - this }
|
|
func isNegative() -> Bool { return this < 0 }
|
|
}
|
|
|
|
struct UInt64 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int64
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> UInt64 {
|
|
return UInt64(Builtin.trunc_Int128_Int64(val))
|
|
}
|
|
|
|
typealias IntegerLiteralType = UInt64
|
|
static func convertFromIntegerLiteral(value : UInt64) -> UInt64 {
|
|
return value
|
|
}
|
|
|
|
func _getBuiltinArrayBoundValue() -> Builtin.Int64 {
|
|
return value
|
|
}
|
|
|
|
typealias ArrayBoundType = UInt64
|
|
func getArrayBoundValue() -> UInt64 {
|
|
return this
|
|
}
|
|
|
|
func replPrint() {
|
|
print(this)
|
|
}
|
|
// FIXME:
|
|
// static var max : UInt64 { get: return 0xFFFFFFFFFFFFFFFF }
|
|
// static var min : UInt64 { get: return 0 }
|
|
static func max() -> UInt64 { return 0xFFFFFFFFFFFFFFFF }
|
|
static func min() -> UInt64 { return 0 }
|
|
}
|
|
|
|
extension UInt64 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: UInt64) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int64(value, rhs.value))
|
|
}
|
|
func __less__(rhs: UInt64) -> Bool {
|
|
return _getBool(Builtin.cmp_ult_Int64(value, rhs.value))
|
|
}
|
|
func succ() -> UInt64 {
|
|
return this + 1
|
|
}
|
|
func pred() -> UInt64 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(value)
|
|
}
|
|
typealias DistanceType = UInt64
|
|
func __sub__(rhs: UInt64) -> DistanceType {
|
|
return UInt64(Builtin.sub_Int64(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> UInt64 {
|
|
return UInt64(Builtin.add_Int64(value, offset.value))
|
|
}
|
|
}
|
|
|
|
struct Int128 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int128
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> Int128 {
|
|
return Int128(val)
|
|
}
|
|
|
|
typealias IntegerLiteralType = Int128
|
|
static func convertFromIntegerLiteral(value : Int128) -> Int128 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(String(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : Int128 { get: return 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
|
|
// static var min : Int128 { get: return -0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF-1 }
|
|
static func max() -> Int128 { return 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
|
|
static func min() -> Int128 { return -0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF-1 }
|
|
}
|
|
|
|
extension Int128 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: Int128) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int128(value, rhs.value))
|
|
}
|
|
func __less__(rhs: Int128) -> Bool {
|
|
return _getBool(Builtin.cmp_slt_Int128(value, rhs.value))
|
|
}
|
|
func succ() -> Int128 {
|
|
return this + 1
|
|
}
|
|
func pred() -> Int128 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(this >> 64) ^ Int(this & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
|
|
}
|
|
typealias DistanceType = Int128
|
|
func __sub__(rhs: Int128) -> DistanceType {
|
|
return Int128(Builtin.sub_Int128(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> Int128 {
|
|
return Int128(Builtin.add_Int128(value, offset.value))
|
|
}
|
|
}
|
|
|
|
extension Int128 : SignedNumber {
|
|
func __negate__() -> Int128 { return 0 - this }
|
|
func isNegative() -> Bool { return this < 0 }
|
|
}
|
|
|
|
struct UInt128 : BuiltinIntegerLiteralConvertible, IntegerLiteralConvertible {
|
|
var value : Builtin.Int128
|
|
|
|
static func _convertFromBuiltinIntegerLiteral(val : Builtin.Int128) -> UInt128 {
|
|
return UInt128(val)
|
|
}
|
|
|
|
typealias IntegerLiteralType = UInt128
|
|
static func convertFromIntegerLiteral(value : UInt128) -> UInt128 {
|
|
return value
|
|
}
|
|
|
|
func replPrint() {
|
|
print(String(this))
|
|
}
|
|
// FIXME:
|
|
// static var max : UInt128 { get: return 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
|
|
// static var min : UInt128 { get: return 0 }
|
|
static func max() -> UInt128 { return 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
|
|
static func min() -> UInt128 { return 0 }
|
|
}
|
|
|
|
extension UInt128 : RandomAccessIndex, Hashable {
|
|
func __equal__(rhs: UInt128) -> Bool {
|
|
return _getBool(Builtin.cmp_eq_Int128(value, rhs.value))
|
|
}
|
|
func __less__(rhs: UInt128) -> Bool {
|
|
return _getBool(Builtin.cmp_ult_Int128(value, rhs.value))
|
|
}
|
|
func succ() -> UInt128 {
|
|
return this + 1
|
|
}
|
|
func pred() -> UInt128 {
|
|
return this - 1
|
|
}
|
|
func hashValue() -> Int {
|
|
return Int(this >> 64) ^ Int(this & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
|
|
}
|
|
typealias DistanceType = UInt128
|
|
func __sub__(rhs: UInt128) -> DistanceType {
|
|
return UInt128(Builtin.sub_Int128(value, rhs.value))
|
|
}
|
|
func __add__(offset: DistanceType) -> UInt128 {
|
|
return UInt128(Builtin.add_Int128(value, offset.value))
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Explicit conversions between types.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
extension Int8 {
|
|
constructor(v : UInt8) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.trunc_Int16_Int8(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.trunc_Int16_Int8(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.trunc_Int32_Int8(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.trunc_Int32_Int8(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int8(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int8(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int8(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int8(v.value)
|
|
}
|
|
}
|
|
|
|
extension UInt8 {
|
|
constructor(v : Int8) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.trunc_Int16_Int8(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.trunc_Int16_Int8(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.trunc_Int32_Int8(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.trunc_Int32_Int8(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int8(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int8(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int8(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int8(v.value)
|
|
}
|
|
}
|
|
|
|
extension Int16 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int16(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int16(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.trunc_Int32_Int16(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.trunc_Int32_Int16(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int16(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int16(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int16(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int16(v.value)
|
|
}
|
|
}
|
|
|
|
extension UInt16 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int16(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int16(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.trunc_Int32_Int16(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.trunc_Int32_Int16(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int16(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int16(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int16(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int16(v.value)
|
|
}
|
|
}
|
|
|
|
extension Int32 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int32(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int32(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int32(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int32(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int32(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int32(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int32(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int32(v.value)
|
|
}
|
|
}
|
|
|
|
extension UInt32 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int32(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int32(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int32(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int32(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.trunc_Int64_Int32(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.trunc_Int64_Int32(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int32(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int32(v.value)
|
|
}
|
|
}
|
|
|
|
extension Int64 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int64(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int64(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int64(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int64(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.sext_Int32_Int64(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.zext_Int32_Int64(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int64(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int64(v.value)
|
|
}
|
|
}
|
|
|
|
extension UInt64 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int64(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int64(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int64(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int64(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.sext_Int32_Int64(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.zext_Int32_Int64(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = v.value
|
|
}
|
|
constructor(v : Int128) {
|
|
value = Builtin.trunc_Int128_Int64(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = Builtin.trunc_Int128_Int64(v.value)
|
|
}
|
|
}
|
|
|
|
extension Int128 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int128(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int128(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int128(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int128(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.sext_Int32_Int128(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.zext_Int32_Int128(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.sext_Int64_Int128(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.zext_Int64_Int128(v.value)
|
|
}
|
|
constructor(v : UInt128) {
|
|
value = v.value
|
|
}
|
|
}
|
|
|
|
extension UInt128 {
|
|
constructor(v : Int8) {
|
|
value = Builtin.sext_Int8_Int128(v.value)
|
|
}
|
|
constructor(v : UInt8) {
|
|
value = Builtin.zext_Int8_Int128(v.value)
|
|
}
|
|
constructor(v : Int16) {
|
|
value = Builtin.sext_Int16_Int128(v.value)
|
|
}
|
|
constructor(v : UInt16) {
|
|
value = Builtin.zext_Int16_Int128(v.value)
|
|
}
|
|
constructor(v : Int32) {
|
|
value = Builtin.sext_Int32_Int128(v.value)
|
|
}
|
|
constructor(v : UInt32) {
|
|
value = Builtin.zext_Int32_Int128(v.value)
|
|
}
|
|
constructor(v : Int64) {
|
|
value = Builtin.sext_Int64_Int128(v.value)
|
|
}
|
|
constructor(v : UInt64) {
|
|
value = Builtin.zext_Int64_Int128(v.value)
|
|
}
|
|
constructor(v : Int128) {
|
|
value = v.value
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Standard Operators
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Unary addition operators.
|
|
func [prefix] +(a : Int8) -> Int8 { return a }
|
|
func [prefix] +(a : UInt8) -> UInt8 { return a }
|
|
func [prefix] +(a : Int16) -> Int16 { return a }
|
|
func [prefix] +(a : UInt16) -> UInt16 { return a }
|
|
func [prefix] +(a : Int32) -> Int32 { return a }
|
|
func [prefix] +(a : UInt32) -> UInt32 { return a }
|
|
func [prefix] +(a : Int64) -> Int64 { return a }
|
|
func [prefix] +(a : UInt64) -> UInt64 { return a }
|
|
func [prefix] +(a : Int128) -> Int128 { return a }
|
|
func [prefix] +(a : UInt128) -> UInt128 { return a }
|
|
|
|
// Bitwise negation operators.
|
|
func [prefix] ~(a : Int8) -> Int8 { return a ^ -1 }
|
|
func [prefix] ~(a : UInt8) -> UInt8 { return a ^ 0xFF }
|
|
func [prefix] ~(a : Int16) -> Int16 { return a ^ -1 }
|
|
func [prefix] ~(a : UInt16) -> UInt16 { return a ^ 0xFFFF }
|
|
func [prefix] ~(a : Int32) -> Int32 { return a ^ -1 }
|
|
func [prefix] ~(a : UInt32) -> UInt32 { return a ^ 0xFFFFFFFF }
|
|
func [prefix] ~(a : Int64) -> Int64 { return a ^ -1 }
|
|
func [prefix] ~(a : UInt64) -> UInt64 { return a ^ 0xFFFFFFFFFFFFFFFF }
|
|
func [prefix] ~(a : Int128) -> Int128 { return a ^ -1 }
|
|
func [prefix] ~(a : UInt128) -> UInt128 { return a ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF }
|
|
|
|
// Binary Multiplication.
|
|
func * (lhs : Int8, rhs : Int8) -> Int8 {
|
|
return Int8(Builtin.mul_Int8(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : UInt8, rhs : UInt8) -> UInt8 {
|
|
return UInt8(Builtin.mul_Int8(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : Int16, rhs : Int16) -> Int16 {
|
|
return Int16(Builtin.mul_Int16(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : UInt16, rhs : UInt16) -> UInt16 {
|
|
return UInt16(Builtin.mul_Int16(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : Int32, rhs : Int32) -> Int32 {
|
|
return Int32(Builtin.mul_Int32(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : UInt32, rhs : UInt32) -> UInt32 {
|
|
return UInt32(Builtin.mul_Int32(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : Int64, rhs : Int64) -> Int64 {
|
|
return Int64(Builtin.mul_Int64(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : UInt64, rhs : UInt64) -> UInt64 {
|
|
return UInt64(Builtin.mul_Int64(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : Int128, rhs : Int128) -> Int128 {
|
|
return Int128(Builtin.mul_Int128(lhs.value, rhs.value))
|
|
}
|
|
func * (lhs : UInt128, rhs : UInt128) -> UInt128 {
|
|
return UInt128(Builtin.mul_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
|
|
// Binary Division.
|
|
func / (lhs : Int8, rhs : Int8) -> Int8 {
|
|
return Int8(Builtin.sdiv_Int8(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : UInt8, rhs : UInt8) -> UInt8 {
|
|
return UInt8(Builtin.udiv_Int8(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : Int16, rhs : Int16) -> Int16 {
|
|
return Int16(Builtin.sdiv_Int16(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : UInt16, rhs : UInt16) -> UInt16 {
|
|
return UInt16(Builtin.udiv_Int16(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : Int32, rhs : Int32) -> Int32 {
|
|
return Int32(Builtin.sdiv_Int32(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : UInt32, rhs : UInt32) -> UInt32 {
|
|
return UInt32(Builtin.udiv_Int32(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : Int64, rhs : Int64) -> Int64 {
|
|
return Int64(Builtin.sdiv_Int64(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : UInt64, rhs : UInt64) -> UInt64 {
|
|
return UInt64(Builtin.udiv_Int64(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : Int128, rhs : Int128) -> Int128 {
|
|
return Int128(Builtin.sdiv_Int128(lhs.value, rhs.value))
|
|
}
|
|
func / (lhs : UInt128, rhs : UInt128) -> UInt128 {
|
|
return UInt128(Builtin.udiv_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
// Binary Remainder.
|
|
func % (lhs : Int8, rhs : Int8) -> Int8 {
|
|
return Int8(Builtin.srem_Int8(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : UInt8, rhs : UInt8) -> UInt8 {
|
|
return UInt8(Builtin.urem_Int8(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : Int16, rhs : Int16) -> Int16 {
|
|
return Int16(Builtin.srem_Int16(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : UInt16, rhs : UInt16) -> UInt16 {
|
|
return UInt16(Builtin.urem_Int16(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : Int32, rhs : Int32) -> Int32 {
|
|
return Int32(Builtin.srem_Int32(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : UInt32, rhs : UInt32) -> UInt32 {
|
|
return UInt32(Builtin.urem_Int32(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : Int64, rhs : Int64) -> Int64 {
|
|
return Int64(Builtin.srem_Int64(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : UInt64, rhs : UInt64) -> UInt64 {
|
|
return UInt64(Builtin.urem_Int64(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : Int128, rhs : Int128) -> Int128 {
|
|
return Int128(Builtin.srem_Int128(lhs.value, rhs.value))
|
|
}
|
|
func % (lhs : UInt128, rhs : UInt128) -> UInt128 {
|
|
return UInt128(Builtin.urem_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
|
|
// Binary Addition.
|
|
func + (lhs: Int8, rhs: Int8) -> Int8 {
|
|
return Int8(Builtin.add_Int8(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: UInt8, rhs: UInt8) -> UInt8 {
|
|
return UInt8(Builtin.add_Int8(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: Int16, rhs: Int16) -> Int16 {
|
|
return Int16(Builtin.add_Int16(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: UInt16, rhs: UInt16) -> UInt16 {
|
|
return UInt16(Builtin.add_Int16(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: Int32, rhs: Int32) -> Int32 {
|
|
return Int32(Builtin.add_Int32(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: UInt32, rhs: UInt32) -> UInt32 {
|
|
return UInt32(Builtin.add_Int32(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: Int64, rhs: Int64) -> Int64 {
|
|
return Int64(Builtin.add_Int64(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: UInt64, rhs: UInt64) -> UInt64 {
|
|
return UInt64(Builtin.add_Int64(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: Int128, rhs: Int128) -> Int128 {
|
|
return Int128(Builtin.add_Int128(lhs.value, rhs.value))
|
|
}
|
|
func + (lhs: UInt128, rhs: UInt128) -> UInt128 {
|
|
return UInt128(Builtin.add_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
|
|
// Binary Subtraction.
|
|
func - (lhs: Int8, rhs: Int8) -> Int8 {
|
|
return Int8(Builtin.sub_Int8(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: UInt8, rhs: UInt8) -> UInt8 {
|
|
return UInt8(Builtin.sub_Int8(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: Int16, rhs: Int16) -> Int16 {
|
|
return Int16(Builtin.sub_Int16(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: UInt16, rhs: UInt16) -> UInt16 {
|
|
return UInt16(Builtin.sub_Int16(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: Int32, rhs: Int32) -> Int32 {
|
|
return Int32(Builtin.sub_Int32(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: UInt32, rhs: UInt32) -> UInt32 {
|
|
return UInt32(Builtin.sub_Int32(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: Int64, rhs: Int64) -> Int64 {
|
|
return Int64(Builtin.sub_Int64(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: UInt64, rhs: UInt64) -> UInt64 {
|
|
return UInt64(Builtin.sub_Int64(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: Int128, rhs: Int128) -> Int128 {
|
|
return Int128(Builtin.sub_Int128(lhs.value, rhs.value))
|
|
}
|
|
func - (lhs: UInt128, rhs: UInt128) -> UInt128 {
|
|
return UInt128(Builtin.sub_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
// Left Shift.
|
|
func << (lhs : Int8, rhs : Int8) -> Int8 {
|
|
return Int8(Builtin.shl_Int8(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : UInt8, rhs : UInt8) -> UInt8 {
|
|
return UInt8(Builtin.shl_Int8(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : Int16, rhs : Int16) -> Int16 {
|
|
return Int16(Builtin.shl_Int16(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : UInt16, rhs : UInt16) -> UInt16 {
|
|
return UInt16(Builtin.shl_Int16(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : Int32, rhs : Int32) -> Int32 {
|
|
return Int32(Builtin.shl_Int32(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : UInt32, rhs : UInt32) -> UInt32 {
|
|
return UInt32(Builtin.shl_Int32(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : Int64, rhs : Int64) -> Int64 {
|
|
return Int64(Builtin.shl_Int64(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : UInt64, rhs : UInt64) -> UInt64 {
|
|
return UInt64(Builtin.shl_Int64(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : Int128, rhs : Int128) -> Int128 {
|
|
return Int128(Builtin.shl_Int128(lhs.value, rhs.value))
|
|
}
|
|
func << (lhs : UInt128, rhs : UInt128) -> UInt128 {
|
|
return UInt128(Builtin.shl_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
// Right Shift.
|
|
func >>(lhs : Int8, rhs : Int8) -> Int8 {
|
|
return Int8(Builtin.ashr_Int8(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : UInt8, rhs : UInt8) -> UInt8 {
|
|
return UInt8(Builtin.lshr_Int8(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : Int16, rhs : Int16) -> Int16 {
|
|
return Int16(Builtin.ashr_Int16(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : UInt16, rhs : UInt16) -> UInt16 {
|
|
return UInt16(Builtin.lshr_Int16(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : Int32, rhs : Int32) -> Int32 {
|
|
return Int32(Builtin.ashr_Int32(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : UInt32, rhs : UInt32) -> UInt32 {
|
|
return UInt32(Builtin.lshr_Int32(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : Int64, rhs : Int64) -> Int64 {
|
|
return Int64(Builtin.ashr_Int64(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : UInt64, rhs : UInt64) -> UInt64 {
|
|
return UInt64(Builtin.lshr_Int64(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : Int128, rhs : Int128) -> Int128 {
|
|
return Int128(Builtin.ashr_Int128(lhs.value, rhs.value))
|
|
}
|
|
func >>(lhs : UInt128, rhs : UInt128) -> UInt128 {
|
|
return UInt128(Builtin.lshr_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
// Bitwise 'and'.
|
|
func & (lhs: Int8, rhs: Int8) -> Int8 {
|
|
return Int8(Builtin.and_Int8(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: UInt8, rhs: UInt8) -> UInt8 {
|
|
return UInt8(Builtin.and_Int8(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: Int16, rhs: Int16) -> Int16 {
|
|
return Int16(Builtin.and_Int16(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: UInt16, rhs: UInt16) -> UInt16 {
|
|
return UInt16(Builtin.and_Int16(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: Int32, rhs: Int32) -> Int32 {
|
|
return Int32(Builtin.and_Int32(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: UInt32, rhs: UInt32) -> UInt32 {
|
|
return UInt32(Builtin.and_Int32(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: Int64, rhs: Int64) -> Int64 {
|
|
return Int64(Builtin.and_Int64(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: UInt64, rhs: UInt64) -> UInt64 {
|
|
return UInt64(Builtin.and_Int64(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: Int128, rhs: Int128) -> Int128 {
|
|
return Int128(Builtin.and_Int128(lhs.value, rhs.value))
|
|
}
|
|
func & (lhs: UInt128, rhs: UInt128) -> UInt128 {
|
|
return UInt128(Builtin.and_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
func ^ (lhs: Int8, rhs: Int8) -> Int8 {
|
|
return Int8(Builtin.xor_Int8(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: UInt8, rhs: UInt8) -> UInt8 {
|
|
return UInt8(Builtin.xor_Int8(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: Int16, rhs: Int16) -> Int16 {
|
|
return Int16(Builtin.xor_Int16(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: UInt16, rhs: UInt16) -> UInt16 {
|
|
return UInt16(Builtin.xor_Int16(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: Int32, rhs: Int32) -> Int32 {
|
|
return Int32(Builtin.xor_Int32(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: UInt32, rhs: UInt32) -> UInt32 {
|
|
return UInt32(Builtin.xor_Int32(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: Int64, rhs: Int64) -> Int64 {
|
|
return Int64(Builtin.xor_Int64(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: UInt64, rhs: UInt64) -> UInt64 {
|
|
return UInt64(Builtin.xor_Int64(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: Int128, rhs: Int128) -> Int128 {
|
|
return Int128(Builtin.xor_Int128(lhs.value, rhs.value))
|
|
}
|
|
func ^ (lhs: UInt128, rhs: UInt128) -> UInt128 {
|
|
return UInt128(Builtin.xor_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
func | (lhs: Int8, rhs: Int8) -> Int8 {
|
|
return Int8(Builtin.or_Int8(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: UInt8, rhs: UInt8) -> UInt8 {
|
|
return UInt8(Builtin.or_Int8(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: Int16, rhs: Int16) -> Int16 {
|
|
return Int16(Builtin.or_Int16(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: UInt16, rhs: UInt16) -> UInt16 {
|
|
return UInt16(Builtin.or_Int16(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: Int32, rhs: Int32) -> Int32 {
|
|
return Int32(Builtin.or_Int32(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: UInt32, rhs: UInt32) -> UInt32 {
|
|
return UInt32(Builtin.or_Int32(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: Int64, rhs: Int64) -> Int64 {
|
|
return Int64(Builtin.or_Int64(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: UInt64, rhs: UInt64) -> UInt64 {
|
|
return UInt64(Builtin.or_Int64(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: Int128, rhs: Int128) -> Int128 {
|
|
return Int128(Builtin.or_Int128(lhs.value, rhs.value))
|
|
}
|
|
func | (lhs: UInt128, rhs: UInt128) -> UInt128 {
|
|
return UInt128(Builtin.or_Int128(lhs.value, rhs.value))
|
|
}
|
|
|
|
// See Bool.swift for && and ||
|
|
// In C, 120 is &&
|
|
// In C, 110 is ||
|
|
|
|
// In C, 100 is ?:
|
|
// In C, 90 is =, *=, += etc.
|
|
|
|
// Compound assignment (with subtraction)
|
|
func [assignment] -= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs - rhs
|
|
}
|
|
func [assignment] -= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs - rhs
|
|
}
|
|
func [assignment] -= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs - rhs
|
|
}
|
|
func [assignment] -= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs - rhs
|
|
}
|
|
func [assignment] -= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs - rhs
|
|
}
|
|
|
|
// Compound assignment (with multiplication)
|
|
func [assignment] *= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs * rhs
|
|
}
|
|
func [assignment] *= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs * rhs
|
|
}
|
|
|
|
// Compound assignment (with division)
|
|
func [assignment] /= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs / rhs
|
|
}
|
|
func [assignment] /= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs / rhs
|
|
}
|
|
|
|
// Compound assignment (with remainder)
|
|
func [assignment] %= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs % rhs
|
|
}
|
|
func [assignment] %= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs % rhs
|
|
}
|
|
|
|
// Compound assignment (with left shift)
|
|
func [assignment] <<= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs << rhs
|
|
}
|
|
func [assignment] <<= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs << rhs
|
|
}
|
|
|
|
// Compound assignment (with right shift)
|
|
func [assignment] >>= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
func [assignment] >>= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs >> rhs
|
|
}
|
|
|
|
// Compound assignment (with bitwise and)
|
|
func [assignment] &= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs & rhs
|
|
}
|
|
func [assignment] &= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs & rhs
|
|
}
|
|
|
|
// Compound assignment (with bitwise or)
|
|
func [assignment] |= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs | rhs
|
|
}
|
|
func [assignment] |= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs | rhs
|
|
}
|
|
|
|
// Compound assignment (with bitwise exclusive or)
|
|
func [assignment] ^= (lhs : [byref] Int8, rhs : Int8) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] UInt8, rhs : UInt8) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] Int16, rhs : Int16) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] UInt16, rhs : UInt16) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] Int32, rhs : Int32) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] UInt32, rhs : UInt32) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] Int64, rhs : Int64) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] UInt64, rhs : UInt64) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] Int128, rhs : Int128) {
|
|
lhs = lhs ^ rhs
|
|
}
|
|
func [assignment] ^= (lhs : [byref] UInt128, rhs : UInt128) {
|
|
lhs = lhs ^ rhs
|
|
}
|