public void Evaluate_Test(string input, double output)
{
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tokens = lex.Tokenize(input);
var t = tree.Evaluate(tokens);
t.Should().Be(output);
}
private CharsetGrammar()
{
var provider = new UnicodeCharSetProvider();
var mapper = new UnicodeUtf16Mapper(false, false);
var rx = RegexLexer.CreateRx(mapper);
var rxWhitespace = new RxAccept <char>(RxOfSymbol <char> .Extract(rx, RegexLexer.SymWhitespace), SymWhitespace, 0);
var rxCharset = new RxAccept <char>(RxOfSymbol <char> .Extract(rx, RegexLexer.SymCharset), SymCharset, 0);
var rxRegexCharset = new RxAccept <char>(RxOfSymbol <char> .Extract(rx, RegexLexer.SymRegexCharset), SymRegexCharset, 0);
var rxUnion = new RxAccept <char>(RegexMatchSet.FromChars('|', '+').ToInvariant(mapper, provider, true), SymUnion, 0);
var rxSubtract = new RxAccept <char>(RegexMatchSet.FromChars('-').ToInvariant(mapper, provider, true), SymSubtract, 0);
var rxIntersect = new RxAccept <char>(RegexMatchSet.FromChars('&').ToInvariant(mapper, provider, true), SymIntersect, 0);
var rxDifference = new RxAccept <char>(RegexMatchSet.FromChars('^').ToInvariant(mapper, provider, true), SymDifference, 0);
var rxNegate = new RxAccept <char>(RegexMatchSet.FromChars('~').ToInvariant(mapper, provider, true), SymNegate, 0);
var rxParensOpen = new RxAccept <char>(RegexMatchSet.FromChars('(').ToInvariant(mapper, provider, true), SymParensOpen, 0);
var rxParensClose = new RxAccept <char>(RegexMatchSet.FromChars(')').ToInvariant(mapper, provider, true), SymParensClose, 0);
var alpha = new AlphabetBuilder <char>(
new RxAlternation <char>(rxWhitespace,
new RxAlternation <char>(rxCharset,
new RxAlternation <char>(rxRegexCharset,
new RxAlternation <char>(rxUnion,
new RxAlternation <char>(rxSubtract,
new RxAlternation <char>(rxIntersect,
new RxAlternation <char>(rxDifference,
new RxAlternation <char>(rxNegate,
new RxAlternation <char>(rxParensOpen, rxParensClose))))))))),
Utf16Chars.EOF,
Utf16Chars.ValidBmp);
var nfa = NfaBuilder <LetterId> .Build(alpha.Expression);
var dfa = DfaBuilder <LetterId> .Build(nfa, LetterId.Eof);
if (dfa.StartState.Id != default(Id <DfaState <LetterId> >))
{
throw new InvalidOperationException($"Internal error: Unexpected DFA start state {dfa.StartState.Id}");
}
this.stateMachine = DfaStateMachineEmitter.CreateExpression(dfa, AlphabetMapperEmitter <char> .CreateExpression(alpha)).Compile();
this.table = new LalrTableGenerator(new GrammarBuilder(-2, -1, SymExpression)
{
{ SymUnionExpression, SymExpression, SymUnion, SymNegateExpression },
{ SymExpression, SymUnionExpression },
{ SymSubtractExpression, SymExpression, SymSubtract, SymNegateExpression },
{ SymExpression, SymSubtractExpression },
{ SymIntersectExpression, SymExpression, SymIntersect, SymNegateExpression },
{ SymExpression, SymIntersectExpression },
{ SymDifferenceExpression, SymExpression, SymDifference, SymNegateExpression },
{ SymExpression, SymDifferenceExpression },
{ SymExpression, SymNegateExpression },
{ SymNegateExpression, SymNegate, SymValueExpression },
{ SymNegateExpression, SymValueExpression },
{ SymValueExpression, SymParensOpen, SymExpression, SymParensClose },
{ SymValueExpression, SymCharset },
{ SymValueExpression, SymRegexCharset }
})
.ComputeTable();
}
public static void AddMathTokens(RegexLexer lex)
{
lex.Ignore(" ");
lex.Add(PascalTerms.LParinth, @"\(");
lex.Add(PascalTerms.RParinth, @"\)");
lex.Add(PascalTerms.IntegerConst, @"\d+");
lex.Add(PascalTerms.Add, @"\+");
lex.Add(PascalTerms.Sub, @"-");
lex.Add(PascalTerms.Multi, @"\*");
lex.Add(PascalTerms.FloatDiv, @"/");
}
public void AddAndSubtract_Should_HaveSubAtTopOfTree()
{
var input = "1+2-3";
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var t = tree.Evaluate().Should().BeOfType <BinaryOperator>().Which;
t.Name.Should().Be(PascalTerms.Sub);
}
public void UnaryOperation()
{
var input = "-2";
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var node = tree.Evaluate();
node.Should().BeOfType <UnaryOperator>().Which.Name.Should().Be(PascalTerms.Sub);
}
public void SimpleExample_ShouldParseToExpectedTokens()
{
// Arrange
var lexer = new RegexLexer <TokenType>(new Dictionary <string, TokenType>
{
["0"] = TokenType.Zero,
["1"] = TokenType.One,
});
// Act
var tokens = (IEnumerable <Token <TokenType> >)lexer.Lex(new StringReader("010"));
// Assert
Assert.Equal(new []
public void Evaluate_Test(string input, double output)
{
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var t = tree.Evaluate();
var inter = new PascalInterpreter();
var r = inter.VisitNode(t);
r.Should().Be(output);
}
public void LispTest(string input, string output)
{
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var t = tree.Evaluate();
var inter = new SuperBasicMathLispInterpreter();
var result = inter.Evaluate(t);
result.Should().Be(output);
}
public void RpnTest()
{
var input = "(5 + 3) * 12 / 3";
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var t = tree.Evaluate();
var inter = new SuperBasicRpnMathInterpreter();
var result = inter.Evaluate(t);
result.Should().Be("5 3 + 12 * 3 /");
}
public void BasicAst_Should_Subtract()
{
var input = "1-2";
var lex = new RegexLexer();
SuperBasicMathAst.AddMathTokens(lex);
var tree = new SuperBasicMathAst(lex.Tokenize(input));
var t = tree.Evaluate().Should().BeOfType <BinaryOperator>().Which;
t.TokenItem.Token.Name.Should().Be(PascalTerms.Sub);
var left = t.Left.Should().BeOfType <IntegerNode>().Which;
var right = t.Right.Should().BeOfType <IntegerNode>().Which;
left.TokenItem.Token.Name.Should().Be(PascalTerms.IntegerConst);
left.TokenItem.Value.Should().Be("1");
right.TokenItem.Token.Name.Should().Be(PascalTerms.IntegerConst);
right.TokenItem.Value.Should().Be("2");
}
public void Setup()
{
_regexLexer = new RegexLexer();
}
