Bitter.swift.gyb

//
//  Bitter.swift
//  Bitter
//
//  Created by Umberto Raimondi on 01/02/16.
//  Copyright © 2016 Umberto Raimondi. All rights reserved.
//

// MARK: Int types extensions
%{
  intTypes = [8,16,32,64]
}%

% for sign in ['','U']:
/**
Extension that adds a few additional functionalities to ${sign}Int:
- toIntN/toUIntN truncating bit pattern conversions
- allOnes
- size
- Byte indexed subscript
*/
extension ${sign}Int{
    % for intType in intTypes[:3]:
    /// Perform a bit pattern truncating conversion to UInt${intType}
    public var toU${intType}: UInt${intType}{return UInt${intType}(truncatingIfNeeded:self)}
    /// Perform a bit pattern truncating conversion to Int${intType}
    public var to${intType}: Int${intType}{return Int${intType}(truncatingIfNeeded:self)}
    %end
    /// Perform a bit pattern truncating conversion to UInt64
    public var toU64: UInt64{
        return UInt64(self) //No difference if the platform is 32 or 64
        }
    /// Perform a bit pattern truncating conversion to Int64
    public var to64: Int64{
        return Int64(self) //No difference if the platform is 32 or 64
        }
    %if sign == '':
    /// Perform a bit pattern truncating conversion to Int
    public var toInt:Int{return self}
    /// Perform a bit pattern truncating conversion to UInt
    public var toUInt:UInt{return UInt(bitPattern:self)}
    %else:
    /// Perform a bit pattern truncating conversion to Int
    public var toInt:Int{return Int(bitPattern:self)}
    /// Perform a bit pattern truncating conversion to UInt
    public var toUInt:UInt{return self}
    %end

    /// Create bits mask with one
    public func mask(_ bits: ${sign}Int, _ msb: Bool) -> ${sign}Int {
        if (bits >> 3) == ${sign}Int.size { return ${sign}Int.max }

        let mask = ${sign}Int(truncating: NSDecimalNumber(decimal:(pow(2, bits.toInt) - 1)))

        switch msb {
        case false:
            return mask
        case true:
            let shift = ${sign}Int(${sign}Int.size << 3) - bits
            return mask << shift
        }
    }

    /// Returns the size of this type (number of bytes)
    public static var size:Int{return MemoryLayout<${sign}Int>.stride}

    % for bitidx in [0,1,2,3,4,5,6,7]:
        %if sign == '':
    /// Get bit ${bitidx} value
    public var b${bitidx}:Int{
        return Int(bitPattern: ( UInt(bitPattern: self) & (0x1 << ${bitidx})) >> ${bitidx} )
    }
    /// Set bit ${bitidx} and return a new ${sign}Int
    public func setb${bitidx}(_ bit:Int)->Int{
        let nv: UInt = bit != 0 ? 1 : 0
        return Int(bitPattern: ( UInt(bitPattern: self) & ~(0x1 << ${bitidx})) | (nv << ${bitidx}) )
    }
        %else:
    /// Get bit ${bitidx} value
    public var b${bitidx}:UInt{
        return ( self & (0x1 << ${bitidx})) >> ${bitidx}
    }
    /// Set bit ${bitidx} and return a new ${sign}Int
    public func setb${bitidx}(_ bit:Int)->UInt{
        let nv:UInt = bit != 0 ? 1 : 0
        return ( self & ~(0x1 << ${bitidx})) | (nv << ${bitidx})
    }
        %end
    %end


    /// Subscript that returns or set one of the bytes of a ${sign}Int
    /// at the given index.
    /// Trying to access an out of index byte will result in an error.
    public subscript(index: Int) -> ${sign}Int {
    %if sign == '':
        get {
            precondition(index<Int.size,"Byte set index out of range")
            let idx: UInt = UInt(bitPattern: index) * 8
            return Int(bitPattern: (UInt(bitPattern: self) & (0xFF << idx)) >> idx )
        }
        set(newValue) {
            precondition(index<Int.size,"Byte set index out of range")
            let idx: UInt = UInt(bitPattern: index) * 8
            self = Int(bitPattern: (UInt(bitPattern: self) & ~(0xFF << idx)) | (UInt(bitPattern: newValue) << idx) )
        }
    %else:
        get {
            precondition(index<Int.size,"Byte set index out of range")
            let idx: UInt = UInt(bitPattern: index) * 8
            return (self & (0xFF << idx)) >> idx
        }
        set(newValue) {
            precondition(index<Int.size,"Byte set index out of range")
            let idx: UInt = UInt(bitPattern: index) * 8
            self = (self & ~(0xFF << idx)) | (newValue << idx)
        }
    %end
    }
}
%end

% for intType in intTypes:
    % for sign in ['','U']:
