Remove kotlin-native/common/src/hash

It is no longer used.

kotlin-native/common/build.gradle.kts

@@ -8,9 +8,6 @@ plugins {
 }
 
 bitcode {
-    create("hash") {
-        dependsOn(":kotlin-native:dependencies:update")
-    }
     create("files"){
         dependsOn(":kotlin-native:dependencies:update")
     }
@@ -19,7 +16,6 @@ bitcode {
 val hostName: String by project
 
 val build by tasks.registering {
-    dependsOn("${hostName}Hash")
     dependsOn("${hostName}Files")
 }
 

kotlin-native/common/src/hash/cpp/Base64.cpp

@@ -1,184 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <string.h>
-#include <stdint.h>
-
-#include "Base64.h"
-
-namespace {
-
-// From https://en.wikibooks.org/wiki/Algorithm_Implementation/Miscellaneous/Base64
-// with minor tweaks.
-
-#define WHITESPACE 64
-#define EQUALS     65
-#define INVALID    66
-
-const char kAlphabet[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-static const unsigned char kDecode[] = {
-    66,66,66,66,66,66,66,66,66,66,64,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,62,66,66,66,63,52,53,
-    54,55,56,57,58,59,60,61,66,66,66,65,66,66,66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-    10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,66,66,66,66,66,66,26,27,28,
-    29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,
-    66,66,66,66,66,66
-};
-
-}  // namespace
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int EncodeBase64(
-    const void* dataBuf, uint32_t dataLength, void* resultBuf, uint32_t resultSize) {
-  char *result = reinterpret_cast<char*>(resultBuf);
-  const uint8_t *data = reinterpret_cast<const uint8_t*>(dataBuf);
-  size_t resultIndex = 0;
-  size_t x;
-  uint32_t n = 0;
-  int padCount = dataLength % 3;
-  uint8_t n0, n1, n2, n3;
-
-  /* increment over the length of the string, three characters at a time */
-  for (x = 0; x < dataLength; x += 3) {
-    /* these three 8-bit (ASCII) characters become one 24-bit number */
-    n = ((uint32_t)data[x]) << 16;
-
-    if ((x+1) < dataLength)
-      n += ((uint32_t)data[x+1]) << 8;
-
-    if ((x+2) < dataLength)
-      n += data[x+2];
-
-    /* this 24-bit number gets separated into four 6-bit numbers */
-    n0 = (uint8_t)(n >> 18) & 63;
-    n1 = (uint8_t)(n >> 12) & 63;
-    n2 = (uint8_t)(n >> 6) & 63;
-    n3 = (uint8_t)n & 63;
-
-    /*
-     * if we have one byte available, then its encoding is spread
-     * out over two characters
-     */
-    if (resultIndex >= resultSize)
-      return 1;   /* indicate failure: buffer too small */
-    result[resultIndex++] = kAlphabet[n0];
-    if (resultIndex >= resultSize)
-      return 1;   /* indicate failure: buffer too small */
-    result[resultIndex++] = kAlphabet[n1];
-
-    /*
-     * if we have only two bytes available, then their encoding is
-     * spread out over three chars
-     */
-    if ((x+1) < dataLength) {
-      if (resultIndex >= resultSize)
-        return 1;   /* indicate failure: buffer too small */
-      result[resultIndex++] = kAlphabet[n2];
-    }
-
-    /*
-     * if we have all three bytes available, then their encoding is spread
-     * out over four characters
-     */
-    if ((x+2) < dataLength) {
-      if (resultIndex >= resultSize)
-        return 1;   /* indicate failure: buffer too small */
-      result[resultIndex++] = kAlphabet[n3];
-    }
-  }
-
-   /*
-    * create and add padding that is required if we did not have a multiple of 3
-    * number of characters available
-    */
-   if (padCount > 0) {
-      for (; padCount < 3; padCount++) {
-         if (resultIndex >= resultSize)
-           return 1;   /* indicate failure: buffer too small */
-         result[resultIndex++] = '=';
-      }
-   }
-   if (resultIndex >= resultSize)
-     return 1;   /* indicate failure: buffer too small */
-
-   result[resultIndex] = 0;
-
-   return 0;   /* indicate success */
-}
-
-int DecodeBase64(
-    const char *in, uint32_t inLen, void* outBuf, uint32_t* outLen) {
-  uint8_t* out = reinterpret_cast<uint8_t*>(outBuf);
-  const char* end = in + inLen;
-  char iter = 0;
-  size_t buf = 0, len = 0;
-
-  while (in < end) {
-    // char may be a signed type. Explicitly convert it to an unsigned byte,
-    // so that indexing into kDecode array is safe. The latter has exactly
-    // 256 elements, so any unsigned byte value is valid.
-    uint8_t index = *in++;
-    unsigned char c = kDecode[index];
-
-    switch (c) {
-      case WHITESPACE: continue;   /* skip whitespace */
-      case INVALID:    return 1;   /* invalid input, return error */
-      case EQUALS:                 /* pad character, end of data */
-        in = end;
-        continue;
-      default:
-        buf = buf << 6 | c;
-        iter++; // increment the number of iteration
-        /* If the buffer is full, split it into bytes */
-        if (iter == 4) {
-          if ((len += 3) > *outLen)
-            return 1; /* buffer overflow */
-          *(out++) = (buf >> 16) & 255;
-          *(out++) = (buf >> 8) & 255;
-          *(out++) = buf & 255;
-          buf = 0; iter = 0;
-        }
-    }
-  }
-
-  if (iter == 3) {
-    if ((len += 2) > *outLen)
-      return 1; /* buffer overflow */
-    *(out++) = (buf >> 10) & 255;
-    *(out++) = (buf >> 2) & 255;
-  }
-  else if (iter == 2) {
-    if (++len > *outLen)
-      return 1; /* buffer overflow */
-    *(out++) = (buf >> 4) & 255;
-  }
-
-  *outLen = len; /* modify to reflect the actual output size */
-  return 0;
-}
-
-#ifdef __cplusplus
-}
-#endif

kotlin-native/common/src/hash/cpp/City.cpp

@@ -1,224 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "City.h"
-
-#include <string.h>
-
-#include <algorithm>
-
-namespace {
-
-// Some primes between 2^63 and 2^64 for various uses.
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t k1 = 0xb492b66fbe98f273ULL;
-static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
-
-uint64_t UNALIGNED_LOAD64(const char *p) {
-  uint64_t result;
-  memcpy(&result, p, sizeof(result));
-  return result;
-}
-
-uint32_t UNALIGNED_LOAD32(const char *p) {
-  uint32_t result;
-  memcpy(&result, p, sizeof(result));
-  return result;
-}
-
-#define bswap32(x) __builtin_bswap32(x)
-#define bswap64(x) __builtin_bswap64(x)
-
-#ifdef WORDS_BIGENDIAN
-#define uint32_in_expected_order(x) (bswap32(x))
-#define uint64_in_expected_order(x) (bswap64(x))
-#else
-#define uint32_in_expected_order(x) (x)
-#define uint64_in_expected_order(x) (x)
-#endif
-
-uint64_t Fetch64(const char *p) {
-  return uint64_in_expected_order(UNALIGNED_LOAD64(p));
-}
-
-uint32_t Fetch32(const char *p) {
-  return uint32_in_expected_order(UNALIGNED_LOAD32(p));
-}
-
-// Bitwise right rotate.  Normally this will compile to a single
-// instruction, especially if the shift is a manifest constant.
-uint64_t Rotate(uint64_t val, int shift) {
-  // Avoid shifting by 64: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-}
-
-uint64_t ShiftMix(uint64_t val) {
-  return val ^ (val >> 47);
-}
-
-uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) {
-  // Murmur-inspired hashing.
-  uint64_t a = (u ^ v) * mul;
-  a ^= (a >> 47);
-  uint64_t b = (v ^ a) * mul;
-  b ^= (b >> 47);
-  b *= mul;
-  return b;
-}
-
-typedef std::pair<uint64_t, uint64_t> uint128_t;
-
-uint64_t Hash128to64(const uint128_t& x) {
-  // Murmur-inspired hashing.
-  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-  uint64_t a = (x.first ^ x.second) * kMul;
-  a ^= (a >> 47);
-  uint64_t b = (x.second ^ a) * kMul;
-  b ^= (b >> 47);
-  b *= kMul;
-  return b;
-}
-
-uint64_t HashLen16(uint64_t u, uint64_t v) {
-  return Hash128to64(uint128_t(u, v));
-}
-
-uint64_t HashLen0to16(const char *s, size_t len) {
-  if (len >= 8) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch64(s) + k2;
-    uint64_t b = Fetch64(s + len - 8);
-    uint64_t c = Rotate(b, 37) * mul + a;
-    uint64_t d = (Rotate(a, 25) + b) * mul;
-    return HashLen16(c, d, mul);
-  }
-  if (len >= 4) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch32(s);
-    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-  }
-  if (len > 0) {
-    uint8_t a = s[0];
-    uint8_t b = s[len >> 1];
-    uint8_t c = s[len - 1];
-    uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
-    uint32_t z = len + (static_cast<uint32_t>(c) << 2);
-    return ShiftMix(y * k2 ^ z * k0) * k2;
-  }
-  return k2;
-}
-
-// This probably works well for 16-byte strings as well, but it may be overkill
-// in that case.
-static uint64_t HashLen17to32(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k1;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 8) * mul;
-  uint64_t d = Fetch64(s + len - 16) * k2;
-  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
-                   a + Rotate(b + k2, 18) + c, mul);
-}
-
-// Return a 16-byte hash for 48 bytes.  Quick and dirty.
-// Callers do best to use "random-looking" values for a and b.
-std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
-    uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) {
-  a += w;
-  b = Rotate(b + a + z, 21);
-  uint64_t c = a;
-  a += x;
-  a += y;
-  b += Rotate(a, 44);
-  return std::make_pair(a + z, b + c);
-}
-
-// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
-    const char* s, uint64_t a, uint64_t b) {
-  return WeakHashLen32WithSeeds(Fetch64(s),
-                                Fetch64(s + 8),
-                                Fetch64(s + 16),
-                                Fetch64(s + 24),
-                                a,
-                                b);
-}
-
-// Return an 8-byte hash for 33 to 64 bytes.
-uint64_t HashLen33to64(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k2;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 24);
-  uint64_t d = Fetch64(s + len - 32);
-  uint64_t e = Fetch64(s + 16) * k2;
-  uint64_t f = Fetch64(s + 24) * 9;
-  uint64_t g = Fetch64(s + len - 8);
-  uint64_t h = Fetch64(s + len - 16) * mul;
-  uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-  uint64_t v = ((a + g) ^ d) + f + 1;
-  uint64_t w = bswap64((u + v) * mul) + h;
-  uint64_t x = Rotate(e + f, 42) + c;
-  uint64_t y = (bswap64((v + w) * mul) + g) * mul;
-  uint64_t z = e + f + c;
-  a = bswap64((x + z) * mul + y) + b;
-  b = ShiftMix((z + a) * mul + d + h) * mul;
-  return b + x;
-}
-
-} // namespace
-
-extern "C" {
-
-uint64_t CityHash64(const void* data, size_t len) {
-  const char* s = reinterpret_cast<const char*>(data);
-  if (len <= 32) {
-    if (len <= 16) {
-      return HashLen0to16(s, len);
-    } else {
-      return HashLen17to32(s, len);
-    }
-  } else if (len <= 64) {
-    return HashLen33to64(s, len);
-  }
-
-  // For strings over 64 bytes we hash the end first, and then as we
-  // loop we keep 56 bytes of state: v, w, x, y, and z.
-  uint64_t x = Fetch64(s + len - 40);
-  uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-  uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-  std::pair<uint64_t, uint64_t> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-  std::pair<uint64_t, uint64_t> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-  x = x * k1 + Fetch64(s);
-
-  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-  len = (len - 1) & ~static_cast<size_t>(63);
-  do {
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    len -= 64;
-  } while (len != 0);
-  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                   HashLen16(v.second, w.second) + x);
-}
-
-} // extern "C"

