vm_run.cpp


#include "vm.h"

inline bool empty(std::vector<Event>& stack) {
	return stack.empty();
}
inline bool empty(int64_t stack_count) {
	return stack_count <= 0;
}
inline Event& back(std::vector<Event>& stack, int64_t& stack_count) {
	return stack[stack_count - 1];
}
inline void pop_back(std::vector<Event>& stack, int64_t& stack_count) {
	stack_count--;
}
inline void push_back(std::vector<Event>& stack, int64_t& stack_count, Event&& e) {
	if (stack_count < stack.size()) {
		stack[stack_count] = std::move(e);
	}
	else {
		stack.push_back(std::move(e));
	}
	stack_count++;
}

inline bool empty(std::vector<Token>& stack) {
	return stack.empty();
}
inline Token& back(std::vector<Token>& stack, int64_t& stack_count) {
	return stack[stack_count - 1];
}
inline void pop_back(std::vector<Token>& stack, int64_t& stack_count) {
	stack_count--;
}
inline void push_back(std::vector<Token>& stack, int64_t& stack_count, Token&& t) {
	if (stack_count < stack.size()) {
		stack[stack_count] = std::move(t);
	}
	else {
		stack.push_back(std::move(t));
	}
	stack_count++;
}


std::vector<Token> VM::Run(std::string str_id, clau_parser::UserType* global,
	const myMap<const char*, Token>& parameter) {
	
	claujson::parser p;
	claujson::Document d;

	int64_t id = this->_event_map[str_id.c_str()];
	Event& main = _event_list[id];
	main.code = &_event_code_list[id];

	//main.parameter = parameter;
	for (auto& x : parameter) {
		main.parameter.insert({ x.first, x.second.clone() });
	}
	std::vector<Token> token_stack;
	int64_t token_count = 0;
	std::vector<Event> _stack;
	int64_t _stack_count = 0;
	
	myMap<std::string_view, std::vector<Token>> global_var;

	token_stack.reserve(1024);
	_stack.reserve(1024);
	_stack.push_back(main.clone());
	_stack_count++;

	int count = 0;
	std::string dir = "";

	std::vector<Token> return_value;


    while (!empty(_stack_count)) {
		auto& x = back(_stack, _stack_count);
		count++;

		//std::cout << func_to_str[x.code->event_data[x.now]] << "\n";

		switch (x.code->event_data[x.now]) {
		case FUNC::TRUE:
		{
			Token token;
			token.SetBool(true);

			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FALSE:
		{
			Token token;
			token.SetBool(false);

			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FUNC_IS_INT:
		{
			auto token = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			token.SetBool(token.IsInt());

			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FUNC_IS_FLOAT:
		{
			auto token = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			token.SetBool(token.IsFloat());

			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FUNC_SPLIT:
		{
			auto divider = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);
			char ch = divider.ToString()[0];

			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);
			auto& dest = global_var[dir.ToString()];

			auto str = back(token_stack, token_count).ToString(); pop_back(token_stack, token_count);

			auto arr = clau_parser::tokenize(str, ch);

			for (const auto& _ : arr) {
				Token token;
				token.SetString(_);
				dest.push_back(std::move(token));
			}
		}
		break;
		case FUNC::FUNC_GET_GLOBAL:
		{
			auto idx = back(token_stack, token_count).ToInt(); pop_back(token_stack, token_count);

			auto dir = back(token_stack, token_count).ToCString(); pop_back(token_stack, token_count);

			push_back(token_stack, token_count, global_var[dir][idx].clone());
		}
		break;
		case FUNC::FUNC_SET_GLOBAL:
		{
			auto value = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);
			auto idx = back(token_stack, token_count).ToInt(); pop_back(token_stack, token_count);
			auto dir = back(token_stack, token_count).ToString(); pop_back(token_stack, token_count);

			global_var[dir][idx] = std::move(value);
		}
		break;
		case FUNC::FUNC_MAKE_GLOBAL:
		{
			auto init = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);
			
			global_var[dir.ToString()].push_back(std::move(init));
		}
		break;
		case FUNC::FUNC_CLEAR_GLOBAL:
		{
			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			auto& dest = global_var[dir.ToString()];
	
			dest.clear();
		}
		break;	
		case FUNC::FUNC_REMOVE:
		{
			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			auto arr = Find(global, dir.ToString());

			for (int i = 0; i < arr.size(); ++i) {
				auto ut = arr[i].workspace.GetReader()->GetUT();
				auto parent = ut->GetParent();

				for (int j = 0; j < parent->GetUserTypeListSize(); ++j) {
					if (parent->GetUserTypeList(j) == ut) {
						parent->RemoveUserTypeList(j);
					}
				}
			}
		}
		break; 
		case FUNC::FUNC_COUNT_GLOBAL:
		{
			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			const auto& arr = global_var[dir.ToString()];
			Token token;
			token.SetInt(arr.size());
			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FUNC_SEARCH:
		{
		//	x.now++;

            auto& ut = (x.code->input)[x.code->constant_data[x.now]]; //x.now++;
			auto to = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);
			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			auto& workspace = this->Find(global, dir.ToString())[0].workspace;
			auto& dest = this->Find(global, to.ToString())[0].workspace;

			for (int i = 2; i < ut.ut_val->GetUserTypeListSize(); ++i) {
				this->SearchFunc(workspace.GetReader()->GetUT(), ut.ut_val->GetUserTypeList(i), dest.GetReader()->GetUT(), this);
			}
		}
		break;
		case FUNC::FUNC_QUERY:
		{
			//x.now++;

			auto& ut = (x.code->input)[x.code->constant_data[x.now]]; //x.now++;
			auto dir = std::move(back(token_stack, token_count)); pop_back(token_stack, token_count);

			auto& workspace = this->Find(global, dir.ToString())[0].workspace;


			for (int i = 1; i < ut.ut_val->GetUserTypeListSize(); ++i) {
				if (ut.ut_val->GetUserTypeList(i)->GetName() == "$insert"sv) {
					this->InsertFunc(workspace.GetReader()->GetUT(), ut.ut_val->GetUserTypeList(i), this);
				}
				else if (ut.ut_val->GetUserTypeList(i)->GetName() == "$update"sv) {
					this->UpdateFunc(workspace.GetReader()->GetUT(), ut.ut_val->GetUserTypeList(i), this);
				}
				else if (ut.ut_val->GetUserTypeList(i)->GetName() == "$delete"sv) {
					this->RemoveFunc(workspace.GetReader()->GetUT(), ut.ut_val->GetUserTypeList(i), this);
				}
			}
		}
		break;
		case FUNC::FUNC_GET:
		{
			auto token = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);
			
			if (token.IsLocal()) { // ToString().starts_with("$local."sv)) {
				//token.ConvertLocal();
				push_back(token_stack, token_count, x.local[token.ToCString()].clone());
			}
			else {
				auto value = FindValue(global, token.ToString()); // ToString?

				push_back(token_stack, token_count, std::move(value[0]));
			}
		}

		break;
		case FUNC::FUNC_ASSIGN:
		{
			auto value = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			auto name = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			if (name.IsLocal()) { // ToString().starts_with("$local."sv)) {
				x.local[name.ToCString()] = std::move(value);
			}
			else {
				auto idx = name.ToString().find_last_of('/');
				if (idx != std::string::npos) {
					auto dir = name.ToString().substr(0, idx);
					auto _name = name.ToString().substr(idx + 1);
					auto ut = Find(global, dir);

					for (int i = 0; i < ut.size(); ++i) {
						auto arr = ut[i].workspace.GetReader()->GetUT()->GetItemIdx(_name);
						
						for (int j = 0; j < arr.size(); ++j) {
							ut[i].workspace.GetReader()->GetUT()->GetItemList(arr[j]).Set(0, value.ToString());
						}
					}
				}
			}
		}
		break;
		case FUNC::START_DIR:
			count = 0;
			dir = "/";
			break;
		case FUNC::DIR:
			////std::cout << "DIR chk" << back(token_stack, token_count).ToString() << "\n";
		{
			auto& str = back(token_stack, token_count);

			if (str.IsParameter()) { //starts_with("$parameter."sv)) {
				str.ConvertParameter();
				Token& token = x.parameter[str.ToCString()];
				dir += token.ToString();
			}
			else if (str.IsLocal()) {
				str.ConvertLocal();
				Token& token = x.local[str.ToCString()];
				dir += token.ToString();
			}
			else {
				dir += back(token_stack, token_count).ToString(); // ToString
			}

			pop_back(token_stack, token_count);
			dir += "/";
		}

		break;
		case FUNC::END_DIR:
		{
			Token token;

			if (dir.back() == '/') {
				token.SetString(dir.substr(0, dir.size() - 1));
			}
			else {
				token.SetString(dir);
			}
			push_back(token_stack, token_count, std::move(token));

			dir = "";
			count = 0;
		}
		break;
		case FUNC::FUNC_REMOVE_QUOTED:
		{
			auto str = back(token_stack, token_count).ToString();

			if (str.size() >= 2) {
				str = str.substr(1, str.size() - 2);
			}
			pop_back(token_stack, token_count);

			Token temp;
			temp.SetString(str);
			push_back(token_stack, token_count, std::move(temp));
		}
		break;
		case FUNC::FUNC_IS_QUOTED_STR:
		{
			const auto& str = back(token_stack, token_count).ToString();
			bool chk = str.size() >= 2 && (str)[0] == str.back() && str.back() == '\"';

			pop_back(token_stack, token_count);

			Token temp;

			temp.SetBool(chk);

			push_back(token_stack, token_count, std::move(temp));
			break;
		}
		case FUNC::FUNC_RETURN:

			if (token_count > 0) {
				Token temp = std::move(back(token_stack, token_count));
				pop_back(token_stack, token_count);

				pop_back(_stack, _stack_count);
				if (_stack_count > 0) {
					back(_stack, _stack_count).return_value = std::move(temp);
				}
			}
			else {
				pop_back(_stack, _stack_count);
			}
		break;
		case FUNC::CONSTANT:
			{
				const auto& value = (x.code->input)[x.code->constant_data[x.now]];
				//std::cout << value.ToString() << "\n";

				if (value.IsParameter()) { // ToString().starts_with("$parameter."sv)) {
					//value.ConvertParameter();
					auto param = value.ToCString(); // .substr(11);

					push_back(token_stack, token_count, x.parameter.find(param)->clone());
				}
				else {
					push_back(token_stack, token_count, value.clone());
				}
			}

			break;
		case FUNC::FUNC_ADD:
		{
			auto a = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);
			auto b = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			{
				Token token;

				if (a.IsFloat() && b.IsFloat()) {
					token.SetFloat(a.ToFloat() + b.ToFloat());
				}
				else if (a.IsInt() && b.IsInt()) {
					token.SetInt(a.ToInt() + b.ToInt());
				}
				// todo...
				else if (a.IsFloat()) {
					
				}

				push_back(token_stack, token_count, std::move(token));
			}
		}
		break;
		case FUNC::FUNC_CALL:
			//x.now++;

			{
				auto count = x.code->constant_data[x.now];
                x.now++;

				Event e;

				for (int i = 0; i < count; ++i) {
					auto value = std::move(back(token_stack, token_count));
					pop_back(token_stack, token_count);
					auto name = std::move(back(token_stack, token_count));
					pop_back(token_stack, token_count);

					//std::cout << "name " << name.ToCString() << "\n";
					//std::cout << "value " << value.ToCString() << "\n";
					if (name.ToCString() == "id"sv) {
						//		//std::cout << e.id << "\n";
						if (value.IsInt()) {
							e.code = _event_code_list.find(value.ToInt());
                        }
						else {
							e.code = &_event_code_list[*_event_map.find(value.ToCString())];
                        }
						e.now = 0;
						continue;
					}

					e.parameter[name.ToCString()] = std::move(value); // name.ToString()
				}

				if (!e.code) {
					exit(-1);
				}
				push_back(_stack, _stack_count, std::move(e));
			}

			continue;

			break;

			// do not compare bools
		case FUNC::FUNC_COMP_LEFT:
			// Compare!
		{
			auto a = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);
			auto b = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			{
				Token token;

				if (a.IsFloat() && b.IsFloat()) {
					token.SetBool(b.ToFloat() > a.ToFloat());
				}
				else if (a.IsInt() && b.IsInt()) {
					token.SetBool(b.ToInt() > a.ToInt());
				}
				else if (a.IsString() && b.IsString()) {
					token.SetBool(b.ToString() > a.ToString());
				}

				push_back(token_stack, token_count, std::move(token));
			}
		}
		break;
		case FUNC::FUNC_COMP_RIGHT:
		{
			auto b = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);
			auto a = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			{
				Token token;

				if (a.IsFloat() && b.IsFloat()) {
					token.SetBool(a.ToFloat() < b.ToFloat());
				}
				else if (a.IsInt() && b.IsInt()) {
					token.SetBool(a.ToInt() < b.ToInt());
				}
				else if (a.IsString() && b.IsString()) {
					token.SetBool(a.ToString() < b.ToString());
				}

				push_back(token_stack, token_count, std::move(token));
			}
		}
		break;
		case FUNC::FUNC_FIND:
		{
            // chk error?
			auto a = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

            x.return_value = Find(global, a.ToString())[0].clone();
		}
		break;
		case FUNC::FUNC_RETURN_VALUE:
		{
			push_back(token_stack, token_count, x.return_value.clone());
		}
		break;
		case FUNC::FUNC_NEXT:
			//x.return_value_now++;
			break;
		case FUNC::FUNC_LOAD_DATA:
		{
			std::string fileName = back(token_stack, token_count).ToString();
			fileName = fileName.substr(1, fileName.size() - 2);
			pop_back(token_stack, token_count);

			clau_parser::UserType* dir = back(token_stack, token_count).workspace.GetReader()->GetUT();
			pop_back(token_stack, token_count);

			clau_parser::LoadData::LoadDataFromFile(fileName, *dir, 0, 0);
		}
		break;
		case FUNC::FUNC_LOAD_JSON:
		{
			std::string fileName = back(token_stack, token_count).ToString();
			fileName = fileName.substr(1, fileName.size() - 2);
			pop_back(token_stack, token_count);

			p.parse(fileName, d, 0);
			
			Token temp;
			temp.SetWorkspaceJ(new claujson::Explorer(d.Get()));
			x.return_value = (std::move(temp));
			//x.return_value_now = 0;
		}
		break;
		case FUNC::FUNC_ENTER:
			if (back(token_stack, token_count).IsWorkspace()) {
				back(token_stack, token_count).workspace.GetReader()->Enter();
				pop_back(token_stack, token_count);
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				back(token_stack, token_count).workspacej.GetReader()->Enter();
				pop_back(token_stack, token_count);
			}
			break;
		case FUNC::FUNC_QUIT:
			if (back(token_stack, token_count).IsWorkspace()) {
				back(token_stack, token_count).workspace.GetReader()->Quit();
				pop_back(token_stack, token_count);
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				back(token_stack, token_count).workspacej.GetReader()->Quit();
				pop_back(token_stack, token_count);
			}
			break;
		case FUNC::FUNC_SET_NAME:
		{
			auto name = back(token_stack, token_count).ToString();

			pop_back(token_stack, token_count);
			if (back(token_stack, token_count).IsWorkspace()) {
				back(token_stack, token_count).workspace.GetReader()->SetKey(name);

				pop_back(token_stack, token_count);
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				back(token_stack, token_count).workspacej.GetReader()->ChangeKey(claujson::_Value(name));

				pop_back(token_stack, token_count);
			}
		}
		break;
		case FUNC::FUNC_SET_VALUE:
		{
			auto value = back(token_stack, token_count).ToString();

			pop_back(token_stack, token_count);
			if (back(token_stack, token_count).IsWorkspace()) {
				back(token_stack, token_count).workspace.GetReader()->SetData(value);

				pop_back(token_stack, token_count);
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				claujson::Document d;
				p.parse_str(value, d, 1);
				back(token_stack, token_count).workspacej.GetReader()->Get() = std::move(d.Get());

				pop_back(token_stack, token_count);
			}
		}
		break;
		case FUNC::FUNC_GET_NAME:

			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;
				token.SetCString(back(token_stack, token_count).workspace.GetReader()->GetKey().c_str());

				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			} 
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;
				bool e = false; // error flag
				token.SetCString(back(token_stack, token_count).workspacej.GetReader()->GetKey().get_string().data());
				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			}
		break;
		case FUNC::FUNC_GET_VALUE:

			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;
				token.SetCString(back(token_stack, token_count).workspace.GetReader()->GetData().c_str());

				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;
				auto& x = back(token_stack, token_count).workspacej.GetReader()->Get();
				if (x.is_int()) {
					token.SetInt(x.get_integer());
				}
				else if (x.is_uint()) {
					token.SetInt(x.get_unsigned_integer());
				}
				else if(x.is_float()) {
					token.SetFloat(x.get_floating());
				}
				else if (x.is_bool()) {
					token.SetBool(x.get_boolean());
				}
				else if (x.is_null()) {
					token.SetCString("null");
				}
				else if (x.is_str()) {
					token.SetCString(x.get_string().data());
				}
				else {
					// object or array
					// nothing to do
					token.SetCString("");
				}
				
				//token.SetString(back(token_stack, token_count).workspacej.GetReader()->Get().convert_primitive_to_std_string());

				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			}
		break;
		case FUNC::FUNC_GET_IDX:
			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;
				token.SetInt(back(token_stack, token_count).workspace.GetReader()->GetIdx());

				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;
				token.SetInt(back(token_stack, token_count).workspacej.GetReader()->GetIdx());

				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(token));
			}
		break;

		case FUNC::FUNC_SET_IDX:
		{
			//auto a = std::stoll(x.code->input[x.code->event_data[x.now]].ToString());

			auto a = back(token_stack, token_count).ToInt();
			pop_back(token_stack, token_count);
			if (back(token_stack, token_count).IsWorkspace()) {
				auto& space = back(token_stack, token_count).workspace;
				
				space.GetReader()->SetIndex(a);
				
				pop_back(token_stack, token_count);
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				auto& space = back(token_stack, token_count).workspacej;
 			
				space.GetReader()->SetIdx(a);
				
				pop_back(token_stack, token_count);
			}
		}
		break;

		case FUNC::FUNC_WHILE:
		{
			//std::cout << "WHILE.... \n";
		}
		break;

		case FUNC::FUNC_AND_ALL:
		{
			//x.now++;
			auto count = x.code->constant_data[x.now]; //x.now++;
			bool result = true;

			for (int i = 0; i < count; i += 1) {
				bool b = back(token_stack, token_count).ToBool();
				
				if (result) {
					result = result && b;
				}

				pop_back(token_stack, token_count);
			}

			Token temp;
			temp.SetBool(result);

			push_back(token_stack, token_count, std::move(temp));
		}
		break;
		case FUNC::FUNC_AND:
		{
			bool result = true;

			for (int i = 0; i < 2; i += 1) {
				bool b = back(token_stack, token_count).ToBool();
				if (result) {
					result = result && b;
				}
				pop_back(token_stack, token_count);
			}

			Token temp;
			temp.SetBool(result);

			push_back(token_stack, token_count, std::move(temp));
		}

		break;
		case FUNC::FUNC_OR:
		{
			bool result = true;

			for (int i = 0; i < 2; i += 1) {
				bool b = back(token_stack, token_count).ToBool();
				result = result || b;
				pop_back(token_stack, token_count);
			}

			Token temp;

			temp.SetBool(result);

			push_back(token_stack, token_count, std::move(temp));
		}
		break;
		case FUNC::FUNC_GET_NOW:
			if (back(token_stack, token_count).IsWorkspace()) {
				auto& space = back(token_stack, token_count).workspace;
				
				Token temp;
				temp.SetWorkspace(space.GetReader());

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(temp));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				auto& space = back(token_stack, token_count).workspacej;
				

				Token temp;
				temp.SetWorkspaceJ(space.GetReader());

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(temp));
			}
		break;

		case FUNC::THEN:
		{
			auto param = back(token_stack, token_count).ToBool(); // bool
			pop_back(token_stack, token_count);

			if (param) {
				//x.now++;
			}
			else {
				x.now = x.code->constant_data[x.now]; 

				x.now--;
			}
		}
		break;
		case FUNC::WHILE_END:
		{
			x.now = x.code->constant_data[x.now];

			//std::cout << "chk .. " << func_to_str[x.code->event_data[x.now]] << "\n";

			x.now--;
		}
		break;
		case FUNC::FUNC_IF:
		{
			//
		}
		break;

		case FUNC::IF_END:
		{
			//
		}
		break;
		case FUNC::FUNC_IS_END: //
		{
			Token token;

			token.SetInt(1);

			push_back(token_stack, token_count, std::move(token));
		}
		break;
		case FUNC::FUNC_NOT:
		{
			auto a = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);

			a.SetBool(!a.ToBool());

			push_back(token_stack, token_count, std::move(a));
		}
		break;
		case FUNC::FUNC_NOT_EMPTY:
		{
			Token token = std::move(back(token_stack, token_count));
			pop_back(token_stack, token_count);
			
			if (token.IsWorkspace()) {
				Token temp;
				temp.SetBool(token.workspace.GetReader()->GetIdx() >= token.workspace.GetReader()->Length());
				push_back(token_stack, token_count, std::move(temp));
			}
			else if (token.IsWorkspaceJ()) {
				Token temp;
				temp.SetBool(!token.workspacej.GetReader()->IsEndOfGroup());
				push_back(token_stack, token_count, std::move(temp));
			}
		}
		break;
		case FUNC::FUNC_IS_GROUP:
			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;

				token.SetBool(back(token_stack, token_count).workspace.GetReader()->IsGroup());

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;

				token.SetBool(back(token_stack, token_count).workspacej.GetReader()->Get().is_structured()); // array or object

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));

			}
		break;
		case FUNC::FUNC_IS_ITEM:
			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;

				token.SetBool(!back(token_stack, token_count).workspace.GetReader()->IsGroup());

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;

				token.SetBool(back(token_stack, token_count).workspacej.GetReader()->Get().is_primitive());

				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));
			}
		break;
		case FUNC::FUNC_GET_SIZE: // for array or object?
			if (back(token_stack, token_count).IsWorkspace()) {
				Token token;
				token.SetInt((back(token_stack, token_count).workspace.GetReader()->Length()));
				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				Token token;
				token.SetInt((back(token_stack, token_count).workspacej.GetReader()->Size()));
				pop_back(token_stack, token_count);

				push_back(token_stack, token_count, std::move(token));
			}
			break;
		case FUNC::FUNC_CLONE: // ?
			if (back(token_stack, token_count).IsWorkspace()) {
				auto& a = back(token_stack, token_count).workspace;
				
				Token b;
				b.SetWorkspace(new clau_parser::Reader(*a.GetReader()));
				
				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(b));
			}
			else if (back(token_stack, token_count).IsWorkspaceJ()) {
				auto& a = back(token_stack, token_count).workspacej;
			
				Token b;
				b.SetWorkspaceJ(new claujson::Explorer(*a.GetReader()));
				
				pop_back(token_stack, token_count);
				push_back(token_stack, token_count, std::move(b));
			}
		break;

		case FUNC::FUNC_PRINT:
		{
			std::vector<Token> vec;

			if (x.code->constant_data[x.now] > 0) {
				vec.reserve(x.code->constant_data[x.now]);
			}

			for (int i = 0; i < x.code->constant_data[x.now]; ++i) {
				vec.push_back(std::move(back(token_stack, token_count)));
				pop_back(token_stack, token_count);
			}
			for (int i = vec.size() - 1; i >= 0; --i) {
				if (vec[i].ToString() == "\\n"sv) {
					std::cout << "\n";
				}
				else {
					std::cout << vec[i].ToString();
				}
			}
		}
		break;

        case FUNC::NOTHING:
        {
            break;
        }
		default:
			//std::cout << "error \n";
			break;

		}
		x.now++;
	}

	return return_value;
}