예제 #1
0
        object EvaluateWhereClause(Runtime.PassiveExpression expr, Runtime.Pattern lastPattern, ScriptThread thread)
        {
            // instantiate where-clause pattern
            var patt = Pattern.Instantiate(thread);

            patt.CopyBoundVariables(lastPattern);

            // perform matching
            var result = patt.Match(expr);

            if (result)
            {
                // store last recognized pattern as a local variable
                thread.SetLastPattern(patt);

                // match succeeded, return result expression
                if (ResultExpression != null)
                {
                    return(ResultExpression.Evaluate(thread));
                }

                // match succeeded, evaluate more conditions
                if (MoreConditions != null)
                {
                    return(MoreConditions.Evaluate(thread));
                }
            }

            // matching failed, return nothing
            return(null);
        }
		public void Symbol_DontMatchAnotherSymbol()
		{
			var pattern = new Pattern(123); // 123
			var expr = PassiveExpression.Build('X'); // 'X'

			var result = pattern.Match(expr);
			Assert.IsFalse(result);
		}
		public void SymbolChain_MatchesSameSymbolChain()
		{
			var pattern = new Pattern(123, 'T', 'e', 's', 't'); // 123 'Test'
			var expr = PassiveExpression.Build(123, 'T', 'e', 's', 't'); // 123 'Test'

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
		}
		public void SymbolChain_DontMatchDifferentSymbolChain()
		{
			var pattern = new Pattern(123, 'T', 'e', 's', 't'); // 123 'Test'
			var expr = PassiveExpression.Build(123, 'T', 'E', 'S', 'T'); // 123 'TEST'

			var result = pattern.Match(expr);
			Assert.IsFalse(result);
		}
		public void Symbol_MatchesSameSymbol()
		{
			var pattern = new Pattern(123); // 123
			var expr = PassiveExpression.Build(123); // 123

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
		}
		public void SymbolVariable_MatchesAnySymbol()
		{
			var pattern = new Pattern(new SymbolVariable("s.1")); // s.1
			var expr = PassiveExpression.Build(123); // 123

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("s.1"));
			Assert.AreEqual(123, pattern.Variables["s.1"].Value);

			expr = PassiveExpression.Build('A'); // 'A'

			result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("s.1"));
			Assert.AreEqual('A', pattern.Variables["s.1"].Value);
		}
		public void CopyBoundVariables(Pattern pattern)
		{
			foreach (string name in pattern.Variables.Keys)
			{
				if (Variables.ContainsKey(name))
				{
					Variable var = Variables[name];
					var.Value = pattern.GetVariable(name);
					// first occurance of the variable is in another pattern
					var.FirstOccurance = -1;
				}
				else
				{
					// copy bound variable from another pattern
					Variable var = pattern.Variables[name];
					Variables[name] = var;
					var.FirstOccurance = -1;
				}
			}
		}
예제 #8
0
        void EvaluateWhereClause(Runtime.Pattern lastPattern, EvaluationContext context, AstMode mode)
        {
            // instantiate where-clause pattern
            var patt = Pattern.Instantiate(context, mode);

            patt.CopyBoundVariables(lastPattern);

            // perform matching
            var expr   = context.Data.Pop() as Runtime.PassiveExpression;
            var result = patt.Match(expr);

            if (result)
            {
                // store last recognized pattern as a local variable
                context.SetLastPattern(patt);

                // match succeeded, return true
                if (ResultExpression != null)
                {
                    ResultExpression.Evaluate(context, AstMode.Read);
                    context.Data.Push(true);
                    return;
                }

                // match succeeded? depends on more conditions
                if (MoreConditions != null)
                {
                    // return true or false
                    MoreConditions.Evaluate(context, AstMode.Read);
                    return;
                }
            }

            // match failed, return false
            context.Data.Push(false);
        }
		public void ComplexPattern_MatchesExpression2()
		{
			var pattern = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new SymbolVariable("s.3"),
				new ClosingBrace(), new OpeningBrace(), new ExpressionVariable("e.2"), '0', new ClosingBrace()); // (e.1 s.3) (e.2 '0')
			var expr = PassiveExpression.Build(new OpeningBrace(), '0', '1', new ClosingBrace(),
				new OpeningBrace(), '0', new ClosingBrace()); // ('01') ('0')

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("e.1"));
			Assert.IsTrue(pattern.Variables.ContainsKey("e.2"));
			Assert.IsTrue(pattern.Variables.ContainsKey("s.3"));
			Assert.AreEqual(PassiveExpression.Build('0'), pattern.Variables["e.1"].Value);
			Assert.AreEqual(PassiveExpression.Build(), pattern.Variables["e.2"].Value);
			Assert.AreEqual('1', pattern.Variables["s.3"].Value);
		}
		public void SymbolVariable_DontMatchBraces()
		{
			var pattern = new Pattern(new SymbolVariable("s.1")); // s.1
			var expr = PassiveExpression.Build(new OpeningBrace()); // (

			var result = pattern.Match(expr);
			Assert.IsFalse(result);
		}
