C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

public class ExpressionEvaluator
{
	private string _expr;
	private int _pos;
	private List<double> _vars = [];
	private int _ivar;

	public static double Evaluate(string strExpr)
	{
		var expr = new ExpressionEvaluator(strExpr.Replace('\n', ' '));
		double value = expr.ParseExpression();
		expr.CheckNoRemain();
		return value;
	}

	private static double ResolveVariable(string name, List<string> args)
	{
		Console.Write($"Resolving variable: <{name}{(args.Count > 0 ? ":" + string.Join(":", args) : "")}>");
		double value = -0.1; // Mocked value
		Console.WriteLine($" == {value}");
		return value;
	}

	private ExpressionEvaluator(string expr)
	{
		string pattern = @"<([^= \t\n0-9.<>()!-][^<>\n]*|[ \t]+(?:[^ \t\n0-9.<>()!-][^<>\n]*)?)>";
		while (Regex.IsMatch(expr, pattern))
		{
			expr = Regex.Replace(expr, pattern, match =>
			{
				string[] parts = match.Groups[1].Value.Split(':');
				string name = parts[0].Trim();
				List<string> args = new List<string>();
				for (int i = 1; i < parts.Length; i++)
					args.Add(parts[i].Trim());
				_vars.Add(ResolveVariable(name, args));
				return "\n"; // placeholder
			});
		}
		_expr = string.Join(" ", expr.Split([' ', '\t'], StringSplitOptions.RemoveEmptyEntries));
		_pos = 0;
		_ivar = 0;
		Console.WriteLine($"Resolved: {_expr.Replace("\n", "<...>")}");
	}

	private char Current => _pos < _expr.Length ? _expr[_pos] : '\0';
	private string RemainDiagnosis => _expr.Substring(_pos).Replace("\n", "<...>");
	private void Next() => _pos++;
	
	private void CheckNoRemain()
	{
		if (Current == ' ')
			Next();
		if (_pos < _expr.Length)
			throw new Exception($"Unexpected: {RemainDiagnosis}");
	}

	private bool Match(char expected, bool skipSpaces = true)
	{
		if (Current == ' ' && skipSpaces)
			Next();
		if (Current == expected)
		{
			Next();
			return true;
		}
		return false;
	}

	private double ParseExpression() => ParseOr();

	private double ParseOr()
	{
		double left = ParseXor();
		while (Match('|'))
		{
			bool bLeft = ToBool(left);
			bool bRight = ToBool(ParseXor());
			Console.Write($"Or({bLeft}, {bRight})");
			left = (bLeft || bRight) ? 1 : 0;
			Console.WriteLine($" == {left}");
		}
		return left;
	}

	private double ParseXor()
	{
		double left = ParseAnd();
		while (Match('^'))
		{
			bool bLeft = ToBool(left);
			bool bRight = ToBool(ParseAnd());
			Console.Write($"Xor({bLeft}, {bRight})");
			left = (bLeft ^ bRight) ? 1 : 0;
			Console.WriteLine($" == {left}");
		}
		return left;
	}

	private double ParseAnd()
	{
		double left = ParseEquality();
		while (Match('&'))
		{
			bool bLeft = ToBool(left);
			bool bRight = ToBool(ParseEquality());
			Console.Write($"And({bLeft}, {bRight})");
			left = (bLeft && bRight) ? 1 : 0;
			Console.WriteLine($" == {left}");
		}
		return left;
	}

	private double ParseEquality()
	{
		double left = ParseComparison();
		while (true)
		{
			if (Match('='))
			{
				if (!Match('=', skipSpaces: false))
					throw new Exception("Expected '=='");
				double right = ParseComparison();
				Console.Write($"Equal({left}, {right})");
				left = right == left ? 1 : 0;
				Console.WriteLine($" == {left}");
			}
			else if (Match('!'))
			{
				if (!Match('=', skipSpaces: false))
					throw new Exception("Expected '!='");
				double right = ParseComparison();
				Console.Write($"NotEqual({left}, {right})");
				left = right != left ? 1 : 0;
				Console.WriteLine($" == {left}");
			}
			else return left;
		}
	}

	private double ParseComparison()
	{
		double left = ParseAddSub();
		while (true)
		{
			if (Match('>'))
			{
				if (Match('=', skipSpaces: false)) {
					double right = ParseAddSub();
					Console.Write($"AboveEqual({left}, {right})");
					left = left >= right ? 1 : 0;
				} else {
					double right = ParseAddSub();
					Console.Write($"Above({left}, {right})");
					left = left > right ? 1 : 0;
				}
				Console.WriteLine($" == {left}");
			}
			else if (Match('<'))
			{
				if (Match('=', skipSpaces: false)) {
					double right = ParseAddSub();
					Console.Write($"BelowEqual({left}, {right})");
					left = left <= right ? 1 : 0;
				} else {
					double right = ParseAddSub();
					Console.Write($"Below({left}, {right})");
					left = left < right ? 1 : 0;
				}
				Console.WriteLine($" == {left}");
			}
			else return left;
		}
	}

	private double ParseAddSub()
	{
		double left = ParseMulDiv();
		while (true)
		{
			if (Match('+')) {
				double right = ParseMulDiv();
				Console.Write($"Add({left}, {right})");
				left += right;
				Console.WriteLine($" == {left}");
			} else if (Match('-')) {
				double right = ParseMulDiv();
				Console.Write($"Sub({left}, {right})");
				left -= right;
				Console.WriteLine($" == {left}");
			} else return left;
		}
	}

