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(); }