int IIpTablesModuleInternal.Feed(RuleParser parser, bool not)
{
int bits;
switch (parser.GetCurrentArg())
{
case OptionHelperLong:
Helper = parser.GetNextArg();
return(1);
}
return(0);
}
public void BankRule()
{
var pcg = CreatePcg();
var ruleParser = new RuleParser(pcg);
ruleParser.Parse("I-A->I-B");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == pcg.ProgramBanks[0].CountPatches);
var rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][127]]; // I-A127
Debug.Assert(rule == pcg.ProgramBanks[1][127]); // I-B127
}
public void RangeRule()
{
var pcg = CreatePcg();
var ruleParser = new RuleParser(pcg);
ruleParser.Parse("I-A000..010->I-B000..010");
Debug.Assert(ruleParser.HasParsedOk);
Debug.Assert(ruleParser.ParsedRules.Count == 11);
var rule = ruleParser.ParsedRules[pcg.ProgramBanks[0][10]]; // I-A010
Debug.Assert(rule == pcg.ProgramBanks[1][10]); // I-B010
}
public void RuleWithInvalidUnaryOperatorThrowsMeaninfulException()
{
var ruleString = "A(x, y) -> B(x + / y)";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(17, e.errorStartIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
public void RuleWith3ConsecutiveExpressionOperatorsThrowsMeaninfulException()
{
var ruleString = "A(x, y) -> B(x + / * y)";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(19, e.errorStartIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
public void RuleWithOneTooFewParensThrowsMeaninfulException()
{
var ruleString = "A(x) -> B(x + (y)";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(17, e.errorStartIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
private void ValidateRulesFormat(PluginProfileErrorCollection errors)
{
var parser = ObjectFactory.GetInstance <RuleParser>();
var parsed = parser.Parse(this);
var stringRules = RuleParser.GetRuleLines(this);
if (parsed.Count() != stringRules.Count())
{
errors.Add(new PluginProfileError {
FieldName = "Rules", Message = "Invalid rules format"
});
}
}
public void ParsesRuleWithGlobalParametersMatch()
{
var ruleFromString = RuleParser.ParseToRule("A(x) -> B(x + stretch, stretch)", globalParameters: new string[] { "stretch" });
Assert.IsNull(ruleFromString.conditionalMatch);
Assert.AreEqual("A(x)", ruleFromString.TargetSymbolString());
Assert.AreEqual(1, ruleFromString.replacementSymbols.Length);
Assert.AreEqual('B', ruleFromString.replacementSymbols[0].targetSymbol);
Assert.AreEqual(2, ruleFromString.replacementSymbols[0].evaluators.Length);
Assert.AreEqual(12, ruleFromString.replacementSymbols[0].evaluators[0].DynamicInvoke(10, 2));
Assert.AreEqual(10, ruleFromString.replacementSymbols[0].evaluators[1].DynamicInvoke(10, 2));
}
public void VerifyPassword_ForPart1_ShouldReturnTrue()
{
string raw = "1-3 a: abcde";
string password = String.Empty;
RuleParser ruleParser = new RuleParser();
ruleParser.ParseRules(raw.Substring(0, raw.IndexOf(':')));
PasswordValidator passValidator = new PasswordValidator(ruleParser, raw.Substring(raw.IndexOf(':')));
bool isValidPassword = passValidator.IsPart1Valid();
Assert.True(isValidPassword);
}
public void VerifyPassword_ForInvalidPart2_ShouldReturnFalse()
{
string raw = "1-3 b: cdefg";
string password = String.Empty;
RuleParser ruleParser = new RuleParser();
ruleParser.ParseRules(raw.Substring(0, raw.IndexOf(':')));
PasswordValidator passValidator = new PasswordValidator(ruleParser, raw.Substring(raw.IndexOf(':')));
bool isValidPassword = passValidator.IsPart2Valid();
Assert.False(isValidPassword);
}
public void AndRedBagContainsWhiteThenCorrectRelationshpiIsFormed()
{
var rule = "light red bags contain 1 bright white bag, 2 muted yellow bags.";
var ruleParser = new RuleParser();
Bag redBag = ruleParser.AddBagToSet(rule);
redBag.Id.Should().Be("light_red");
// redBag.Children.Should().NotBeEmpty()
// .And.HaveCount(2)
// .And.Contain(c => c.Id == "bright_white" || c.Id == "muted_yellow");
}
public void RuleParser_ParseParamCondition_ValidInputTest(string input, string[] variableNames,
int[] variableValues, bool expectedOutput)
{
var expressionParserFactory = new IntExpressionParserFactory();
var parser = new RuleParser <int>(new ModuleParser <int>(expressionParserFactory), expressionParserFactory);
var intParser = expressionParserFactory.Create(variableNames);
var handler = parser.ParseParamCondition(input, intParser);
var output = handler(variableValues);
Assert.That(output, Is.EqualTo(expectedOutput));
}
public int Feed(RuleParser parser, bool not)
{
String current = parser.GetCurrentArg();
switch (current)
{
case OptionHashRouteMode:
Mode = parser.GetNextArg();
return(1);
case OptionHashRouteSrcMask:
SrcMask = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteDstMask:
DstMask = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteHtableSize:
HtableSize = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteHtableMax:
HtableMax = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteHtableExpire:
HtableExpire = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteHtableGcInterval:
HtableGcInterval = int.Parse(parser.GetNextArg());
return(1);
case OptionHashRouteMatchOnly:
MatchOnly = true;
return(0);
case OptionHashRouteName:
Name = parser.GetNextArg();
if (Name.Length > 15)
{
Name = Name.Substring(0, 15);
}
return(1);
}
return(0);
}
public void RuleWithExtraRightParenThrowsMeaninfulException()
{
var ruleString = "A(x, y) -> B(x))";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(15, e.errorStartIndex);
Assert.AreEqual(16, e.ErrorEndIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
public int Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionPrefixLong:
LogPrefix = parser.GetNextArg();
return(1);
case OptionLevelLong:
LogLevel = int.Parse(parser.GetNextArg());
return(1);
}
return(0);
}
public int Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionSrcGroup:
SrcGroup = new ValueOrNot <UInt32>(FlexibleUInt32.Parse(parser.GetNextArg()), not);
return(1);
case OptionDstGroup:
DstGroup = new ValueOrNot <UInt32>(FlexibleUInt32.Parse(parser.GetNextArg()), not);
return(1);
}
return(0);
}
static void TestRuleParser()
{
Console.WriteLine("hum hum...");
RuleParser <EbnfToken> parserInstance = new RuleParser <EbnfToken>();
var builder = new ParserBuilder <EbnfToken, IClause <EbnfToken> >();
var r = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "rule");
//var conf = r.Result.Configuration;
//var clause = conf.NonTerminals["clause"];
//Console.WriteLine($"{r.IsError} {r.Result}");
var parser = r.Result;
var rule = parser.Parse("a ( b ) ", "clauses");
;
}
public void ParsesRuleWithNonAlphaContextMatchWithParameter()
{
var ruleFromString = RuleParser.ParseToRule("C(x) < K(y) > `A(z) : x >= timeToFruit -> D(1)", globalParameters: new string[] { "timeToFruit" });
Assert.AreEqual(false, ruleFromString.conditionalMatch.DynamicInvoke(3, 0, 0, 0) > 0);
Assert.AreEqual(false, ruleFromString.conditionalMatch.DynamicInvoke(3, 1, 0, 0) > 0);
Assert.AreEqual(true, ruleFromString.conditionalMatch.DynamicInvoke(3, 4, 0, 0) > 0);
Assert.AreEqual("C(x) < K(y) > `A(z)", ruleFromString.TargetSymbolString());
Assert.AreEqual(1, ruleFromString.replacementSymbols.Length);
Assert.AreEqual('D', ruleFromString.replacementSymbols[0].targetSymbol);
Assert.AreEqual(1, ruleFromString.replacementSymbols[0].evaluators.Length);
Assert.AreEqual(1, ruleFromString.replacementSymbols[0].evaluators[0].DynamicInvoke(10, 10, 10, 10));
}
public void ParsesRuleWithExtraParens()
{
var ruleFromString = RuleParser.ParseToRule("A(x) -> A((x + 1))");
Assert.AreEqual(0, ruleFromString.forwardsMatch.Length);
Assert.AreEqual(0, ruleFromString.backwardsMatch.Length);
Assert.AreEqual("A(x)", ruleFromString.TargetSymbolString());
Assert.AreEqual(1, ruleFromString.replacementSymbols.Length);
Assert.AreEqual('A', ruleFromString.replacementSymbols[0].targetSymbol);
Assert.AreEqual(1, ruleFromString.replacementSymbols[0].evaluators.Length);
Assert.AreEqual(2, ruleFromString.replacementSymbols[0].evaluators[0].DynamicInvoke(1));
Assert.AreEqual(11, ruleFromString.replacementSymbols[0].evaluators[0].DynamicInvoke(10));
}
public void AndWhiteBagContainsGoldOnlyThenCorrectRelationshpiIsFormed()
{
var rule = "bright white bags contain 1 shiny gold bag.";
var ruleParser = new RuleParser();
Bag whiteBag = ruleParser.AddBagToSet(rule);
whiteBag.Id.Should().Be("bright_white");
// whiteBag.Children.Should().NotBeEmpty()
// .And.HaveCount(1)
// .And.OnlyContain(b => b.Id == "shiny_gold");
// whiteBag.Children.Single().Parents.Single().Should().Be(whiteBag);
}
public void RuleWithStrandedOperatorThrowsMeaninfulException()
{
var ruleString = "A(x, y) -> B(+)";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(13, e.errorStartIndex);
Assert.AreEqual(14, e.ErrorEndIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
public int Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionClampMssToPmtuLong:
ClampMssToPmtu = true;
return(1);
case OptionSetMss:
SetMss = int.Parse(parser.GetNextArg());
return(1);
}
return(0);
}
int IIpTablesModuleInternal.Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionQueueNumber:
Num = int.Parse(parser.GetNextArg());
return(1);
case OptionQueueBypass:
Bypass = true;
return(0);
}
return(0);
}
public void RuleWithInvalidParameterInConditionalThrowsMeaningfulException()
{
var ruleString = "A(x, y) : x >= e -> B(x)";
try
{
RuleParser.ParseToRule(ruleString);
}
catch (SyntaxException e)
{
Assert.AreEqual(15, e.errorStartIndex);
Assert.AreEqual(16, e.ErrorEndIndex);
Assert.AreEqual(ruleString, e.ruleText);
}
}
public int Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionQueueNumber:
Num = int.Parse(parser.GetNextArg());
return(1);
case OptionQueueBypass:
Bypass = true;
return(0);
}
return(0);
}
int IIpTablesModuleInternal.Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionPrefixLong:
LogPrefix = parser.GetNextArg();
return(1);
case OptionLevelLong:
LogLevel = int.Parse(parser.GetNextArg());
return(1);
}
return(0);
}
/// <summary>
/// 新方法-加载所有规则
/// </summary>
public void LoadRules()
{
var files = Directory.GetFiles(config.RulefilesPath, "*.rule");
if (files == null || files.Length == 0)
{
throw new Exception("rule文件不存在");
}
List <Region> regions = new List <Region>();
string fileName = string.Empty;
StringBuilder text = new StringBuilder();
files.ToList().ForEach(file =>
{
fileName = Path.GetFileNameWithoutExtension(file);
var fileText = File.ReadAllText(file);
config.FileRegion[fileName] = RegionParser.ParseRegions(fileText.ToString());
regions.AddRange(config.FileRegion[fileName]);
text.AppendLine(fileText);
});
if (regions == null || regions.Count == 0)
{
throw new Exception("region不存在");
}
regions.ForEach(region =>
{
var rules = RuleParser.ParseRules(region.RegionContent);
if (regions == null || regions.Count == 0)
{
throw new Exception(string.Format("region '{0}' 无法找到rule", region.RegionName));
}
rules.ForEach(rule =>
{
rule.RegionName = region.RegionName;
});
rules.ForEach(rule =>
{
var key = string.Format("{0}.{1}", rule.RegionName, rule.RuleName);
config.RuleDefinations[key] = rule;
});
});
}
private void ParseUrl(string url)
{
matchResult = RuleParser.ParseUrl(url);
string pageStr = matchResult["page"];
try
{
StartPage = (pageStr != null) ? int.Parse(pageStr) : 0;
}
catch (Exception)
{
StartPage = 0;
}
CurrentPage = StartPage;
}
int IIpTablesModuleInternal.Feed(RuleParser parser, bool not)
{
String current = parser.GetCurrentArg();
_data.Add(current, new List <string>());
for (int i = 1; i < parser.GetRemainingArgs(); i++)
{
string arg = parser.GetNextArg(i);
if (arg[0] == '-')
{
return(i - 1);
}
_data[current].Add(arg);
}
return(0);
}
public int Feed(RuleParser parser, bool not)
{
switch (parser.GetCurrentArg())
{
case OptionMarkLong:
var s = parser.GetNextArg().Split(new char[] { '/' });
Mark.Set(not, FlexibleInt32.Parse(s[0]));
if (s.Length != 1)
{
Mask = FlexibleInt32.Parse(s[1]);
}
return(1);
}
return(0);
}
static void Main()
{
var ms = new ListMemoryStore();
var re = new RulesEngine(ms);
const string rule = @"
;
; Animal Identification
;
(defrule init
(true null)
=>
(add (is-flier animal))
(add (is-egg-layer animal))
(add (can-talk animal))
(enable-timer (timera 5))
(disable-rule (self))
)
(defrule mammal-1
(has-hair ?)
=>
(add (is-animal ?))
)
(defrule mammal-2
(is-milk-giver ?)
=>
(add (is-mammal ?))
)
(defrule trigger1
(timer-triggered timera)
=>
(add (lives-in-jungle animal))
(delete (timer-triggered timera))
)
(defrule bird-1
(has-feathers ?)
=>
(add (is-bird ?))
)
(defrule bird-2
(is-flier ?)
(is-egg-layer ?)
=>
(add (is-bird ?))
)
(defrule carnivore-1
(is-meat-eater ?)
=>
(add (is-carnivore ?))
)
(defrule carnivore-2
(has-pointed-teeth ?)
(has-claws ?)
(has-forward-eyes ?)
=>
(add (is-carnivore ?))
)
(defrule ungulate-1
(is-mammal ?)
(has-hooves ?)
=>
(add (is-ungulate ?))
)
(defrule ungulate-2
(is-mammal ?)
(is-cud-chewer ?)
=>
(add (is-ungulate ?))
)
(defrule even-toed
(is-mammal ?)
(is-cud-chewer ?)
=>
(add (is-even-toed ?))
)
(defrule cheetah
(is-mammal ?)
(is-carnivore ?)
(is-tawny-colored ?)
(has-dark-spots ?)
=>
(add (is-cheetah ?))
(print (""Animal is a cheetah""))
(quit null)
)
(defrule parrot
(is-bird ?)
(can-talk ?)
(lives-in-jungle ?)
=>
(add (is-parrot ?))
(print (""Animal is a parrot!""))
(quit null)
)
(defrule tiger
(is-mammal ?)
(is-carnivore ?)
(is-tawny-colored ?)
(has-black-stripes ?)
=>
(add(is-tiger ?))
(print(""Animal is a tiger""))
(quit null)
)
(defrule giraffe
(is-ungulate ?)
(has-long-neck ?)
(has-long-legs ?)
(has-dark-spots ?)
=>
(add (is-giraffe ?))
(print (""Animal is a giraffe""))
(quit null)
)
(defrule zebra
(is-ungulate ?)
(has-black-stripes ?)
=>
(add (is-zebra ?))
(print (""Animal is a zebra""))
(quit null)
)";
var parser = new RuleParser(rule);
re.AddRuleCollection(parser);
//// now we can operate on the rules
//re.Interpret();
//Console.WriteLine(re.PrintWorkingMemory());
//re.Interpret();
//Console.WriteLine(re.PrintWorkingMemory());
while (!re.EndRun)
{
re.Interpret();
Console.WriteLine(re.PrintWorkingMemory());
re.ProcessTimers();
//Thread.Sleep(1000);
}
}