	private double ParseMulDiv()
	{
		double left = ParseUnary();
		while (true)
		{
			if (Match('*')) {
				double right = ParseUnary();
				Console.Write($"Mul({left}, {right})");
				left *= right;
				Console.WriteLine($" == {left}");
			} else if (Match('/')) {
				double right = ParseUnary();
				Console.Write($"Div({left}, {right})");
				left /= right;
				Console.WriteLine($" == {left}");
			} else return left;
		}
	}

	private double ParseUnary()
	{
		if (Match('-')) {
			double left = ParseUnary();
			Console.WriteLine($"Neg({left})");
			left = -left;
			Console.WriteLine($" == {left}");
			return left;
		}
		if (Match('!')) {
			bool bLeft = ToBool(ParseUnary());
			Console.Write($"Not({bLeft})");
			double left = !bLeft ? 1 : 0;
			Console.WriteLine($" == {left}");
			return left;
		}
		return ParseFunctionCall();
	}
	
	private double ParseFunctionCall()
	{
		double left = ParsePrimary();
		while (Match('(')) // function call (with function represented by a number index)
		{
			var args = new List<double>();
			while (true) {
				args.Add(ParseExpression());
				if (Match(':')) continue;
				if (Match(')')) break;
				throw new Exception($"Unexpected: {RemainDiagnosis}");
			}
			left = DoFunc(left, args);
		}
		return left;
	}

	private double ParsePrimary()
	{
		if (Match('('))
		{
			double val = ParseExpression();
			if (!Match(')')) throw new Exception($"Expected ')', got {RemainDiagnosis}");
			return val;
		}

		double left;
		if (Match('\n')) { // placeholder
			Console.Write($"Number(Vars[{_ivar}])");
			left = (_ivar < _vars.Count) ? _vars[_ivar++] : 0;
		} else {
			int start = _pos;
			while (char.IsDigit(Current) || Current == '.') Next();
			if (start == _pos) {
				if (Current == '\0')
					throw new Exception($"Unexpected end of input");
				throw new Exception($"Unexpected: {RemainDiagnosis}");
			}
			string strLeft = _expr.Substring(start, _pos - start);
			Console.Write($"Number(\"{strLeft}\")");
			left = double.Parse(strLeft);
		}
		Console.WriteLine($" == {left}");
		return left;
	}

	private bool ToBool(double value)
	{
		if (value != 0 && value != 1)
			Console.WriteLine($"Warning: treating non-zero logical value {value} as 1");
		Console.Write($"Bool({value})");
		bool bLeft = value != 0;
		Console.WriteLine($" == {bLeft}");
		return bLeft;
	}
	
	private double DoFunc(double idxFunc, List<double> args)
	{
		double value;
		string strArgList = string.Join(", ", args.Select(x => x.ToString()).ToList());
		Console.WriteLine($"Function call: Function({idxFunc})({strArgList})");
		value = -0.2; // mock function
		return value;
	}

