#include <string>

#include <malloc.h>

#include <functional>

#include <emscripten/bind.h>

using namespace emscripten;

val emval_test_mallinfo() {

const auto& i = mallinfo();

val rv(val::object());

rv.set("arena", val(i.arena));

rv.set("ordblks", val(i.ordblks));

rv.set("smblks", val(i.smblks));

rv.set("hblks", val(i.hblks));

rv.set("usmblks", val(i.usmblks));

rv.set("fsmblks", val(i.fsmblks));

rv.set("uordblks", val(i.uordblks));

rv.set("fordblks", val(i.fordblks));

rv.set("keepcost", val(i.keepcost));

return rv;

}

val emval_test_new_integer() {

return val(15);

}

val emval_test_new_string() {

return val("Hello everyone");

}

std::string emval_test_get_string_from_val(val v) {

return v["key"].as<std::string>();

}

val emval_test_new_object() {

val rv(val::object());

rv.set("foo", val("bar"));

rv.set("baz", val(1));

return rv;

}

unsigned emval_test_passthrough_unsigned(unsigned v) {

return v;

}

val emval_test_passthrough(val v) {

return v;

}

void emval_test_return_void() {

}

bool emval_test_not(bool b) {

return !b;

}

bool emval_test_is_true(val v) {

return v.isTrue();

}

bool emval_test_is_false(val v) {

return v.isFalse();

}

bool emval_test_is_null(val v) {

return v.isNull();

}

bool emval_test_is_undefined(val v) {

return v.isUndefined();

}

bool emval_test_equals(val v1,val v2) {

return v1.equals(v2);

}

bool emval_test_strictly_equals(val v1, val v2) {

return v1.strictlyEquals(v2);

}

unsigned emval_test_as_unsigned(val v) {

return v.as<unsigned>();

}

unsigned emval_test_get_length(val v) {

return v["length"].as<unsigned>();

}

double emval_test_add(char c, signed char sc, unsigned char uc, signed short ss, unsigned short us, signed int si, unsigned int ui, signed long sl, unsigned long ul, float f, double d) {

return c + sc + uc + ss + us + si + ui + sl + ul + f + d;

}

float const_ref_adder(const int& i, const float& f) {

return i + f;

}

unsigned emval_test_sum(val v) {

unsigned length = v["length"].as<unsigned>();

double rv = 0;

for (unsigned i = 0; i < length; ++i) {

rv += v[i].as<double>();

}

return rv;

}

std::string get_non_ascii_string() {

char c[128 + 1];

c[128] = 0;

for (int i = 0; i < 128; ++i) {

c[i] = 128 + i;

}

return c;

}

std::wstring get_non_ascii_wstring() {

std::wstring ws(4, 0);

ws[0] = 10;

ws[1] = 1234;

ws[2] = 2345;

ws[3] = 65535;

return ws;

}

std::wstring get_literal_wstring() {

return L"get_literal_wstring";

}

void force_memory_growth() {

auto heapu8 = val::global("Module")["HEAPU8"];

delete [] new char[heapu8["byteLength"].as<size_t>() + 1];

}

std::string emval_test_take_and_return_const_char_star(const char* str) {

return str;

}

std::string emval_test_take_and_return_std_string(std::string str) {

return str;

}

std::string emval_test_take_and_return_std_string_const_ref(const std::string& str) {

return str;

}

std::basic_string<unsigned char> emval_test_take_and_return_std_basic_string_unsigned_char(std::basic_string<unsigned char> str) {

return str;

}

std::wstring take_and_return_std_wstring(std::wstring str) {

return str;

}

std::function<std::string (std::string)> emval_test_get_function_ptr() {

return emval_test_take_and_return_std_string;

}

std::string emval_test_take_and_call_functor(std::function<std::string(std::string)> func) {

return func("asdf");

}

class ValHolder {

public:

ValHolder(val v)

: v_(v)

{}

val getVal() const {

return v_;

}

val getValNonConst() {

return v_;

}

const val getConstVal() const {

return v_;

}

const val& getValConstRef() const {

return v_;

}

void setVal(val v) {

this->v_ = v;

}

static int some_class_method(int i) {

return i;

}

static const ValHolder* makeConst(val v) {

return new ValHolder(v);

}

static ValHolder makeValHolder(val v) {

return ValHolder(v);

}

static void set_via_raw_pointer(ValHolder* vh, val v) {

vh->setVal(v);

}

static val get_via_raw_pointer(const ValHolder* vh) {

return vh->getVal();

}

static void transfer_via_raw_pointer(ValHolder* target, const ValHolder* source) {

target->setVal(source->getVal());

}

static val getValNonMember(const ValHolder& target) {

return target.getVal();

}

private:

val v_;

};

ValHolder emval_test_return_ValHolder() {

return val::object();

}

void emval_test_set_ValHolder_to_empty_object(ValHolder& vh) {

vh.setVal(val::object());

}

class StringHolder {

public:

StringHolder(const std::string& s)

: str_(s)

{}

void set(const std::string& s) {

str_ = s;

}

std::string get() const {

return str_;

}

std::string& get_ref() {

return str_;

}

const std::string& get_const_ref() const {

return str_;

}

private:

std::string str_;

};

class SharedPtrHolder {

public:

SharedPtrHolder()

: ptr_(new StringHolder("a string"))

{}

std::shared_ptr<StringHolder> get() const {

return ptr_;

}

void set(std::shared_ptr<StringHolder> p) {

ptr_ = p;

}

private:

std::shared_ptr<StringHolder> ptr_;

};

class VectorHolder {

public:

VectorHolder() {

v_.push_back(StringHolder("string #1"));

v_.push_back(StringHolder("string #2"));

}

std::vector<StringHolder> get() const {

return v_;

}

void set(std::vector<StringHolder> vec) {

v_ = vec;

}

private:

std::vector<StringHolder> v_;

};

class SmallClass {

public:

SmallClass(): member(7) {};

int member;

};

class BigClass {

public:

BigClass(): member(11) {};

int member;

int otherMember;

int yetAnotherMember;

int getMember() {

return member;

}

};

class ParentClass {

public:

ParentClass(): bigClass() {};

BigClass bigClass;

const BigClass& getBigClass() {

return bigClass;

};

};

template<typename T>

class TemplateClass {

public:

TemplateClass(T a, T b, T c) {

members[0] = a;

members[1] = b;

members[2] = c;

};

const T getMember(int n) {

return members[n];

}

protected:

T members[3];

};

class ContainsTemplatedMemberClass {

public:

ContainsTemplatedMemberClass(): testTemplate(86, 87, 88) {};

TemplateClass<int> testTemplate;

const TemplateClass<int>& getTestTemplate() {

return testTemplate;

};

};

// Begin Inheritance Hierarchy Class Definitions

class Base {

public:

Base(): name("Base"),

member(0),

baseMember(0)

{}

std::string getClassName() const {

return name;

}

std::string getClassNameFromBase() const {

return name;

}

std::string getClassNameNotAvailableInDerivedClasses() {

// but wait -- if you act now we will throw in a SECOND base class method ABSOLUTELY FREE!!

return name;

}

void setMember(int value) {

member = value;

}

int getMember() {

return member;

}

void setBaseMember(int value) {

baseMember = value;

}

int getBaseMember() {

return baseMember;

}

std::string name;

int member;

int baseMember;

};

class SecondBase {

public:

SecondBase()

: name("SecondBase"),

member(0),

secondBaseMember(0)

{}

std::string getClassName() const {

return name;

}

std::string getClassNameNotAvailableInDerivedClasses() {

return name;

}

std::string getClassNameFromSecondBase() const {

return name;

}

void setMember(int value) {

member = value;

}

int getMember() {

return member;

}

void setSecondBaseMember(int value) {

secondBaseMember = value;

}

int getSecondBaseMember() {

return secondBaseMember;

}

std::string name;

int member;

int secondBaseMember;

};

class Derived : public Base{

public:

Derived()

: Base()

, member(0)

, name_("Derived")

{}

std::string getClassName() const {

return name_;

}

void setMember(int value) {

member = value;

}

int getMember() {

return member;

}

int member;

private:

std::string name_;

};

class DerivedHolder {

public:

DerivedHolder() {

derived_.reset();

}

void newDerived() {

deleteDerived();

derived_ = std::shared_ptr<Derived>(new Derived());

}

void deleteDerived() {

derived_.reset();

}

std::shared_ptr<Derived> getDerived() {

return derived_;

}

std::string getDerivedClassName() {

return derived_->getClassName();

}

private:

std::shared_ptr<Derived> derived_;

};