kotlin-native/common/src/hash/cpp/Names.cpp

@@ -1,70 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <cassert>
-
-#include "Names.h"
-
-#include "Base64.h"
-#include "City.h"
-#include "Sha1.h"
-
-namespace {
-
-constexpr uint32_t PrintableBase64Size(uint32_t input_length) {
-  return ((input_length + 2) / 3 * 4) + 1;
-}
-
-void PrintableBase64(const uint8_t* data, uint32_t data_length, char* base64) {
-  int rv = EncodeBase64(data, data_length, base64, PrintableBase64Size(data_length));
-  assert(rv == 0);
-}
-
-} // namespace
-
-extern "C" {
-
-// Make local hash out of arbitrary data.
-void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash) {
-  *hash = CityHash64(data, size);
-}
-
-// Make global hash out of arbitrary data.
-void MakeGlobalHash(const void* data, uint32_t size, GlobalHash* hash) {
-  SHA1_CTX ctx;
-  SHA1Init(&ctx);
-  SHA1Update(&ctx, reinterpret_cast<const unsigned char *>(data), size);
-  SHA1Final(&hash->bits[0], &ctx);
-}
-
-// Make printable C string out of local hash.
-void PrintableLocalHash(const LocalHash* hash, char* buffer, uint32_t size) {
-  if (size < PrintableBase64Size(sizeof(*hash))) {
-    assert(false);
-    return;
-  }
-  PrintableBase64(reinterpret_cast<const uint8_t*>(&hash), sizeof(*hash), buffer);
-}
-
-// Make printable C string out of global hash.
-void PrintableGlobalHash(const GlobalHash* hash, char* buffer, uint32_t size) {
-  if (size < PrintableBase64Size(sizeof(*hash))) {
-    assert(false);
-    return;
-  }
-  PrintableBase64(hash->bits, sizeof(*hash), buffer);
-}
-
-} // extern "C"

