public void TestNots()
{
var command = new Command("if", "not", "not", "not", "$var", "1", "say", "test");
var output = _filter.Filter(command);
IfToken token = output.Arguments[0].Tokens[0] as IfToken;
Assert.That(token, Is.Not.Null);
Assert.That(token.Conditions[0].Not, Is.True);
}
public void TestSimpleMatchesIf()
{
var command = new Command("if", "$var", "1..2", "say", "test");
var output = _filter.Filter(command);
IfToken token = output.Arguments[0].Tokens[0] as IfToken;
Assert.That(token, Is.Not.Null);
Assert.That(token.Conditions[0].Not, Is.False);
Assert.That(token.Conditions[0], Is.InstanceOf(typeof(MatchesCondition)));
MatchesCondition matches = token.Conditions[0] as MatchesCondition;
Assert.That(matches.LeftVariable.Name, Is.EqualTo("var"));
Assert.That(matches.Matches, Is.EqualTo("1..2"));
}
public void TestMultipleConditions()
{
var command = new Command("if", "$var", "1", "&&", "$left", "=", "$right", "say", "test");
var output = _filter.Filter(command);
IfToken token = output.Arguments[0].Tokens[0] as IfToken;
Assert.That(token, Is.Not.Null);
Assert.That(token.Conditions.Count, Is.EqualTo(2));
Assert.That(((MatchesCondition)token.Conditions[0]).LeftVariable.Name, Is.EqualTo("var"));
Assert.That(((MatchesCondition)token.Conditions[0]).Matches, Is.EqualTo("1"));
Assert.That(((OperationCondition)token.Conditions[1]).LeftVariable.Name, Is.EqualTo("left"));
Assert.That(((OperationCondition)token.Conditions[1]).Operation, Is.EqualTo("="));
Assert.That(((OperationCondition)token.Conditions[1]).RightVariable.Name, Is.EqualTo("right"));
}
public void TestSimpleOperationIf()
{
var command = new Command("if", "$left", ">", "$right", "say", "test");
var output = _filter.Filter(command);
IfToken token = output.Arguments[0].Tokens[0] as IfToken;
Assert.That(token, Is.Not.Null);
Assert.That(token.Conditions[0].Not, Is.False);
Assert.That(token.Conditions[0], Is.InstanceOf(typeof(OperationCondition)));
OperationCondition operation = token.Conditions[0] as OperationCondition;
Assert.That(operation.LeftVariable.Name, Is.EqualTo("left"));
Assert.That(operation.Operation, Is.EqualTo(">"));
Assert.That(operation.RightVariable.Name, Is.EqualTo("right"));
}
private Ast IfStatement()
{
if (!_tokenStream.IsMatch <IfToken>())
{
return(null);
}
IfToken token = _tokenStream.Take <IfToken>();
_tokenStream.Take <LeftParensToken>();
Ast predicate = Expression();
if (predicate == null)
{
throw new InvalidSyntaxException("Condition of if statement must be an expression", _tokenStream.Current.Position, null);
}
_tokenStream.Take <RightParensToken>();
Ast body = Statement();
if (body == null)
{
throw new InvalidSyntaxException("Body of if statement must be a statement", _tokenStream.Current.Position, null);
}
if (!_tokenStream.IsMatch <ElseToken>())
{
return(new ConditionalBranch(token, predicate, body));
}
_tokenStream.Take <ElseToken>();
Ast alternative = Statement();
if (alternative == null)
{
throw new InvalidSyntaxException("An else statement must be followed by a statement", _tokenStream.Current.Position, null);
}
return(new ConditionalBranch(token, predicate, body, alternative));
}
public Token GetToken()
{
State = LexicAnalyserState.Initial;
Value = HasNext ? Character.ToString() : "";
Token token = null;
while (HasNext && token == null)
{
switch (State)
{
case LexicAnalyserState.Initial:
HandleInitial();
break;
case LexicAnalyserState.NonTerminal:
token = new NonTerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Space:
token = new SpaceToken();
CurrentIndex++;
break;
case LexicAnalyserState.Terminal:
token = new TerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Empty:
token = new EmptyToken();
CurrentIndex++;
break;
case LexicAnalyserState.NewLine:
token = new NewLineToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Identifier:
token = new IdentifierToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Number:
token = new NumberToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Var:
token = new VarToken();
CurrentIndex++;
break;
case LexicAnalyserState.Write:
token = new WriteToken();
CurrentIndex++;
break;
case LexicAnalyserState.Read:
token = new ReadToken();
CurrentIndex++;
break;
case LexicAnalyserState.If:
token = new IfToken();
CurrentIndex++;
break;
case LexicAnalyserState.End:
token = new EndToken();
CurrentIndex++;
break;
case LexicAnalyserState.Then:
token = new ThenToken();
CurrentIndex++;
break;
case LexicAnalyserState.Begin:
token = new BeginToken();
CurrentIndex++;
break;
case LexicAnalyserState.While:
token = new WhileToken();
CurrentIndex++;
break;
case LexicAnalyserState.Do:
token = new DoToken();
CurrentIndex++;
break;
case LexicAnalyserState.SemiColon:
token = new SemiColonToken();
CurrentIndex++;
break;
case LexicAnalyserState.OpenParentheses:
token = new OpenParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.CloseParentheses:
token = new CloseParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.Plus:
token = new PlusToken();
CurrentIndex++;
break;
case LexicAnalyserState.Sub:
token = new SubToken();
CurrentIndex++;
break;
case LexicAnalyserState.Great:
token = new GreatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Less:
token = new LessToken();
CurrentIndex++;
break;
case LexicAnalyserState.Equal:
token = new EqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.Repeat:
token = new RepeatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Until:
token = new UntilToken();
CurrentIndex++;
break;
case LexicAnalyserState.Attribution:
token = new AttributionToken();
CurrentIndex++;
break;
case LexicAnalyserState.NotEqual:
token = new NotEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.GreatOrEqual:
token = new GreatOrEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.LessOrEqual:
token = new LessOrEqualToken();
CurrentIndex++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(token);
}
protected string CreateIfCommand(params Condition[] conditions)
{
IfToken token = new IfToken(new List <Condition>(conditions));
return(token.Compile(_env) + " test");
}
