Initial

Utils/private/Utils.cpp

@@ -0,0 +1,94 @@
+
+#include "Utils.hpp"
+
+#include "ContainersCommon.hpp"
+
+#include "Testing.hpp"
+
+#include <random>
+
+void initializeCallStackCapture();
+void deinitializeCallStackCapture();
+
+static bool initialize(const tp::ModuleManifest* self) {
+  initializeCallStackCapture();
+  return true;
+}
+
+static void deinitialize(const tp::ModuleManifest* self) {
+  deinitializeCallStackCapture();
+  tp::gTesting.reportState();
+  if (tp::gTesting.hasFailed()) { exit(1); }
+}
+
+namespace tp {
+
+  static ModuleManifest* sModuleUtilsDeps[] = { &gModuleContainers, nullptr };
+  ModuleManifest gModuleUtils = ModuleManifest("Utils", initialize, deinitialize, sModuleUtilsDeps);
+
+  void memsetv(void* p, uhalni bytesize, uint1 val) {
+    MODULE_SANITY_CHECK(gModuleBase)
+
+    alni alignedval = 0;
+    for (ualni idx = 0; idx < sizeof(alni); idx++) {
+      ((uint1*) &alignedval)[idx] = val;
+    }
+
+    ualni alignedlen = bytesize / sizeof(alni);
+    for (ualni idx = 0; idx < alignedlen; idx++) {
+      ((alni*) p)[idx] = alignedval;
+    }
+
+    ualni unalignedlen = bytesize - (alignedlen * sizeof(alni));
+    for (ualni idx = 0; idx < unalignedlen; idx++) {
+      ((uint1*) p)[bytesize - idx - 1] = val;
+    }
+  }
+
+  void memcp(void* left, const void* right, uhalni len) {
+    MODULE_SANITY_CHECK(gModuleBase)
+
+    ualni alignedlen = len / sizeof(alni);
+    for (ualni idx = 0; idx < alignedlen; idx++) {
+      ((alni*) left)[idx] = ((alni*) right)[idx];
+    }
+
+    ualni unalignedlen = len - (alignedlen * sizeof(alni));
+    for (ualni idx = 0; idx < unalignedlen; idx++) {
+      ((uint1*) left)[len - idx - 1] = ((uint1*) right)[len - idx - 1];
+    }
+  }
+
+  int1 memecomp(const void* left, const void* right, uhalni len) {
+    MODULE_SANITY_CHECK(gModuleBase)
+    if (!len) return 0;
+
+    ualni alignedLength = len / sizeof(alni);
+    for (ualni idx = 0; idx < alignedLength; idx++) {
+      if (((alni*) left)[idx] == ((alni*) right)[idx]) {
+        continue;
+      }
+      if (((alni*) left)[idx] > ((alni*) right)[idx]) {
+        return 1;
+      }
+      return -1;
+    }
+
+    ualni unalignedLength = len - (alignedLength * sizeof(alni));
+    for (ualni idx = 0; idx < unalignedLength; idx++) {
+      if (((uint1*) left)[len - idx - 1] == ((uint1*) right)[len - idx - 1]) {
+        continue;
+      }
+      if (((uint1*) left)[len - idx - 1] > ((uint1*) right)[len - idx - 1]) {
+        return 1;
+      }
+      return -1;
+    }
+    return 0;
+  }
+
+  alnf randf() {
+    alnf r = static_cast<alnf>(std::rand()) / static_cast<alnf>(RAND_MAX);
+    return r;
+  }
+}