6 files changed, 690 insertions, 15 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b948328f1..f4e224ebe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -90,6 +90,11 @@ SET(support_SOURCES
 )
 ADD_LIBRARY(support STATIC ${support_SOURCES})
 
+SET(binaryen_c_SOURCES
+  src/binaryen-c.cpp
+)
+ADD_LIBRARY(binaryen-c STATIC ${binaryen_c_SOURCES})
+
 SET(binaryen-shell_SOURCES
   src/binaryen-shell.cpp
   src/pass.cpp
diff --git a/check.py b/check.py
index 977da0764..4e8699b05 100755
--- a/check.py
+++ b/check.py
@@ -569,21 +569,33 @@ if has_vanilla_emcc and has_vanilla_llvm:
 
 print '\n[ checking example testcases... ]\n'
 
-cmd = [os.environ.get('CXX') or 'g++', '-std=c++11',
-       os.path.join('test', 'example', 'find_div0s.cpp'),
-       os.path.join('src', 'pass.cpp'),
-       os.path.join('src', 'wasm.cpp'),
-       os.path.join('src', 'passes', 'Print.cpp'),
-       '-Isrc', '-g', '-lasmjs', '-lsupport', '-Llib/.', '-pthread']
-if os.environ.get('COMPILER_FLAGS'):
-  for f in os.environ.get('COMPILER_FLAGS').split(' '):
-    cmd.append(f)
-print ' '.join(cmd)
-subprocess.check_call(cmd)
-actual = subprocess.Popen(['./a.out'], stdout=subprocess.PIPE).communicate()[0]
-expected = open(os.path.join('test', 'example', 'find_div0s.txt')).read()
-if actual != expected:
-  fail(actual, expected)
+for t in sorted(os.listdir(os.path.join('test', 'example'))):
+  cmd = [os.path.join('src', 'pass.cpp'),
+         os.path.join('src', 'wasm.cpp'),
+         os.path.join('src', 'passes', 'Print.cpp'),
+         '-Isrc', '-g', '-lasmjs', '-lsupport', '-Llib/.', '-pthread']
+  if t.endswith('.cpp'):
+    cmd = [os.path.join('test', 'example', t)] + cmd
+  elif t.endswith('.c'):
+    # build the C file separately
+    extra = [os.environ.get('CC') or 'gcc',
+             os.path.join('test', 'example', t), '-c', '-o', 'example.o',
+             '-Isrc', '-g', '-lasmjs', '-lsupport', '-Llib/.', '-pthread']
+    print ' '.join(extra)
+    subprocess.check_call(extra)
+    cmd = ['example.o', '-lbinaryen-c'] + cmd
+  else:
+    continue
+  if os.environ.get('COMPILER_FLAGS'):
+    for f in os.environ.get('COMPILER_FLAGS').split(' '):
+      cmd.append(f)
+  cmd = [os.environ.get('CXX') or 'g++', '-std=c++11'] + cmd
+  print ' '.join(cmd)
+  subprocess.check_call(cmd)
+  actual = subprocess.Popen(['./a.out'], stdout=subprocess.PIPE).communicate()[0]
+  expected = open(os.path.join('test', 'example', '.'.join(t.split('.')[:-1]) + '.txt')).read()
+  if actual != expected:
+    fail(actual, expected)
 
 if has_emcc:
 
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
new file mode 100644
index 000000000..3ee47e2a9
--- /dev/null
+++ b/src/binaryen-c.cpp
@@ -0,0 +1,373 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//===============================
+// Binaryen C API implementation
+//===============================
+
+#include "binaryen-c.h"
+#include "wasm.h"
+#include "wasm-builder.h"
+#include "wasm-printing.h"
+
+using namespace wasm;
+
+// Literal utilities
+
+static_assert(sizeof(BinaryenLiteral) == sizeof(Literal), "Binaryen C API literal must match wasm.h");
+
+BinaryenLiteral toBinaryenLiteral(Literal x) {
+  BinaryenLiteral ret;
+  switch (x.type) {
+    case WasmType::i32: ret.i32 = x.geti32(); break;
+    case WasmType::i64: ret.i64 = x.geti64(); break;
+    case WasmType::f32: ret.i32 = x.reinterpreti32(); break;
+    case WasmType::f64: ret.i64 = x.reinterpreti64(); break;
+    default: abort();
+  }
+  return ret;
+}
+
+Literal fromBinaryenLiteral(BinaryenLiteral x) {
+  switch (x.type) {
+    case WasmType::i32: return Literal(x.i32);
+    case WasmType::i64: return Literal(x.i64);
+    case WasmType::f32: return Literal(x.i32).castToF32();
+    case WasmType::f64: return Literal(x.i64).castToF64();
+    default: abort();
+  }
+}
+
+extern "C" {
+
+//
+// ========== Module Creation ==========
+//
+
+// Core types
+
+BinaryenType BinaryenNone(void) { return none; }
+BinaryenType BinaryenInt32(void) { return i32; }
+BinaryenType BinaryenInt64(void) { return i64; }
+BinaryenType BinaryenFloat32(void) { return f32; }
+BinaryenType BinaryenFloat64(void) { return f64; }
+
+// Modules
+
+BinaryenModuleRef BinaryenModuleCreate() { return new Module(); }
+void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; }
+
+// Function types
+
+BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, const char* name, BinaryenType result, BinaryenType* paramTypes, BinaryenIndex numParams) {
+  auto* wasm = (Module*)module;
+  auto* ret = new FunctionType;
+  ret->name = name;
+  ret->result = WasmType(result);
+  for (BinaryenIndex i = 0; i < numParams; i++) {
+    ret->params.push_back(WasmType(paramTypes[i]));
+  }
+  wasm->addFunctionType(ret);
+  return ret;
+}
+
+BinaryenLiteral BinaryenLiteralInt32(int32_t x) { return toBinaryenLiteral(Literal(x)); }
+BinaryenLiteral BinaryenLiteralInt64(int64_t x) { return toBinaryenLiteral(Literal(x)); }
+BinaryenLiteral BinaryenLiteralFloat32(float x) { return toBinaryenLiteral(Literal(x)); }
+BinaryenLiteral BinaryenLiteralFloat64(double x) { return toBinaryenLiteral(Literal(x)); }
+BinaryenLiteral BinaryenLiteralFloat32Bits(int32_t x) { return toBinaryenLiteral(Literal(x).castToF32()); }
+BinaryenLiteral BinaryenLiteralFloat64Bits(int64_t x) { return toBinaryenLiteral(Literal(x).castToF64()); }
+
+// Expressions
+
+BinaryenOp BinaryenClz(void) { return Clz; }
+BinaryenOp BinaryenCtz(void) { return Ctz; }
+BinaryenOp BinaryenPopcnt(void) { return Popcnt; }
+BinaryenOp BinaryenNeg(void) { return Neg; }
+BinaryenOp BinaryenAbs(void) { return Abs; }
+BinaryenOp BinaryenCeil(void) { return Ceil; }
+BinaryenOp BinaryenFloor(void) { return Floor; }
+BinaryenOp BinaryenTrunc(void) { return Trunc; }
+BinaryenOp BinaryenNearest(void) { return Nearest; }
+BinaryenOp BinaryenSqrt(void) { return Sqrt; }
+BinaryenOp BinaryenEqz(void) { return EqZ; }
+BinaryenOp BinaryenExtendSInt32(void) { return ExtendSInt32; }
+BinaryenOp BinaryenExtentUInt32(void) { return ExtendUInt32; }
+BinaryenOp BinaryenWrapInt64(void) { return WrapInt64; }
+BinaryenOp BinaryenTruncSFloat32(void) { return TruncSFloat32; }
+BinaryenOp BinaryenTruncUFloat32(void) { return TruncUFloat32; }
+BinaryenOp BinaryenTruncSFloat64(void) { return TruncSFloat64; }
+BinaryenOp BinaryenTruncUFloat64(void) { return TruncUFloat64; }
+BinaryenOp BinaryenReinterpretFloat(void) { return ReinterpretFloat; }
+BinaryenOp BinaryenConvertSInt32(void) { return ConvertSInt32; }
+BinaryenOp BinaryenConvertUInt32(void) { return ConvertUInt32; }
+BinaryenOp BinaryenConvertSInt64(void) { return ConvertSInt64; }
+BinaryenOp BinaryenConvertUInt64(void) { return ConvertUInt64; }
+BinaryenOp BinaryenPromoteFloat32(void) { return PromoteFloat32; }
+BinaryenOp BinaryenDemoteFloat64(void) { return DemoteFloat64; }
+BinaryenOp BinaryenReinterpretInt(void) { return ReinterpretInt; }
+BinaryenOp BinaryenAdd(void) { return Add; }
+BinaryenOp BinaryenSub(void) { return Sub; }
+BinaryenOp BinaryenMul(void) { return Mul; }
+BinaryenOp BinaryenDivS(void) { return DivS; }
+BinaryenOp BinaryenDivU(void) { return DivU; }
+BinaryenOp BinaryenRemS(void) { return RemS; }
+BinaryenOp BinaryenRemU(void) { return RemU; }
+BinaryenOp BinaryenAnd(void) { return And; }
+BinaryenOp BinaryenOr(void) { return Or; }
+BinaryenOp BinaryenXor(void) { return Xor; }
+BinaryenOp BinaryenShl(void) { return Shl; }
+BinaryenOp BinaryenShrU(void) { return ShrU; }
+BinaryenOp BinaryenShrS(void) { return ShrS; }
+BinaryenOp BinaryenRotL(void) { return RotL; }
+BinaryenOp BinaryenRotR(void) { return RotR; }
+BinaryenOp BinaryenDiv(void) { return Div; }
+BinaryenOp BinaryenCopySign(void) { return CopySign; }
+BinaryenOp BinaryenMin(void) { return Min; }
+BinaryenOp BinaryenMax(void) { return Max; }
+BinaryenOp BinaryenEq(void) { return Eq; }
+BinaryenOp BinaryenNe(void) { return Ne; }
+BinaryenOp BinaryenLtS(void) { return LtS; }
+BinaryenOp BinaryenLtU(void) { return LtU; }
+BinaryenOp BinaryenLeS(void) { return LeS; }
+BinaryenOp BinaryenLeU(void) { return LeU; }
+BinaryenOp BinaryenGtS(void) { return GtS; }
+BinaryenOp BinaryenGtU(void) { return GtU; }
+BinaryenOp BinaryenGes(void) { return GeS; }
+BinaryenOp BinaryenGeU(void) { return GeU; }
+BinaryenOp BinaryenLt(void) { return Lt; }
+BinaryenOp BinaryenLe(void) { return Le; }
+BinaryenOp BinaryenGt(void) { return Gt; }
+BinaryenOp BinaryenGe(void) { return Ge; }
+BinaryenOp BinaryenPageSize(void) { return PageSize; }
+BinaryenOp BinaryenCurrentMemory(void) { return CurrentMemory; }
+BinaryenOp BinaryenGrowMemory(void) { return GrowMemory; }
+BinaryenOp BinaryenHasFeature(void) { return HasFeature; }
+
+BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, BinaryenExpressionRef* children, BinaryenIndex numChildren) {
+  auto* ret = ((Module*)module)->allocator.alloc<Block>();
+  if (name) {
+    ret->name = name;
+  }
+  for (BinaryenIndex i = 0; i < numChildren; i++) {
+    ret->list.push_back((Expression*)children[i]);
+  }
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) {
+  auto* ret = ((Module*)module)->allocator.alloc<If>();
+  ret->condition = (Expression*)condition;
+  ret->ifTrue = (Expression*)ifTrue;
+  ret->ifFalse = (Expression*)ifFalse;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, const char* out, const char* in, BinaryenExpressionRef body) {
+  return Builder(*((Module*)module)).makeLoop(out ? Name(out) : Name(), in ? Name(in) : Name(), (Expression*)body);
+}
+BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, BinaryenExpressionRef value, BinaryenExpressionRef condition) {
+  return Builder(*((Module*)module)).makeBreak(name, (Expression*)value, (Expression*)condition);
+}
+BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char **names, BinaryenIndex numNames, const char* defaultName, BinaryenExpressionRef condition, BinaryenExpressionRef value) {
+  auto* ret = ((Module*)module)->allocator.alloc<Switch>();
+  for (BinaryenIndex i = 0; i < numNames; i++) {
+    ret->targets.push_back(names[i]);
+  }
+  ret->default_ = defaultName;
+  ret->condition = (Expression*)condition;
+  ret->value = (Expression*)value;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands) {
+  auto* ret = ((Module*)module)->allocator.alloc<Call>();
+  ret->target = target;
+  for (BinaryenIndex i = 0; i < numOperands; i++) {
+    ret->operands.push_back((Expression*)operands[i]);
+  }
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenCallImport(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands) {
+  auto* ret = ((Module*)module)->allocator.alloc<CallImport>();
+  ret->target = target;
+  for (BinaryenIndex i = 0; i < numOperands; i++) {
+    ret->operands.push_back((Expression*)operands[i]);
+  }
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExpressionRef target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenFunctionTypeRef type) {
+  auto* ret = ((Module*)module)->allocator.alloc<CallIndirect>();
+  ret->target = (Expression*)target;
+  for (BinaryenIndex i = 0; i < numOperands; i++) {
+    ret->operands.push_back((Expression*)operands[i]);
+  }
+  ret->fullType = (FunctionType*)type;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenType type) {
+  auto* ret = ((Module*)module)->allocator.alloc<GetLocal>();
+  ret->index = index;
+  ret->type = WasmType(type);
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value) {
+  auto* ret = ((Module*)module)->allocator.alloc<SetLocal>();
+  ret->index = index;
+  ret->value = (Expression*)value;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, uint32_t bytes, int8_t signed_, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr) {
+  auto* ret = ((Module*)module)->allocator.alloc<Load>();
+  ret->bytes = bytes;
+  ret->signed_ = signed_;
+  ret->offset = offset;
+  ret->align = align;
+  ret->ptr = (Expression*)ptr;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr, BinaryenExpressionRef value) {
+  auto* ret = ((Module*)module)->allocator.alloc<Store>();
+  ret->bytes = bytes;
+  ret->offset = offset;
+  ret->align = align;
+  ret->ptr = (Expression*)ptr;
+  ret->value = (Expression*)value;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, BinaryenLiteral value) {
+  return Builder(*((Module*)module)).makeConst(fromBinaryenLiteral(value));
+}
+BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef value, BinaryenType type) {
+  return Builder(*((Module*)module)).makeUnary(UnaryOp(op), (Expression*)value, WasmType(type));
+}
+BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef left, BinaryenExpressionRef right) {
+  return Builder(*((Module*)module)).makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right);
+}
+BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse) {
+  auto* ret = ((Module*)module)->allocator.alloc<Select>();
+  ret->condition = (Expression*)condition;
+  ret->ifTrue = (Expression*)ifTrue;
+  ret->ifFalse = (Expression*)ifFalse;
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module, BinaryenExpressionRef value) {
+  return Builder(*((Module*)module)).makeReturn((Expression*)value);
+}
+BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, BinaryenOp op, const char* name, BinaryenExpressionRef* operands, BinaryenIndex numOperands) {
+  auto* ret = ((Module*)module)->allocator.alloc<Host>();
+  ret->op = HostOp(op);
+  if (name) ret->nameOperand = name;
+  for (BinaryenIndex i = 0; i < numOperands; i++) {
+    ret->operands.push_back((Expression*)operands[i]);
+  }
+  ret->finalize();
+  return ret;
+}
+BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module) {
+  return ((Module*)module)->allocator.alloc<Nop>();
+}
+BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) {
+  return ((Module*)module)->allocator.alloc<Unreachable>();
+}
+
+// Functions
+
+BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, const char* name, BinaryenFunctionTypeRef type, BinaryenType* localTypes, BinaryenIndex numLocalTypes, BinaryenExpressionRef body) {
+  auto* wasm = (Module*)module;
+  auto* ret = new Function;
+  ret->name = name;
+  ret->type = ((FunctionType*)type)->name;
+  auto* functionType = wasm->getFunctionType(ret->type);
+  ret->result = functionType->result;
+  ret->params = functionType->params;
+  for (BinaryenIndex i = 0; i < numLocalTypes; i++) {
+    ret->vars.push_back(WasmType(localTypes[i]));
+  }
+  ret->body = (Expression*)body;
+  wasm->addFunction(ret);
+  return ret;
+}
+
+// Imports
+
+BinaryenImportRef BinaryenAddImport(BinaryenModuleRef module, const char* internalName, const char* externalModuleName, const char *externalBaseName, BinaryenFunctionTypeRef type) {
+  auto* wasm = (Module*)module;
+  auto* ret = new Import();
+  ret->name = internalName;
+  ret->module = externalModuleName;
+  ret->base = externalBaseName;
+  ret->type = (FunctionType*)type;
+  wasm->addImport(ret);
+  return ret;
+}
+
+// Exports
+
+BinaryenExportRef BinaryenAddExport(BinaryenModuleRef module, const char* internalName, const char* externalName) {
+  auto* wasm = (Module*)module;
+  auto* ret = new Export();
+  ret->name = internalName;
+  ret->value = externalName;
+  wasm->addExport(ret);
+  return ret;
+}
+
+// Function table. One per module
+
+void BinaryenSetFunctionTable(BinaryenModuleRef module, BinaryenFunctionRef* functions, BinaryenIndex numFunctions) {
+  auto* wasm = (Module*)module;
+  for (BinaryenIndex i = 0; i < numFunctions; i++) {
+    wasm->table.names.push_back(((Function*)functions[i])->name);
+  }
+}
+
+// Memory. One per module
+
+void BinaryenSetMemory(BinaryenModuleRef module, BinaryenIndex initial, BinaryenIndex maximum, const char* exportName, const char **segments, BinaryenIndex* segmentOffsets, BinaryenIndex* segmentSizes, BinaryenIndex numSegments) {
+  auto* wasm = (Module*)module;
+  wasm->memory.initial = initial;
+  wasm->memory.max = maximum;
+  wasm->memory.exportName = exportName;
+  for (BinaryenIndex i = 0; i < numSegments; i++) {
+    wasm->memory.segments.emplace_back(segmentOffsets[i], segments[i], segmentSizes[i]);
+  }
+}
+
+// Start function. One per module
+
+void BinaryenSetStart(BinaryenModuleRef module, const char* name) {
+  auto* wasm = (Module*)module;
+  wasm->addStart(name);
+}
+
+//
+// ========== Module Operations ==========
+//
+
+void BinaryenModulePrint(BinaryenModuleRef module) {
+  WasmPrinter::printModule((Module*)module);
+}
+
+} // extern "C"
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
new file mode 100644
index 000000000..94523afcc
--- /dev/null
+++ b/src/binaryen-c.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//================
+// Binaryen C API
+//
+// The first part of the API lets you create modules and their parts.
+// The second part of the API lets you perform operations on modules.
+//================
+
+#ifndef binaryen_h
+#define binaryen_h
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//
+// ========== Module Creation ==========
+//
+
+// BinaryenIndex
+//
+// Used for internal indexes and list sizes.
+
+typedef uint32_t BinaryenIndex;
+
+// Core types (call to get the value of each; you can cache them, they
+// never change)
+
+typedef uint32_t BinaryenType;
+
+BinaryenType BinaryenNone(void);
+BinaryenType BinaryenInt32(void);
+BinaryenType BinaryenInt64(void);
+BinaryenType BinaryenFloat32(void);
+BinaryenType BinaryenFloat64(void);
+
+// Modules
+//
+// Modules contain lists of functions, imports, exports, function types. The
+// Add* methods create them on a module. The module owns them and will free their
+// memory when the module is disposed of.
+//
+// Expressions are also allocated inside modules, and freed with the module. They
+// are not created by Add* methods, since they are not added directly on the
+// module, instead, they are arguments to other expressions (and then they are
+// the children of that AST node), or to a function (and then they are the body
+// of that function).
+//
+// A module can also contain a function table for indirect calls, a memory,
+// and a start method.
+
+typedef void* BinaryenModuleRef;
+
+BinaryenModuleRef BinaryenModuleCreate();
+void BinaryenModuleDispose(BinaryenModuleRef module);
+
+// Function types
+
+typedef void* BinaryenFunctionTypeRef;
+
+BinaryenFunctionTypeRef BinaryenAddFunctionType(BinaryenModuleRef module, const char* name, BinaryenType result, BinaryenType* paramTypes, BinaryenIndex numParams);
+
+// Literals. These are passed by value.
+
+struct BinaryenLiteral {
+  int type; // size of enum in c++
+  union {
+    int32_t i32;
+    int64_t i64;
+    float f32;
+    double f64;
+  };
+};
+
+struct BinaryenLiteral BinaryenLiteralInt32(int32_t x);
+struct BinaryenLiteral BinaryenLiteralInt64(int64_t x);
+struct BinaryenLiteral BinaryenLiteralFloat32(float x);
+struct BinaryenLiteral BinaryenLiteralFloat64(double x);
+struct BinaryenLiteral BinaryenLiteralFloat32Bits(int32_t x);
+struct BinaryenLiteral BinaryenLiteralFloat64Bits(int64_t x);
+
+// Expressions
+//
+// Some expressions have a BinaryenOp, which is the more
+// specific operation/opcode.
+//
+// Some expressions have optional parameters, like Return may not
+// return a value. You can supply a NULL pointer in those cases.
+
+typedef int32_t BinaryenOp;
+
+BinaryenOp BinaryenClz(void);
+BinaryenOp BinaryenCtz(void);
+BinaryenOp BinaryenPopcnt(void);
+BinaryenOp BinaryenNeg(void);
+BinaryenOp BinaryenAbs(void);
+BinaryenOp BinaryenCeil(void);
+BinaryenOp BinaryenFloor(void);
+BinaryenOp BinaryenTrunc(void);
+BinaryenOp BinaryenNearest(void);
+BinaryenOp BinaryenSqrt(void);
+BinaryenOp BinaryenEqz(void);
+BinaryenOp BinaryenExtendSInt32(void);
+BinaryenOp BinaryenExtentUInt32(void);
+BinaryenOp BinaryenWrapInt64(void);
+BinaryenOp BinaryenTruncSFloat32(void);
+BinaryenOp BinaryenTruncUFloat32(void);
+BinaryenOp BinaryenTruncSFloat64(void);
+BinaryenOp BinaryenTruncUFloat64(void);
+BinaryenOp BinaryenReinterpretFloat(void);
+BinaryenOp BinaryenConvertSInt32(void);
+BinaryenOp BinaryenConvertUInt32(void);
+BinaryenOp BinaryenConvertSInt64(void);
+BinaryenOp BinaryenConvertUInt64(void);
+BinaryenOp BinaryenPromoteFloat32(void);
+BinaryenOp BinaryenDemoteFloat64(void);
+BinaryenOp BinaryenReinterpretInt(void);
+BinaryenOp BinaryenAdd(void);
+BinaryenOp BinaryenSub(void);
+BinaryenOp BinaryenMul(void);
+BinaryenOp BinaryenDivS(void);
+BinaryenOp BinaryenDivU(void);
+BinaryenOp BinaryenRemS(void);
+BinaryenOp BinaryenRemU(void);
+BinaryenOp BinaryenAnd(void);
+BinaryenOp BinaryenOr(void);
+BinaryenOp BinaryenXor(void);
+BinaryenOp BinaryenShl(void);
+BinaryenOp BinaryenShrU(void);
+BinaryenOp BinaryenShrS(void);
+BinaryenOp BinaryenRotL(void);
+BinaryenOp BinaryenRotR(void);
+BinaryenOp BinaryenDiv(void);
+BinaryenOp BinaryenCopySign(void);
+BinaryenOp BinaryenMin(void);
+BinaryenOp BinaryenMax(void);
+BinaryenOp BinaryenEq(void);
+BinaryenOp BinaryenNe(void);
+BinaryenOp BinaryenLtS(void);
+BinaryenOp BinaryenLtU(void);
+BinaryenOp BinaryenLeS(void);
+BinaryenOp BinaryenLeU(void);
+BinaryenOp BinaryenGtS(void);
+BinaryenOp BinaryenGtU(void);
+BinaryenOp BinaryenGes(void);
+BinaryenOp BinaryenGeU(void);
+BinaryenOp BinaryenLt(void);
+BinaryenOp BinaryenLe(void);
+BinaryenOp BinaryenGt(void);
+BinaryenOp BinaryenGe(void);
+BinaryenOp BinaryenPageSize(void);
+BinaryenOp BinaryenCurrentMemory(void);
+BinaryenOp BinaryenGrowMemory(void);
+BinaryenOp BinaryenHasFeature(void);
+
+typedef void* BinaryenExpressionRef;
+
+// Block: name can be NULL
+BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, BinaryenExpressionRef* children, BinaryenIndex numChildren);
+// If: ifFalse can be NULL
+BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse);
+// Loop: out and in can be NULL
+BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, const char* out, const char* in, BinaryenExpressionRef body);
+// Break: value and condition can be NULL
+BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, const char* name, BinaryenExpressionRef value, BinaryenExpressionRef condition);
+// Switch: value and condition can be NULL
+BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char **names, BinaryenIndex numNames, const char* defaultName, BinaryenExpressionRef condition, BinaryenExpressionRef value);
+BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands);
+BinaryenExpressionRef BinaryenCallImport(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands);
+BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExpressionRef target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenFunctionTypeRef type);
+BinaryenExpressionRef BinaryenGetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenType type);
+BinaryenExpressionRef BinaryenSetLocal(BinaryenModuleRef module, BinaryenIndex index, BinaryenExpressionRef value);
+BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, uint32_t bytes, int8_t signed_, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr);
+BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, uint32_t bytes, uint32_t offset, uint32_t align, BinaryenExpressionRef ptr, BinaryenExpressionRef value);
+BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, struct BinaryenLiteral value);
+BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef value, BinaryenType type);
+BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef left, BinaryenExpressionRef right);
+BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, BinaryenExpressionRef condition, BinaryenExpressionRef ifTrue, BinaryenExpressionRef ifFalse);
+// Return: value can be NULL
+BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module, BinaryenExpressionRef value);
+// Host: name may be NULL
+BinaryenExpressionRef BinaryenHost(BinaryenModuleRef module, BinaryenOp op, const char* name, BinaryenExpressionRef* operands, BinaryenIndex numOperands);
+BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module);
+BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module);
+
+// Functions
+
+typedef void* BinaryenFunctionRef;
+
+BinaryenFunctionRef BinaryenAddFunction(BinaryenModuleRef module, const char* name, BinaryenFunctionTypeRef type, BinaryenType* localTypes, BinaryenIndex numLocalTypes, BinaryenExpressionRef body);
+
+// Imports
+
+typedef void* BinaryenImportRef;
+
+BinaryenImportRef BinaryenAddImport(BinaryenModuleRef module, const char* internalName, const char* externalModuleName, const char *externalBaseName, BinaryenFunctionTypeRef type);
+
+// Exports
+
+typedef void* BinaryenExportRef;
+
+BinaryenExportRef BinaryenAddExport(BinaryenModuleRef module, const char* internalName, const char* externalName);
+
+// Function table. One per module
+
+void BinaryenSetFunctionTable(BinaryenModuleRef module, BinaryenFunctionRef* functions, BinaryenIndex numFunctions);
+
+// Memory. One per module
+
+// Each segment has data in segments, a start offset in segmentOffsets, and a size in segmentSizes.
+void BinaryenSetMemory(BinaryenModuleRef module, BinaryenIndex initial, BinaryenIndex maximum, const char* exportName, const char **segments, BinaryenIndex* segmentOffsets, BinaryenIndex* segmentSizes, BinaryenIndex numSegments);
+
+// Start function. One per module
+
+void BinaryenSetStart(BinaryenModuleRef module, const char* name);
+
+//
+// ========== Module Operations ==========
+//
+
+// Print a module to stdout.
+void BinaryenModulePrint(BinaryenModuleRef module);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif  // binaryen_h
diff --git a/test/example/c-api-hello-world.c b/test/example/c-api-hello-world.c
new file mode 100644
index 000000000..016c2404b
--- /dev/null
+++ b/test/example/c-api-hello-world.c
@@ -0,0 +1,29 @@
+
+#include <binaryen-c.h>
+
+// "hello world" type example: create a function that adds two i32s and returns the result
+
+int main() {
+  BinaryenModuleRef module = BinaryenModuleCreate();
+
+  // Creation a function type for  i32 (i32, i32)
+  BinaryenType params[2] = { BinaryenInt32(), BinaryenInt32() };
+  BinaryenFunctionTypeRef iii = BinaryenAddFunctionType(module, "iii", BinaryenInt32(), params, 2);
+
+  // Get the 0 and 1 arguments, and add them
+  BinaryenExpressionRef x = BinaryenGetLocal(module, 0, BinaryenInt32()),
+                        y = BinaryenGetLocal(module, 1, BinaryenInt32());
+  BinaryenExpressionRef add = BinaryenBinary(module, BinaryenAdd(), x, y);
+
+  // Create the add function
+  // Note: no additional local variables
+  // Note: no basic blocks here, we are an AST. The function body is just an expression node.
+  BinaryenFunctionRef adder = BinaryenAddFunction(module, "adder", iii, NULL, 0, add);
+
+  // Print it out
+  BinaryenModulePrint(module);
+
+  // Clean up the module, which owns all the objects we created above
+  BinaryenModuleDispose(module);
+}
+
diff --git a/test/example/c-api-hello-world.txt b/test/example/c-api-hello-world.txt
new file mode 100644
index 000000000..4360107d3
--- /dev/null
+++ b/test/example/c-api-hello-world.txt
@@ -0,0 +1,10 @@
+(module
+  (memory 0)
+  (type $iii (func (param i32 i32) (result i32)))
+  (func $adder (type $iii) (param $0 i32) (param $1 i32) (result i32)
+    (i32.add
+      (get_local $0)
+      (get_local $1)
+    )
+  )
+)