kotlin-native/common/src/hash/cpp/Sha1.cpp

@@ -1,190 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
-SHA-1 in C
-By Steve Reid <steve@edmweb.com>
-100% Public Domain
-
-Test Vectors (from FIPS PUB 180-1)
-"abc"
-  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
-"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
-  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
-A million repetitions of "a"
-  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
-*/
-
-/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
-/* #define SHA1HANDSOFF * Copies data before messing with it. */
-
-#define SHA1HANDSOFF
-
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-
-#include "Sha1.h"
-
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
-
-/* blk0() and blk() perform the initial expand. */
-/* I got the idea of expanding during the round function from SSLeay */
-#if BYTE_ORDER == LITTLE_ENDIAN
-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
-    |(rol(block->l[i],8)&0x00FF00FF))
-#elif BYTE_ORDER == BIG_ENDIAN
-#define blk0(i) block->l[i]
-#else
-#error "Endianness not defined!"
-#endif
-#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
-
-/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
-
-/* Hash a single 512-bit block. This is the core of the algorithm. */
-static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
-{
-    uint32_t a, b, c, d, e;
-    typedef union {
-        unsigned char c[64];
-        uint32_t l[16];
-    } CHAR64LONG16;
-#ifdef SHA1HANDSOFF
-    CHAR64LONG16 block[1];  /* use array to appear as a pointer */
-    memcpy(block, buffer, 64);
-#else
-    /* The following had better never be used because it causes the
-     * pointer-to-const buffer to be cast into a pointer to non-const.
-     * And the result is written through.  I threw a "const" in, hoping
-     * this will cause a diagnostic.
-     */
-    CHAR64LONG16* block = (const CHAR64LONG16*)buffer;
-#endif
-    /* Copy context->state[] to working vars */
-    a = state[0];
-    b = state[1];
-    c = state[2];
-    d = state[3];
-    e = state[4];
-    /* 4 rounds of 20 operations each. Loop unrolled. */
-    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
-    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
-    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
-    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
-    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
-    /* Add the working vars back into context.state[] */
-    state[0] += a;
-    state[1] += b;
-    state[2] += c;
-    state[3] += d;
-    state[4] += e;
-    /* Wipe variables */
-    a = b = c = d = e = 0;
-#ifdef SHA1HANDSOFF
-    memset(block, '\0', sizeof(block));
-#endif
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* SHA1Init - Initialize new context */
-void SHA1Init(SHA1_CTX* context)
-{
-    /* SHA1 initialization constants */
-    context->state[0] = 0x67452301;
-    context->state[1] = 0xEFCDAB89;
-    context->state[2] = 0x98BADCFE;
-    context->state[3] = 0x10325476;
-    context->state[4] = 0xC3D2E1F0;
-    context->count[0] = context->count[1] = 0;
-}
-
-
-/* Run your data through this. */
-void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)
-{
-    uint32_t i, j;
-
-    j = context->count[0];
-    if ((context->count[0] += len << 3) < j)
-        context->count[1]++;
-    context->count[1] += (len>>29);
-    j = (j >> 3) & 63;
-    if ((j + len) > 63) {
-        memcpy(&context->buffer[j], data, (i = 64-j));
-        SHA1Transform(context->state, context->buffer);
-        for ( ; i + 63 < len; i += 64) {
-            SHA1Transform(context->state, &data[i]);
-        }
-        j = 0;
-    }
-    else i = 0;
-    memcpy(&context->buffer[j], &data[i], len - i);
-}
-
-/* Add padding and return the message digest. */
-void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
-{
-    unsigned i;
-    unsigned char finalcount[8];
-    unsigned char c;
-
-    for (i = 0; i < 8; i++) {
-        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
-         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
-    }
-    c = 0200;
-    SHA1Update(context, &c, 1);
-    while ((context->count[0] & 504) != 448) {
-        c = 0000;
-        SHA1Update(context, &c, 1);
-    }
-    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
-    for (i = 0; i < 20; i++) {
-        digest[i] = (unsigned char)
-         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-    }
-    /* Wipe variables */
-    memset(context, '\0', sizeof(*context));
-    memset(&finalcount, '\0', sizeof(finalcount));
-}
-
-#ifdef __cplusplus
-}
-#endif

