protected override void Build()
{
base.Build();
var simpleIdentifier = new Pattern("simpleIdentifier")
{
Data = identifier.Data
};
var identifierOrInline = new Pattern("identifierOrInline")
{
Data = new PrioritizedChoice(identifier,
new CaptureGroup((int)ExtendedCaptureKeys.InlinePattern,
new Sequence(
"\\(",
spacing,
internalExpression,
')'
)
)
)
};
// Prevent 'export' from being seen as a non-terminal
// This effectively reserves export as a global keyword
prefix.Data = new Sequence(new Not(CharacterClass.String("export")), prefix.Data);
var parameterizedIdentifier = BuildParameterizedIdentifier(simpleIdentifier, identifierOrInline);
var parameterizedIdentifierDeclaration = BuildParameterizedIdentifier(simpleIdentifier, new CaptureGroup((int)ExtendedCaptureKeys.PatternParameterReference, simpleIdentifier));
var complexIdentifier = new Pattern("complexIdentifier")
{
Data = new PrioritizedChoice(parameterizedIdentifier, simpleIdentifier)
};
var namespacedIdentifier = new Pattern("namespacedIdentifier");
namespacedIdentifier.Data = new PrioritizedChoice(
new CaptureGroup((int)ExtendedCaptureKeys.Namespace,
new Sequence(simpleIdentifier, "::", namespacedIdentifier)
),
complexIdentifier
);
identifier.Data = namespacedIdentifier;
var possibleDeclarationIdentifiers = new PrioritizedChoice(parameterizedIdentifierDeclaration, simpleIdentifier);
identifierDeclaration.Data = new PrioritizedChoice(
new CaptureGroup((int)ExtendedCaptureKeys.Export,
new Sequence("export", spacing, possibleDeclarationIdentifiers)
),
possibleDeclarationIdentifiers
);
var number = Operator.OneOrMore(new CharacterClass(new CharacterRange('0', '9')));
var fixedRepeat = new CaptureGroup((int)ExtendedCaptureKeys.FixedRepeat, new Sequence(primary, '^', number, Operator.Optional(new Sequence("..", number))));
suffix.Data = new PrioritizedChoice(new Sequence(fixedRepeat, spacing), suffix.Data);
}
public void CompositeVisitor_CapturingGroup_SandBoxTest_PriorityChoice3()
{
var prefix = new PrioritizedChoice(
new CapturingGroup("AndPredicate", new Literal {
MatchText = "&"
}),
new CapturingGroup("NotPredicate", new Literal {
MatchText = "!"
})
);
PrioritizedChoice suffix = new PrioritizedChoice(
new CapturingGroup("ZeroOrMore", new Literal {
MatchText = "*"
}),
new CapturingGroup("OneOrMore", new Literal {
MatchText = "+"
})
)
.Or(new CapturingGroup("Optional", new Literal {
MatchText = "?"
}));
var terminal = new CapturingGroup("AnyCharacter", new Literal {
MatchText = "."
});
var expression = new CapturingGroup("Expression",
new PrioritizedChoice(
// match prefixes first
prefix.Plus()
.Sequence(terminal)
,
// match suffixes next
terminal
.Sequence(
suffix.Plus()
)
)
.Or(terminal)
.Plus()
);
var input = ".";
var bytes = Encoding.UTF8.GetBytes(input);
var iterator = new ByteInputIterator(bytes);
var visitor = new NpegParserVisitor(iterator);
expression.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
AstNode node = visitor.AST;
Assert.IsTrue(node.Children.Count == 1);
Assert.IsTrue(node.Token.Name == "Expression");
Assert.IsTrue(node.Token.ValueAsString(iterator) == ".");
Assert.IsTrue(node.Children[0].Token.Name == "AnyCharacter");
}
public void Choice()
{
var p = new PrioritizedChoice(letters, capitals);
MustMatch(p, "a");
MustMatch(p, "F");
MustMatch(p, "z");
MustNotMatch(p, "++");
MustNotMatch(p, "Aa");
MustNotMatch(p, "0");
MustNotMatch(p, "");
MustNotMatch(p, "+");
}
public void RegexChoice()
{
var first = new Sequence(new Any(), new Any(), new CharacterClass('S'));
var second = new Sequence(new Any(), new Any(), new CharacterClass('T'));
var p = new PrioritizedChoice(first, second);
MustMatch(p, "abS");
MustMatch(p, "zyT");
MustMatch(p, "ccS");
MustNotMatch(p, "a");
MustNotMatch(p, "ff");
MustNotMatch(p, "zzzzzzzz");
MustNotMatch(p, "AbTs");
MustNotMatch(p, "++++");
}
public void ConcatenationInChoice()
{
var first = new Sequence(new Any(), letters);
var second = new Sequence(new Any(), new CharacterClass(new CharacterRange('A', 'Z')));
var p = new PrioritizedChoice(first, second);
MustMatch(p, "xa");
MustMatch(p, ")F");
MustMatch(p, "6z");
MustNotMatch(p, "+");
MustNotMatch(p, "A");
MustNotMatch(p, "+");
MustNotMatch(p, "");
MustNotMatch(p, "++++++");
}
public override void VisitLeave(PrioritizedChoice expression)
{
terminal.Peek().Append(")");
//String input = terminal.Pop().ToString();
//if (!this.uniqueBranches.ContainsKey(input))
//{
// String nodename = "node" + branchcount++;
// this.uniqueBranches.Add(input, nodename);
// this.statements.Add( String.Format("{0}: {1};", nodename, input) );
//}
//// remember last node is always a captured group so peek should not throw exceptions
//// insert terminal name
//terminal.Peek().Append(this.uniqueBranches[input]);
}
public void NestedChoice()
{
var first = new PrioritizedChoice(new CharacterClass('S'), letters);
var second = new PrioritizedChoice(new CharacterClass('T'), capitals, new CharacterClass('.'));
var p = new PrioritizedChoice(first, second);
MustMatch(p, "S");
MustMatch(p, "a");
MustMatch(p, "T");
MustMatch(p, ".");
MustNotMatch(p, "");
MustNotMatch(p, "ff");
MustNotMatch(p, "zzzzzzzz");
MustNotMatch(p, "AbTs");
MustNotMatch(p, "++++");
}
public abstract void VisitExecute(PrioritizedChoice expression);
public override void VisitLeave(PrioritizedChoice expression)
{
IsMatchPredicate localRight = _matchStack.Pop();
IsMatchPredicate localLeft = _matchStack.Pop();
_matchStack.Push(
delegate(IInputIterator iterator)
{
Int32 savePosition = iterator.Index;
_sandbox.Push(new Stack <AstNode>());
_sandbox.Peek().Push(new AstNode());
// create new sandbox which capturing group works in.
// have a dummy node to act as parent container (CapturedGroup logic)
if (localLeft(iterator))
{
Stack <AstNode> s = _sandbox.Pop();
if (s.Count >= 1)
{
AstNode child = s.Pop();
if (_sandbox.Peek().Count == 0)
{
_sandbox.Peek().Push(child);
}
else
{
_sandbox.Peek().Peek().Children.AddRange(child.Children);
// our dummy node for this sandbox is child.
// move important data over to the previous sandbox.
}
}
return(true);
}
_sandbox.Pop();
// destory sandbox since anything captured is no longer valid.
iterator.Index = savePosition;
_sandbox.Push(new Stack <AstNode>());
_sandbox.Peek().Push(new AstNode());
// create new sandbox which capturing group works in.
// have a dummy node to act as parent container (CapturedGroup logic)
if (localRight(iterator))
{
Stack <AstNode> s = _sandbox.Pop();
if (s.Count >= 1)
{
AstNode child = s.Pop();
if (_sandbox.Peek().Count == 0)
{
_sandbox.Peek().Push(child);
}
else
{
_sandbox.Peek().Peek().Children.AddRange(child.Children);
// our dummy node for this sandbox is child.
// move important data over to the previous sandbox.
}
}
return(true);
}
_sandbox.Pop();
// destory sandbox since anything captured is no longer valid.
return(false);
}
);
}
public RegexGrammar(PatternCompiler patternCompiler)
{
var RE = new Pattern("RE");
var simpleRE = new Pattern("SimpleRE");
var metaCharacter = new Pattern("metaCharacter")
{
Data = new PrioritizedChoice(
new CharacterClass('*', '+', '^', '$', '|', '(', ')', '[', ']'),
new Sequence(new CharacterClass('\\'), new CharacterClass('t', 'n', 'r', 'f', 'b', 'B', 'd', 'D', 's', 'S', 'w', 'W', 'Q', 'U', 'L')),
CharacterClass.String(@"*?"),
CharacterClass.String(@"+?"),
CharacterClass.String(@"$`"),
CharacterClass.String(@"$'"),
CharacterClass.String(@"$&"),
CharacterClass.String(@"\cX"),
new Sequence(new CharacterClass('\\', '$'), CharacterClass.Range('0', '9')),
new Sequence(new CharacterClass('\\'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'))
)
};
var allowedMetaCharacters = new Pattern("allowedMetaCharacter")
{
Data = new CaptureGroup((int)CaptureType.MetaCharacter,
new PrioritizedChoice(
new Sequence(new CharacterClass('\\'), new CharacterClass('t', 'n', 'r', 'f', 'b', 'B', 'd', 'D', 's', 'S', 'w', 'W', 'Q', 'U', 'L')),
CharacterClass.String(@"*?"),
CharacterClass.String(@"+?"),
CharacterClass.String(@"$`"),
CharacterClass.String(@"$'"),
CharacterClass.String(@"$&"),
CharacterClass.String(@"\cX"),
new Sequence(new CharacterClass('\\', '$'), CharacterClass.Range('0', '9')),
new Sequence(new CharacterClass('\\'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'), CharacterClass.Range('0', '7'))
)
)
};
var character = new Pattern("character")
{
Data = new CaptureGroup((int)CaptureType.Char,
new PrioritizedChoice(
new Sequence(
new CharacterClass('\\'),
metaCharacter
),
new Sequence(
new Not(metaCharacter),
new Any()
)
)
)
};
var range = new CaptureGroup((int)CaptureType.Range, new Sequence(character, new CharacterClass('-'), character));
var setItem = new PrioritizedChoice(range, character);
var setItems = new Pattern()
{
Data = Operator.OneOrMore(setItem)
};
var positiveSet = new CaptureGroup((int)CaptureType.PositiveSet, new Sequence(new CharacterClass('['), setItems, new CharacterClass(']')));
var negativeSet = new CaptureGroup((int)CaptureType.NegativeSet, new Sequence(CharacterClass.String("[^"), setItems, new CharacterClass(']')));
var set = new Pattern("set")
{
Data = new PrioritizedChoice(negativeSet, positiveSet)
};
var eos = new CaptureGroup((int)CaptureType.Eos, new CharacterClass('$'));
var any = new CaptureGroup((int)CaptureType.Any, new CharacterClass('.'));
var group = new Sequence(new CharacterClass('('), RE, new CharacterClass(')'));
var elementaryRE = new Pattern("elementaryRE")
{
Data = new PrioritizedChoice(group, any, eos, set, character, allowedMetaCharacters)
};
var number = Operator.OneOrMore(CharacterClass.Range('0', '9'));
var repeatRange = new Sequence(new CharacterClass('{'), new CaptureGroup((int)CaptureType.RepeatRange, new Sequence(number, Operator.Optional(new Sequence(new CharacterClass(','), number)))), new CharacterClass('}'));
var plus = new Pattern("plus")
{
Data = new CaptureGroup((int)CaptureType.Plus, new Sequence(elementaryRE, new CharacterClass('+')))
};
var star = new Pattern("star")
{
Data = new CaptureGroup((int)CaptureType.Star, new Sequence(elementaryRE, new CharacterClass('*')))
};
var repeat = new Pattern("repeat")
{
Data = new CaptureGroup((int)CaptureType.Repeat, new Sequence(elementaryRE, repeatRange))
};
var basicRE = new PrioritizedChoice(star, plus, repeat, elementaryRE);
simpleRE.Data = new CaptureGroup((int)CaptureType.Concatenation, Operator.OneOrMore(basicRE));
RE.Data = new CaptureGroup((int)CaptureType.Union, new Sequence(simpleRE, new ZeroOrMore(new Sequence(new CharacterClass('|'), RE))));
Parser = patternCompiler.Compile(RE);
}
public void CompositeVisitor_Recursiveness()
{
var whitespace = new CharacterClass {
ClassExpression = "[ \t\r\n\v]"
};
var terminal = new PrioritizedChoice(
new CapturingGroup("AnyCharacter", new Literal {
MatchText = "."
})
,
new CapturingGroup("CapturingGroup",
new Sequence(
new Literal {
MatchText = "(?<"
},
new CapturingGroup("ReplacementNode",
new OneOrMore(
new CharacterClass {
ClassExpression = "[a-z0-9A-Z]"
}
)
)
)
.Sequence(new Literal {
MatchText = ">"
})
.Sequence(new RecursionCall("Expression"))
.Sequence(new Literal {
MatchText = ")"
})
)
);
var sequence = new CapturingGroup(
"Sequence",
new Sequence(
terminal,
new ZeroOrMore(whitespace)
).Plus()
)
{
DoReplaceBySingleChildNode = true
};
var prioritizedchoice = new CapturingGroup("PrioritizedChoice",
new Sequence(
sequence,
new Literal {
MatchText = "/"
}
)
.Sequence(new ZeroOrMore(whitespace))
.Sequence(sequence)
.Sequence(
new ZeroOrMore(
new Sequence(
new ZeroOrMore(whitespace),
new Literal {
MatchText = "/"
}
)
.Sequence(new ZeroOrMore(whitespace))
.Sequence(sequence)
.Plus()
)
)
);
var expression = new CapturingGroup("Root",
new RecursionCreate("Expression",
new PrioritizedChoice(prioritizedchoice, sequence)));
var input = @"(?<NPEGNode>./.. )";
var bytes = Encoding.UTF8.GetBytes(input);
var iterator = new ByteInputIterator(bytes);
var visitor = new NpegParserVisitor(iterator);
expression.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
AstNode node = visitor.AST;
Assert.IsTrue(node.Token.Name == "Root");
Assert.IsTrue(node.Children.Count == 1);
Assert.IsTrue(node.Children.Count == 1);
Assert.IsTrue(node.Children[0].Token.Name == "CapturingGroup");
Assert.IsTrue(node.Children[0].Children.Count == 2);
Assert.IsTrue(node.Children[0].Children[0].Token.Name == "ReplacementNode");
Assert.IsTrue(node.Children[0].Children[1].Token.Name == "PrioritizedChoice");
Assert.IsTrue(node.Children[0].Children[1].Children[0].Token.Name == "AnyCharacter");
Assert.IsTrue(node.Children[0].Children[1].Children[1].Token.Name == "Sequence");
Assert.IsTrue(node.Children[0].Children[1].Children[1].Children[0].Token.Name == "AnyCharacter");
Assert.IsTrue(node.Children[0].Children[1].Children[1].Children[1].Token.Name == "AnyCharacter");
}
public void PracticalExample_MathematicalFormula()
{
#region Composite
var VALUE = new PrioritizedChoice(
new CapturingGroup("VALUE",
new OneOrMore(new CharacterClass {
ClassExpression = "[0-9]"
})
)
,
new Sequence(
new Literal {
MatchText = "("
},
new RecursionCall("ParethesisFunction")
)
.Sequence(new Literal {
MatchText = ")"
})
);
var PRODUCT = new Sequence(
VALUE,
new Sequence(
new CapturingGroup("SYMBOL",
new PrioritizedChoice(
new Literal {
MatchText = "*"
},
new Literal {
MatchText = "/"
}
)
),
VALUE
).Star()
);
var SUM = new Sequence(
PRODUCT,
new Sequence(
new CapturingGroup("SYMBOL",
new PrioritizedChoice(
new Literal {
MatchText = "+"
},
new Literal {
MatchText = "-"
}
)
),
PRODUCT
).Star()
);
AExpression EXPRESSION = new RecursionCreate("ParethesisFunction", new CapturingGroup("EXPRESSION", SUM));
#endregion
var input = "((((12/3)+5-2*(81/9))+1))";
var bytes = Encoding.UTF8.GetBytes(input);
var iterator = new ByteInputIterator(bytes);
var visitor = new NpegParserVisitor(iterator);
EXPRESSION.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
AstNode node = visitor.AST;
Assert.IsTrue(node.Token.ValueAsString(iterator) == input);
}
public void CompositeVisitor_CapturingGroup_SandBoxTest_PriorityChoice1()
{
PrioritizedChoice newline = new PrioritizedChoice(
new Literal {
MatchText = "\r\n"
}, // windows
new Literal {
MatchText = "\r\r"
} // old macs
)
.Or(new Literal {
MatchText = "\n"
}); // linux
// Single Line Comment
var singleLineComment = new Sequence(
new Literal {
MatchText = "//"
},
new Sequence(
new NotPredicate(newline),
new AnyCharacter()
)
.Star()
);
// Multiline Comment
var multiLineComment = new Sequence(
new Literal {
MatchText = "/*"
},
new Sequence(
new NotPredicate(new Literal {
MatchText = "*/"
}),
new AnyCharacter()
)
.Star()
.Sequence(new Literal {
MatchText = "*/"
})
);
var comment = new PrioritizedChoice(singleLineComment, multiLineComment);
var whitespace = new PrioritizedChoice(
new CharacterClass {
ClassExpression = "[ \t\r\n\v]"
},
comment
);
var label = new CapturingGroup("Label",
new Sequence(
new CharacterClass {
ClassExpression = "[a-zA-Z_]"
},
// must start with alpha character
new ZeroOrMore(new CharacterClass {
ClassExpression = "[a-zA-Z0-9_]"
})
)
);
var backreference = new CapturingGroup("DynamicBackReferencing",
new Sequence(
new Literal {
MatchText = @"\k<"
},
new Sequence(new ZeroOrMore(whitespace), label).Sequence(
new ZeroOrMore(whitespace))
)
.Sequence(
new Optional(
new Sequence(
new Sequence(
new Literal {
MatchText = "["
},
new CapturingGroup("CaseSensitive",
new Literal {
MatchText = @"\i"
}
)
),
new Literal {
MatchText = "]"
}
)
)
)
.Sequence(
new Sequence(new ZeroOrMore(whitespace), new Literal {
MatchText = ">"
})
)
);
var root = new CapturingGroup("Test",
new Sequence(
backreference,
new NotPredicate(new AnyCharacter())
)
);
var input = @"\k< CapturedLabelVariableName >";
var bytes = Encoding.UTF8.GetBytes(input);
var iterator = new ByteInputIterator(bytes);
var visitor = new NpegParserVisitor(iterator);
root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
AstNode node = visitor.AST;
Assert.IsTrue(node.Token.Name == "Test");
Assert.IsTrue(node.Children[0].Token.Name == "DynamicBackReferencing");
Assert.IsTrue(node.Children[0].Children[0].Token.Name == "Label");
Assert.IsTrue(node.Children[0].Children[0].Token.ValueAsString(iterator) == "CapturedLabelVariableName");
}
public override void VisitExecute(PrioritizedChoice expression)
{
}
public void PracticalExample_BooleanAlgebra()
{
#region Composite
//AND: */AND
AExpression AND = new PrioritizedChoice(new Literal {
MatchText = "*"
}, new Literal {
MatchText = "AND"
});
//NAND: ~*/NAND
AExpression NAND = new PrioritizedChoice(new Literal {
MatchText = "~*"
}, new Literal {
MatchText = "NAND"
});
//OR: +/OR
AExpression OR = new PrioritizedChoice(new Literal {
MatchText = "+"
}, new Literal {
MatchText = "OR"
});
//NOR: ~+/NOR
AExpression NOR = new PrioritizedChoice(new Literal {
MatchText = "~+"
}, new Literal {
MatchText = "NOR"
});
//XOR: ^/XOR
AExpression XOR = new PrioritizedChoice(new Literal {
MatchText = "^"
}, new Literal {
MatchText = "XOR"
});
//XNOR: ~^/XNOR
AExpression XNOR = new PrioritizedChoice(new Literal {
MatchText = "~^"
}, new Literal {
MatchText = "XNOR"
});
AExpression GATE = new CapturingGroup("GATE", new PrioritizedChoice(AND, NAND).Or(OR).Or(NOR).Or(XOR).Or(XNOR));
// Variable: "[a-zA-Z0-9]+" / '[a-zA-Z0-9]+' / [a-zA-Z]
AExpression VARIABLE = new PrioritizedChoice(
new Sequence(
new Literal {
MatchText = "\""
},
new CapturingGroup("VARIABLE", new OneOrMore(new CharacterClass {
ClassExpression = "[a-zA-Z0-9]"
}))
).Sequence(new Literal {
MatchText = "\""
}),
new Sequence(
new Literal {
MatchText = "'"
},
new CapturingGroup("VARIABLE", new OneOrMore(new CharacterClass {
ClassExpression = "[a-zA-Z0-9]"
}))
).Sequence(new Literal {
MatchText = "'"
})
).Or(
new CapturingGroup("VARIABLE", new CharacterClass {
ClassExpression = "[a-zA-Z]"
})
);
// Variable: Variable / !Variable
VARIABLE = new PrioritizedChoice(
VARIABLE
,
new CapturingGroup("INVERTOR",
new Sequence(
new Literal {
MatchText = "!"
},
VARIABLE
)
)
);
// Variable: Variable / Expression / !Expression
VARIABLE = new PrioritizedChoice(
VARIABLE
,
new Sequence(
new Literal {
MatchText = "("
},
new RecursionCall("RECURSIONEXPRESSION")
).Sequence(new Literal {
MatchText = ")"
})
).Or(
new CapturingGroup("INVERTOR",
new Sequence(
new Literal {
MatchText = "!"
}
,
new Sequence(
new Literal {
MatchText = "("
},
new RecursionCall("RECURSIONEXPRESSION")
).Sequence(new Literal {
MatchText = ")"
})
)
)
);
AExpression Root = new CapturingGroup("BOOLEANEQUATION",
new Sequence(
new RecursionCreate("RECURSIONEXPRESSION",
//Expression: Variable ((AND|NAND|OR|NOR|XOR|XNOR) Variable)*
new Sequence(VARIABLE, new Sequence(GATE, VARIABLE).Star())
)
,
// ensure reaches end of file
new NotPredicate(new AnyCharacter())
)
);
#endregion
// single variable
var input = "A*!B+!A*B";
var bytes = Encoding.UTF8.GetBytes(input);
var iterator = new ByteInputIterator(bytes);
var visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
AstNode node = visitor.AST;
Assert.IsTrue(node.Token.Name == "BOOLEANEQUATION");
Assert.IsTrue(node.Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[0].Token.ValueAsString(iterator) == "A");
Assert.IsTrue(node.Children[1].Token.Name == "GATE");
Assert.IsTrue(node.Children[1].Token.ValueAsString(iterator) == "*");
Assert.IsTrue(node.Children[2].Token.Name == "INVERTOR");
Assert.IsTrue(node.Children[2].Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[2].Children[0].Token.ValueAsString(iterator) == "B");
Assert.IsTrue(node.Children[3].Token.Name == "GATE");
Assert.IsTrue(node.Children[4].Token.Name == "INVERTOR");
Assert.IsTrue(node.Children[4].Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[4].Children[0].Token.ValueAsString(iterator) == "A");
Assert.IsTrue(node.Children[5].Token.Name == "GATE");
Assert.IsTrue(node.Children[6].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[6].Token.ValueAsString(iterator) == "B");
// quoted variable
input = "'aA'*!'bB'+!'aA'*'bB'";
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
Assert.IsTrue(node.Token.Name == "BOOLEANEQUATION");
Assert.IsTrue(node.Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[0].Token.ValueAsString(iterator) == "aA");
Assert.IsTrue(node.Children[1].Token.Name == "GATE");
Assert.IsTrue(node.Children[1].Token.ValueAsString(iterator) == "*");
Assert.IsTrue(node.Children[2].Token.Name == "INVERTOR");
Assert.IsTrue(node.Children[2].Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[2].Children[0].Token.ValueAsString(iterator) == "bB");
Assert.IsTrue(node.Children[3].Token.Name == "GATE");
Assert.IsTrue(node.Children[4].Token.Name == "INVERTOR");
Assert.IsTrue(node.Children[4].Children[0].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[4].Children[0].Token.ValueAsString(iterator) == "aA");
Assert.IsTrue(node.Children[5].Token.Name == "GATE");
Assert.IsTrue(node.Children[6].Token.Name == "VARIABLE");
Assert.IsTrue(node.Children[6].Token.ValueAsString(iterator) == "bB");
// expression + gate + variable .star()
input = "A*!B*C+!A*B*C";
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
// parethesis
input = "((A)*(!B)+(!A)*(B))";
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = "((A)*!(B)+!(A)*(B))";
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = "((A)*(!(B))+(!(A))*(B))";
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = ("(!X*Y*!Z)");
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = ("(!X*Y*!Z)+(!X*Y*Z)");
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = ("(X*Z)");
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = ("(!X*Y*!Z)+(!X*Y*Z)+(X*Z)");
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
input = ("((((!X*Y*Z)+(!X*Y*!Z)+(X*Z))))");
bytes = Encoding.UTF8.GetBytes(input);
iterator = new ByteInputIterator(bytes);
visitor = new NpegParserVisitor(iterator);
Root.Accept(visitor);
Assert.IsTrue(visitor.IsMatch);
node = visitor.AST;
#warning Assert.IsTrue(node.Token.Value == input);
}
public abstract void VisitEnter(PrioritizedChoice expression);
public override void VisitExecute(PrioritizedChoice expression)
{
terminal.Peek().Append(" / ");
}
public abstract void VisitLeave(PrioritizedChoice expression);
public override void VisitEnter(PrioritizedChoice expression)
{
}
