// hello.c
#include <stdio.h>

int main() {
    printf("Hello from C!\n");
    return 0;
}

# 编译为 HTML + JS + Wasm
emcc hello.c -o hello.html

# 编译为纯 JS + Wasm
emcc hello.c -o hello.js

# 编译为纯 Wasm（需要 -s STANDALONE_WASM）
emcc hello.c -o hello.wasm -s STANDALONE_WASM

// math_utils.c
#include <emscripten.h>

EMSCRIPTEN_KEEPALIVE
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

EMSCRIPTEN_KEEPALIVE
double power(double base, int exp) {
    double result = 1.0;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

emcc math_utils.c -o math_utils.js \
  -s EXPORTED_FUNCTIONS='["_factorial","_power","_malloc","_free"]' \
  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap"]' \
  -O2

<script src="math_utils.js"></script>
<script>
Module.onRuntimeInitialized = () => {
  // 方式 1：使用 ccall（自动处理类型转换）
  const result = Module.ccall('factorial', 'number', ['number'], [10]);
  console.log('10! =', result);  // 3628800

  // 方式 2：使用 cwrap（创建可复用的函数引用）
  const power = Module.cwrap('power', 'number', ['number', 'number']);
  console.log('2^10 =', power(2, 10));  // 1024
};
</script>

// array_ops.c
#include <stdlib.h>
#include <string.h>
#include <emscripten.h>

EMSCRIPTEN_KEEPALIVE
int* create_array(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        arr[i] = i * i;
    }
    return arr;
}

EMSCRIPTEN_KEEPALIVE
int sum_array(int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

EMSCRIPTEN_KEEPALIVE
void free_array(int* arr) {
    free(arr);
}

// JavaScript 侧操作 Wasm 内存
Module.onRuntimeInitialized = () => {
  const N = 100;
  
  // 在 Wasm 堆上分配数组
  const ptr = Module._create_array(N);
  
  // 从 Wasm 内存中读取数据
  const heap = new Int32Array(Module.HEAP32.buffer, ptr, N);
  console.log('前 10 个元素:', Array.from(heap.slice(0, 10)));
  
  // 计算总和
  const sum = Module._sum_array(ptr, N);
  console.log('总和:', sum);
  
  // 释放内存
  Module._free_array(ptr);
};

// string_utils.c
#include <emscripten.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

EMSCRIPTEN_KEEPALIVE
char* to_upper(const char* input) {
    int len = strlen(input);
    char* result = (char*)malloc(len + 1);
    for (int i = 0; i < len; i++) {
        result[i] = toupper(input[i]);
    }
    result[len] = '\0';
    return result;
}

// 返回新字符串长度
EMSCRIPTEN_KEEPALIVE
int get_string_length(const char* str) {
    return strlen(str);
}

emcc string_utils.c -o string_utils.js \
  -s EXPORTED_FUNCTIONS='["_to_upper","_get_string_length","_malloc","_free"]' \
  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap","UTF8ToString","stringToUTF8","lengthBytesUTF8"]'

Module.onRuntimeInitialized = () => {
  // ccall 传字符串自动处理
  const result = Module.ccall('to_upper', 'string', ['string'], ['hello world']);
  console.log(result);  // "HELLO WORLD"
};

#include <emscripten.h>

// EM_JS: 在 C 中定义一个 JS 实现的函数
EM_JS(void, js_console_log, (const char* str), {
  // 这里的代码是 JavaScript
  console.log('From C:', UTF8ToString(str));
});

EM_JS(int, js_get_timestamp, (), {
  return Date.now();
});

// EM_ASYNC_JS: 异步 JS 函数
EM_ASYNC_JS(int, js_fetch_data, (const char* url), {
  const response = await fetch(UTF8ToString(url));
  const text = await response.text();
  console.log('Fetched:', text.length, 'bytes');
  return text.length;
});

int main() {
    js_console_log("Hello from C via EM_JS!");
    int ts = js_get_timestamp();
    js_console_log("Timestamp recorded");
    return 0;
}

// EM_ASM: 简单内联（不支持返回值和参数类型声明）
EM_ASM({
  console.log('Hello from EM_ASM');
  console.log('Arg0:', $0);
  console.log('Arg1:', $1);
}, 42, 3.14);

// EM_ASM_INT: 返回 i32
int result = EM_ASM_INT({
  return $0 + $1;
}, 10, 20);

// EM_ASM_DOUBLE: 返回 f64
double val = EM_ASM_DOUBLE({
  return Math.PI * $0;
}, 2.0);

// add.c
#include <emscripten.h>

EMSCRIPTEN_KEEPALIVE
int add(int a, int b) {
    return a + b;
}

// 使用 extern 声明外部 JS 函数
extern int js_random(void);
extern void js_report(int result);

EMSCRIPTEN_KEEPALIVE
void process_data(int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += js_random();
    }
    js_report(total);
}