예제 #11
0
		// extract arguments specified as <Function t.1 e.2>
		void GetArguments(PassiveExpression expression, out object arg1, out object arg2)
		{
			var p = new Pattern(new TermVariable("t.1"), new ExpressionVariable("e.2"));
			if (p.Match(expression))
			{
				arg1 = p.GetVariable("t.1");
				arg2 = p.GetVariable("e.2");
				return;
			}

			// can't find match
			throw new RecognitionImpossibleException();
		}
예제 #12
0
파일: test16.cs 프로젝트: yallie/refal
		private static PassiveExpression _Lex(PassiveExpression expression)
		{
			Pattern pattern10 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "(".ToCharArray(), new ExpressionVariable("e.2"));
			if (pattern10.Match(expression))
			{
				return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), new OpeningBrace(), pattern10.GetVariable("e.1"), new ClosingBrace(), new ClosingBrace(), pattern10.GetVariable("e.2"))));
			};

			Pattern pattern11 = new Pattern(new OpeningBrace(), new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), new ExpressionVariable("e.2"), new ClosingBrace(), ")".ToCharArray(), new ExpressionVariable("e.3"));
			if (pattern11.Match(expression))
			{
				return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern11.GetVariable("e.1"), new OpeningBrace(), pattern11.GetVariable("e.2"), new ClosingBrace(), new ClosingBrace(), pattern11.GetVariable("e.3"))));
			};

			Pattern pattern12 = new Pattern(new OpeningBrace(), "$".ToCharArray(), new ExpressionVariable("e.1"), new ClosingBrace(), ")".ToCharArray(), new ExpressionVariable("e.3"));
			if (pattern12.Match(expression))
			{
				return PassiveExpression.Build(_Prout(PassiveExpression.Build("ERROR: Unpaired right parenthsis:".ToCharArray())), _Prout(PassiveExpression.Build(pattern12.GetVariable("e.1"), ")".ToCharArray())));
			};

			Pattern pattern13 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), " ".ToCharArray(), new ExpressionVariable("e.2"));
			if (pattern13.Match(expression))
			{
				return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern13.GetVariable("e.1"), new ClosingBrace(), pattern13.GetVariable("e.2"))));
			};

			Pattern pattern14 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "\\t".ToCharArray(), new ExpressionVariable("e.2"));
			if (pattern14.Match(expression))
			{
				return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern14.GetVariable("e.1"), new ClosingBrace(), pattern14.GetVariable("e.2"))));
			};

			Pattern pattern15 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "\'".ToCharArray(), new ExpressionVariable("e.2"));
			if (pattern15.Match(expression))
			{
				expression = PassiveExpression.Build(_Quotes(PassiveExpression.Build("\'".ToCharArray(), new OpeningBrace(), new ClosingBrace(), pattern15.GetVariable("e.2"))));
				{
					Pattern pattern16 = new Pattern(new OpeningBrace(), new ClosingBrace(), new ExpressionVariable("e.3"));
					pattern16.CopyBoundVariables(pattern15);
					if (pattern16.Match(expression))
					{
						return PassiveExpression.Build(_Prout(PassiveExpression.Build("ERROR: Unpaired quote \'".ToCharArray(), pattern16.GetVariable("e.2"))));
					};

					Pattern pattern17 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.0"), new ClosingBrace(), new ExpressionVariable("e.3"));
					pattern17.CopyBoundVariables(pattern15);
					if (pattern17.Match(expression))
					{
						return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern17.GetVariable("e.1"), pattern17.GetVariable("e.0"), new ClosingBrace(), pattern17.GetVariable("e.2"))));
					};

					throw new RecognitionImpossibleException("Recognition impossible. Last expression: " + expression.ToString());
				}
			};

			Pattern pattern19 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), new SymbolVariable("s.A"), new ExpressionVariable("e.2"));
			if (pattern19.Match(expression))
			{
				expression = PassiveExpression.Build(_Type(PassiveExpression.Build(pattern19.GetVariable("s.A"))));
				{
					Pattern pattern20 = new Pattern("L".ToCharArray(), new ExpressionVariable("e.A1"));
					pattern20.CopyBoundVariables(pattern19);
					if (pattern20.Match(expression))
					{
						expression = PassiveExpression.Build(_Id__tail(PassiveExpression.Build(new OpeningBrace(), pattern20.GetVariable("s.A"), new ClosingBrace(), pattern20.GetVariable("e.2"))));
						Pattern pattern21 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.Id"), new ClosingBrace(), new ExpressionVariable("e.3"));
						pattern21.CopyBoundVariables(pattern20);
						if (pattern21.Match(expression))
						{
							return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern21.GetVariable("e.1"), _Implode(PassiveExpression.Build(pattern21.GetVariable("e.Id"))), new ClosingBrace(), pattern21.GetVariable("e.3"))));
						}
					};

					Pattern pattern22 = new Pattern("D".ToCharArray(), new ExpressionVariable("e.A1"));
					pattern22.CopyBoundVariables(pattern19);
					if (pattern22.Match(expression))
					{
						expression = PassiveExpression.Build(_D__string(PassiveExpression.Build(new OpeningBrace(), pattern22.GetVariable("s.A"), new ClosingBrace(), pattern22.GetVariable("e.2"))));
						Pattern pattern23 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.D-Str"), new ClosingBrace(), new ExpressionVariable("e.3"));
						pattern23.CopyBoundVariables(pattern22);
						if (pattern23.Match(expression))
						{
							return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern23.GetVariable("e.1"), _Numb(PassiveExpression.Build(pattern23.GetVariable("e.D-Str"))), new ClosingBrace(), pattern23.GetVariable("e.3"))));
						}
					};

					Pattern pattern24 = new Pattern(new SymbolVariable("s.T"), new ExpressionVariable("e.A1"));
					pattern24.CopyBoundVariables(pattern19);
					if (pattern24.Match(expression))
					{
						return PassiveExpression.Build(_Lex(PassiveExpression.Build(new OpeningBrace(), pattern24.GetVariable("e.1"), pattern24.GetVariable("s.A"), new ClosingBrace(), pattern24.GetVariable("e.2"))));
					};

					throw new RecognitionImpossibleException("Recognition impossible. Last expression: " + expression.ToString());
				}
			};

			Pattern pattern26 = new Pattern(new OpeningBrace(), "$".ToCharArray(), new ExpressionVariable("e.1"), new ClosingBrace());
			if (pattern26.Match(expression))
			{
				return PassiveExpression.Build(pattern26.GetVariable("e.1"));
			};

			Pattern pattern27 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.M"), new ClosingBrace());
			if (pattern27.Match(expression))
			{
				return PassiveExpression.Build(_Prout(PassiveExpression.Build("ERROR: Unpaired left parentheses".ToCharArray())), _Pr__lmb(PassiveExpression.Build(pattern27.GetVariable("e.M"))));
			};

			throw new RecognitionImpossibleException("Recognition impossible. Last expression: " + expression.ToString());
		}
		public void SymbolVariable_DontMatchSymbolChain()
		{
			var pattern = new Pattern(new SymbolVariable("s.1")); // s.1
			var expr = PassiveExpression.Build(123, 321); // 123 321

			var result = pattern.Match(expr);
			Assert.IsFalse(result);
		}
