Method parse_expr

sources/instance/runtime.cpp:410–585

	}

	var runtime_type::parse_expr(const tree_type<token_base *>::iterator &it, bool disable_parallel)
	{
		if (!it.usable())
			throw internal_error("The expression tree is not available.");
		token_base *token = it.data();
		if (token == nullptr)
			return var();
		switch (token->get_type()) {
		default:
			break;
		case token_types::vargs:
			throw runtime_error("Wrong declaration of variable argument list.");
			break;
		case token_types::expand:
			throw runtime_error("Wrong expanding position.");
			break;
		case token_types::id:
			return storage.get_var(static_cast<token_id *>(token)->get_id());
			break;
		case token_types::literal: {
			token_literal *ptr = static_cast<token_literal *>(token);
			return get_string_literal(ptr->get_data(), ptr->get_literal());
		}
		case token_types::value:
			return static_cast<token_value *>(token)->get_value();
			break;
		case token_types::expr:
			return parse_expr(static_cast<token_expr *>(token)->get_tree().root());
			break;
		case token_types::array: {
			array arr;
			token_base *ptr = nullptr;
			for (auto &tree : static_cast<token_array *>(token)->get_array()) {
				ptr = tree.root().data();
				if (ptr != nullptr && ptr->get_type() == token_types::expand) {
					var val = parse_expr(static_cast<token_expand *>(ptr)->get_tree().root());
					const auto &child_arr = val.const_val<array>();
					for (auto &it : child_arr)
						arr.push_back(copy(it));
				}
				else
					arr.push_back(copy(parse_expr(tree.root())));
			}
			return rvalue(var::make<array>(std::move(arr)));
		}
		case token_types::parallel: {
			if (disable_parallel)
				throw runtime_error("Do not allowed parallel list.");
			var result;
			for (auto &tree : static_cast<token_parallel *>(token)->get_parallel())
				result = parse_expr(tree.root());
			return result;
		}
		case token_types::signal: {
			switch (static_cast<token_signal *>(token)->get_signal()) {
			default:
				break;
			case signal_types::add_: