Method IsSOLContExpr

source/script.cpp:2936–3056

bool Script::IsSOLContExpr(LineBuffer &next_buf)
{
	LPTSTR cp, hotkey_flag;

	switch(ctoupper(*next_buf)) // Above has ensured *next_buf != '\0' (toupper might have problems with '\0').
	{
	case 'A': // AND, AS (future use)
	case 'O': // OR
	case 'I': // IS, IN, (unwanted) ISSET
	case 'C': // CONTAINS (future use)
		// See comments in the default section further below.
		cp = find_identifier_end<LPTSTR>(next_buf);
		// Although (x)and(y) is technically valid, it's quite unusual.  The space or tab requirement is kept
		// as the simplest way to allow method definitions to use these as names (when called, the leading dot
		// ensures there is no ambiguity).  Note that checking if we're inside a class definition is not
		// sufficient because multi-line expressions are valid there too (i.e. for var initializers).
		// This also rules out valid double-derefs such as and%suffix% := 1.
		if (IS_SPACE_OR_TAB(*cp) && ConvertWordOperator(next_buf, cp - next_buf))
		{
			// ISSET doesn't need to be excluded here because it can't be legally followed by a space or tab.
			// Unlike in v1, there's no check for an operator after AND/OR (such as AND := 1) because they
			// should never be used as variable names.
			return true;
		}
		break;
	default:
		// Desired line continuation operators:
		// Pretty much everything, namely:
		// +, -, *, /, //, **, <<, >>, &, |, ^, <, >, <=, >=, =, ==, <>, !=, :=, +=, -=, /=, *=, ?, :
		// And also the following remaining unaries (i.e. those that aren't also binaries): !, ~
		// The first line below checks for ::, ++, and --.  Those can't be continuation lines because:
		// "::" isn't a valid operator (this also helps performance if there are many hotstrings).
		// ++ and -- are ambiguous with an isolated line containing ++Var or --Var (and besides,
		// wanting to use ++ to continue an expression seems extremely rare, though if there's ever
		// demand for it, might be able to look at what lies to the right of the operator's operand
		// -- though that would produce inconsistent continuation behavior since ++Var itself still
		// could never be a continuation line due to ambiguity).
		//
		// The logic here isn't smart enough to differentiate between a leading - that's meant as a
		// continuation character and one that isn't. Even if it were, it would still be ambiguous in
		// some cases because the author's intent isn't known; for example, the leading minus sign on
		// the second line below is ambiguous:
		//    x := y 
		//    -z ? a:=1 : func() 
		if ((*next_buf == ':' || *next_buf == '+' || *next_buf == '-') && next_buf[1] == *next_buf // See above.
			|| !_tcschr(CONTINUATION_LINE_SYMBOLS, *next_buf)) // Line doesn't start with a continuation char.
			break;
		// Some of the above checks must be done before the next ones.
		if (   !(hotkey_flag = _tcsstr(next_buf, HOTKEY_FLAG))   ) // Without any "::", it can't be a hotkey or hotstring.
			return true;
		if (*next_buf == ':') // First char is ':', so it's more likely a hotstring than a hotkey.
		{
			// Remember that hotstrings can contain what *appear* to be quoted literal strings,
			// so detecting whether a "::" is in a quoted/literal string in this case would
			// be more complicated.  That's one reason this other method is used.
			bool hotstring_options_all_valid = true;
			for (cp = next_buf + 1; *cp && *cp != ':'; ++cp)
				if (!IS_HOTSTRING_OPTION(*cp)) // Not a perfect test, but eliminates most of what little remaining ambiguity exists between ':' as a continuation character vs. ':' as the start of a hotstring.  It especially eliminates the ":=" operator.