Formated and linted

Author: perseoGI

examples/cross_build/wasm/bindigs/CMakeLists.txt

@@ -15,10 +15,6 @@ install(TARGETS wasm_example DESTINATION "."
 # Required for Emscripten + embind
 set(CMAKE_EXECUTABLE_SUFFIX ".html")
 
-# set_target_properties(wasm_example PROPERTIES
-#     LINK_FLAGS "-sEXPORTED_FUNCTIONS=['_malloc','_free'] -sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','getValue','setValue'] -sENVIRONMENT=web -sALLOW_MEMORY_GROWTH=1 -sNO_EXIT_RUNTIME=1  --shell-file ${CMAKE_SOURCE_DIR}/shell.html"
-# )
-
 set_target_properties(wasm_example PROPERTIES
     LINK_FLAGS
         "-sEXPORTED_FUNCTIONS=['_malloc','_free'] \

examples/cross_build/wasm/bindigs/main.cpp

@@ -1,7 +1,7 @@
+#include <Eigen/Core>
 #include <cstdint>
 #include <emscripten/emscripten.h>
 #include <iostream>
-#include <Eigen/Core>
 #include <string>
 
 #ifdef __cplusplus
@@ -10,46 +10,42 @@
 #define EXTERN
 #endif
 
-
-EXTERN EMSCRIPTEN_KEEPALIVE
-uint32_t fib(uint32_t n) {
-    std::cout << "Calculating Fibonacci for n = " << n << std::endl;
-    if (n <= 1) return n;
-    uint32_t a = 0, b = 1, c;
-    for (uint32_t i = 2; i <= n; ++i) {
-        c = a + b;
-        a = b;
-        b = c;
-    }
-    return c;
+EXTERN EMSCRIPTEN_KEEPALIVE uint32_t fib(uint32_t n) {
+  std::cout << "Calculating Fibonacci for n = " << n << std::endl;
+  if (n <= 1)
+    return n;
+  uint32_t a = 0, b = 1, c;
+  for (uint32_t i = 2; i <= n; ++i) {
+    c = a + b;
+    a = b;
+    b = c;
+  }
+  return c;
 }
 
-EXTERN EMSCRIPTEN_KEEPALIVE
-void printMessage(const char* message) {
-    std::cout << "Message from C: " << message << std::endl;
-    std::string script = "alert('Message from C++: " + std::string(message) + "')";
-    std::cout << "Executing script: " << script << std::endl;
-    emscripten_run_script(script.c_str());
+EXTERN EMSCRIPTEN_KEEPALIVE void printMessage(const char *message) {
+  std::cout << "Message from C: " << message << std::endl;
+  std::string script =
+      "alert('Message from C++: " + std::string(message) + "')";
+  std::cout << "Executing script: " << script << std::endl;
+  emscripten_run_script(script.c_str());
 }
 
-EXTERN EMSCRIPTEN_KEEPALIVE
-void addOne(int32_t *input, int32_t *output){
-    *output = *input + 1;
+EXTERN EMSCRIPTEN_KEEPALIVE void addOne(int32_t *input, int32_t *output) {
+  *output = *input + 1;
 }
 
-EXTERN EMSCRIPTEN_KEEPALIVE
-float sumArray(const float* data, int32_t size) {
-    // print data input 
-    std::cout << "Data input: ";
-    for (int i = 0; i < size; ++i) {
-        std::cout << data[i] << " ";
-    }
-    std::cout << std::endl;
-    Eigen::Map<const Eigen::ArrayXf> vec(data, size);
-    return vec.sum();
+EXTERN EMSCRIPTEN_KEEPALIVE float sumArray(const float *data, int32_t size) {
+  // print data input
+  std::cout << "Data input: ";
+  for (int i = 0; i < size; ++i) {
+    std::cout << data[i] << " ";
+  }
+  std::cout << std::endl;
+  Eigen::Map<const Eigen::ArrayXf> vec(data, size);
+  return vec.sum();
 }
 
-
 int main() {
   std::cout << "Hello World!" << std::endl;
   auto data = new float[5]{1.0f, 2.0f, 3.0f, 4.0f, 5.0f};

examples/cross_build/wasm/bindigs/shell.html

@@ -96,7 +96,7 @@ <h1>Conan C++ WebAssembly Example</h1>
 
       // Example of auto string handle by WASM on simple string parameter passing
       const printMessage = () => {
-        var printer = Module.ccall(
+        Module.ccall(
           "printMessage",
           null,
           ["string"],
@@ -106,48 +106,51 @@ <h1>Conan C++ WebAssembly Example</h1>
 
       // Example of a simple invocation to fibonachi
       const fibExample = () => {
-        var fib = Module.cwrap("fib", "number", ["number"]); // returns a number
-        var input = parseInt(document.getElementById("fibInput").value);
+        const fib = Module.cwrap("fib", "number", ["number"]); // returns a number
+        const input = parseInt(document.getElementById("fibInput").value);
         if (isNaN(input)) {
           alert("Please enter a valid integer.");
           return;
         }
-        var result = fib(input);
+        const result = fib(input);
         document.getElementById("fibResult").textContent =
           "Fibonacci of " + input + " is: " + result;
       };
 
       var value = 0; // (static) value to increment by one
       const pressBtn = () => {
-        var addOne = Module.cwrap("addOne", null, ["number", "number"]); // void function
+        const addOne = Module.cwrap("addOne", null, ["number", "number"]); // void function
         // alloc 4 bytes of memory for the input and 4 for the output (32-bit integers)
-        var input_ptr = Module._malloc(4);
-        var output_ptr = Module._malloc(4);
+        const inputPtr = Module._malloc(4);
+        const outputPtr = Module._malloc(4);
 
-        Module.setValue(input_ptr, value, "i32"); // set the value in WASM memory
-        addOne(input_ptr, output_ptr); // call the WASM function
-        var result = Module.getValue(output_ptr, "i32"); // extract the result from WASM memory
+        Module.setValue(inputPtr, value, "i32");
+        addOne(inputPtr, outputPtr);
+        const result = Module.getValue(outputPtr, "i32");
         value = result;
         document.getElementById("counterResult").textContent = "Sum: " + result;
 
         // dealloc memory to avoid memory leaks
-        Module._free(input_ptr);
-        Module._free(output_ptr);
+        Module._free(inputPtr);
+        Module._free(outputPtr);
       };
 
       const sumExample = () => {
-        var sumArray = Module.cwrap("sumArray", "number", ["number", "number"]);
+        const sumArray = Module.cwrap("sumArray", "number", [
+          "number",
+          "number",
+        ]);
         // Get the input string and split by commas
         const inputStr = document.getElementById("numbersInput").value;
         const numberStrings = inputStr.split(",").map((s) => s.trim());
 
         // Convert to Float32Array
         const inputArray = new Float32Array(numberStrings.map(Number));
-        var len = inputArray.length;
-        var bytesPerElement = inputArray.BYTES_PER_ELEMENT;
-        var inputPtr = Module._malloc(len * bytesPerElement);
+        const len = inputArray.length;
+        const bytesPerElement = inputArray.BYTES_PER_ELEMENT;
+        const inputPtr = Module._malloc(len * bytesPerElement);
         Module.HEAPF32.set(inputArray, inputPtr / bytesPerElement);
-        var result = sumArray(inputPtr, len);
+        const result = sumArray(inputPtr, len);
         Module._free(inputPtr);
         document.getElementById("sumResult").textContent = "Sum: " + result;
       };

examples/cross_build/wasm/wasm64/main.cpp

@@ -1,34 +1,37 @@
-#include <iostream>
-#include <vector>
 #include <cstdlib>
 #include <cstring>
+#include <iostream>
+#include <vector>
 
 int main() {
-    const size_t GIGABYTE = 1024 * 1024 * 1024;
-    const size_t CHUNK_SIZE = 32 * 1024 * 1024; // 32 MiB
-    std::vector<char*> allocations;
-    size_t total_allocated = 0;
-
-    while (true) {
-        char* block = static_cast<char*>(malloc(CHUNK_SIZE));
-        if (!block) {
-            std::cerr << "Failed after allocating " << total_allocated / (1024 * 1024) << " MiB ~ " << total_allocated / GIGABYTE << " GiB" << std::endl;
-            break;
-        }
+  const size_t GIGABYTE = 1024 * 1024 * 1024;
+  const size_t CHUNK_SIZE = 32 * 1024 * 1024; // 32 MiB
+  std::vector<char *> allocations;
+  size_t total_allocated = 0;
 
-        // Touch memory to ensure it's actually committed (not lazy-allocated)
-        std::memset(block, 0xAB, CHUNK_SIZE);
-        allocations.push_back(block);
-        total_allocated += CHUNK_SIZE;
-        if (total_allocated % GIGABYTE == 0) {
-            std::cout << "Current allocated: " << total_allocated / GIGABYTE << " GiB" << std::endl;
-        }
+  while (true) {
+    char *block = static_cast<char *>(malloc(CHUNK_SIZE));
+    if (!block) {
+      std::cerr << "Failed after allocating " << total_allocated / (1024 * 1024)
+                << " MiB ~ " << total_allocated / GIGABYTE << " GiB"
+                << std::endl;
+      break;
     }
 
-    // Free the memory afterward
-    for (char* ptr : allocations) {
-        free(ptr);
+    // Touch memory to ensure it's actually committed (not lazy-allocated)
+    std::memset(block, 0xAB, CHUNK_SIZE);
+    allocations.push_back(block);
+    total_allocated += CHUNK_SIZE;
+    if (total_allocated % GIGABYTE == 0) {
+      std::cout << "Current allocated: " << total_allocated / GIGABYTE << " GiB"
+                << std::endl;
     }
+  }
+
+  // Free the memory afterward
+  for (char *ptr : allocations) {
+    free(ptr);
+  }
 
-    return 0;
+  return 0;
 }