public SemanticValueDebugDisplay(SemanticValue value) { _value = value.Value; _dictionary = value._dictionary; _name = value.KeyName; _confidence = value.Confidence; }
private void RecursivelyExtractSemanticValue(IntPtr phraseBuffer, int semanticsOffset, SemanticValue semanticValue, IList <RecognizedWordUnit> words, bool isSapi53Header, GrammarOptions semanticTag) { IntPtr ptr = new IntPtr((long)phraseBuffer + semanticsOffset); SPSERIALIZEDPHRASEPROPERTY sPSERIALIZEDPHRASEPROPERTY = (SPSERIALIZEDPHRASEPROPERTY)Marshal.PtrToStructure(ptr, typeof(SPSERIALIZEDPHRASEPROPERTY)); string propertyName; SemanticValue semanticValue2 = ExtractSemanticValueInformation(semanticsOffset, sPSERIALIZEDPHRASEPROPERTY, phraseBuffer, isSapi53Header, out propertyName); if (propertyName == "_value" && semanticValue != null) { semanticValue.Value = semanticValue2.Value; if (sPSERIALIZEDPHRASEPROPERTY.pFirstChildOffset != 0) { semanticValue2 = semanticValue; } } else { InsertSemanticValueToDictionary(semanticValue, propertyName, semanticValue2, semanticTag, ref _dupItems); } if (sPSERIALIZEDPHRASEPROPERTY.pFirstChildOffset != 0) { RecursivelyExtractSemanticValue(phraseBuffer, (int)sPSERIALIZEDPHRASEPROPERTY.pFirstChildOffset, semanticValue2, words, isSapi53Header, semanticTag); } if (sPSERIALIZEDPHRASEPROPERTY.pNextSiblingOffset != 0) { RecursivelyExtractSemanticValue(phraseBuffer, (int)sPSERIALIZEDPHRASEPROPERTY.pNextSiblingOffset, semanticValue, words, isSapi53Header, semanticTag); } }
private static void RecursivelyExtractSemanticProperties(List <ResultPropertiesRef> propertyList, int semanticsOffset, IntPtr phraseBuffer, RuleNode ruleTree, IList <RecognizedWordUnit> words, bool isSapi53Header) { IntPtr ptr = new IntPtr((long)phraseBuffer + semanticsOffset); SPSERIALIZEDPHRASEPROPERTY sPSERIALIZEDPHRASEPROPERTY = (SPSERIALIZEDPHRASEPROPERTY)Marshal.PtrToStructure(ptr, typeof(SPSERIALIZEDPHRASEPROPERTY)); string propertyName; SemanticValue semanticValue = ExtractSemanticValueInformation(semanticsOffset, sPSERIALIZEDPHRASEPROPERTY, phraseBuffer, isSapi53Header, out propertyName); RuleNode ruleNode = ruleTree.Find(sPSERIALIZEDPHRASEPROPERTY.ulFirstElement, sPSERIALIZEDPHRASEPROPERTY.ulCountOfElements); if (propertyName == "SemanticKey") { ruleNode._name = (string)semanticValue.Value; ruleNode._hasName = true; } else { propertyList.Add(new ResultPropertiesRef(propertyName, semanticValue, ruleNode)); } if (sPSERIALIZEDPHRASEPROPERTY.pFirstChildOffset != 0) { RecursivelyExtractSemanticProperties(propertyList, (int)sPSERIALIZEDPHRASEPROPERTY.pFirstChildOffset, phraseBuffer, ruleTree, words, isSapi53Header); } if (sPSERIALIZEDPHRASEPROPERTY.pNextSiblingOffset != 0) { RecursivelyExtractSemanticProperties(propertyList, (int)sPSERIALIZEDPHRASEPROPERTY.pNextSiblingOffset, phraseBuffer, ruleTree, words, isSapi53Header); } }
private void AppendAttributes(XmlElement propertyNode, SemanticValue semanticValue) { foreach (KeyValuePair <string, SemanticValue> item in (IEnumerable <KeyValuePair <string, SemanticValue> >)semanticValue) { if (propertyNode.Attributes[item.Key] == null) { propertyNode.SetAttribute(item.Key, item.Value.Value.ToString()); } } }
private bool CalcILSemantics(IntPtr phraseBuffer) { if ((_grammarOptions & GrammarOptions.SemanticInterpretation) != 0 || _grammarOptions == GrammarOptions.KeyValuePairs) { IList <RecognizedWordUnit> words = Words; _semantics = new SemanticValue("<ROOT>", null, _confidence); if (_serializedPhrase.PropertiesOffset != 0) { RecursivelyExtractSemanticValue(phraseBuffer, (int)_serializedPhrase.PropertiesOffset, _semantics, words, _isSapi53Header, _grammarOptions & GrammarOptions.TagFormat); } return(true); } return(false); }
private static bool TryExecuteOnParse(RuleNode ruleRef, SemanticValue value, IList <RecognizedWordUnit> words, out object newValue, ref Exception exceptionThrown) { newValue = null; bool result = false; Grammar grammar = ruleRef._grammar; if (grammar != null && grammar._scripts != null) { try { if (exceptionThrown != null) { if (!ExecuteOnError(grammar, ruleRef, exceptionThrown)) { return(result); } exceptionThrown = null; return(result); } result = ExecuteOnParse(grammar, ruleRef, value, words, out newValue); return(result); } catch (Exception ex) { if (exceptionThrown == null) { exceptionThrown = ex; try { if (!ExecuteOnError(grammar, ruleRef, exceptionThrown)) { return(result); } exceptionThrown = null; return(result); } catch (Exception ex2) { Exception ex3 = exceptionThrown = ex2; return(result); } } return(result); } } return(result); }
private static bool ExecuteOnParse(Grammar grammar, RuleNode ruleRef, SemanticValue value, IList <RecognizedWordUnit> words, out object newValue) { ScriptRef[] scripts = grammar._scripts; bool result = false; newValue = null; foreach (ScriptRef scriptRef in scripts) { if (!(ruleRef._rule == scriptRef._rule) || scriptRef._method != RuleMethodScript.onParse) { continue; } RecognizedWordUnit[] array = new RecognizedWordUnit[ruleRef._count]; for (int j = 0; j < ruleRef._count; j++) { array[j] = words[j]; } object[] parameters = new object[2] { value, array }; if (grammar._proxy != null) { Exception exceptionThrown; newValue = grammar._proxy.OnParse(scriptRef._rule, scriptRef._sMethod, parameters, out exceptionThrown); if (exceptionThrown != null) { throw exceptionThrown; } } else { MethodInfo onParse; Grammar ruleInstance; GetRuleInstance(grammar, scriptRef._rule, scriptRef._sMethod, out onParse, out ruleInstance); newValue = onParse.Invoke(ruleInstance, parameters); } result = true; } return(result); }
private static void InsertSemanticValueToDictionary(SemanticValue semanticValue, string propertyName, SemanticValue thisSemanticValue, GrammarOptions semanticTag, ref Collection <SemanticValue> dupItems) { string text = propertyName; if ((text == "$" && semanticTag == GrammarOptions.MssV1) || (text == "=" && (semanticTag == GrammarOptions.KeyValuePairSrgs || semanticTag == GrammarOptions.KeyValuePairs)) || (thisSemanticValue.Count == -1 && semanticTag == GrammarOptions.W3cV1)) { if ((semanticTag & GrammarOptions.SemanticInterpretation) == 0 && semanticValue._valueFieldSet && !semanticValue.Value.Equals(thisSemanticValue.Value)) { throw new InvalidOperationException(SR.Get(SRID.DupSemanticValue, semanticValue.KeyName)); } semanticValue.Value = thisSemanticValue.Value; semanticValue._valueFieldSet = true; } else if (!semanticValue._dictionary.ContainsKey(text)) { semanticValue._dictionary.Add(text, thisSemanticValue); } else if (!semanticValue._dictionary[text].Equals(thisSemanticValue)) { if (semanticTag == GrammarOptions.KeyValuePairSrgs) { throw new InvalidOperationException(SR.Get(SRID.DupSemanticKey, propertyName, semanticValue.KeyName)); } int num = 0; do { text = propertyName + string.Format(CultureInfo.InvariantCulture, "_{0}", new object[1] { num++ }); }while (semanticValue._dictionary.ContainsKey(text)); semanticValue._dictionary.Add(text, thisSemanticValue); if (dupItems == null) { dupItems = new Collection <SemanticValue>(); } SemanticValue item = semanticValue._dictionary[text]; dupItems.Add(item); } }
private void CalcSemantics(Grammar grammar) { if (_semantics == null && _serializedPhrase.SemanticErrorInfoOffset == 0) { GCHandle gCHandle = GCHandle.Alloc(_phraseBuffer, GCHandleType.Pinned); try { IntPtr phraseBuffer = gCHandle.AddrOfPinnedObject(); if (!CalcILSemantics(phraseBuffer)) { IList <RecognizedWordUnit> words = Words; RuleNode ruleNode = ExtractRules(grammar, _serializedPhrase.Rule, phraseBuffer); List <ResultPropertiesRef> properties = BuildRecoPropertyTree(_serializedPhrase, phraseBuffer, ruleNode, words, _isSapi53Header); _semantics = RecursiveBuildSemanticProperties(words, properties, ruleNode, _grammarOptions & GrammarOptions.TagFormat, ref _dupItems); _semantics.Value = TryExecuteOnRecognition(grammar, _recoResult, ruleNode._rule); } } finally { gCHandle.Free(); } } }
private void AppendPropertiesSML(XmlDocument document, XmlElement alternateNode, SemanticValue semanticsNode, NumberFormatInfo nfo) { if (semanticsNode != null) { foreach (KeyValuePair <string, SemanticValue> item in (IEnumerable <KeyValuePair <string, SemanticValue> >)semanticsNode) { if (item.Key == "_attributes") { AppendAttributes(alternateNode, item.Value); if (string.IsNullOrEmpty(alternateNode.InnerText) && semanticsNode.Value != null) { XmlText newChild = document.CreateTextNode(semanticsNode.Value.ToString()); alternateNode.AppendChild(newChild); } } else { string name = item.Key; if (_dupItems != null && _dupItems.Contains(item.Value)) { name = RemoveTrailingNumber(item.Key); } XmlElement xmlElement = document.CreateElement(name); xmlElement.SetAttribute("confidence", semanticsNode[item.Key].Confidence.ToString("f", nfo)); alternateNode.AppendChild(xmlElement); if (item.Value.Count > 0) { if (item.Value.Value != null) { XmlText newChild2 = document.CreateTextNode(item.Value.Value.ToString()); xmlElement.AppendChild(newChild2); } AppendPropertiesSML(document, xmlElement, item.Value, nfo); } else if (item.Value.Value != null) { XmlText newChild3 = document.CreateTextNode(item.Value.Value.ToString()); xmlElement.AppendChild(newChild3); } } } } }
internal ResultPropertiesRef(string name, SemanticValue value, RuleNode ruleNode) { _name = name; _value = value; _ruleNode = ruleNode; }
private static SemanticValue RecursiveBuildSemanticProperties(IList <RecognizedWordUnit> words, List <ResultPropertiesRef> properties, RuleNode ruleTree, GrammarOptions semanticTag, ref Collection <SemanticValue> dupItems) { SemanticValue semanticValue = new SemanticValue(ruleTree._name, null, ruleTree._confidence); for (RuleNode ruleNode = ruleTree._child; ruleNode != null; ruleNode = ruleNode._next) { SemanticValue semanticValue2 = RecursiveBuildSemanticProperties(words, properties, ruleNode, semanticTag, ref dupItems); if (!ruleNode._hasName) { foreach (KeyValuePair <string, SemanticValue> item in semanticValue2._dictionary) { InsertSemanticValueToDictionary(semanticValue, item.Key, item.Value, semanticTag, ref dupItems); } if (semanticValue2.Value != null) { if ((semanticTag & GrammarOptions.SemanticInterpretation) == 0 && semanticValue._valueFieldSet && !semanticValue.Value.Equals(semanticValue2.Value)) { throw new InvalidOperationException(SR.Get(SRID.DupSemanticValue, ruleTree._name)); } semanticValue.Value = semanticValue2.Value; semanticValue._valueFieldSet = true; } } else { if (!semanticValue2._valueFieldSet && semanticValue2.Count == 0) { StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < ruleNode._count; i++) { if (stringBuilder.Length > 0) { stringBuilder.Append(" "); } stringBuilder.Append(words[(int)ruleNode._firstElement + i].Text); } semanticValue2._valueFieldSet = true; semanticValue2.Value = stringBuilder.ToString(); } semanticValue._dictionary.Add(ruleNode._name, semanticValue2); } } foreach (ResultPropertiesRef property in properties) { if (property._ruleNode == ruleTree) { InsertSemanticValueToDictionary(semanticValue, property._name, property._value, semanticTag, ref dupItems); } } Exception exceptionThrown = null; object newValue; bool flag = TryExecuteOnParse(ruleTree, semanticValue, words, out newValue, ref exceptionThrown); if (exceptionThrown != null) { throw exceptionThrown; } if (flag) { semanticValue._dictionary.Clear(); semanticValue.Value = newValue; semanticValue._valueFieldSet = true; } return(semanticValue); }