private bool Accept <TInput>(OrParser <TInput> p, BnfStringifyVisitor state)
{
var children = p.GetChildren().ToArray();
state.Append(children[0], " || ", children[1]);
return(true);
}
public void 二つとも失敗ならカーソルは進みません()
{
var tested = new OrParser <string>(new WordParser("abc"), new WordParser("ab"));
var(_, cursol, _) = tested.Parse(new Cursol("a"));
cursol.Index.Is(0);
}
public void 二つとも失敗ならパースは失敗です()
{
var tested = new OrParser <string>(new WordParser("abc"), new WordParser("ab"));
var(isSuccess, _, _) = tested.Parse(new Cursol("a"));
isSuccess.IsFalse();
}
public void 一つ目の要素のパースに失敗し二つ目の要素には成功したら二つ目の要素の分だけカーソルが進みます()
{
var tested = new OrParser <string>(new WordParser("abc"), new WordParser("ab"));
var(_, cursol, _) = tested.Parse(new Cursol("ab"));
cursol.Index.Is("ab".Length);
}
public void 一つ目の要素のパースに失敗し二つ目の要素のパースに成功したら二つ目の要素が返ります()
{
var tested = new OrParser <string>(new WordParser("abc"), new WordParser("ab"));
var(_, _, parsed) = tested.Parse(new Cursol("abc"));
parsed.Is("abc");
}
public void 一つ目の要素のパースに失敗し二つ目の要素には成功したら成功です()
{
var tested = new OrParser <string>(new WordParser("abc"), new WordParser("ab"));
var(isSuccess, _, _) = tested.Parse(new Cursol("ab"));
isSuccess.IsTrue();
}
public void The_Whole_Thing_Fails_If_All_The_Rules_Fail()
{
var rules = new OrParser()
.Or <object>(ExpectsWords("no", "more", "heros"), n => throw new Exception("There were heros."))
.Or <object>(ExpectsWords("no", "way", "this"), n => throw new Exception("It matched"));
var tokens = WordTokens("no", "way", "words");
var lastResult = FeedToCoroutine(rules, tokens);
lastResult.AssertFailed();
}
/// <summary>
/// Converts the multirule parser into a coroutine.
/// Runs the coroutine until it stops, and returns the final result.
/// </summary>
/// <param name="tokens">The sequence of tokens that the current token callback will return.</param>
private RuleResult FeedToCoroutine(OrParser rules, IEnumerable <Token> tokens)
{
var tokenMachine = tokens.GetEnumerator();
return(rules.ToCoroutine(CurrentToken).Last());
Token CurrentToken()
{
tokenMachine.MoveNext();
return(tokenMachine.Current);
}
}
public void It_Can_Complete_A_Single_Rule()
{
bool callbackInvoked = false;
var rules = new OrParser()
.Or <object>(ExpectsWords("A", "simple", "rule"), n => callbackInvoked = true);
var tokens = WordTokens("A", "simple", "rule");
var lastResult = FeedToCoroutine(rules, tokens);
lastResult.AssertComplete();
Assert.True(callbackInvoked);
}
public static RuleCallbackPair Of(params RuleCallbackPair[] rules)
{
IRuleParser RuleFactory()
{
var orParser = new OrParser();
foreach (var pair in rules)
{
orParser.AddRule(pair);
}
return(orParser);
}
return(new RuleCallbackPair(RuleFactory, _ => { }));
}
public void It_Throws_An_Exception_If_You_Feed_It_A_Token_After_It_Has_Failed()
{
var rules = new OrParser()
.Or <object>(ExpectsWords("foo", "bar", "baz"), n => { });
var tokens = WordTokens("foo", "bar", "fizz");
var lastResult = FeedAll(rules, tokens);
lastResult.AssertFailed();
Assert.ThrowsAny <Exception>(() =>
{
FeedToCoroutine(rules, WordTokens("extra"));
});
}
public void The_First_Rule_To_Complete_Wins()
{
int ruleCompleted = -1;
var rules = new OrParser()
.Or <object>(ExpectsWords("not", "even", "close"), n => ruleCompleted = 0)
.Or <object>(ExpectsWords("no", "more", "time"), n => ruleCompleted = 1)
.Or <object>(ExpectsWords("no", "more", "time", "left"), n => ruleCompleted = 2);
var tokens = WordTokens("no", "more", "time");
var lastResult = FeedToCoroutine(rules, tokens);
lastResult.AssertComplete();
Assert.Equal(1, ruleCompleted);
}
public void The_First_Rule_In_The_List_Wins_If_There_Is_A_Tie()
{
bool firstCallbackInvoked = false;
bool secondCallbackInvoked = false;
var rules = new OrParser()
.Or <object>(ExpectsWords("foo", "bar", "baz"), n => firstCallbackInvoked = true)
.Or <object>(ExpectsWords("foo", "bar", "baz"), n => secondCallbackInvoked = true);
var tokens = WordTokens("foo", "bar", "baz");
var lastResult = FeedToCoroutine(rules, tokens);
lastResult.AssertComplete();
Assert.True(firstCallbackInvoked);
Assert.False(secondCallbackInvoked);
}
public static bool Parse(SyntaxContext context, int position)
{
var list = context.list;
var offset = 0;
var index = position;
var count = 0;
var isMissed = false;
if (!ParserHelper.IsOperator(list[index], "["))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (FunctionAParser.Parse(context, index))
{
;
}
while (ParenParser.Parse(context, index))
{
;
}
while (TableIParser.Parse(context, index))
{
;
}
while (TableSParser.Parse(context, index))
{
;
}
while (ListParser.Parse(context, index))
{
;
}
while (PropertyParser.Parse(context, index))
{
;
}
while (IndexParser.Parse(context, index))
{
;
}
while (CallParser.Parse(context, index))
{
;
}
while (NotParser.Parse(context, index))
{
;
}
while (LengthParser.Parse(context, index))
{
;
}
while (NegateParser.Parse(context, index))
{
;
}
while (PowerParser.Parse(context, index))
{
;
}
while (MultiplyParser.Parse(context, index))
{
;
}
while (DivisionParser.Parse(context, index))
{
;
}
while (ModParser.Parse(context, index))
{
;
}
while (AddParser.Parse(context, index))
{
;
}
while (SubtractParser.Parse(context, index))
{
;
}
while (ConcatParser.Parse(context, index))
{
;
}
while (LessParser.Parse(context, index))
{
;
}
while (GreaterParser.Parse(context, index))
{
;
}
while (LessEqualParser.Parse(context, index))
{
;
}
while (GreaterEqualParser.Parse(context, index))
{
;
}
while (EqualParser.Parse(context, index))
{
;
}
while (NotEqualParser.Parse(context, index))
{
;
}
while (AndParser.Parse(context, index))
{
;
}
while (OrParser.Parse(context, index))
{
;
}
if (!list[index].isRightValue)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsOperator(list[index], "]"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsOperator(list[index], "="))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (FunctionAParser.Parse(context, index))
{
;
}
while (ParenParser.Parse(context, index))
{
;
}
while (TableIParser.Parse(context, index))
{
;
}
while (TableSParser.Parse(context, index))
{
;
}
while (ListParser.Parse(context, index))
{
;
}
while (PropertyParser.Parse(context, index))
{
;
}
while (IndexParser.Parse(context, index))
{
;
}
while (CallParser.Parse(context, index))
{
;
}
while (NotParser.Parse(context, index))
{
;
}
while (LengthParser.Parse(context, index))
{
;
}
while (NegateParser.Parse(context, index))
{
;
}
while (PowerParser.Parse(context, index))
{
;
}
while (MultiplyParser.Parse(context, index))
{
;
}
while (DivisionParser.Parse(context, index))
{
;
}
while (ModParser.Parse(context, index))
{
;
}
while (AddParser.Parse(context, index))
{
;
}
while (SubtractParser.Parse(context, index))
{
;
}
while (ConcatParser.Parse(context, index))
{
;
}
while (LessParser.Parse(context, index))
{
;
}
while (GreaterParser.Parse(context, index))
{
;
}
while (LessEqualParser.Parse(context, index))
{
;
}
while (GreaterEqualParser.Parse(context, index))
{
;
}
while (EqualParser.Parse(context, index))
{
;
}
while (NotEqualParser.Parse(context, index))
{
;
}
while (AndParser.Parse(context, index))
{
;
}
while (OrParser.Parse(context, index))
{
;
}
if (!list[index].isRightValue)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsOperator(list[index], ","))
{
isMissed = true;
context.isMissed = true;
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (isMissed)
{
offset -= 1;
}
context.Insert(position, ExpressionCreator.CreateKV2(list, position, offset));
context.Remove(position + 1, offset);
if (isMissed)
{
return(false);
}
return(true);
}
public void OrParserTest()
{
var chars = new List<char>();
var p1 = new RangeParser<char>('A', 'Z');
var p2 = new RangeParser<char>('a', 'z');
var orParser = new OrParser<char, char, char, char>(
p1, _ => _,
p2, _ => _);
int endInput;
char result;
orParser.Parse(chars, 0, out endInput, out result).IsFalse();
chars.Add('0');
orParser.Parse(chars, 0, out endInput, out result).IsFalse();
chars.Add('a');
orParser.Parse(chars, 1, out endInput, out result).IsTrue();
result.Is('a');
chars.Add('C');
orParser.Parse(chars, 2, out endInput, out result).IsTrue();
result.Is('C');
chars.Add('0');
orParser.Parse(chars, 3, out endInput, out result).IsFalse();
}
public static bool Parse(SyntaxContext context, int position)
{
var list = context.list;
var offset = 0;
var index = position;
var count = 0;
var isMissed = false;
if (!ParserHelper.IsKeyword(list[index], "if"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (FunctionAParser.Parse(context, index))
{
;
}
while (ParenParser.Parse(context, index))
{
;
}
while (TableIParser.Parse(context, index))
{
;
}
while (TableSParser.Parse(context, index))
{
;
}
while (ListParser.Parse(context, index))
{
;
}
while (PropertyParser.Parse(context, index))
{
;
}
while (IndexParser.Parse(context, index))
{
;
}
while (CallParser.Parse(context, index))
{
;
}
while (NotParser.Parse(context, index))
{
;
}
while (LengthParser.Parse(context, index))
{
;
}
while (NegateParser.Parse(context, index))
{
;
}
while (PowerParser.Parse(context, index))
{
;
}
while (MultiplyParser.Parse(context, index))
{
;
}
while (DivisionParser.Parse(context, index))
{
;
}
while (ModParser.Parse(context, index))
{
;
}
while (AddParser.Parse(context, index))
{
;
}
while (SubtractParser.Parse(context, index))
{
;
}
while (ConcatParser.Parse(context, index))
{
;
}
while (LessParser.Parse(context, index))
{
;
}
while (GreaterParser.Parse(context, index))
{
;
}
while (LessEqualParser.Parse(context, index))
{
;
}
while (GreaterEqualParser.Parse(context, index))
{
;
}
while (EqualParser.Parse(context, index))
{
;
}
while (NotEqualParser.Parse(context, index))
{
;
}
while (AndParser.Parse(context, index))
{
;
}
while (OrParser.Parse(context, index))
{
;
}
if (!list[index].isRightValue)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsKeyword(list[index], "then"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (ModuleParser.Parse(context, index))
{
;
}
if (list[index].type != Expression.Type.Module)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsKeyword(list[index], "else"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (ModuleParser.Parse(context, index))
{
;
}
if (list[index].type != Expression.Type.Module)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
if (!ParserHelper.IsKeyword(list[index], "end"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
context.Insert(position, ExpressionCreator.CreateIfElse(list, position, offset));
context.Remove(position + 1, offset);
return(true);
}
