#include "CZetScript.h"

using namespace zetscript;

void say_helloworld(){
	printf("Hello World!");
}

int main(){

	CZetScript *zs = CZetScript::getInstance(); // instance zetscript

	register_C_Function("say_helloworld",say_helloworld);

	zs->eval("say_helloworld();"); // Call c function and prints hello world!
	return 0;
}

#include "CZetScript.h"

using namespace zetscript;

int main(){

	CZetScript *zs = CZetScript::getInstance(); // instance zetscript

	zs->eval(
		"class Test{"
		"	var data1;"
		"	function function1(arg){"
		"		print(\"calling Test.Function:\"+arg);"
		"	}"
		"};"
		""
		"function delete_test(){"
		"	delete test;"
		"	print(\"test variable was deleted\");"
		"}"
		""
		"var test=new Test();"
	);

	
    // instance function delete_test function.
	std::function<void()>  * delete_test=bind_function<void ()>("delete_test"); 

    // instance member function test.function1.
	std::function<void(int)> * test_function1=bind_function<void (int)>("test.function1"); 
	
    // it calls "test.function" member function with 10 as parameter.
	(*test_function1)(10); 

    // it calls "delete_test" function with no parameters
	(*delete_test)(); 

	// delete functions when they are used anymore
	delete 	test_function1;
	delete 	delete_test;

}

#include "CZetScript.h"

using namespace zetscript;

int main(){

    int i=10;
	string	string_var = "in c++";
    bool b=false;
    float f=5.0;

	CZetScript *zs = CZetScript::getInstance(); // instance zetscript

    register_C_Variable("i",i); // it registers int variable called i
    register_C_Variable("b",b); // it registers bool var ble called b
    register_C_Variable("f",f); // it registers float variable called f
	register_C_Variable("string_var",string_var); // it registers string variable called string_var

	zs->eval(
        "i+=10;" // i+=10 => i=20
        "b=!b;" //  b=!b  => b=true
        "f+=10.5;" // f+=10.5 => f = 15.5
		"string_var+=\" and in script\";" // concatenates " and in script
		"print(\"string_var:\"+string_var);" // prints "string_var:in c++ and in script
	);
	return 0;
}

#include "CZetScript.h"

using namespace zetscript;

class MyClass{
public:
	int data1;

	void function1(int arg){
		this->data1 = arg;
		printf("Int argument is %i\n",this->data1);
	}
};

class MyClassExtend:public MyClass{
public:
	float data2;

	void function2(float * arg){
		this->data2 = *arg;
		printf("Float argument is %.02f\n",this->data2);
	}
};

int main(){

	CZetScript *zs = CZetScript::getInstance(); // instance zetscript
	
    // register MyClass with name MyClass in script side.
	register_C_Class<MyClass>("MyClass"); 

    // register MyClassExtend with name MyClassExtend in script side.
	register_C_Class<MyClassExtend>("MyClassExtend"); 
	
    // tell that MyClassExtend is base of MyClass
	class_C_baseof<MyClassExtend,MyClass>(); 

    // register data1 named data1 in script side as variable member.
	register_C_VariableMember<MyClassExtend>("data1",&MyClass::data1); 

    // register function1 named function1 in script side as function member.
	register_C_FunctionMember<MyClassExtend>("function1",&MyClass::function1); 

    // register data2 named data1 in script side as variable member.
	register_C_VariableMember<MyClassExtend>("data2",&MyClassExtend::data2); 

    // register function2 named function2 in script side as function member.
	register_C_FunctionMember<MyClassExtend>("function2",&MyClassExtend::function2); 



	zs->eval(
		"var myclass = new MyClassExtend();" // instances MyClassExtend
		"myclass.function1(12);" // it prints "Int argument is 12"
		"myclass.function2(0.5);" // it prints "Float argument is 0.5"
		"print(\"data1:\"+myclass.data1);" // it prints "data1:12"
		"print(\"data2:\"+myclass.data2);" // it prints "data2:0.5"
		"delete myclass;" // delete script var with c pointers attached inside.
	);

	return 0;
}

class MyNumber{
  var num;
  function MyNumber(_n){
    this.num=_n;
  }
  function _add(op1,op2){
    return new MyNumber(op1.num+op2.num);
  }
};

var n1 = new MyNumber (20);
var n2 = new MyNumber (10);
var n3 =n1+n2;

print("n1 ("+n1.num+") n2 ("+n2.num+") = "+n3.num);

#include "CZetScript.h"

using namespace zetscript;

class MyNumber{
public:
    int num;
    MyNumber(){
        this->num=0;
    }
    MyNumber(int _n){
        this->num=_n;
    }
    void set(int _n){
        this->num=_n;
    }
    static MyNumber * _add(MyNumber *op1, MyNumber *op2){
        return new MyNumber(op1->num + op2->num);
    }
};
int main(){
    CZetScript *zs = CZetScript::getInstance();

    // register class MyNumber
    register_C_Class<MyNumber>("MyNumber");

    // register variable member num
    register_C_VariableMember<MyNumber>("num",&MyNumber::num);

    // register constructor through function MyNumber::set
    register_C_FunctionMember<MyNumber>("MyNumber",&MyNumber:: set);

    // register static function _add as metamethod
    register_C_StaticFunctionMember<MyNumber>("_add",&MyNumber::_add);
    
    if(!zs->eval(
        "var n1 = new MyNumber (20);\n"
        "var n2 = new MyNumber (10); \n"
        "var n3 =n1+n2; \n "
        "print(\"n1 (\"+n1.num+\") + n2 (\"+n2.num+\") = \"+n3.num);\n"
    )){
        fprintf(stderr,ZS_GET_ERROR_MSG());
    }
    return 0;
}