예제 #14
0
        private static PassiveExpression _Lookm(PassiveExpression expression)
        {
            Pattern pattern13 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "[".ToCharArray(), new ExpressionVariable("e.2"));

            if (pattern13.Match(expression))
            {
                return(PassiveExpression.Build(new OpeningBrace(), pattern13.GetVariable("e.1"), new ClosingBrace(), "[".ToCharArray(), pattern13.GetVariable("e.2")));
            }
            ;

            Pattern pattern14 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "\"".ToCharArray(), new ExpressionVariable("e.2"));

            if (pattern14.Match(expression))
            {
                expression = PassiveExpression.Build(_Quotes(PassiveExpression.Build("\"".ToCharArray(), new OpeningBrace(), new ClosingBrace(), pattern14.GetVariable("e.2"))));
                Pattern pattern15 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.0"), new ClosingBrace(), new ExpressionVariable("e.3"));
                pattern15.CopyBoundVariables(pattern14);
                if (pattern15.Match(expression))
                {
                    return(PassiveExpression.Build(_Lookm(PassiveExpression.Build(new OpeningBrace(), pattern15.GetVariable("e.1"), pattern15.GetVariable("e.0"), new ClosingBrace(), pattern15.GetVariable("e.3")))));
                }
            }
            ;

            Pattern pattern16 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "\'".ToCharArray(), new ExpressionVariable("e.2"));

            if (pattern16.Match(expression))
            {
                expression = PassiveExpression.Build(_Quotes(PassiveExpression.Build("\'".ToCharArray(), new OpeningBrace(), new ClosingBrace(), pattern16.GetVariable("e.2"))));
                Pattern pattern17 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.0"), new ClosingBrace(), new ExpressionVariable("e.3"));
                pattern17.CopyBoundVariables(pattern16);
                if (pattern17.Match(expression))
                {
                    return(PassiveExpression.Build(_Lookm(PassiveExpression.Build(new OpeningBrace(), pattern17.GetVariable("e.1"), pattern17.GetVariable("e.0"), new ClosingBrace(), pattern17.GetVariable("e.3")))));
                }
            }
            ;

            Pattern pattern18 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), "/*".ToCharArray(), new ExpressionVariable("e.2"), "*/".ToCharArray(), new ExpressionVariable("e.3"));

            if (pattern18.Match(expression))
            {
                return(PassiveExpression.Build(_Lookm(PassiveExpression.Build(new OpeningBrace(), pattern18.GetVariable("e.1"), "/*".ToCharArray(), pattern18.GetVariable("e.2"), "*/".ToCharArray(), new ClosingBrace(), pattern18.GetVariable("e.3")))));
            }
            ;

            Pattern pattern19 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace(), new TermVariable("t.A"), new ExpressionVariable("e.2"));

            if (pattern19.Match(expression))
            {
                return(PassiveExpression.Build(_Lookm(PassiveExpression.Build(new OpeningBrace(), pattern19.GetVariable("e.1"), pattern19.GetVariable("t.A"), new ClosingBrace(), pattern19.GetVariable("e.2")))));
            }
            ;

            Pattern pattern20 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace());

            if (pattern20.Match(expression))
            {
                return(PassiveExpression.Build(pattern20.GetVariable("e.1")));
            }
            ;

            throw new RecognitionImpossibleException("Recognition impossible. Last expression: " + expression.ToString());
        }