kotlin-native/common/src/hash/headers/Base64.h

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef COMMON_BASE64_H
-#define COMMON_BASE64_H
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int EncodeBase64(
-    const void* input, uint32_t inputLen, void* output, uint32_t outputLen);
-
-int DecodeBase64(
-    const char* input, uint32_t inputLen, void* output, uint32_t* outputLen);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // COMMON_BASE64_H

kotlin-native/common/src/hash/headers/City.h

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef COMMON_CITY_H
-#define COMMON_CITY_H
-
-// CityHash, by Geoff Pike and Jyrki Alakuijala.
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Hash function for a byte array.
-uint64_t CityHash64(const void* buf, size_t len);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // COMMON_CITY_H

kotlin-native/common/src/hash/headers/Names.h

@@ -1,58 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef COMMON_NAMES_H
-#define COMMON_NAMES_H
-
-#include <stdint.h>
-
-// All names in system are stored as hashes (or maybe, for debug builds,
-// as pointers to uniqued C strings containing names?).
-// There are two types of hashes:
-//  - local hash, must be unique per class/scope (CityHash64 is being used)
-//  - global hash, must be unique globally (SHA1 is being used)
-// Generic guideline is that global hash is being used in global persistent
-// context, while local hashes are more local in scope.
-// Local hash.
-typedef int64_t LocalHash;
-// Hash of field name.
-typedef LocalHash FieldNameHash;
-// Hash of open method name.
-typedef LocalHash MethodNameHash;
-// Global hash.
-typedef struct {
-  uint8_t bits[20];
-} GlobalHash;
-// Hash of function name.
-typedef GlobalHash FunctionNameHash;
-// Hash of class name.
-typedef GlobalHash ClassNameHash;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// Make local hash out of arbitrary data.
-void MakeLocalHash(const void* data, uint32_t size, LocalHash* hash);
-// Make global hash out of arbitrary data.
-void MakeGlobalHash(const void* data, uint32_t size, GlobalHash* hash);
-// Make printable C string out of local hash.
-void PrintableLocalHash(const LocalHash* hash, char* buffer, uint32_t size);
-// Make printable C string out of global hash.
-void PrintableGlobalHash(const GlobalHash* hash, char* buffer, uint32_t size);
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // COMMON_NAMES_H

kotlin-native/common/src/hash/headers/Sha1.h

@@ -1,45 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef COMMON_SHA1_H
-#define COMMON_SHA1_H
-
-#include <stdint.h>
-
-/*
-SHA-1 in C
-By Steve Reid <steve@edmweb.com>
-100% Public Domain
-*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SHA1_CTX {
-    uint32_t state[5];
-    uint32_t count[2];
-    unsigned char buffer[64];
-} SHA1_CTX;
-
-void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
-void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // COMMON_SHA1_H