public void When_Two_Group_Do_It()
{
var target = GroupParser.NobiGroupParser();
var grpA = new BitPlane(10);
grpA.Add(new Coords(1, 1));
grpA.Add(new Coords(1, 2));
grpA.Add(new Coords(1, 3));
grpA.Add(new Coords(1, 4));
var grpB = new BitPlane(10);
grpB.Add(new Coords(4, 1));
grpB.Add(new Coords(4, 2));
grpB.Add(new Coords(4, 3));
grpB.Add(new Coords(4, 4));
var data = new BitPlane(10);
data.Or(grpA);
data.Or(grpB);
var actual = target.Parse(data.Copy());
Assert.AreEqual(2, actual.Count);
BitPlaneTestHelper.AssertBitPlane(grpA, actual[0], "Group A"); //Todo Algorithm : Make to Order Tolerance
BitPlaneTestHelper.AssertBitPlane(grpB, actual[1], "Group B");
}
public XmlGrammar()
: base("xml")
{
EnableMatchEvents = false;
var comment = new GroupParser("<!--", "-->");
var ws = Terminals.Repeat(Char.IsWhiteSpace, 1);
var ows = Terminals.Repeat(Char.IsWhiteSpace, 0);
var wsc = -(ws | comment);
var name = Terminals.Repeat(new RepeatCharItem(Char.IsLetter, 1, 1), new RepeatCharItem(Char.IsLetterOrDigit, 0));
var namedName = Terminals.Repeat(new RepeatCharItem(Char.IsLetter, 1, 1), new RepeatCharItem(Char.IsLetterOrDigit, 0)).WithName("name");
var text = new UntilParser("<", 1).WithName("text");
var attributeValue = new StringParser {
QuoteCharacters = new [] { '"' }, Name = "value"
};
var attribute = (namedName & ows & "=" & ows & attributeValue);
var attributes = (ws & (+attribute).SeparatedBy(ws).WithName("attributes")).Optional();
var content = new RepeatParser {
Separator = wsc
};
var startTag = "<" & namedName & attributes & ows;
var endTag = "</" & name & ">";
var obj = (startTag & ("/>" | (">" & wsc & content & wsc & endTag))).WithName("object");
var cdata = ("<![CDATA[" & new UntilParser("]]>", 0, skip: true)).WithName("cdata");
content.Inner = obj | text | cdata;
var declaration = "<?" & name & attributes & ows & "?>";
Inner = declaration & wsc & obj & wsc;
}
private int ItemsInZone(Zone i, int ItemPid)
{
int num = 0;
if (i.EncounterGroups == null)
{
return(0);
}
foreach (EncounterZoneGroup gr in i.EncounterGroups)
{
EncounterGroup realgroup = GroupParser.GetGroupByName(gr.Name); // Because gr contains only small amount of data parsed
// from worldmap.fowm, rest is in parser.
foreach (EncounterNpc npc in realgroup.Npcs)
{
foreach (EncounterItem item in npc.Items)
{
if (item.Item.Pid == ItemPid)
{
num++;
}
}
}
}
return(num);
}
public override void Load()
{
if (alreadyLoaded)
{
return;
}
alreadyLoaded = true;
GroupParser parser = null;
try
{
ANTLRStringStream fs = new ANTLRStringStream(text);
fs.name = sourceName;
GroupLexer lexer = new GroupLexer(fs);
CommonTokenStream tokens = new CommonTokenStream(lexer);
parser = new GroupParser(tokens);
// no prefix since this group file is the entire group, nothing lives
// beneath it.
parser.group(this, "/");
}
catch (Exception e)
{
ErrorManager.IOError(null, ErrorType.CANT_LOAD_GROUP_FILE, e, "<string>");
}
}
public void GroupParser_Calculates_CorrectScore(string input, int expectedScore)
{
var parser = new GroupParser();
parser.Parse(input);
Assert.Equal(expectedScore, parser.Score);
}
public void GroupParser_Calculates_CorrectNonCancelledGarbabeCharacterCount(string input, int expected)
{
var parser = new GroupParser();
parser.Parse(input);
Assert.Equal(expected, parser.NonCancelledGarbageCharacterCount);
}
public void GroupParser_CountsGroupsCorrectly(string input, int expectedNumGroups)
{
var parser = new GroupParser();
parser.Parse(input);
Assert.Equal(expectedNumGroups, parser.NumGroups);
}
private void GetGroupUsers(string groupUrl)
{
var x = new GroupParser(groupUrl);
x.GetEm();
var list = x.UserHrefs;
list.ForEach(AddMobile);
}
public void When_Empty_BitPlane_Do_EmptyList()
{
var target = GroupParser.NobiGroupParser();
var data = new BitPlane(19);
var actual = target.Parse(data);
Assert.AreEqual(0, actual.Count);
}
// ToDo: check if each panel is Present!!
public void MainLoop()
{
Helpers.GlobalDelay = 2000;
SingleLoop();
Helpers.Print("Main loop started");
Helpers.Print("");
GetGroupPage();
var x = new GroupParser("https://www.facebook.com/groups/1379225572136343/members/");
x.GetEm();
/*
*
* oyy tgooooa
*
*/
x.UserHrefs.ForEach(e => {
if (!_visited.Contains(e))
{
Helpers.Print($"Getting {e}", ConsoleColor.Black);
_driver.Url = e;
SaveHrefToVisited(e);
Helpers.Wait(1000, 500);
GetAboutTab();
Helpers.ScrollToBottom();
var u = new User {
Url = e
};
_nav = new Navigator(u);
_nav.Perform();
Helpers.Print("\n ---- \n");
u.PrintUser();
u.Jsonise();
}
else
{
Helpers.Print($"{e} alredy visited, skipping...", ConsoleColor.Black);
}
});
}
private static void Part2()
{
var groups = GroupParser.Parse(Input.Data);
Console.WriteLine(groups.Sum(x => x.Persons.Select(x => x.Responses).Aggregate((x, y) =>
{
var v = new HashSet <char>(x);
v.IntersectWith(y);
return(v);
}).Count));
}
private object[] ParseFunction(string text)
{
Line codeLine = new Line(0, text);
text = codeLine.Text; // it's trimmed
List <object> result = new List <object>();
result.Add(codeLine.Name);
int c_index = codeLine.Name.Length; // Start at the end of the name
int expected = 0;
int last = c_index;
for (; c_index < text.Length; c_index++)
{
char cur = text[c_index];
switch (cur)
{
case ' ': // ignore spaces
continue;
case '\'':
case '\"': {
c_index = GroupParser.IndexString(text, c_index);
}
break;
case '(':
expected++;
break;
case ')':
expected--;
break;
}
if ((expected == 1 && cur == ',') ||
expected == 0) // The commas in between other parentheses are not ours.
{
string param = text.Substring(last + 1, c_index - last - 1).Trim();
if (!param.Equals(""))
{
result.Add(param); // From the last comma to this one. That's a parameter.
}
last = c_index;
if (expected == 0) // fin
{
return(result.ToArray());
}
}
}
throw ThrowHelper.UnterminatedBlock("FUNC");
}
/// <summary>
/// Parse a filter string
/// </summary>
/// <param name="filter"></param>
/// <param name="operatorOverrides"></param>
/// <returns></returns>
public IEnumerable <ICriterion> Parse(string filter, Dictionary <OperatorType, string> operatorOverrides)
{
if (operatorOverrides == null)
{
throw new ArgumentNullException(nameof(operatorOverrides), "Operator overrides cannot be null");
}
var operators = this.InitOperators(operatorOverrides);
var groups = new GroupParser(operators).Parse(filter);
return(this.ConvertGroupsToCriteria(groups));
}
/** Load full path name .st file relative to root by prefix */
public virtual CompiledTemplate LoadTemplateFile(string prefix, string fileName)
{
if (Path.IsPathRooted(fileName))
{
throw new ArgumentException();
}
//System.out.println("load "+fileName+" from "+root+" prefix="+prefix);
string templateName = Path.ChangeExtension(fileName, null);
Uri f = null;
try
{
f = new Uri(Path.Combine(root.LocalPath, fileName));
}
catch (UriFormatException me)
{
ErrorManager.RuntimeError(null, 0, ErrorType.INVALID_TEMPLATE_NAME, me, Path.Combine(root.LocalPath, fileName));
return(null);
}
ANTLRReaderStream fs = null;
try
{
fs = new ANTLRReaderStream(new StreamReader(f.LocalPath, Encoding ?? Encoding.UTF8));
}
catch (IOException)
{
// doesn't exist; just return null to say not found
return(null);
}
GroupLexer lexer = new GroupLexer(fs);
fs.name = fileName;
CommonTokenStream tokens = new CommonTokenStream(lexer);
GroupParser parser = new GroupParser(tokens);
parser.Group = this;
lexer.group = this;
try
{
parser.templateDef(prefix);
}
catch (RecognitionException re)
{
ErrorManager.GroupSyntaxError(ErrorType.SYNTAX_ERROR, Path.GetFileName(f.LocalPath), re, re.Message);
}
return(RawGetTemplate(templateName));
}
public void When_Singleton_Stones_Do_It()
{
var target = GroupParser.NobiGroupParser();
var data = new BitPlane(19);
data.Add(new Coords(1, 1));
data.Add(new Coords(2, 2));
data.Add(new Coords(3, 3));
data.Add(new Coords(4, 4));
data.Add(new Coords(5, 5));
var actual = target.Parse(data);
Assert.AreEqual(5, actual.Count);
}
public void When_One_Group_Do_It()
{
var target = GroupParser.NobiGroupParser();
var grpA = new BitPlane(10);
grpA.Add(new Coords(1, 1));
grpA.Add(new Coords(1, 2));
grpA.Add(new Coords(1, 3));
grpA.Add(new Coords(1, 4));
var actual = target.Parse(grpA.Copy());
Assert.AreEqual(1, actual.Count);
BitPlaneTestHelper.AssertBitPlane(grpA, actual[0], "Group A");
}
public void TestThatParseSuccess()
{
// Arrange
var text = "block Rule {\r\n space: \'\r\'|\'\n\'|\'\t\'|\' \' => Name: \"space\", first:1;\r\n}";
var stream = new MemoryStream().FromString(text);
// Act
var parser = new GroupParser();
var result = parser.Parse(stream);
// Arrange
Assert.AreEqual(1, result.ParsedRules.Count);
}
public ObjLoader Create(MaterialStreamProvider materialStreamProvider)
{
var dataStore = new DataStore(_name);
var faceParser = new FaceParser(dataStore);
var groupParser = new GroupParser(dataStore);
var normalParser = new NormalParser(dataStore);
var textureParser = new TextureParser(dataStore);
var vertexParser = new VertexParser(dataStore);
var materialLibraryLoader = new MaterialLibraryLoader(dataStore);
var materialLibraryLoaderFacade = new MaterialLibraryLoaderFacade(materialLibraryLoader, materialStreamProvider);
var materialLibraryParser = new MaterialLibraryParser(materialLibraryLoaderFacade);
var useMaterialParser = new UseMaterialParser(dataStore);
return(new ObjLoader(dataStore, faceParser, groupParser, normalParser, textureParser, vertexParser, materialLibraryParser, useMaterialParser));
}
private string[] ParseArguments(string commandLine)
{
commandLine = commandLine.Trim(); // just a precaution
List <string> args = new List <string>();
StringBuilder sb = new StringBuilder();
for (int index = 0; index < commandLine.Length; index++)
{
switch (commandLine[index])
{
case ' ':
if (index > 0 && commandLine[index - 1] == ' ')
{
continue; // ignore extra whitespace
}
else
{
args.Add(sb.ToString());
sb = new StringBuilder();
}
break;
case '\'':
case '"':
string parsed;
index = GroupParser.ReadString(commandLine, index, out parsed);
if (parsed.Length == 0)
{
args.Add(parsed);
}
else
{
sb.Append(parsed);
}
break;
default:
sb.Append(commandLine[index]);
break;
}
}
if (sb.Length > 0)
{
args.Add(sb.ToString()); // Don't forget about me!
}
return(args.ToArray());
}
public IWavefrontObjLoader Create(IMaterialStreamProvider materialStreamProvider)
{
var dataStore = new DataStore();
var faceParser = new FaceParser(dataStore);
var groupParser = new GroupParser(dataStore);
var normalParser = new VertexNormalParser(dataStore);
var textureParser = new TextureCoordinateParser(dataStore);
var vertexParser = new GeometricVertexParser(dataStore);
var materialLibraryLoader = new MaterialLibraryLoader(dataStore);
var materialLibraryLoaderFacade = new MaterialLibraryLoaderFacade(materialLibraryLoader, materialStreamProvider);
var materialLibraryParser = new MaterialLibraryParser(materialLibraryLoaderFacade);
var useMaterialParser = new UseMaterialParser(dataStore);
return(new WavefrontObjLoader(dataStore, faceParser, groupParser, normalParser, textureParser, vertexParser, materialLibraryParser, useMaterialParser));
}
public void SetUp()
{
_textureDataStore = new DataStore();
_faceParser = new FaceParser(_textureDataStore);
_groupParser = new GroupParser(_textureDataStore);
_normalParser = new NormalParser(_textureDataStore);
_textureParser = new TextureParser(_textureDataStore);
_vertexParser = new VertexParser(_textureDataStore);
_materialStreamProviderSpy = new MaterialStreamProviderSpy();
_materialStreamProviderSpy.StreamToReturn = CreateMemoryStreamFromString(MaterialLibraryString);
_materialLibraryLoader = new MaterialLibraryLoader(_textureDataStore);
_materialLibraryLoaderFacade = new MaterialLibraryLoaderFacade(_materialLibraryLoader, _materialStreamProviderSpy);
_materialLibraryParser = new MaterialLibraryParser(_materialLibraryLoaderFacade);
_useMaterialParser = new UseMaterialParser(_textureDataStore);
_loader = new Loader.Loaders.ObjLoader(_textureDataStore, _faceParser, _groupParser, _normalParser, _textureParser, _vertexParser, _materialLibraryParser, _useMaterialParser);
}
private int AddObjectToExprList(object val, int startIndex, Scanner scanner)
{
if (Equals(val, "("))
{
scanner.IntPosition = GroupParser.IndexGroup(_expression, startIndex) + 1;
Evaluator eval = new Evaluator(
_expression.Subsegment(startIndex + 1, scanner.IntPosition - startIndex - 2),
CurrentExecution // share the wealth
);
_tokens.AddLast(eval);
}
else
{
_tokens.AddLast(val);
}
return(scanner.IntPosition);
}
/** Load a group file with full path fileName; it's relative to root by prefix. */
public virtual void LoadGroupFile(string prefix, string fileName)
{
//System.out.println("load group file prefix="+prefix+", fileName="+fileName);
GroupParser parser = null;
try
{
Uri f = new Uri(fileName);
ANTLRReaderStream fs = new ANTLRReaderStream(new System.IO.StreamReader(f.LocalPath, Encoding ?? Encoding.UTF8));
GroupLexer lexer = new GroupLexer(fs);
fs.name = fileName;
CommonTokenStream tokens = new CommonTokenStream(lexer);
parser = new GroupParser(tokens);
parser.group(this, prefix);
}
catch (Exception e)
{
ErrorManager.IOError(null, ErrorType.CANT_LOAD_GROUP_FILE, e, fileName);
}
}
public ObjLoader(
DataStore dataStore,
FaceParser faceParser,
GroupParser groupParser,
NormalParser normalParser,
TextureParser textureParser,
VertexParser vertexParser,
MaterialLibraryParser materialLibraryParser,
UseMaterialParser useMaterialParser)
{
_dataStore = dataStore;
SetupTypeParsers(
vertexParser,
faceParser,
normalParser,
textureParser,
groupParser,
materialLibraryParser,
useMaterialParser);
}
public void TestThatParseManyRulesWhereOneUseAnotherSuccess()
{
// Arrange
var name1 = "space";
var name2 = "test";
var text = "block Rule {\r\n space: \'\r\'|\'\n\'|\'\t\'|\' \' => Name: \"space\", first:1;\r\n" +
"test: \'a\'|\'a\' => Name: \"test\", furst:1;\r\n" +
"}";
var stream = new MemoryStream().FromString(text);
// Act
var parser = new GroupParser();
var result = parser.Parse(stream);
// Arrange
Assert.AreEqual(2, result.ParsedRules.Count);
Assert.AreEqual(name2, (result.ParsedRules.First() as UserRule)?.Name);
Assert.AreEqual(name1, (result.ParsedRules.Last() as UserRule)?.Name);
}
public BnfGrammar(BnfStyle style = BnfStyle.All)
: base("bnf")
{
Parser ows = Terminals.WhiteSpace.Repeat(0);
Parser rws = Terminals.WhiteSpace.Repeat(1);
if (style.HasFlag(BnfStyle.CommonTerminals))
{
foreach (var terminal in Terminals.GetTerminals())
{
baseLookup[terminal.Item1] = terminal.Item2;
}
}
if (style.HasFlag(BnfStyle.Comments))
{
// allow ebnf comments
var comment = new GroupParser("(*", "*)");
ows = (Terminals.WhiteSpace | comment).Repeat(0);
rws = (Terminals.WhiteSpace | comment).Repeat(1);
}
literal = (
(sq & (+!sq).WithName("value").Optional() & sq)
| (dq & (+!dq).WithName("value").Optional() & dq)
| (+Terminals.Set(" \n\r<[{(|)}]>").Inverse()).WithName("value")
).WithName("parser");
RuleNameParser = "<" & Terminals.Set("<>\n\r").Inverse().Repeat().WithName("name") & ">";
RuleParser = new AlternativeParser(); // defined later
TermParser = new AlternativeParser();
TermParser.Name = "term";
TermParser.Add((ruleName = RuleNameParser.Named("parser")).NotFollowedBy(ows & ruleSeparator));
if (style.HasFlag(BnfStyle.Cardinality))
{
TermParser.Items.Add('(' & ows & RuleParser & ows & ')');
TermParser.Items.Add(repeatRule = ('{' & ows & RuleParser & ows & '}').WithName("parser"));
TermParser.Items.Add(optionalRule = ('[' & ows & RuleParser & ows & ']').WithName("parser"));
}
TermParser.Items.Add(literal);
var rep = -(~((+Terminals.WhiteSpace).WithName("ws")) & TermParser);
rep.Name = "rep";
rep.AddMatch = false;
list = (TermParser & rep).WithName("parser");
listRepeat = (list.Named("list") & ows & '|' & ~(ows & RuleParser.Named("expression"))).WithName("parser");
RuleParser.Items.Add(listRepeat);
RuleParser.Items.Add(list);
RuleParser.Items.Add((ows & RuleNameParser & ows & ruleSeparator).Not() & Terminals.WhiteSpace.Inverse().Repeat().WithName("value").Named("parser"));
rule = (RuleNameParser.Named("ruleName") & ows & ruleSeparator & ows & RuleParser).WithName("parser");
Expresssions = new AlternativeParser();
Expresssions.Items.Add(rule);
this.Inner = ows & (+Expresssions).SeparatedBy(rws) & ows;
AttachEvents();
}
public GoldGrammar()
: base("gold")
{
Parser oldSeparator = DefaultSeparator;
// Special Terminals
ExceptParser parameterCh = Terminals.Printable - Terminals.Set("\"'");
AlternativeParser nonterminalCh = Terminals.LetterOrDigit | Terminals.Set("_-. ");
AlternativeParser terminalCh = Terminals.LetterOrDigit | Terminals.Set("_-.");
ExceptParser literalCh = Terminals.Printable - Terminals.Set('\'');
ExceptParser setLiteralCh = Terminals.Printable - Terminals.Set("[]'");
ExceptParser setNameCh = Terminals.Printable - Terminals.Set("{}");
SequenceParser parameterName = ('"' & (+parameterCh).WithName("value") & '"').Separate();
SequenceParser nonterminal = ('<' & (+nonterminalCh).WithName("value") & '>').Separate();
AlternativeParser terminal =
((+terminalCh).WithName("terminal") | ('\'' & (-literalCh).WithName("literal") & '\'')).Separate();
SequenceParser setLiteral =
('[' & +(setLiteralCh.WithName("ch") | '\'' & (-literalCh).WithName("ch") & '\'') & ']').WithName(
"setLiteral");
SequenceParser setName = ('{' & (+setNameCh).WithName("value") & '}').WithName("setName");
// Line-Based Grammar Declarations
var comments = new GroupParser("!*", "*!", "!");
Parser newline = Terminals.Eol;
whitespace = -(Terminals.SingleLineWhiteSpace | comments);
DefaultSeparator = whitespace;
RepeatParser nlOpt = -newline;
AlternativeParser nl = +newline | Terminals.End;
// Parameter Definition
AlternativeParser parameterItem = parameterName | terminal | setLiteral | setName | nonterminal;
RepeatParser parameterItems = +parameterItem;
SequenceParser parameterBody = parameterItems & -(nlOpt & '|' & parameterItems);
parameter =
(parameterName.Named("name") & nlOpt & '=' & parameterBody.WithName("body") & nl).WithName("parameter");
// Set Definition
AlternativeParser setItem = setLiteral | setName;
var setExp = new AlternativeParser {
Name = "setExp"
};
setExp.Add((setExp & nlOpt & '+' & setItem).WithName("add"),
(setExp & nlOpt & '-' & setItem).WithName("sub"),
setItem);
setDecl = (setName & nlOpt & '=' & setExp & nl).WithName("setDecl");
// Terminal Definition
var regExp2 = new SequenceParser();
OptionalParser kleeneOpt = (~((Parser)'+' | '?' | '*')).WithName("kleene");
regExpItem = ((setLiteral & kleeneOpt)
| (setName & kleeneOpt)
| (terminal.Named("terminal") & kleeneOpt)
| ('(' & regExp2.Named("regExp2") & ')' & kleeneOpt)).WithName("regExpItem");
RepeatParser regExpSeq = (+regExpItem).WithName("regExpSeq");
regExp2.Items.Add(regExpSeq);
regExp2.Items.Add(-('|' & regExpSeq));
regExp = (regExpSeq & -(nlOpt & '|' & regExpSeq)).WithName("regExp");
RepeatParser terminalName = +terminal;
terminalDecl = (terminalName.Named("name") & nlOpt & '=' & regExp & nl).WithName("terminalDecl");
// Rule Definition
symbol = (terminal.Named("terminal") | nonterminal.Named("nonterminal")).WithName("symbol");
handle = (-symbol).WithName("handle");
SequenceParser handles = handle & -(nlOpt & '|' & handle);
ruleDecl = (nonterminal.Named("name") & nlOpt & "::=" & handles & nl).WithName("ruleDecl");
// Rules
AlternativeParser definitionDecl = parameter | setDecl | terminalDecl | ruleDecl;
RepeatParser content = -definitionDecl;
Inner = nlOpt & content & nlOpt;
DefaultSeparator = oldSeparator;
AttachEvents();
}
private void AttachEvents()
{
// attach logic to parsers
parameter.PreMatch += m =>
{
string name = m["name"]["value"].Text;
string value = m["body"].Text;
definition.Properties[name] = value;
bool val;
if (
string.Equals("Auto Whitespace", name, StringComparison.OrdinalIgnoreCase) &&
bool.TryParse(value, out val) && !val)
{
definition.Whitespace = null;
}
};
ruleDecl.Matched += m =>
{
string name = m["name"]["value"].Text;
bool addWhitespace = name == definition.GrammarName;
Parser parser = Alternative(m, "handle",
r => Sequence(r, "symbol", Symbol, addWhitespace));
definition.Rules[name].Inner = parser;
};
ruleDecl.PreMatch += m =>
{
string name = m["name"]["value"].Text;
UnaryParser parser;
if (name == definition.GrammarName)
{
parser = new Grammar(name);
}
else
{
parser = new UnaryParser(name);
}
definition.Rules.Add(parser.Name, parser);
};
terminalDecl.Matched += m =>
{
Parser inner = Sequence(m, "regExp", RegExp);
var parser = m.Tag as UnaryParser;
if (parser != null)
{
parser.Inner = inner;
}
var groupParser = m.Tag as GroupParser;
string name = m["name"].Text;
if (groupParser != null)
{
if (name.EndsWith(" Start", StringComparison.Ordinal))
{
groupParser.Start = inner;
}
else if (name.EndsWith(" End", StringComparison.Ordinal))
{
groupParser.End = inner;
}
else if (name.EndsWith(" Line", StringComparison.Ordinal))
{
groupParser.Line = inner;
}
int count = name.EndsWith(" Start", StringComparison.Ordinal)
? 6
: name.EndsWith(" Line", StringComparison.Ordinal)
? 5
: name.EndsWith(" End", StringComparison.Ordinal)
? 4
: 0;
name = name.Substring(0, name.Length - count);
}
if (name.Equals("Comment", StringComparison.OrdinalIgnoreCase) ||
name.Equals("Whitespace", StringComparison.OrdinalIgnoreCase)
)
{
definition.ClearSeparator();
}
};
terminalDecl.PreMatch += m =>
{
string name = m["name"].Text;
if (name.EndsWith(" Start", StringComparison.Ordinal) ||
name.EndsWith(" End", StringComparison.Ordinal) ||
name.EndsWith(" Line", StringComparison.Ordinal))
{
Parser parser;
int count = name.EndsWith(" Start", StringComparison.Ordinal)
? 6
: name.EndsWith(" Line", StringComparison.Ordinal)
? 5
: name.EndsWith(" End", StringComparison.Ordinal)
? 4
: 0;
name = name.Substring(0, name.Length - count);
if (definition.Terminals.TryGetValue(name, out parser))
{
parser = parser as GroupParser ?? new GroupParser();
}
else
{
parser = new GroupParser();
}
m.Tag = definition.Terminals[name] = parser;
}
else
{
m.Tag = definition.Terminals[name] = new UnaryParser(name);
}
};
setDecl.PreMatch += m =>
{
Parser parser = SetMatch(m["setExp"]);
definition.Sets[m["setName"]["value"].Text] = parser;
m.Tag = parser;
};
}
public Group Parse(string group)
{
return(GroupParser.Parse(group));
}
public Analyser()
{
_groupParser = GroupParser.NobiGroupParser();
_libertiesParser = new LibertiesParser();
}