예제 #15
0
파일: test16.cs 프로젝트: yallie/refal
		private static PassiveExpression _Parse(PassiveExpression expression)
		{
			Pattern pattern48 = new Pattern(new ExpressionVariable("e.Exp"));
			if (pattern48.Match(expression))
			{
				expression = PassiveExpression.Build(_Last1(PassiveExpression.Build(new OpeningBrace(), "+-".ToCharArray(), new ClosingBrace(), pattern48.GetVariable("e.Exp"), new OpeningBrace(), new ClosingBrace())));
				Pattern pattern49 = new Pattern(new ExpressionVariable("e.1"), new SymbolVariable("s.Op"), new OpeningBrace(), new ExpressionVariable("e.2"), new ClosingBrace());
				pattern49.CopyBoundVariables(pattern48);
				if (pattern49.Match(expression))
				{
					return PassiveExpression.Build(pattern49.GetVariable("s.Op"), new OpeningBrace(), _Parse(PassiveExpression.Build(pattern49.GetVariable("e.1"))), new ClosingBrace(), _Parse(PassiveExpression.Build(pattern49.GetVariable("e.2"))));
				}
			};

			Pattern pattern50 = new Pattern(new ExpressionVariable("e.Exp"));
			if (pattern50.Match(expression))
			{
				expression = PassiveExpression.Build(_Last1(PassiveExpression.Build(new OpeningBrace(), "*/".ToCharArray(), new ClosingBrace(), pattern50.GetVariable("e.Exp"), new OpeningBrace(), new ClosingBrace())));
				Pattern pattern51 = new Pattern(new ExpressionVariable("e.1"), new SymbolVariable("s.Op"), new OpeningBrace(), new ExpressionVariable("e.2"), new ClosingBrace());
				pattern51.CopyBoundVariables(pattern50);
				if (pattern51.Match(expression))
				{
					return PassiveExpression.Build(pattern51.GetVariable("s.Op"), new OpeningBrace(), _Parse(PassiveExpression.Build(pattern51.GetVariable("e.1"))), new ClosingBrace(), _Parse(PassiveExpression.Build(pattern51.GetVariable("e.2"))));
				}
			};

			Pattern pattern52 = new Pattern(new ExpressionVariable("e.1"), "^".ToCharArray(), new ExpressionVariable("e.2"));
			if (pattern52.Match(expression))
			{
				return PassiveExpression.Build("^".ToCharArray(), new OpeningBrace(), _Parse(PassiveExpression.Build(pattern52.GetVariable("e.1"))), new ClosingBrace(), _Parse(PassiveExpression.Build(pattern52.GetVariable("e.2"))));
			};

			Pattern pattern53 = new Pattern(new SymbolVariable("s.Symb"));
			if (pattern53.Match(expression))
			{
				expression = PassiveExpression.Build(_Type(PassiveExpression.Build(pattern53.GetVariable("s.Symb"))));
				Pattern pattern54 = new Pattern("Wi".ToCharArray(), new ExpressionVariable("e.S"));
				pattern54.CopyBoundVariables(pattern53);
				if (pattern54.Match(expression))
				{
					return PassiveExpression.Build(pattern54.GetVariable("s.Symb"));
				}
			};

			Pattern pattern55 = new Pattern(new SymbolVariable("s.Symb"));
			if (pattern55.Match(expression))
			{
				expression = PassiveExpression.Build(_Type(PassiveExpression.Build(pattern55.GetVariable("s.Symb"))));
				Pattern pattern56 = new Pattern("N".ToCharArray(), new ExpressionVariable("e.S"));
				pattern56.CopyBoundVariables(pattern55);
				if (pattern56.Match(expression))
				{
					return PassiveExpression.Build(pattern56.GetVariable("s.Symb"));
				}
			};

			Pattern pattern57 = new Pattern(new OpeningBrace(), new ExpressionVariable("e.Exp"), new ClosingBrace());
			if (pattern57.Match(expression))
			{
				return PassiveExpression.Build(_Parse(PassiveExpression.Build(pattern57.GetVariable("e.Exp"))));
			};

			Pattern pattern58 = new Pattern();
			if (pattern58.Match(expression))
			{
				return PassiveExpression.Build();
			};

			Pattern pattern59 = new Pattern(new ExpressionVariable("e.Exp"));
			if (pattern59.Match(expression))
			{
				return PassiveExpression.Build(_Prout(PassiveExpression.Build("Syntax error. Cannot parse ".ToCharArray(), pattern59.GetVariable("e.Exp"))), _Br(PassiveExpression.Build("compl=fail".ToCharArray())));
			};

			throw new RecognitionImpossibleException("Recognition impossible. Last expression: " + expression.ToString());
		}
		public void TermVariable_MatchesNonEmptyExpressionInBraces()
		{
			var pattern = new Pattern(new TermVariable("t.1")); // t.1
			var expr = PassiveExpression.Build(new OpeningBrace(), "Hello", new ClosingBrace()); // ()

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("t.1"));
			Assert.AreEqual(PassiveExpression.Build(new OpeningBrace(), "Hello", new ClosingBrace()), pattern.Variables["t.1"].Value);
		}
		public void ExpressionVariable_MatchesEmptyExpression()
		{
			var pattern = new Pattern(new ExpressionVariable("e.1")); // e.1
			var expr = PassiveExpression.Build(); // 

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("e.1"));
		}