const imports = {
  env: {
    js_random: () => Math.floor(Math.random() * 100),
    js_report: (result) => console.log('Result:', result)
  }
};

// 编译时需要声明这些导入

cmake_minimum_required(VERSION 3.13)
project(my_wasm_project)

# 设置 Emscripten 编译选项
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} \
  -s WASM=1 \
  -s EXPORTED_FUNCTIONS='[_process_image,_malloc,_free]' \
  -s EXPORTED_RUNTIME_METHODS='[ccall,cwrap]' \
  -s ALLOW_MEMORY_GROWTH=1 \
  -s MODULARIZE=1 \
  -s EXPORT_NAME='MyModule'")

add_executable(my_module src/main.c src/image_process.c)

# 链接第三方库
# find_package(PNG REQUIRED)
# target_link_libraries(my_module PNG::PNG)

# 使用 Emscripten 的 CMake 工具链文件
mkdir build && cd build
emcmake cmake ..
emmake make

# 示例：移植 zlib
git clone https://github.com/nicedoc/zlib.git
cd zlib
emcmake cmake . -DCMAKE_INSTALL_PREFIX=$HOME/wasm-libs
emmake make
emmake make install

# 编译自己的代码时链接 zlib
emcc my_code.c -o my_code.js \
  -I$HOME/wasm-libs/include \
  -L$HOME/wasm-libs/lib -lz

# 1. 使用 -Oz 优化
emcc input.c -o output.js -Oz

# 2. 使用 wasm-opt 进一步优化
wasm-opt -Oz output.wasm -o output_optimized.wasm

# 3. 只导出需要的函数
emcc input.c -o output.js \
  -s EXPORTED_FUNCTIONS='["_needed_func"]' \
  -s EXPORTED_RUNTIME_METHODS='[]'

# 4. 剥离调试信息
emcc input.c -o output.js -O2 --strip-debug

# 5. 禁用不需要的功能
emcc input.c -o output.js \
  -s DISABLE_EXCEPTION_CATCHING=1 \
  -s FILESYSTEM=0  # 禁用虚拟文件系统

// include/common.h
#ifndef COMMON_H
#define COMMON_H

#include <emscripten.h>

#define EXPORT EMSCRIPTEN_KEEPALIVE

#endif

// src/math/vector.h
#ifndef VECTOR_H
#define VECTOR_H

typedef struct {
    float x, y, z;
} Vec3;

Vec3 vec3_add(Vec3 a, Vec3 b);
float vec3_length(Vec3 v);
Vec3 vec3_normalize(Vec3 v);

#endif

// src/math/vector.c
#include "vector.h"
#include <math.h>
#include "common.h"

EXPORT
Vec3 vec3_add(Vec3 a, Vec3 b) {
    return (Vec3){a.x + b.x, a.y + b.y, a.z + b.z};
}

EXPORT
float vec3_length(Vec3 v) {
    return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
}

EXPORT
Vec3 vec3_normalize(Vec3 v) {
    float len = vec3_length(v);
    return (Vec3){v.x / len, v.y / len, v.z / len};
}

# 使用 -g 参数保留调试信息
emcc debug.c -o debug.js -g -s ASSERTIONS=1

# 生成 source map
emcc debug.c -o debug.js -g4 --source-map-base http://localhost:8080/