	public static void Main()
	{
		int nFail = 0;
		
		(bool NoError, double Value) Exec(string expr)
		{
			Console.WriteLine($"\nExpr: {expr}");
			try
			{
				double result = Evaluate(expr);
				Console.WriteLine($"Result: {result}");
				return (true, result);
			}
			catch (Exception ex)
			{
				Console.WriteLine($"Error: {ex.Message}");
				return (false, default);
			}
		}

		void Expect(string expr, double value)
		{
			if (Exec(expr) != (true, value)) {
				Console.WriteLine($"Wrong: Expected {value}");
				++nFail;
			}
		}

		bool Bool(double v) => v != 0;
		double Double(bool v) => v ? 1 : 0;
		void ExpectBool(string expr, bool value) => Expect(expr, Double(value));
		
		void ExpectError(string expr)
		{
			if (Exec(expr).NoError) {
				Console.WriteLine($"Wrong: Expected error");
				++nFail;
			}
		}
		
		double x = -0.1; // Mocked value
		double f = -0.2; // mock function
		ExpectBool("((3 + 4) * 2 > 10) & ((8 / 2) == 4)", ((3 + 4) * 2 > 10) && ((8 / 2) == 4));
		ExpectBool("(5 * (2 + 3) != 20) | ((1 + 1) * 2 == 4)", (5 * (2 + 3) != 20) || ((1 + 1) * 2 == 4));
		ExpectBool("!((3 + 2) < 4)", !((3 + 2) < 4));
		ExpectBool("!(2 + 2 == 4) | (3 ^ 3)", !(2 + 2 == 4) || (Bool(3) ^ Bool(3)));
		ExpectBool("(((1+2)*3)>8)^((4*2)<=8)", (((1+2)*3)>8)^((4*2)<=8));
		ExpectBool("(<a:val> + 3) * 2 > (<b:x:y> - 1)", (x + 3) * 2 > (x - 1));
		ExpectBool("((<x> + 2) * 5) == (10 + <x>)", ((x + 2) * 5) == (10 + x));
		Expect("5 + (3 * (<temp> + 2))", 5 + (3 * (x + 2)));
		ExpectBool("!(1 & 0) | (0 ^ 1)", !(Bool(1) & Bool(0)) || (Bool(0) ^ Bool(1)));
		ExpectBool("!1 & 1 | 1", !Bool(1) && Bool(1) || Bool(1));
		ExpectBool("!(1 | 0) & (1 ^ 0)", !(Bool(1) || Bool(0)) && (Bool(1) ^ Bool(0)));
		ExpectBool("10 / (2 + 3) >= 2", 10 / (2 + 3) >= 2);
		ExpectBool("1 + 2 + 3 + 4 + 5 == 15", 1 + 2 + 3 + 4 + 5 == 15);
		ExpectBool("((2+3)*2 + 1) == (3*3 + 1)", ((2+3)*2 + 1) == (3*3 + 1));
		ExpectBool("4 * (2 + (1 + 3)) > 20", 4 * (2 + (1 + 3)) > 20);
		ExpectBool("((<a:x:y> * 2 + 1) >= 1) & (3 < 4)", ((x * 2 + 1) >= 1) && (3 < 4));
		ExpectBool("<foo:bar:baz> + 1 != 1", x + 1 != 1);

		// Function call
		Expect("<math:atan2>(<math:cos>(<lc:t>) * <math:pi> : <math:sin>(<lc:t>) * <math:pi>)", f);
		Expect("<func:select>(<math:get_random_int>(0 : 1) : <math:sin> : <math:cos>)(<lc:t>)", f);
		Expect("(<game:set_effect_attr> + <math:get_random_int>(0 : <game:effect_attr_count>))(42)", f);

		// Special case
		Expect("1.-0.7", 1.0-0.7);
		ExpectBool("\t40\t+\t2\t==\t42\t", 40 + 2 == 42);
		ExpectBool(" < jp > < < lc : perfect_count > < ( < jb > < < lc : bad_count > ) ", Double(x < x) < Double(x < x));
		ExpectBool(" 3 < < lc : perfect_count > < ( 1 < < lc : bad_count > ) ", Double(3 < x) < Double(1 < x));
		ExpectBool("2 <4&4> 2", 2 <4&&4> 2);
		ExpectBool("2 <=4&4>= 2", 2 <=4&4>= 2);
		ExpectBool("0 <=1> 0", Double(0 <=1)> 0);
		Expect("42(0(69) : 11(45))", f); // Somehow someone managed to remember all the function indexes
		Expect("(8)(8)(8)", f);

		// variable lookup failure
		Expect("< >", x);
		Expect("< = >", x);
		Expect("<a b>", x);
		Expect("<:simplestyleSweat:>", x);
		ExpectBool("3 < < x & x > > 3", Double(3 < x) > 3);
		ExpectError("3 < < 4 & 4 > > 3"); // however:

		// Illegal cases
		ExpectError("0 = = 0");
		ExpectError("0 <> 0");
		ExpectError("0 <=> 0");
		ExpectError("<artist:Tanger>(:3)");
		ExpectError("<math:max>(3 0 0)");
		ExpectError("3+");
		ExpectError("helloworld");
		ExpectError("🥁");
		ExpectError(" ");
		ExpectError("");
		ExpectError("<jp><lc>"); // no forming numbers by concatenating
		ExpectError("3<jp>");
		ExpectError("()"); // function parentheses are not normal parentheses
		ExpectError("(1:1)");
		
		if (nFail > 0)
			Console.WriteLine($"\n{nFail} cases failed!");
		else
			Console.WriteLine($"\nPass!");
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
​
public class ExpressionEvaluator
{
    private string _expr;
    private int _pos;
    private List<double> _vars = [];
    private int _ivar;
​
    public static double Evaluate(string strExpr)
    {
        var expr = new ExpressionEvaluator(strExpr.Replace('\n', ' '));
        double value = expr.ParseExpression();
        expr.CheckNoRemain();
        return value;
    }
​
    private static double ResolveVariable(string name, List<string> args)
    {
        Console.Write($"Resolving variable: <{name}{(args.Count > 0 ? ":" + string.Join(":", args) : "")}>");
        double value = -0.1; // Mocked value
        Console.WriteLine($" == {value}");
        return value;
    }
​
    private ExpressionEvaluator(string expr)
    {
        string pattern = @"<([^= \t\n0-9.<>()!-][^<>\n]*|[ \t]+(?:[^ \t\n0-9.<>()!-][^<>\n]*)?)>";
        while (Regex.IsMatch(expr, pattern))
        {
            expr = Regex.Replace(expr, pattern, match =>
            {
                string[] parts = match.Groups[1].Value.Split(':');
                string name = parts[0].Trim();
                List<string> args = new List<string>();
                for (int i = 1; i < parts.Length; i++)
                    args.Add(parts[i].Trim());
                _vars.Add(ResolveVariable(name, args));
                return "\n"; // placeholder
            });
        }
        _expr = string.Join(" ", expr.Split([' ', '\t'], StringSplitOptions.RemoveEmptyEntries));
        _pos = 0;
        _ivar = 0;
        Console.WriteLine($"Resolved: {_expr.Replace("\n", "<...>")}");
    }
​
    private char Current => _pos < _expr.Length ? _expr[_pos] : '\0';
    private string RemainDiagnosis => _expr.Substring(_pos).Replace("\n", "<...>");
    private void Next() => _pos++;
    
    private void CheckNoRemain()
    {
        if (Current == ' ')
            Next();
        if (_pos < _expr.Length)
            throw new Exception($"Unexpected: {RemainDiagnosis}");
    }
​
    private bool Match(char expected, bool skipSpaces = true)
    {
        if (Current == ' ' && skipSpaces)
            Next();
        if (Current == expected)
        {
            Next();
            return true;
        }
        return false;
    }
​
    private double ParseExpression() => ParseOr();
​
    private double ParseOr()
    {
        double left = ParseXor();
        while (Match('|'))
        {
            bool bLeft = ToBool(left);
            bool bRight = ToBool(ParseXor());
            Console.Write($"Or({bLeft}, {bRight})");
            left = (bLeft || bRight) ? 1 : 0;
            Console.WriteLine($" == {left}");
        }
        return left;
    }
​
    private double ParseXor()
    {
        double left = ParseAnd();
        while (Match('^'))
        {
            bool bLeft = ToBool(left);
            bool bRight = ToBool(ParseAnd());
            Console.Write($"Xor({bLeft}, {bRight})");
            left = (bLeft ^ bRight) ? 1 : 0;
            Console.WriteLine($" == {left}");
        }
        return left;
    }
​
    private double ParseAnd()
    {
        double left = ParseEquality();
        while (Match('&'))
        {
            bool bLeft = ToBool(left);
            bool bRight = ToBool(ParseEquality());
            Console.Write($"And({bLeft}, {bRight})");
            left = (bLeft && bRight) ? 1 : 0;
            Console.WriteLine($" == {left}");
        }
        return left;
    }
​
    private double ParseEquality()
    {
        double left = ParseComparison();
        while (true)
        {
            if (Match('='))
            {
                if (!Match('=', skipSpaces: false))
                    throw new Exception("Expected '=='");
                double right = ParseComparison();
                Console.Write($"Equal({left}, {right})");
                left = right == left ? 1 : 0;
                Console.WriteLine($" == {left}");
            }
            else if (Match('!'))
            {
                if (!Match('=', skipSpaces: false))
                    throw new Exception("Expected '!='");
                double right = ParseComparison();
                Console.Write($"NotEqual({left}, {right})");
                left = right != left ? 1 : 0;
                Console.WriteLine($" == {left}");
            }
            else return left;
        }
    }
​
    private double ParseComparison()
    {
        double left = ParseAddSub();
        while (true)
        {
            if (Match('>'))
            {
                if (Match('=', skipSpaces: false)) {
                    double right = ParseAddSub();
                    Console.Write($"AboveEqual({left}, {right})");
                    left = left >= right ? 1 : 0;
                } else {
                    double right = ParseAddSub();
                    Console.Write($"Above({left}, {right})");
                    left = left > right ? 1 : 0;
                }
                Console.WriteLine($" == {left}");
            }
            else if (Match('<'))
            {
                if (Match('=', skipSpaces: false)) {
                    double right = ParseAddSub();
                    Console.Write($"BelowEqual({left}, {right})");
                    left = left <= right ? 1 : 0;
                } else {
                    double right = ParseAddSub();
                    Console.Write($"Below({left}, {right})");
                    left = left < right ? 1 : 0;
                }
                Console.WriteLine($" == {left}");
            }
            else return left;
        }
    }
​
    private double ParseAddSub()
    {
        double left = ParseMulDiv();
        while (true)
        {
            if (Match('+')) {
                double right = ParseMulDiv();
                Console.Write($"Add({left}, {right})");
                left += right;
                Console.WriteLine($" == {left}");
            } else if (Match('-')) {
                double right = ParseMulDiv();
                Console.Write($"Sub({left}, {right})");
                left -= right;
                Console.WriteLine($" == {left}");
            } else return left;
        }
    }
​
    private double ParseMulDiv()
    {
        double left = ParseUnary();
        while (true)
        {
            if (Match('*')) {
                double right = ParseUnary();
                Console.Write($"Mul({left}, {right})");
                left *= right;
                Console.WriteLine($" == {left}");
            } else if (Match('/')) {
                double right = ParseUnary();
                Console.Write($"Div({left}, {right})");
                left /= right;
                Console.WriteLine($" == {left}");
            } else return left;
        }
    }
​
    private double ParseUnary()
    {
        if (Match('-')) {
            double left = ParseUnary();
            Console.WriteLine($"Neg({left})");
            left = -left;
            Console.WriteLine($" == {left}");
            return left;
        }
        if (Match('!')) {
            bool bLeft = ToBool(ParseUnary());
            Console.Write($"Not({bLeft})");
            double left = !bLeft ? 1 : 0;
            Console.WriteLine($" == {left}");
            return left;
        }
        return ParseFunctionCall();
    }
    
    private double ParseFunctionCall()
    {
        double left = ParsePrimary();
        while (Match('(')) // function call (with function represented by a number index)
        {
            var args = new List<double>();
            while (true) {
                args.Add(ParseExpression());
                if (Match(':')) continue;
                if (Match(')')) break;
                throw new Exception($"Unexpected: {RemainDiagnosis}");
            }
            left = DoFunc(left, args);
        }
        return left;
    }
​
    private double ParsePrimary()
    {
        if (Match('('))
        {
            double val = ParseExpression();
            if (!Match(')')) throw new Exception($"Expected ')', got {RemainDiagnosis}");
            return val;
        }
​
        double left;
        if (Match('\n')) { // placeholder
            Console.Write($"Number(Vars[{_ivar}])");
            left = (_ivar < _vars.Count) ? _vars[_ivar++] : 0;
        } else {
            int start = _pos;
            while (char.IsDigit(Current) || Current == '.') Next();
            if (start == _pos) {
                if (Current == '\0')
                    throw new Exception($"Unexpected end of input");
                throw new Exception($"Unexpected: {RemainDiagnosis}");
            }
            string strLeft = _expr.Substring(start, _pos - start);
            Console.Write($"Number(\"{strLeft}\")");
            left = double.Parse(strLeft);
        }
        Console.WriteLine($" == {left}");
        return left;
    }
​
    private bool ToBool(double value)
    {
        if (value != 0 && value != 1)
            Console.WriteLine($"Warning: treating non-zero logical value {value} as 1");
        Console.Write($"Bool({value})");
        bool bLeft = value != 0;
        Console.WriteLine($" == {bLeft}");
        return bLeft;
    }
    
    private double DoFunc(double idxFunc, List<double> args)
    {
        double value;
        string strArgList = string.Join(", ", args.Select(x => x.ToString()).ToList());
        Console.WriteLine($"Function call: Function({idxFunc})({strArgList})");
        value = -0.2; // mock function
        return value;
    }
​
    public static void Main()
    {
        int nFail = 0;
        
        (bool NoError, double Value) Exec(string expr)
        {
            Console.WriteLine($"\nExpr: {expr}");
            try
            {
                double result = Evaluate(expr);
                Console.WriteLine($"Result: {result}");
                return (true, result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                return (false, default);
            }
        }
​
        void Expect(string expr, double value)
        {
            if (Exec(expr) != (true, value)) {
                Console.WriteLine($"Wrong: Expected {value}");
                ++nFail;
            }
        }
​
        bool Bool(double v) => v != 0;
        double Double(bool v) => v ? 1 : 0;
        void ExpectBool(string expr, bool value) => Expect(expr, Double(value));
        
        void ExpectError(string expr)
        {
            if (Exec(expr).NoError) {
                Console.WriteLine($"Wrong: Expected error");
                ++nFail;
            }
        }
        
        double x = -0.1; // Mocked value
        double f = -0.2; // mock function
        ExpectBool("((3 + 4) * 2 > 10) & ((8 / 2) == 4)", ((3 + 4) * 2 > 10) && ((8 / 2) == 4));
        ExpectBool("(5 * (2 + 3) != 20) | ((1 + 1) * 2 == 4)", (5 * (2 + 3) != 20) || ((1 + 1) * 2 == 4));
        ExpectBool("!((3 + 2) < 4)", !((3 + 2) < 4));
        ExpectBool("!(2 + 2 == 4) | (3 ^ 3)", !(2 + 2 == 4) || (Bool(3) ^ Bool(3)));
        ExpectBool("(((1+2)*3)>8)^((4*2)<=8)", (((1+2)*3)>8)^((4*2)<=8));
        ExpectBool("(<a:val> + 3) * 2 > (<b:x:y> - 1)", (x + 3) * 2 > (x - 1));
        ExpectBool("((<x> + 2) * 5) == (10 + <x>)", ((x + 2) * 5) == (10 + x));
        Expect("5 + (3 * (<temp> + 2))", 5 + (3 * (x + 2)));
        ExpectBool("!(1 & 0) | (0 ^ 1)", !(Bool(1) & Bool(0)) || (Bool(0) ^ Bool(1)));
        ExpectBool("!1 & 1 | 1", !Bool(1) && Bool(1) || Bool(1));
        ExpectBool("!(1 | 0) & (1 ^ 0)", !(Bool(1) || Bool(0)) && (Bool(1) ^ Bool(0)));
        ExpectBool("10 / (2 + 3) >= 2", 10 / (2 + 3) >= 2);
        ExpectBool("1 + 2 + 3 + 4 + 5 == 15", 1 + 2 + 3 + 4 + 5 == 15);
        ExpectBool("((2+3)*2 + 1) == (3*3 + 1)", ((2+3)*2 + 1) == (3*3 + 1));
        ExpectBool("4 * (2 + (1 + 3)) > 20", 4 * (2 + (1 + 3)) > 20);
        ExpectBool("((<a:x:y> * 2 + 1) >= 1) & (3 < 4)", ((x * 2 + 1) >= 1) && (3 < 4));
        ExpectBool("<foo:bar:baz> + 1 != 1", x + 1 != 1);
​
        // Function call
        Expect("<math:atan2>(<math:cos>(<lc:t>) * <math:pi> : <math:sin>(<lc:t>) * <math:pi>)", f);
        Expect("<func:select>(<math:get_random_int>(0 : 1) : <math:sin> : <math:cos>)(<lc:t>)", f);
        Expect("(<game:set_effect_attr> + <math:get_random_int>(0 : <game:effect_attr_count>))(42)", f);
​
        // Special case
        Expect("1.-0.7", 1.0-0.7);
        ExpectBool("\t40\t+\t2\t==\t42\t", 40 + 2 == 42);
        ExpectBool(" < jp > < < lc : perfect_count > < ( < jb > < < lc : bad_count > ) ", Double(x < x) < Double(x < x));
        ExpectBool(" 3 < < lc : perfect_count > < ( 1 < < lc : bad_count > ) ", Double(3 < x) < Double(1 < x));
        ExpectBool("2 <4&4> 2", 2 <4&&4> 2);
        ExpectBool("2 <=4&4>= 2", 2 <=4&4>= 2);
        ExpectBool("0 <=1> 0", Double(0 <=1)> 0);
        Expect("42(0(69) : 11(45))", f); // Somehow someone managed to remember all the function indexes
        Expect("(8)(8)(8)", f);
​
        // variable lookup failure
        Expect("< >", x);
        Expect("< = >", x);
        Expect("<a b>", x);
        Expect("<:simplestyleSweat:>", x);
        ExpectBool("3 < < x & x > > 3", Double(3 < x) > 3);
        ExpectError("3 < < 4 & 4 > > 3"); // however:
​
        // Illegal cases
        ExpectError("0 = = 0");
        ExpectError("0 <> 0");
        ExpectError("0 <=> 0");
        ExpectError("<artist:Tanger>(:3)");
        ExpectError("<math:max>(3 0 0)");
        ExpectError("3+");
        ExpectError("helloworld");
        ExpectError("🥁");
        ExpectError(" ");
        ExpectError("");
        ExpectError("<jp><lc>"); // no forming numbers by concatenating
        ExpectError("3<jp>");
        ExpectError("()"); // function parentheses are not normal parentheses
        ExpectError("(1:1)");
        
        if (nFail > 0)
            Console.WriteLine($"\n{nFail} cases failed!");
        else
            Console.WriteLine($"\nPass!");
    }
}
​

Expr: ((3 + 4) * 2 > 10) & ((8 / 2) == 4)
Resolved: ((3 + 4) * 2 > 10) & ((8 / 2) == 4)
Number("3") == 3
Number("4") == 4
Add(3, 4) == 7
Number("2") == 2
Mul(7, 2) == 14
Number("10") == 10
Above(14, 10) == 1
Bool(1) == True
Number("8") == 8
Number("2") == 2
Div(8, 2) == 4
Number("4") == 4
Equal(4, 4) == 1
Bool(1) == True
And(True, True) == 1
Result: 1

Expr: (5 * (2 + 3) != 20) | ((1 + 1) * 2 == 4)
Resolved: (5 * (2 + 3) != 20) | ((1 + 1) * 2 == 4)
Number("5") == 5
Number("2") == 2
Number("3") == 3
Add(2, 3) == 5
Mul(5, 5) == 25
Number("20") == 20
NotEqual(25, 20) == 1
Bool(1) == True
Number("1") == 1
Number("1") == 1
Add(1, 1) == 2
Number("2") == 2
Mul(2, 2) == 4
Number("4") == 4
Equal(4, 4) == 1
Bool(1) == True
Or(True, True) == 1
Result: 1

Expr: !((3 + 2) < 4)
Resolved: !((3 + 2) < 4)
Number("3") == 3
Number("2") == 2
Add(3, 2) == 5
Number("4") == 4
Below(5, 4) == 0
Bool(0) == False
Not(False) == 1
Result: 1

Expr: !(2 + 2 == 4) | (3 ^ 3)
Resolved: !(2 + 2 == 4) | (3 ^ 3)
Number("2") == 2
Number("2") == 2
Add(2, 2) == 4
Number("4") == 4
Equal(4, 4) == 1
Bool(1) == True
Not(True) == 0
Bool(0) == False
Number("3") == 3
Warning: treating non-zero logical value 3 as 1
Bool(3) == True
Number("3") == 3
Warning: treating non-zero logical value 3 as 1
Bool(3) == True
Xor(True, True) == 0
Bool(0) == False
Or(False, False) == 0
Result: 0

Expr: (((1+2)*3)>8)^((4*2)<=8)
Resolved: (((1+2)*3)>8)^((4*2)<=8)
Number("1") == 1
Number("2") == 2
Add(1, 2) == 3
Number("3") == 3
Mul(3, 3) == 9
Number("8") == 8
Above(9, 8) == 1
Bool(1) == True
Number("4") == 4
Number("2") == 2
Mul(4, 2) == 8
Number("8") == 8
BelowEqual(8, 8) == 1
Bool(1) == True
Xor(True, True) == 0
Result: 0

Expr: (<a:val> + 3) * 2 > (<b:x:y> - 1)
Resolving variable: <a:val> == -0.1
Resolving variable: <b:x:y> == -0.1
Resolved: (<...> + 3) * 2 > (<...> - 1)
Number(Vars[0]) == -0.1
Number("3") == 3
Add(-0.1, 3) == 2.9
Number("2") == 2
Mul(2.9, 2) == 5.8
Number(Vars[1]) == -0.1
Number("1") == 1
Sub(-0.1, 1) == -1.1
Above(5.8, -1.1) == 1
Result: 1

Expr: ((<x> + 2) * 5) == (10 + <x>)
Resolving variable: <x> == -0.1
Resolving variable: <x> == -0.1
Resolved: ((<...> + 2) * 5) == (10 + <...>)
Number(Vars[0]) == -0.1
Number("2") == 2
Add(-0.1, 2) == 1.9
Number("5") == 5
Mul(1.9, 5) == 9.5
Number("10") == 10
Number(Vars[1]) == -0.1
Add(10, -0.1) == 9.9
Equal(9.5, 9.9) == 0
Result: 0

Expr: 5 + (3 * (<temp> + 2))
Resolving variable: <temp> == -0.1
Resolved: 5 + (3 * (<...> + 2))
Number("5") == 5
Number("3") == 3
Number(Vars[0]) == -0.1
Number("2") == 2
Add(-0.1, 2) == 1.9
Mul(3, 1.9) == 5.699999999999999
Add(5, 5.699999999999999) == 10.7
Result: 10.7

Expr: !(1 & 0) | (0 ^ 1)
Resolved: !(1 & 0) | (0 ^ 1)
Number("1") == 1
Bool(1) == True
Number("0") == 0
Bool(0) == False
And(True, False) == 0
Bool(0) == False
Not(False) == 1
Bool(1) == True
Number("0") == 0
Bool(0) == False
Number("1") == 1
Bool(1) == True
Xor(False, True) == 1
Bool(1) == True
Or(True, True) == 1
Result: 1

Expr: !1 & 1 | 1
Resolved: !1 & 1 | 1
Number("1") == 1
Bool(1) == True
Not(True) == 0
Bool(0) == False
Number("1") == 1
Bool(1) == True
And(False, True) == 0
Bool(0) == False
Number("1") == 1
Bool(1) == True
Or(False, True) == 1
Result: 1

Expr: !(1 | 0) & (1 ^ 0)
Resolved: !(1 | 0) & (1 ^ 0)
Number("1") == 1
Bool(1) == True
Number("0") == 0
Bool(0) == False
Or(True, False) == 1
Bool(1) == True
Not(True) == 0
Bool(0) == False
Number("1") == 1
Bool(1) == True
Number("0") == 0
Bool(0) == False
Xor(True, False) == 1
Bool(1) == True
And(False, True) == 0
Result: 0

Expr: 10 / (2 + 3) >= 2
Resolved: 10 / (2 + 3) >= 2
Number("10") == 10
Number("2") == 2
Number("3") == 3
Add(2, 3) == 5
Div(10, 5) == 2
Number("2") == 2
AboveEqual(2, 2) == 1
Result: 1

Expr: 1 + 2 + 3 + 4 + 5 == 15
Resolved: 1 + 2 + 3 + 4 + 5 == 15
Number("1") == 1
Number("2") == 2
Add(1, 2) == 3
Number("3") == 3
Add(3, 3) == 6
Number("4") == 4
Add(6, 4) == 10
Number("5") == 5
Add(10, 5) == 15
Number("15") == 15
Equal(15, 15) == 1
Result: 1

Expr: ((2+3)*2 + 1) == (3*3 + 1)
Resolved: ((2+3)*2 + 1) == (3*3 + 1)
Number("2") == 2
Number("3") == 3
Add(2, 3) == 5
Number("2") == 2
Mul(5, 2) == 10
Number("1") == 1
Add(10, 1) == 11
Number("3") == 3
Number("3") == 3
Mul(3, 3) == 9
Number("1") == 1
Add(9, 1) == 10
Equal(11, 10) == 0
Result: 0

Expr: 4 * (2 + (1 + 3)) > 20
Resolved: 4 * (2 + (1 + 3)) > 20
Number("4") == 4
Number("2") == 2
Number("1") == 1
Number("3") == 3
Add(1, 3) == 4
Add(2, 4) == 6
Mul(4, 6) == 24
Number("20") == 20
Above(24, 20) == 1
Result: 1

Expr: ((<a:x:y> * 2 + 1) >= 1) & (3 < 4)
Resolving variable: <a:x:y> == -0.1
Resolved: ((<...> * 2 + 1) >= 1) & (3 < 4)
Number(Vars[0]) == -0.1
Number("2") == 2
Mul(-0.1, 2) == -0.2
Number("1") == 1
Add(-0.2, 1) == 0.8
Number("1") == 1
AboveEqual(0.8, 1) == 0
Bool(0) == False
Number("3") == 3
Number("4") == 4
Below(3, 4) == 1
Bool(1) == True
And(False, True) == 0
Result: 0

Expr: <foo:bar:baz> + 1 != 1
Resolving variable: <foo:bar:baz> == -0.1
Resolved: <...> + 1 != 1
Number(Vars[0]) == -0.1
Number("1") == 1
Add(-0.1, 1) == 0.9
Number("1") == 1
NotEqual(0.9, 1) == 1
Result: 1

Expr: <math:atan2>(<math:cos>(<lc:t>) * <math:pi> : <math:sin>(<lc:t>) * <math:pi>)
Resolving variable: <math:atan2> == -0.1
Resolving variable: <math:cos> == -0.1
Resolving variable: <lc:t> == -0.1
Resolving variable: <math:pi> == -0.1
Resolving variable: <math:sin> == -0.1
Resolving variable: <lc:t> == -0.1
Resolving variable: <math:pi> == -0.1
Resolved: <...>(<...>(<...>) * <...> : <...>(<...>) * <...>)
Number(Vars[0]) == -0.1
Number(Vars[1]) == -0.1
Number(Vars[2]) == -0.1
Function call: Function(-0.1)(-0.1)
Number(Vars[3]) == -0.1
Mul(-0.2, -0.1) == 0.020000000000000004
Number(Vars[4]) == -0.1
Number(Vars[5]) == -0.1
Function call: Function(-0.1)(-0.1)
Number(Vars[6]) == -0.1
Mul(-0.2, -0.1) == 0.020000000000000004
Function call: Function(-0.1)(0.020000000000000004, 0.020000000000000004)
Result: -0.2

Expr: <func:select>(<math:get_random_int>(0 : 1) : <math:sin> : <math:cos>)(<lc:t>)
Resolving variable: <func:select> == -0.1
Resolving variable: <math:get_random_int> == -0.1
Resolving variable: <math:sin> == -0.1
Resolving variable: <math:cos> == -0.1
Resolving variable: <lc:t> == -0.1
Resolved: <...>(<...>(0 : 1) : <...> : <...>)(<...>)
Number(Vars[0]) == -0.1
Number(Vars[1]) == -0.1
Number("0") == 0
Number("1") == 1
Function call: Function(-0.1)(0, 1)
Number(Vars[2]) == -0.1
Number(Vars[3]) == -0.1
Function call: Function(-0.1)(-0.2, -0.1, -0.1)
Number(Vars[4]) == -0.1
Function call: Function(-0.2)(-0.1)
Result: -0.2

Expr: (<game:set_effect_attr> + <math:get_random_int>(0 : <game:effect_attr_count>))(42)
Resolving variable: <game:set_effect_attr> == -0.1
Resolving variable: <math:get_random_int> == -0.1
Resolving variable: <game:effect_attr_count> == -0.1
Resolved: (<...> + <...>(0 : <...>))(42)
Number(Vars[0]) == -0.1
Number(Vars[1]) == -0.1
Number("0") == 0
Number(Vars[2]) == -0.1
Function call: Function(-0.1)(0, -0.1)
Add(-0.1, -0.2) == -0.30000000000000004
Number("42") == 42
Function call: Function(-0.30000000000000004)(42)
Result: -0.2

Expr: 1.-0.7
Resolved: 1.-0.7
Number("1.") == 1
Number("0.7") == 0.7
Sub(1, 0.7) == 0.30000000000000004
Result: 0.30000000000000004

Expr:     40    +    2    ==    42
Resolved: 40 + 2 == 42
Number("40") == 40
Number("2") == 2
Add(40, 2) == 42
Number("42") == 42
Equal(42, 42) == 1
Result: 1

Expr:  < jp > < < lc : perfect_count > < ( < jb > < < lc : bad_count > )
Resolving variable: <jp> == -0.1
Resolving variable: <lc:perfect_count> == -0.1
Resolving variable: <jb> == -0.1
Resolving variable: <lc:bad_count> == -0.1
Resolved: <...> < <...> < ( <...> < <...> )
Number(Vars[0]) == -0.1
Number(Vars[1]) == -0.1
Below(-0.1, -0.1) == 0
Number(Vars[2]) == -0.1
Number(Vars[3]) == -0.1
Below(-0.1, -0.1) == 0
Below(0, 0) == 0
Result: 0

Expr:  3 < < lc : perfect_count > < ( 1 < < lc : bad_count > )
Resolving variable: <lc:perfect_count> == -0.1
Resolving variable: <lc:bad_count> == -0.1
Resolved: 3 < <...> < ( 1 < <...> )
Number("3") == 3
Number(Vars[0]) == -0.1
Below(3, -0.1) == 0
Number("1") == 1
Number(Vars[1]) == -0.1
Below(1, -0.1) == 0
Below(0, 0) == 0
Result: 0

Expr: 2 <4&4> 2
Resolved: 2 <4&4> 2
Number("2") == 2
Number("4") == 4
Below(2, 4) == 1
Bool(1) == True
Number("4") == 4
Number("2") == 2
Above(4, 2) == 1
Bool(1) == True
And(True, True) == 1
Result: 1

Expr: 2 <=4&4>= 2
Resolved: 2 <=4&4>= 2
Number("2") == 2
Number("4") == 4
BelowEqual(2, 4) == 1
Bool(1) == True
Number("4") == 4
Number("2") == 2
AboveEqual(4, 2) == 1
Bool(1) == True
And(True, True) == 1
Result: 1

Expr: 0 <=1> 0
Resolved: 0 <=1> 0
Number("0") == 0
Number("1") == 1
BelowEqual(0, 1) == 1
Number("0") == 0
Above(1, 0) == 1
Result: 1

Expr: 42(0(69) : 11(45))
Resolved: 42(0(69) : 11(45))
Number("42") == 42
Number("0") == 0
Number("69") == 69
Function call: Function(0)(69)
Number("11") == 11
Number("45") == 45
Function call: Function(11)(45)
Function call: Function(42)(-0.2, -0.2)
Result: -0.2

Expr: (8)(8)(8)
Resolved: (8)(8)(8)
Number("8") == 8
Number("8") == 8
Function call: Function(8)(8)
Number("8") == 8
Function call: Function(-0.2)(8)
Result: -0.2

Expr: < >
Resolving variable: <> == -0.1
Resolved: <...>
Number(Vars[0]) == -0.1
Result: -0.1

Expr: < = >
Resolving variable: <=> == -0.1
Resolved: <...>
Number(Vars[0]) == -0.1
Result: -0.1

Expr: <a b>
Resolving variable: <a b> == -0.1
Resolved: <...>
Number(Vars[0]) == -0.1
Result: -0.1

Expr: <:simplestyleSweat:>
Resolving variable: <:simplestyleSweat:> == -0.1
Resolved: <...>
Number(Vars[0]) == -0.1
Result: -0.1

Expr: 3 < < x & x > > 3
Resolving variable: <x & x> == -0.1
Resolved: 3 < <...> > 3
Number("3") == 3
Number(Vars[0]) == -0.1
Below(3, -0.1) == 0
Number("3") == 3
Above(0, 3) == 0
Result: 0

Expr: 3 < < 4 & 4 > > 3
Resolved: 3 < < 4 & 4 > > 3
Number("3") == 3
Error: Unexpected: < 4 & 4 > > 3

Expr: 0 = = 0
Resolved: 0 = = 0
Number("0") == 0
Error: Expected '=='

Expr: 0 <> 0
Resolved: 0 <> 0
Number("0") == 0
Error: Unexpected: > 0

Expr: 0 <=> 0
Resolved: 0 <=> 0
Number("0") == 0
Error: Unexpected: > 0

Expr: <artist:Tanger>(:3)
Resolving variable: <artist:Tanger> == -0.1
Resolved: <...>(:3)
Number(Vars[0]) == -0.1
Error: Unexpected: :3)

Expr: <math:max>(3 0 0)
Resolving variable: <math:max> == -0.1
Resolved: <...>(3 0 0)
Number(Vars[0]) == -0.1
Number("3") == 3
Error: Unexpected: 0 0)

Expr: 3+
Resolved: 3+
Number("3") == 3
Error: Unexpected end of input

Expr: helloworld
Resolved: helloworld
Error: Unexpected: helloworld

Expr: 🥁
Resolved: 🥁
Error: Unexpected: 🥁

Expr:
Resolved:
Error: Unexpected end of input

Expr:
Resolved:
Error: Unexpected end of input

Expr: <jp><lc>
Resolving variable: <jp> == -0.1
Resolving variable: <lc> == -0.1
Resolved: <...><...>
Number(Vars[0]) == -0.1
Error: Unexpected: <...>

Expr: 3<jp>
Resolving variable: <jp> == -0.1
Resolved: 3<...>
Number("3") == 3
Error: Unexpected: <...>

Expr: ()
Resolved: ()
Error: Unexpected: )

Expr: (1:1)
Resolved: (1:1)
Number("1") == 1
Error: Expected ')', got :1)

Pass!

Cached Result
Last Run:	9:29:07 am
Compile:	0.062s
Execute:	0.14s
Memory:	5.38Mb
CPU:	0.202s

View IL Code