toilscript 0.0.1 → 0.1.0

package/std/assembly/uri.ts

@@ -1,17 +1,17 @@
-import { encode, decode, URI_UNSAFE, URL_UNSAFE } from "./util/uri";
-
-export function encodeURI(str: string): string {
-  return changetype<string>(encode(changetype<usize>(str), str.length, URI_UNSAFE));
-}
-
-export function decodeURI(str: string): string {
-  return changetype<string>(decode(changetype<usize>(str), str.length, false));
-}
-
-export function encodeURIComponent(str: string): string {
-  return changetype<string>(encode(changetype<usize>(str), str.length, URL_UNSAFE));
-}
-
-export function decodeURIComponent(str: string): string {
-  return changetype<string>(decode(changetype<usize>(str), str.length, true));
-}
+import { encode, decode, URI_UNSAFE, URL_UNSAFE } from "./util/uri";
+
+export function encodeURI(str: string): string {
+  return changetype<string>(encode(changetype<usize>(str), str.length, URI_UNSAFE));
+}
+
+export function decodeURI(str: string): string {
+  return changetype<string>(decode(changetype<usize>(str), str.length, false));
+}
+
+export function encodeURIComponent(str: string): string {
+  return changetype<string>(encode(changetype<usize>(str), str.length, URL_UNSAFE));
+}
+
+export function decodeURIComponent(str: string): string {
+  return changetype<string>(decode(changetype<usize>(str), str.length, true));
+}

package/std/assembly/util/bytes.ts

