//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
///
/// This file contains Swift wrappers for functions defined in the C++ runtime.
///
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
// Conversion of primitive types to `String`
//===----------------------------------------------------------------------===//

/// A 32 byte buffer.
struct _Buffer32 {
  var x0: UInt64 = 0
  var x1: UInt64 = 0
  var x2: UInt64 = 0
  var x3: UInt64 = 0
}

/// A 72 byte buffer.
struct _Buffer72 {
  var x0: UInt64 = 0
  var x1: UInt64 = 0
  var x2: UInt64 = 0
  var x3: UInt64 = 0
  var x4: UInt64 = 0
  var x5: UInt64 = 0
  var x6: UInt64 = 0
  var x7: UInt64 = 0
  var x8: UInt64 = 0
}

% for bits in [ 32, 64, 80 ]:

% if bits == 80:
#if arch(i386) || arch(x86_64)
% end

@asmname("swift_float${bits}ToString")
func _float${bits}ToStringImpl(
  buffer: UnsafeMutablePointer<UTF8.CodeUnit>,
  bufferLength: UWord, value: Float${bits}
) -> UWord

func _float${bits}ToString(value: Float${bits}) -> String {
  _sanityCheck(sizeof(_Buffer32.self) == 32)
  _sanityCheck(sizeof(_Buffer72.self) == 72)

  var buffer = _Buffer32()
  return withUnsafeMutablePointer(&buffer) {
    (bufferPtr) in
    let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
    let actualLength = _float${bits}ToStringImpl(bufferUTF8Ptr, 32, value)
    return String._fromWellFormedCodeUnitSequence(
      UTF8.self,
      input: UnsafeBufferPointer(
        start: bufferUTF8Ptr, count: Int(actualLength)))
  }
}

% if bits == 80:
#endif
% end

% end

@asmname("swift_int64ToString")
func _int64ToStringImpl(
  buffer: UnsafeMutablePointer<UTF8.CodeUnit>,
  bufferLength: UWord, value: Int64,
  radix: Int64, uppercase: Bool
) -> UWord

func _int64ToString(
  value: Int64, radix: Int64 = 10, uppercase: Bool = false
) -> String {
  if radix >= 10 {
    var buffer = _Buffer32()
    return withUnsafeMutablePointer(&buffer) {
      (bufferPtr) in
      let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
      let actualLength =
        _int64ToStringImpl(bufferUTF8Ptr, 32, value, radix, uppercase)
      return String._fromWellFormedCodeUnitSequence(
        UTF8.self,
        input: UnsafeBufferPointer(
          start: bufferUTF8Ptr, count: Int(actualLength)))
    }
  } else {
    var buffer = _Buffer72()
    return withUnsafeMutablePointer(&buffer) {
      (bufferPtr) in
      let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
      let actualLength =
        _int64ToStringImpl(bufferUTF8Ptr, 72, value, radix, uppercase)
      return String._fromWellFormedCodeUnitSequence(
        UTF8.self,
        input: UnsafeBufferPointer(
          start: bufferUTF8Ptr, count: Int(actualLength)))
    }
  }
}

@asmname("swift_uint64ToString")
func _uint64ToStringImpl(
  buffer: UnsafeMutablePointer<UTF8.CodeUnit>,
  bufferLength: UWord, value: UInt64, radix: Int64, uppercase: Bool
) -> UWord

func _uint64ToString(
    value: UInt64, radix: Int64 = 10, uppercase: Bool = false
) -> String {
  if radix >= 10 {
    var buffer = _Buffer32()
    return withUnsafeMutablePointer(&buffer) {
      (bufferPtr) in
      let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
      let actualLength =
        _uint64ToStringImpl(bufferUTF8Ptr, 32, value, radix, uppercase)
      return String._fromWellFormedCodeUnitSequence(
        UTF8.self,
        input: UnsafeBufferPointer(
          start: bufferUTF8Ptr, count: Int(actualLength)))
    }
  } else {
    var buffer = _Buffer72()
    return withUnsafeMutablePointer(&buffer) {
      (bufferPtr) in
      let bufferUTF8Ptr = UnsafeMutablePointer<UTF8.CodeUnit>(bufferPtr)
      let actualLength =
        _uint64ToStringImpl(bufferUTF8Ptr, 72, value, radix, uppercase)
      return String._fromWellFormedCodeUnitSequence(
        UTF8.self,
        input: UnsafeBufferPointer(
          start: bufferUTF8Ptr, count: Int(actualLength)))
    }
  }
}

func _rawPointerToString(value: Builtin.RawPointer) -> String {
  var result = _uint64ToString(
    UInt64(unsafeBitCast(value, UWord.self)), radix: 16, uppercase: false)
  for i in 0..<(2 * sizeof(Builtin.RawPointer) - countElements(result)) {
    result = "0" + result
  }
  return "0x" + result
}