예제 #18
0
		public PassiveExpression Br(PassiveExpression expression)
		{
			// <Br e.N '=' e.Expr>, where e.N is expression which does not
			// include '=' on the upper level of the bracket's structure
			Pattern pattern = new Pattern(new ExpressionVariable("Key"), '=', new ExpressionVariable("Value"));
			if (pattern.Match(expression))
			{
				var key = (PassiveExpression)pattern.GetVariable("Key");
				var value = (PassiveExpression)pattern.GetVariable("Value");
				var strKey = key.ToString();

				BuriedKeys[strKey] = key;
				BuriedValues[strKey] = value;

				return PassiveExpression.Build();
			}

			throw new RecognitionImpossibleException("<Br e.N '=' e.Expr>: unexpected arguments");
		}
		public void ExpressionVariableInBraces_MatchesNonEmptyBraces()
		{
			var pattern = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace()); // (e.1)
			var expr = PassiveExpression.Build(new OpeningBrace(), 123, new ClosingBrace()); // (123)

			var result = pattern.Match(expr);
			Assert.IsTrue(result);
			Assert.IsTrue(pattern.Variables.ContainsKey("e.1"));
			Assert.AreEqual(PassiveExpression.Build(123), pattern.Variables["e.1"].Value);
		}
		public void ExpressionVariableInBraces_DontMatchEmptyExpression()
		{
			var pattern = new Pattern(new OpeningBrace(), new ExpressionVariable("e.1"), new ClosingBrace()); // (e.1)
			var expr = PassiveExpression.Build(); //

			var result = pattern.Match(expr);
			Assert.IsFalse(result);
		}