public override bool Parse(SyntacticState state) { if (state.IsEndOfData) { return(false); } // ensure that identifier is captured LexicalEntry entry = state.GetInner(state.InnerPosition); if (entry.Key != Identifier.S.Key) { return(false); } // check that identifier consists only of specified letters string checkOuter = state.GetOuter(entry); LexicalState checkState = new LexicalState(checkOuter); if (!m_check.ParseFull(checkState)) { return(false); } state.AddAbsolute( Key, state.InnerPosition + 1, entry.EndPosition); return(true); }
public override bool Parse(SyntacticState state) { // this terminal consists of two lexical punctuators // and should be parsed in a special way if (state.InnerPosition + 1 >= state.InnerLength) { return(false); } LexicalEntry e1 = state.GetInner(state.InnerPosition); if (state.GetOuter(e1) != ">") { return(false); } LexicalEntry e2 = state.GetInner(state.InnerPosition + 1); if (state.GetOuter(e2) != ">=") { return(false); } if (e2.StartPosition != e1.StartPosition + 1) { return(false); } state.AddAbsolute( Key, state.InnerPosition + 2, state.OuterPosition + 3); return(true); }
private static void ParseLexicalEntryContent(XmlNode lexiconChild, LexicalEntry lexicalEntry, IDictionary <string, Sense> senses, IDictionary <string, Synset> synsets, bool loadRelations) { foreach (XmlNode lexicalEntryChild in lexiconChild.ChildNodes) { if (lexicalEntryChild.Name == "Lemma") { lexicalEntry.Lemma = lexicalEntryChild.Attributes["writtenForm"].Value; lexicalEntry.PartOfSpeech = PartOfSpeechExtensions.Parse(lexicalEntryChild.Attributes["partOfSpeech"].Value); } else if (lexicalEntryChild.Name == "Form") { lexicalEntry.Forms.Add(lexicalEntryChild.Attributes["writtenForm"].Value); } else if (lexicalEntryChild.Name == "Sense") { var sense = senses.GetOrAdd( lexicalEntryChild.Attributes["id"].Value, id => new Sense { Id = id }); sense.LexicalEntry = lexicalEntry; sense.Synset = synsets.GetOrAdd( lexicalEntryChild.Attributes["synset"].Value, id => new Synset { Id = id }); if (loadRelations) { foreach (XmlNode relationNode in lexicalEntryChild.ChildNodes) { var relation = new SenseRelation { Type = Enum.Parse <SenseRelationType>(relationNode.Attributes["relType"].Value), SourceId = sense.Id, TargetId = relationNode.Attributes["target"].Value }; sense.Relations.Add(relation); } } lexicalEntry.Senses.Add(sense); } else if (lexicalEntryChild.Name == "SyntacticBehaviour") { lexicalEntry.SyntacticBehaviours.Add(new SyntacticBehaviour { Senses = lexicalEntryChild.Attributes["senses"].Value, SubcategorizationFrame = lexicalEntryChild.Attributes["subcategorizationFrame"].Value }); } } }
private List <LexicalEntry> CreateLexicalEntryFromOxfordDictionaryResponse(string word, string response) { var odData = JsonConvert.DeserializeObject <OxfordDictionaryEntityV2>(response); var result = new List <LexicalEntry>(); var audioFiles = new List <AudioFile>(); var odLexicalEntries = odData?.Results?.FirstOrDefault()?.LexicalEntries; if (odLexicalEntries?.Count > 0) { foreach (var le in odLexicalEntries) { var lexicalEntry = new LexicalEntry { Word = le.Text, LexicalCategory = le.LexicalCategory.Text, OxfordDictionaryLexicalEntryV2Json = JsonConvert.SerializeObject(le) }; var audioFileUri = le.Pronunciations?.FirstOrDefault()?.AudioFile; if (audioFileUri != null) { var audioFile = audioFiles.FirstOrDefault(af => af.Url == audioFileUri.AbsoluteUri) ?? _oxfordDictionariesCacheDBContext.AudioFiles.FirstOrDefault(af => af.Url == audioFileUri.AbsoluteUri); if (audioFile == null) { audioFile = new AudioFile { Url = audioFileUri.AbsoluteUri, FileName = Path.GetFileName(audioFileUri.LocalPath), Data = _fileDownloader.GetFileFromUrl(audioFileUri.AbsoluteUri), LexicalEntries = new List <LexicalEntry>() }; audioFiles.Add(audioFile); } lexicalEntry.AudioFile = audioFile; } _oxfordDictionariesCacheDBContext.LexicalEntries.Add(lexicalEntry); result.Add(lexicalEntry); } } else { var lexicalEntry = new LexicalEntry { Word = word }; result.Add(lexicalEntry); _oxfordDictionariesCacheDBContext.LexicalEntries.Add(lexicalEntry); } _oxfordDictionariesCacheDBContext.SaveChanges(); return(result); }
public override bool Parse(SyntacticState state) { // this is a special case when we are trying to // catch null-coalescing-expression without trailing "?" int innerIndex = state.InnerPosition; int outerIndex = state.OuterPosition; // ensure that usual null-coalescing-expression can be parsed if (!NullCoalescingExpression.S.Parse(state)) { return(false); } // we should not do anything if captured expression // doesn't end with a "?" LexicalEntry entry = state.GetInner(state.InnerPosition - 1); if (state.GetOuter(entry) != "?") { return(true); } // get a position of the last type entry int lastTypeIndex = 0; for (int i = innerIndex; i <= state.InnerPosition; i++) { if (state.CheckEntry(Type.S.Key, i)) { lastTypeIndex = i; } } // reset parsing and make another attempt // ignoring nullable types after specified index state.Reset(innerIndex, outerIndex); state.SetFlag(StateFlags.IgnoreNullableAfterPosition, lastTypeIndex - 1); bool parsed = ParseMany( state, ConditionalOrExpression.S, DoubleQuestionTerminal.S); state.ResetFlag(StateFlags.IgnoreNullableAfterPosition); return(parsed); }
public override bool Parse(SyntacticState state) { if (state.IsEndOfData) { return(false); } LexicalEntry entry = state.GetInner(state.InnerPosition); if (entry.Key != Identifier.S.Key) { return(false); } // parse all identidiers except those // which are similar to LINQ keywords string name = state.GetOuter(entry); if (name == "ascending" || name == "by" || name == "descending" || name == "equals" || name == "from" || name == "group" || name == "in" || name == "into" || name == "join" || name == "let" || name == "on" || name == "orderby" || name == "select" || name == "where") { return(false); } state.AddAbsolute( Key, state.InnerPosition + 1, entry.EndPosition); return(true); }
/// <summary> /// Tries to parse an entity from the specified syntactic machine state. /// In case of success returns true and advances parsing position. /// </summary> public override bool Parse(SyntacticState state) { if (state.IsEndOfData) { return(false); } LexicalEntry entry = state.GetInner(state.InnerPosition); if (entry.Key != m_item.Key) { return(false); } state.AddAbsolute( Key, state.InnerPosition + 1, entry.EndPosition); return(true); }
/// <summary> /// Tries to parse an entity from the specified syntactic machine state. /// In case of success returns true and advances parsing position. /// </summary> public override bool Parse(SyntacticState state) { if (state.IsEndOfData) { return(false); } LexicalEntry entry = state.GetInner(state.InnerPosition); string text = state.GetOuter(entry); if (text != m_text) { return(false); } state.AddAbsolute( Key, state.InnerPosition + 1, entry.EndPosition); return(true); }
public void TestExistingWord() { var searchResult = _client.SearchEntries("study", CancellationToken.None).Result; // result is present Assert.True(searchResult != null); // result is not empty Assert.True(searchResult.Results.Length > 0); // result match Result result = searchResult.Results.First(); Assert.True(result.Id == "study" && result.Word == "study"); // element in lexical Assert.True(result.LexicalEntries.Length == 2); Assert.True(result.LexicalEntries.First().LexicalCategory == "Noun"); // Sense LexicalEntry lexicalEntry = result.LexicalEntries.First(); Assert.True(lexicalEntry.Entries.Length == 1); Assert.True(lexicalEntry.Entries.First().Senses.Length == 5); Sense[] eachDefinition = lexicalEntry.Entries.First().Senses; Assert.True(eachDefinition.First().Definitions.First() == "the devotion of time and attention to gaining knowledge of an academic subject, especially by means of books"); }
public void LexicalEntry_Uncovered() { LexicalEntry entry = new LexicalEntry("key", 1, 2); Assert.AreEqual("key [1:2]", entry.ToString()); }
public override bool Parse(SyntacticState state) { int innerIndex = state.InnerPosition; int outerIndex = state.OuterPosition; // null-coalescing-expression is required if (!NullCoalescingExpression.S.Parse(state)) { return(false); } // if captured expression ends with "?" LexicalEntry entry = state.GetInner(state.InnerPosition - 1); if (state.GetOuter(entry) == "?") { // check whether "? and :" part goes after bool full = ParseAll( state, QuestionTerminal.S, Expression.S, ColonTerminal.S, Expression.S); // if so, everything is OK if (full) { state.AddBack(Key, innerIndex, outerIndex); return(true); } // if not, make another attempt to parse conditional expression // handling null-coalescing-expression without trailing "?" state.Reset(innerIndex, outerIndex); // if we could do that, we can return if (ParseAll( state, NullCoalescingExpressionShorten.S, QuestionTerminal.S, Expression.S, ColonTerminal.S, Expression.S)) { return(true); } // if not, parse initial null-coalescing-expression once again NullCoalescingExpression.S.Parse(state); } ParseAll( state, QuestionTerminal.S, Expression.S, ColonTerminal.S, Expression.S); state.AddBack(Key, innerIndex, outerIndex); return(true); }
public ParseResult Parse(string fileName, bool loadRelations) { var result = new ParseResult(); var lexicalEntries = new Dictionary <string, LexicalEntry>(); var senses = new Dictionary <string, Sense>(); var synsets = new Dictionary <string, Synset>(); var document = new XmlDocument(); document.Load(fileName); foreach (XmlNode lexicon in document.DocumentElement.ChildNodes) { var language = lexicon.Attributes["language"].Value; Console.WriteLine($"Started processing lexicon \"{lexicon.Attributes["label"].Value} ({language})\"."); foreach (XmlNode lexiconChild in lexicon.ChildNodes) { if (lexiconChild.Name == "LexicalEntry") { var lexicalEntry = new LexicalEntry { Id = lexiconChild.Attributes["id"].Value, Language = language, }; lexicalEntries.Add(lexicalEntry.Id, lexicalEntry); ParseLexicalEntryContent(lexiconChild, lexicalEntry, senses, synsets, loadRelations); } else if (lexiconChild.Name == "Synset") { var synset = synsets.GetOrAdd( lexiconChild.Attributes["id"].Value, id => new Synset { Id = id, }); synset.Ili = lexiconChild.Attributes["ili"].Value; synset.PartOfSpeech = PartOfSpeechExtensions.Parse(lexiconChild.Attributes["partOfSpeech"].Value); ParseSynsetContent(lexiconChild, synset, loadRelations); } } } Console.WriteLine($"Loaded {lexicalEntries.Count} lexical entries, {senses.Count} senses and {synsets.Count} synsets."); result.LexicalEntries = lexicalEntries.Values; if (loadRelations) { var senseRelations = new List <SenseRelation>(); var synsetRelations = new List <SynsetRelation>(); foreach (var sense in senses.Values) { senseRelations.AddRange(sense.Relations); sense.Relations = null; } foreach (var synset in synsets.Values) { synsetRelations.AddRange(synset.Relations); synset.Relations = null; } result.SenseRelations = senseRelations; result.SynsetRelations = synsetRelations; Console.WriteLine($"Loaded {senseRelations.Count} sense relations, {synsetRelations.Count} synset relations."); } return(result); }
/// <summary> /// Gets input data related to specified entry. /// </summary> public string GetOuter(LexicalEntry entry) { return(m_outerData.Substring(entry.StartPosition, entry.Length)); }