/**
Extension that adds a few additional functionalities to ${sign}Int${intType}:
- toIntN/toUIntN truncating bit pattern conversions
- allOnes
- size
- Byte indexed subscript
*/
extension ${sign}Int${intType} {
        % for aSize in intTypes:
            %if intType > aSize:
    /// Perform a bit pattern truncating conversion to UInt${aSize}
    public var toU${aSize}: UInt${aSize}{return UInt${aSize}(truncatingIfNeeded:self)}
    /// Perform a bit pattern truncating conversion to Int${aSize}
    public var to${aSize}: Int${aSize}{return Int${aSize}(truncatingIfNeeded:self)}
            %elif intType == aSize:
                %if sign == '':
    /// Perform a bit pattern truncating conversion to UInt${aSize}
    public var toU${aSize}: UInt${aSize}{return UInt${aSize}(bitPattern:self)}
    /// Perform a bit pattern truncating conversion to Int${aSize}
    public var to${aSize}: Int${aSize}{return self}
                %else:
    /// Perform a bit pattern truncating conversion to UInt${aSize}
    public var toU${aSize}: UInt${aSize}{return self}
    /// Perform a bit pattern truncating conversion to Int${aSize}
    public var to${aSize}: Int${aSize}{return Int${aSize}(bitPattern:self)}
                %end
            %else:
    /// Perform a bit pattern truncating conversion to UInt${aSize}
    public var toU${aSize}: UInt${aSize}{return UInt${aSize}(self)}
    /// Perform a bit pattern truncating conversion to Int${aSize}
    public var to${aSize}: Int${aSize}{return Int${aSize}(self)}
            %end
        %end
        %if intType < 64:
    /// Perform a bit pattern truncating conversion to Int
    public var toInt:Int{return Int(bitPattern:UInt(self))}
    /// Perform a bit pattern truncating conversion to UInt
    public var toUInt:UInt{return UInt(self)}
        %else:
    /// Perform a bit pattern truncating conversion to Int
    public var toInt:Int{return Int(truncatingIfNeeded:self)}
    /// Perform a bit pattern truncating conversion to UInt
    public var toUInt:UInt{return UInt(truncatingIfNeeded:self)}
        %end

    /// Create bits mask with one
    public func mask(_ bits: ${sign}Int${intType}, _ msb: Bool) -> ${sign}Int${intType} {
        if (bits >> 3) == ${sign}Int${intType}.size { return ${sign}Int${intType}.max }

        let mask = ${sign}Int${intType}(truncating: NSDecimalNumber(decimal:(pow(2, bits.toInt) - 1)))

        switch msb {
        case false:
            return mask
        case true:
            let shift = ${sign}Int${intType}(${sign}Int${intType}.size << 3) - bits
            return mask << shift
        }
    }

    /// Returns the size of this type (number of bytes)
    public static var size:Int{return MemoryLayout<${sign}Int${intType}>.stride}

        % for bitidx in [0,1,2,3,4,5,6,7]:
            %if sign == '':
    /// Get bit ${bitidx} value
    public var b${bitidx}:${sign}Int${intType}{
        return ( (self.toU${intType} & (0x1 << ${bitidx})) >> ${bitidx} ).to${intType}
    }
    /// Set bit ${bitidx} and return a new ${sign}Int
    public func setb${bitidx}(_ bit:Int)->${sign}Int${intType}{
        let nv = bit != 0 ? 1 : 0
        return ( (self.toU${intType} & ~(0x1 << ${bitidx})) | (nv.toU${intType} << ${bitidx}) ).to${intType}
    }
            %else:
    /// Get bit ${bitidx} value
    public var b${bitidx}:${sign}Int${intType}{
        return (self & (0x1 << ${bitidx})) >> ${bitidx}
    }
    /// Set bit ${bitidx} and return a new ${sign}Int
    public func setb${bitidx}(_ bit:Int)->${sign}Int${intType}{
        let nv = bit != 0 ? 1 : 0
        return (self & ~(0x1 << ${bitidx})) | (nv.toU${intType} << ${bitidx})
    }
            %end
        %end


        %if intType == 8:

    /// Subscript that returns or set one of the bytes of this integer
    /// at the given index.
    /// Trying to access an out of index byte will result in an error.
    public subscript(index: Int) -> ${sign}Int8 {
        get {
            precondition(index<Int8.size,"Byte set index out of range")
            return self
        }
        set(newValue) {
            precondition(index<Int8.size,"Byte set index out of range")
            self = newValue
        }
    }
        %else:

    /// Subscript that returns or set one of the bytes of a ${sign}Int${intType}
    /// at the given index.
    /// Trying to access an out of index byte will result in an error.
    public subscript(index: Int) -> ${sign}Int${intType} {
            %if sign == '':
        get {
            precondition(index<Int${intType}.size,"Byte set index out of range")
            return ((self.toU${intType} & (0xFF << (index.toU${intType}*8))) >> (index.toU${intType}*8)).to${intType}
        }
        set(newValue) {
            precondition(index<Int${intType}.size,"Byte set index out of range")
            self = ( (self.toU${intType} & ~(0xFF << (index.toU${intType}*8))) | (newValue.toU${intType} << (index.toU${intType}*8)) ).to${intType}
        }
            %else:
        get {
            precondition(index<Int${intType}.size,"Byte set index out of range")
            return (self & (0xFF << (index.toU${intType}*8))) >> (index.toU${intType}*8)
        }
        set(newValue) {
            precondition(index<Int${intType}.size,"Byte set index out of range")
            self = (self & ~(0xFF << (index.toU${intType}*8))) | (newValue.toU${intType} << (index.toU${intType}*8))
        }
            %end
    }
        %end
}

    %end
%end


// MARK: Operators

/// Double negation operator
prefix operator ~~

% for intType in intTypes:
    % for sign in ['','U']:
/// Double negation operator for ${sign}Int${intType}
/// Returns 1 if value is not equal to 0, 0 otherwise
prefix func ~~(value: ${sign}Int${intType})->${sign}Int${intType}{
    return (value>0) ? 1 : 0
}
    %end
%end