Function make_nested_token

engine/src/parser/expression_utils.cpp:1540–1586

Used by `nary_to_nestedbinary` to convert an expression string CALL(arg1, arg2, arg3, ...) to CALL(CALL(CALL(arg1, arg2), arg3), ...)

// Used by `nary_to_nestedbinary` to convert an expression string CALL(arg1, arg2, arg3, ...) to CALL(CALL(CALL(arg1, arg2), arg3), ...)
static inline std::string make_nested_token(std::string & subexpression,
                                            const std::string & operator_name) {
  static const std::string::value_type arg_separator = ',';
	static const std::string::value_type flag_separator = 1;

	bool isnt_string = true;
	std::size_t bracket_count = 0;
	std::string::value_type * data = subexpression.data();
	do {
		switch (*data) {
		case '(': ++bracket_count; break;
		case ')': --bracket_count; break;
		case '\'': isnt_string = !isnt_string; break;
		}
		if (isnt_string && !bracket_count && *data == arg_separator) {
			*data = flag_separator;
		}
	} while (*data++);

	std::istringstream iss{subexpression};
	std::vector<std::string> targs;
	std::string targ;
	while (std::getline(iss, targ, flag_separator)) {
		targs.emplace_back(targ);
	}

	if (targs.size() < 2) {
		throw std::runtime_error(
			"CONCAT operator must have at least two children, as CONCAT($0, "
			"$1) .");
	}

	std::ostringstream oss;
	std::size_t n_calls = targs.size() - 1;
	while (n_calls--) {
		oss << operator_name << '(';
	}

	std::vector<std::string>::const_iterator tbegin = targs.cbegin();
	std::vector<std::string>::const_iterator tend = targs.cend();
	oss << *tbegin;
	while (++tbegin != tend) {
		oss << arg_separator << *tbegin << ')';
	}

	return oss.str();
}

// Used by `convert_internals_nary_concat_to_nested_binary_concat` to expand an n-ary function calls to multiple binary calls.
static inline std::string