// Copyright 2012 The Emscripten Authors. All rights reserved.

// Emscripten is available under two separate licenses, the MIT license and the

// University of Illinois/NCSA Open Source License. Both these licenses can be

// found in the LICENSE file.

#include <string>

#include <malloc.h>

#include <functional>

#include <emscripten/bind.h>

#include <emscripten/heap.h>

#include <emscripten/em_asm.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;

}

struct DummyForPointer {

int value;

DummyForPointer(const int v) : value(v) {}

};

static DummyForPointer emval_pointer_dummy(42);

val emval_test_instance_pointer() {

DummyForPointer* p = &emval_pointer_dummy;

return val(p);

}

int emval_test_value_from_instance_pointer(val v) {

DummyForPointer * p = v.as<DummyForPointer *>(allow_raw_pointers());

return p->value;

}

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(bool embindStdStringUTF8Support) {

if(embindStdStringUTF8Support) {

//ASCII

std::string testString{"aei"};

//Latin-1 Supplement

testString += "\u00E1\u00E9\u00ED";

//Greek

testString += "\u03B1\u03B5\u03B9";

//Cyrillic

testString += "\u0416\u041B\u0424";

//CJK

testString += "\u5F9E\u7345\u5B50";

//Euro sign

testString += "\u20AC";

return testString;

} else {

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::u16string get_non_ascii_u16string() {

std::u16string u16s(4, 0);

u16s[0] = 10;

u16s[1] = 1234;

u16s[2] = 2345;

u16s[3] = 65535;

return u16s;

}

std::u32string get_non_ascii_u32string() {

std::u32string u32s(5, 0);

u32s[0] = 10;

u32s[1] = 1234;

u32s[2] = 2345;

u32s[3] = 128513;

u32s[4] = 128640;

return u32s;

}

std::wstring get_literal_wstring() {

return L"get_literal_wstring";

}

std::u16string get_literal_u16string() {

return u"get_literal_u16string";

}

std::u32string get_literal_u32string() {

return U"get_literal_u32string";

}

void force_memory_growth() {

std::size_t old_size = emscripten_get_heap_size();

EM_ASM({"globalThis.oldheap = HEAPU8;"});

assert(val::global("oldheap")["byteLength"].as<size_t>() == old_size);

emscripten_resize_heap(old_size + EMSCRIPTEN_PAGE_SIZE);

assert(emscripten_get_heap_size() > old_size);

// HEAPU8 on the module should now be rebound, and our oldheap should be detached

assert(val::module_property("HEAPU8")["byteLength"].as<size_t>() > old_size);

assert(val::global("oldheap")["byteLength"].as<size_t>() == 0);

}

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::u16string take_and_return_std_u16string(std::u16string str) {

return str;

}

std::u32string take_and_return_std_u32string(std::u32string 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();

}

val valholder_get_value_mixin(const ValHolder& target) {

return target.getVal();

}

void valholder_set_value_mixin(ValHolder& target, const val& value) {

target.setVal(value);

}

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 NoExceptClass {

public:

int getValue() noexcept {

return 42;

}

int getValueConst() const noexcept {

return 43;

}

int getX() const noexcept { return x; }

void setX(int x_) noexcept { x = x_; }

private:

int x;

};

void embind_test_no_except_function(NoExceptClass&) noexcept {}

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;

};

};

class SymbolNameClass {

public:

std::string iterator() {

return "Iterator";

}

static std::string species() {

return "Species";

}

};

// 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;

}

static std::string classFunction() {

return "Base";

};

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;

}

static std::string classFunction() {

return "Derived";

}

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;