@@ -1,107 +1,107 @@
-export function REVERSE<T>(ptr: usize, len: usize): void {
-  if (len > 1) {
-    let
-      i: usize = 0,
-      tail: usize,
-      hlen: usize = len >> 1;
-
-    if (ASC_SHRINK_LEVEL < 1) {
-      if (sizeof<T>() == 1) {
-        // TODO: Decide later: Does we need this fast path cases?
-        //
-        // if (len == 4) {
-        //   store<u32>(ptr, bswap(load<u32>(ptr)));
-        //   return;
-        // }
-        // if (len == 8) {
-        //   store<u64>(ptr, bswap(load<u64>(ptr)));
-        //   return;
-        // }
-        tail = len - 8;
-        while (i + 7 < hlen) {
-          let front = ptr + i;
-          let back  = ptr + tail - i;
-          let temp  = bswap(load<u64>(front));
-          store<u64>(front, bswap(load<u64>(back)));
-          store<u64>(back, temp);
-          i += 8;
-        }
-      }
-
-      if (sizeof<T>() == 2) {
-        tail = len - 2;
-        while (i + 1 < hlen) {
-          let front = ptr + (i << 1);
-          let back  = ptr + (tail - i << 1);
-          let temp  = rotr(load<u32>(back), 16);
-          store<u32>(back, rotr(load<u32>(front), 16));
-          store<u32>(front, temp);
-          i += 2;
-        }
-      }
-    }
-
-    tail = len - 1;
-    while (i < hlen) {
-      let front = ptr + (i << alignof<T>());
-      let back  = ptr + (tail - i << alignof<T>());
-      let temp  = load<T>(front);
-      store<T>(front, load<T>(back));
-      store<T>(back, temp);
-      i++;
-    }
-  }
-}
-
-export function FILL<T>(
-  ptr: usize,
-  len: usize,
-  value: T,
-  start: isize,
-  end: isize
-): void {
-  start = start < 0 ? max(len + start, 0) : min(start, len);
-  end   = end   < 0 ? max(len + end,   0) : min(end,   len);
-
-  if (sizeof<T>() == 1) {
-    if (start < end) {
-      memory.fill(
-        ptr + <usize>start,
-        u8(value),
-        <usize>(end - start)
-      );
-    }
-  } else {
-    if (ASC_SHRINK_LEVEL <= 1) {
-      if (isInteger<T>()) {
-        // @ts-ignore
-        if (value == <T>0 | value == <T>-1) {
-          if (start < end) {
-            memory.fill(
-              ptr + (<usize>start << alignof<T>()),
-              u8(value),
-              <usize>(end - start) << alignof<T>()
-            );
-          }
-          return;
-        }
-      } else if (isFloat<T>()) {
-        // for floating non-negative zeros we can use fast memory.fill
-        if ((sizeof<T>() == 4 && reinterpret<u32>(f32(value)) == 0) ||
-            (sizeof<T>() == 8 && reinterpret<u64>(f64(value)) == 0)) {
-          if (start < end) {
-            memory.fill(
-              ptr + (<usize>start << alignof<T>()),
-              0,
-              <usize>(end - start) << alignof<T>()
-            );
-          }
-          return;
-        }
-      }
-    }
-    for (; start < end; ++start) {
-      store<T>(ptr + (<usize>start << alignof<T>()), value);
-    }
-  }
-}
+export function REVERSE<T>(ptr: usize, len: usize): void {
+  if (len > 1) {
+    let
+      i: usize = 0,
+      tail: usize,
+      hlen: usize = len >> 1;
+
+    if (ASC_SHRINK_LEVEL < 1) {
+      if (sizeof<T>() == 1) {
+        // TODO: Decide later: Does we need this fast path cases?
+        //
+        // if (len == 4) {
+        //   store<u32>(ptr, bswap(load<u32>(ptr)));
+        //   return;
+        // }
+        // if (len == 8) {
+        //   store<u64>(ptr, bswap(load<u64>(ptr)));
+        //   return;
+        // }
+        tail = len - 8;
+        while (i + 7 < hlen) {
+          let front = ptr + i;
+          let back  = ptr + tail - i;
+          let temp  = bswap(load<u64>(front));
+          store<u64>(front, bswap(load<u64>(back)));
+          store<u64>(back, temp);
+          i += 8;
+        }
+      }
+
+      if (sizeof<T>() == 2) {
+        tail = len - 2;
+        while (i + 1 < hlen) {
+          let front = ptr + (i << 1);
+          let back  = ptr + (tail - i << 1);
+          let temp  = rotr(load<u32>(back), 16);
+          store<u32>(back, rotr(load<u32>(front), 16));
+          store<u32>(front, temp);
+          i += 2;
+        }
+      }
+    }
+
+    tail = len - 1;
+    while (i < hlen) {
+      let front = ptr + (i << alignof<T>());
+      let back  = ptr + (tail - i << alignof<T>());
+      let temp  = load<T>(front);
+      store<T>(front, load<T>(back));
+      store<T>(back, temp);
+      i++;
+    }
+  }
+}
+
+export function FILL<T>(
+  ptr: usize,
+  len: usize,
+  value: T,
+  start: isize,
+  end: isize
+): void {
+  start = start < 0 ? max(len + start, 0) : min(start, len);
+  end   = end   < 0 ? max(len + end,   0) : min(end,   len);
+
+  if (sizeof<T>() == 1) {
+    if (start < end) {
+      memory.fill(
+        ptr + <usize>start,
+        u8(value),
+        <usize>(end - start)
+      );
+    }
+  } else {
+    if (ASC_SHRINK_LEVEL <= 1) {
+      if (isInteger<T>()) {
+        // @ts-ignore
+        if (value == <T>0 | value == <T>-1) {
+          if (start < end) {
+            memory.fill(
+              ptr + (<usize>start << alignof<T>()),
+              u8(value),
+              <usize>(end - start) << alignof<T>()
+            );
+          }
+          return;
+        }
+      } else if (isFloat<T>()) {
+        // for floating non-negative zeros we can use fast memory.fill
+        if ((sizeof<T>() == 4 && reinterpret<u32>(f32(value)) == 0) ||
+            (sizeof<T>() == 8 && reinterpret<u64>(f64(value)) == 0)) {
+          if (start < end) {
+            memory.fill(
+              ptr + (<usize>start << alignof<T>()),
+              0,
+              <usize>(end - start) << alignof<T>()
+            );
+          }
+          return;
+        }
+      }
+    }
+    for (; start < end; ++start) {
+      store<T>(ptr + (<usize>start << alignof<T>()), value);
+    }
+  }
+}