class SiblingDerived : public Base {

public:

SiblingDerived()

: Base(),

name_("SiblingDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class MultiplyDerived : public Base, public SecondBase {

public:

MultiplyDerived()

: Base(), SecondBase(),

name_("MultiplyDerived")

{ instanceCount_ ++; }

~MultiplyDerived()

{ instanceCount_ --; }

std::string getClassName() const {

return name_;

}

static int getInstanceCount() {

return instanceCount_;

}

private:

std::string name_;

static int instanceCount_;

};

int MultiplyDerived::instanceCount_ = 0;

class DerivedTwice : public Derived {

public:

DerivedTwice()

: Derived(),

name_("DerivedTwice")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class DerivedTwiceNotBound : public Derived {

public:

DerivedTwiceNotBound()

: Derived(),

name_("DerivedTwiceNotBound")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class DerivedThrice: public DerivedTwiceNotBound {

public:

DerivedThrice()

: DerivedTwiceNotBound(),

name_("DerivedThrice")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class DerivedFourTimesNotBound: public DerivedThrice {

public:

DerivedFourTimesNotBound()

: DerivedThrice(),

name_("DerivedFourTimesNotBound")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyBase {

public:

PolyBase(const std::string& s)

: str_(s),

name_("PolyBase")

{}

PolyBase(): name_("PolyBase") {}

virtual ~PolyBase() {}

virtual std::string virtualGetClassName() const {

return name_;

}

std::string getClassName() const {

return name_;

}

private:

std::string str_;

std::string name_;

};

class PolySecondBase {

public:

PolySecondBase(): name_("PolySecondBase")

{}

virtual ~PolySecondBase() {}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDerived : public PolyBase{

public:

PolyDerived()

: PolyBase("PolyDerived"),

name_("PolyDerived")

{}

std::string virtualGetClassName() const {

return name_;

}

std::string getClassName() const {

return name_;

}

static void setPtrDerived() {

ptr_ = std::shared_ptr<PolyDerived>(new PolyDerived());

}

static void releasePtr() {

ptr_.reset();

}

static std::string getPtrClassName() {

return ptr_->getClassName();

}

static std::shared_ptr<PolyBase> getPtr() {

return ptr_;

}

private:

std::string name_;

static std::shared_ptr<PolyBase> ptr_;

};

std::shared_ptr<PolyBase> PolyDerived::ptr_;

class PolySiblingDerived : public PolyBase {

public:

PolySiblingDerived()

: PolyBase(),

name_("PolySiblingDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyMultiplyDerived : public PolyBase, public PolySecondBase {

public:

PolyMultiplyDerived()

: PolyBase(), PolySecondBase(),

name_("PolyMultiplyDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDerivedTwiceWithoutSmartPointer: public PolyDerived {

public:

PolyDerivedTwiceWithoutSmartPointer()

: PolyDerived(),

name_("PolyDerivedTwiceWithoutSmartPointer")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDerivedTwiceNotBound : public PolyDerived {

public:

PolyDerivedTwiceNotBound()

: PolyDerived(),

name_("PolyDerivedTwiceNotBound")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDerivedThrice: public PolyDerivedTwiceNotBound {

public:

PolyDerivedThrice()

: PolyDerivedTwiceNotBound(),

name_("PolyDerivedThrice")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDerivedFourTimesNotBound: public PolyDerivedThrice {

public:

PolyDerivedFourTimesNotBound()

: PolyDerivedThrice(),

name_("PolyDerivedFourTimesNotBound")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDiamondBase {

public:

PolyDiamondBase():

name_("PolyBase")

{}

~PolyDiamondBase() {}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDiamondDerived: public PolyDiamondBase {

public:

PolyDiamondDerived()

: PolyDiamondBase(),

name_("PolyDiamondDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDiamondSiblingDerived: public PolyDiamondBase {

public:

PolyDiamondSiblingDerived()

: PolyDiamondBase(),

name_("PolyDiamondSiblingDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

class PolyDiamondMultiplyDerived: public PolyDiamondDerived, public PolyDiamondSiblingDerived {

public:

PolyDiamondMultiplyDerived()

: PolyDiamondDerived(), PolyDiamondSiblingDerived(),

name_("PolyDiamondMultiplyDerived")

{}

std::string getClassName() const {

return name_;

}

private:

std::string name_;

};

// End Inheritance Hierarchy Class Definitions

std::map<std::string, int> embind_test_get_string_int_map() {

std::map<std::string, int> m;

m["one"] = 1;

m["two"] = 2;

return m;

};

struct Vector {

Vector() = delete;

Vector(float x_, float y_, float z_, float w_)

: x(x_)

, y(y_)

, z(z_)

, w(w_)

{}

float x, y, z, w;

float& operator[](int i) {

return (&x)[i];

}

const float& operator[](int i) const {

return (&x)[i];

}

float getY() const {

return y;

}

void setY(float _y) {

y = _y;

}

};

struct DummyDataToTestPointerAdjustment {

std::string dummy;

};

struct TupleVector : DummyDataToTestPointerAdjustment, Vector {

TupleVector(): Vector(0, 0, 0, 0) {}

TupleVector(float x, float y, float z, float w): Vector(x, y, z, w) {}

};

struct StructVector : DummyDataToTestPointerAdjustment, Vector {

StructVector(): Vector(0, 0, 0, 0) {}

StructVector(float x, float y, float z, float w): Vector(x, y, z, w) {}

};

float readVectorZ(const Vector& v) {

return v.z;

}

void writeVectorZ(Vector& v, float z) {

v.z = z;

}

struct TupleVectorTuple {

TupleVector v = TupleVector(0, 0, 0, 0);

};

TupleVector emval_test_return_TupleVector() {

return TupleVector(1, 2, 3, 4);

}

TupleVector emval_test_take_and_return_TupleVector(TupleVector v) {

return v;

}

TupleVectorTuple emval_test_return_TupleVectorTuple() {

TupleVectorTuple cvt;

cvt.v = emval_test_return_TupleVector();

return cvt;

}

StructVector emval_test_return_StructVector() {

return StructVector(1, 2, 3, 4);

}

StructVector emval_test_take_and_return_StructVector(StructVector v) {

return v;

}

struct CustomStruct {

CustomStruct()

: field(10)

{}

const int& getField() const {

return field;

}

int field;

};

struct TupleInStruct {

TupleVector field;

};

TupleInStruct emval_test_take_and_return_TupleInStruct(TupleInStruct cs) {

return cs;

}

struct NestedStruct {

int x;

int y;

};

struct ArrayInStruct {

int field1[2];

NestedStruct field2[2];

};

ArrayInStruct emval_test_take_and_return_ArrayInStruct(ArrayInStruct cs) {

return cs;

}

enum Enum { ONE, TWO };

Enum emval_test_take_and_return_Enum(Enum e) {

return e;

}

enum class EnumClass : char { ONE, TWO };

EnumClass emval_test_take_and_return_EnumClass(EnumClass e) {

return e;

}

void emval_test_call_function(val v, int i, float f, TupleVector tv, StructVector sv) {

v(i, f, tv, sv);

}

class UniquePtrToConstructor {

public:

UniquePtrToConstructor(std::unique_ptr<int> p)

: value(*p)

{}

int getValue() const {

return value;

}

private:

int value;

};

std::unique_ptr<int> embind_test_return_unique_ptr(int v) {

return std::unique_ptr<int>(new int(v));

}

UniquePtrToConstructor* embind_test_construct_class_with_unique_ptr(int v) {

return new UniquePtrToConstructor(embind_test_return_unique_ptr(v));

}

int embind_test_accept_unique_ptr(std::unique_ptr<int> p) {

return *p.get();

}

std::unique_ptr<ValHolder> emval_test_return_unique_ptr() {

return std::unique_ptr<ValHolder>(new ValHolder(val::object()));

}

class UniquePtrLifetimeMock {

public:

UniquePtrLifetimeMock(val l) : logger(l) {

logger(std::string("(constructor)"));

}

~UniquePtrLifetimeMock() {

logger(std::string("(destructor)"));

}

private:

val logger;

};

std::unique_ptr<UniquePtrLifetimeMock> emval_test_return_unique_ptr_lifetime(val logger) {

return std::unique_ptr<UniquePtrLifetimeMock>(new UniquePtrLifetimeMock(logger));

}

std::shared_ptr<ValHolder> emval_test_return_shared_ptr() {

return std::shared_ptr<ValHolder>(new ValHolder(val::object()));

}

std::shared_ptr<ValHolder> emval_test_return_empty_shared_ptr() {

return std::shared_ptr<ValHolder>();

}

bool emval_test_is_shared_ptr_null(std::shared_ptr<ValHolder> p) {

return !p;

}

static SmallClass smallClass;

static BigClass bigClass;

SmallClass embind_test_return_small_class_instance() {

return smallClass;

}

BigClass embind_test_return_big_class_instance() {

return bigClass;

}

int embind_test_accept_small_class_instance(SmallClass c) {

return c.member;

}

int embind_test_accept_big_class_instance(BigClass c) {

return c.member;

}

// Begin Inheritance Hierarchy Test Wrappers

Base* embind_test_return_raw_base_ptr() {

return new Base();

}

Base* embind_test_return_raw_derived_ptr_as_base() {

return new Derived();

}

Base* embind_test_return_raw_sibling_derived_ptr_as_base() {

return new SiblingDerived();

}

PolyBase* embind_test_return_raw_polymorphic_derived_ptr_as_base() {

return new PolyDerived();

}

PolyBase* embind_test_return_raw_polymorphic_sibling_derived_ptr_as_base() {