internal float Serialize(StreamMarshaler streamBuffer, bool isLast, uint arcIndex) { CfgArc cfgArc = default(CfgArc); cfgArc.LastArc = isLast; cfgArc.HasSemanticTag = (SemanticTagCount > 0); cfgArc.NextStartArcIndex = (uint)((_end != null) ? _end.SerializeId : 0); if (_ruleRef != null) { cfgArc.RuleRef = true; cfgArc.TransitionIndex = (uint)_ruleRef._iSerialize; } else { cfgArc.RuleRef = false; if (_specialTransitionIndex != 0) { cfgArc.TransitionIndex = (uint)_specialTransitionIndex; } else { cfgArc.TransitionIndex = (uint)_iWord; } } cfgArc.LowConfRequired = (_confidence < 0); cfgArc.HighConfRequired = (_confidence > 0); cfgArc.MatchMode = (uint)_matchMode; _iSerialize = arcIndex; streamBuffer.WriteStream(cfgArc); return(_flWeight); }
private static StringBlob LoadStringBlob(StreamMarshaler streamHelper, uint iPos, int c) { char[] array = new char[c]; streamHelper.Position = iPos; streamHelper.ReadArrayChar(array, c); return(new StringBlob(array)); }
// // This helper converts a serialized CFG grammar header into an in-memory header // internal static ScriptRef[] LoadScriptRefs(StreamMarshaler streamHelper, CfgSerializedHeader pFH) { // // Because in 64-bit code, pointers != sizeof(ULONG) we copy each member explicitly. // if (pFH.FormatId != CfgGrammar._SPGDF_ContextFree) { return(null); } //We know that in SAPI 5.0 grammar format pszWords follows header immediately. if (pFH.pszWords < Marshal.SizeOf <CfgSerializedHeader>()) { // Must be SAPI 6.0 or above to hold a .NET script return(null); } // Get the symbols StringBlob symbols = LoadStringBlob(streamHelper, pFH.pszSymbols, pFH.cchSymbols); // Get the script refs CfgScriptRef[] cfgScripts = Load <CfgScriptRef>(streamHelper, pFH.pScripts, pFH.cScripts); // Convert the CFG script reference to ScriptRef ScriptRef[] scripts = new ScriptRef[cfgScripts.Length]; for (int i = 0; i < cfgScripts.Length; i++) { CfgScriptRef cfgScript = cfgScripts[i]; scripts[i] = new ScriptRef(symbols[cfgScript._idRule], symbols[cfgScript._idMethod], cfgScript._method); } return(scripts); }
private static MemoryStream CombineCfg(string rule, Stream stream, SrgsRule[] extraRules) { using (MemoryStream memoryStream = new MemoryStream()) { SrgsDocument srgsDocument = new SrgsDocument(); srgsDocument.TagFormat = SrgsTagFormat.KeyValuePairs; foreach (SrgsRule srgsRule in extraRules) { srgsDocument.Rules.Add(srgsRule); } SrgsGrammarCompiler.Compile(srgsDocument, memoryStream); using (StreamMarshaler streamHelper = new StreamMarshaler(stream)) { long position = stream.Position; Backend org = new Backend(streamHelper); stream.Position = position; memoryStream.Position = 0L; MemoryStream memoryStream2 = new MemoryStream(); using (StreamMarshaler streamHelper2 = new StreamMarshaler(memoryStream)) { Backend extra = new Backend(streamHelper2); Backend backend = Backend.CombineGrammar(rule, org, extra); using (StreamMarshaler streamBuffer = new StreamMarshaler(memoryStream2)) { backend.Commit(streamBuffer); memoryStream2.Position = 0L; return(memoryStream2); } } } } }
internal static ScriptRef[] LoadIL(Stream stream) { using (StreamMarshaler streamMarshaler = new StreamMarshaler(stream)) { CfgSerializedHeader cfgSerializedHeader = new CfgSerializedHeader(); streamMarshaler.ReadStream(cfgSerializedHeader); return(LoadScriptRefs(streamMarshaler, cfgSerializedHeader)); } }
internal void Serialize(StreamMarshaler streamBuffer) { // Dynamic rules and imports have no arcs _cfgRule.FirstArcIndex = _firstState != null && !_firstState.OutArcs.IsEmpty ? (uint)_firstState.SerializeId : 0; _cfgRule.DirtyRule = true; streamBuffer.WriteStream(_cfgRule); }
internal void Serialize(StringBlob symbols, StreamMarshaler streamBuffer) { CfgScriptRef cfgScriptRef = default(CfgScriptRef); cfgScriptRef._idRule = symbols.Find(_rule); cfgScriptRef._method = _method; cfgScriptRef._idMethod = _idSymbol; streamBuffer.WriteStream(cfgScriptRef); }
public void WriteToWaveStream(Stream outputStream) { Helpers.ThrowIfNull(outputStream, "outputStream"); using (StreamMarshaler sm = new StreamMarshaler(outputStream)) { WriteWaveHeader(sm); } outputStream.Write(_rawAudioData, 0, _rawAudioData.Length); outputStream.Flush(); }
private static T[] Load <T>(StreamMarshaler streamHelper, uint iPos, int c) { T[] array = null; array = new T[c]; if (c > 0) { streamHelper.Position = iPos; streamHelper.ReadArray(array, c); } return(array); }
private static MemoryStream BuildCfg(Backend backend) { MemoryStream memoryStream = new MemoryStream(); using (StreamMarshaler streamBuffer = new StreamMarshaler(memoryStream)) { backend.IL = null; backend.PDB = null; backend.Commit(streamBuffer); return(memoryStream); } }
internal void SerializeStateEntries(StreamMarshaler streamBuffer, bool tagsCannotSpanOverMultipleArcs, float[] pWeights, ref uint iArcOffset, ref int iOffset) { List <Arc> list = _outArcs.ToList(); list.Sort(); Arc arc = (list.Count > 0) ? list[list.Count - 1] : null; IEnumerator <Arc> enumerator = ((IEnumerable <Arc>)list).GetEnumerator(); enumerator.MoveNext(); uint num = (uint)(list.Count + (int)iArcOffset); uint num2 = num; foreach (Arc item in list) { int semanticTagCount = item.SemanticTagCount; if (semanticTagCount > 0) { item.SetArcIndexForTag(0, iArcOffset, tagsCannotSpanOverMultipleArcs); } if (semanticTagCount <= 1) { pWeights[iOffset++] = item.Serialize(streamBuffer, arc == item, iArcOffset++); } else { iArcOffset++; pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, item, arc == item, num); num = (uint)((int)num + (semanticTagCount - 1)); } } enumerator = ((IEnumerable <Arc>)list).GetEnumerator(); enumerator.MoveNext(); num = num2; foreach (Arc item2 in list) { int semanticTagCount2 = item2.SemanticTagCount; if (semanticTagCount2 > 1) { for (int i = 1; i < semanticTagCount2 - 1; i++) { item2.SetArcIndexForTag(i, iArcOffset, tagsCannotSpanOverMultipleArcs); num++; pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, item2, true, num); iArcOffset++; } item2.SetArcIndexForTag(semanticTagCount2 - 1, iArcOffset, tagsCannotSpanOverMultipleArcs); pWeights[iOffset++] = item2.Serialize(streamBuffer, true, iArcOffset++); num++; } } }
internal static float SerializeExtraEpsilonWithTag(StreamMarshaler streamBuffer, Arc arc, bool isLast, uint arcIndex) { CfgArc cfgArc = default(CfgArc); cfgArc.LastArc = isLast; cfgArc.HasSemanticTag = true; cfgArc.NextStartArcIndex = arcIndex; cfgArc.TransitionIndex = 0u; cfgArc.LowConfRequired = false; cfgArc.HighConfRequired = false; cfgArc.MatchMode = (uint)arc._matchMode; streamBuffer.WriteStream(cfgArc); return(arc._flWeight); }
internal void Compile(Stream stream) { Backend backend = new Backend(); CustomGrammar cg = new CustomGrammar(); SrgsElementCompilerFactory elementFactory = new SrgsElementCompilerFactory(backend, cg); CreateGrammar(elementFactory); backend.Optimize(); using (StreamMarshaler streamBuffer = new StreamMarshaler(stream)) { backend.Commit(streamBuffer); } stream.Position = 0L; }
private void WriteWaveHeader(StreamMarshaler sm) { char[] array = new char[4] { 'R', 'I', 'F', 'F' }; byte[] array2 = _audioFormat.FormatSpecificData(); sm.WriteArray(array, array.Length); sm.WriteStream((uint)(_rawAudioData.Length + 38 + array2.Length)); char[] array3 = new char[4] { 'W', 'A', 'V', 'E' }; sm.WriteArray(array3, array3.Length); char[] array4 = new char[4] { 'f', 'm', 't', ' ' }; sm.WriteArray(array4, array4.Length); sm.WriteStream(18 + array2.Length); sm.WriteStream((ushort)_audioFormat.EncodingFormat); sm.WriteStream((ushort)_audioFormat.ChannelCount); sm.WriteStream(_audioFormat.SamplesPerSecond); sm.WriteStream(_audioFormat.AverageBytesPerSecond); sm.WriteStream((ushort)_audioFormat.BlockAlign); sm.WriteStream((ushort)_audioFormat.BitsPerSample); sm.WriteStream((ushort)array2.Length); if (array2.Length != 0) { sm.WriteStream(array2); } char[] array5 = new char[4] { 'd', 'a', 't', 'a' }; sm.WriteArray(array5, array5.Length); sm.WriteStream(_rawAudioData.Length); }
internal void Serialize(StringBlob symbols, StreamMarshaler streamBuffer) { CfgScriptRef script = new(); // Get the symbol id for the rule script._idRule = symbols.Find(_rule); script._method = _method; script._idMethod = _idSymbol; System.Diagnostics.Debug.Assert(script._idRule != -1 && script._idMethod != -1); streamBuffer.WriteStream(script); }
internal static CfgHeader ConvertCfgHeader(StreamMarshaler streamHelper, bool includeAllGrammarData, bool loadSymbols, out CfgSerializedHeader cfgSerializedHeader) { cfgSerializedHeader = new CfgSerializedHeader(streamHelper.Stream); CfgHeader cfgHeader = default(CfgHeader); cfgHeader.FormatId = cfgSerializedHeader.FormatId; cfgHeader.GrammarGUID = cfgSerializedHeader.GrammarGUID; cfgHeader.langId = cfgSerializedHeader.LangID; cfgHeader.pszGlobalTags = cfgSerializedHeader.pszSemanticInterpretationGlobals; cfgHeader.cArcsInLargestState = cfgSerializedHeader.cArcsInLargestState; cfgHeader.rules = Load <CfgRule>(streamHelper, cfgSerializedHeader.pRules, cfgSerializedHeader.cRules); if (includeAllGrammarData || loadSymbols) { cfgHeader.pszSymbols = LoadStringBlob(streamHelper, cfgSerializedHeader.pszSymbols, cfgSerializedHeader.cchSymbols); } if (includeAllGrammarData) { cfgHeader.pszWords = LoadStringBlob(streamHelper, cfgSerializedHeader.pszWords, cfgSerializedHeader.cchWords); cfgHeader.arcs = Load <CfgArc>(streamHelper, cfgSerializedHeader.pArcs, cfgSerializedHeader.cArcs); cfgHeader.tags = Load <CfgSemanticTag>(streamHelper, cfgSerializedHeader.tags, cfgSerializedHeader.cTags); cfgHeader.weights = Load <float>(streamHelper, cfgSerializedHeader.pWeights, cfgSerializedHeader.cArcs); } if (cfgSerializedHeader.pszWords < Marshal.SizeOf(typeof(CfgSerializedHeader))) { cfgHeader.ulRootRuleIndex = uint.MaxValue; cfgHeader.GrammarOptions = GrammarOptions.KeyValuePairs; cfgHeader.BasePath = null; cfgHeader.GrammarMode = GrammarType.VoiceGrammar; } else { cfgHeader.ulRootRuleIndex = cfgSerializedHeader.ulRootRuleIndex; cfgHeader.GrammarOptions = cfgSerializedHeader.GrammarOptions; cfgHeader.GrammarMode = (GrammarType)cfgSerializedHeader.GrammarMode; if (includeAllGrammarData) { cfgHeader.scripts = Load <CfgScriptRef>(streamHelper, cfgSerializedHeader.pScripts, cfgSerializedHeader.cScripts); } if (cfgSerializedHeader.cBasePath != 0) { streamHelper.Stream.Position = (int)cfgSerializedHeader.pRules + cfgHeader.rules.Length * Marshal.SizeOf(typeof(CfgRule)); cfgHeader.BasePath = streamHelper.ReadNullTerminatedString(); } } CheckValidCfgFormat(cfgSerializedHeader, cfgHeader, includeAllGrammarData); return(cfgHeader); }
private static string CheckRuleName(Stream stream, string rulename, bool isImportedGrammar, bool stgInit, out bool sapi53Only, out GrammarOptions grammarOptions) { sapi53Only = false; long position = stream.Position; using (StreamMarshaler streamHelper = new StreamMarshaler(stream)) { CfgGrammar.CfgSerializedHeader cfgSerializedHeader = null; CfgGrammar.CfgHeader cfgHeader = CfgGrammar.ConvertCfgHeader(streamHelper, false, true, out cfgSerializedHeader); StringBlob pszSymbols = cfgHeader.pszSymbols; string text = (cfgHeader.ulRootRuleIndex != uint.MaxValue && cfgHeader.ulRootRuleIndex < cfgHeader.rules.Length) ? pszSymbols.FromOffset(cfgHeader.rules[cfgHeader.ulRootRuleIndex]._nameOffset) : null; sapi53Only = ((cfgHeader.GrammarOptions & (GrammarOptions.MssV1 | GrammarOptions.IpaPhoneme | GrammarOptions.W3cV1 | GrammarOptions.STG)) != 0); if (text == null && string.IsNullOrEmpty(rulename)) { throw new ArgumentException(SR.Get(SRID.SapiErrorNoRulesToActivate)); } if (!string.IsNullOrEmpty(rulename)) { bool flag = false; CfgRule[] rules = cfgHeader.rules; for (int i = 0; i < rules.Length; i++) { CfgRule cfgRule = rules[i]; if (pszSymbols.FromOffset(cfgRule._nameOffset) == rulename) { flag = (cfgRule.Export || stgInit || (!isImportedGrammar && (cfgRule.TopLevel || rulename == text))); break; } } if (!flag) { throw new ArgumentException(SR.Get(SRID.RecognizerRuleNotFoundStream, rulename)); } } else { rulename = text; } grammarOptions = (cfgHeader.GrammarOptions & GrammarOptions.TagFormat); } stream.Position = position; return(rulename); }
private void WriteWaveHeader(StreamMarshaler sm) { char[] riff = new char[4] { 'R', 'I', 'F', 'F' }; byte[] formatSpecificData = _audioFormat.FormatSpecificData(); sm.WriteArray <char>(riff, riff.Length); sm.WriteStream((uint)(_rawAudioData.Length + 38 + formatSpecificData.Length)); // Must be four bytes char[] wave = new char[4] { 'W', 'A', 'V', 'E' }; sm.WriteArray(wave, wave.Length); char[] fmt = new char[4] { 'f', 'm', 't', ' ' }; sm.WriteArray(fmt, fmt.Length); sm.WriteStream(18 + formatSpecificData.Length); sm.WriteStream((ushort)_audioFormat.EncodingFormat); sm.WriteStream((ushort)_audioFormat.ChannelCount); sm.WriteStream(_audioFormat.SamplesPerSecond); sm.WriteStream(_audioFormat.AverageBytesPerSecond); sm.WriteStream((ushort)_audioFormat.BlockAlign); sm.WriteStream((ushort)_audioFormat.BitsPerSample); sm.WriteStream((ushort)formatSpecificData.Length); // write codec specific data if (formatSpecificData.Length > 0) { sm.WriteStream(formatSpecificData); } char[] data = new char[4] { 'd', 'a', 't', 'a' }; sm.WriteArray(data, data.Length); sm.WriteStream(_rawAudioData.Length); }
internal static ScriptRef[] LoadScriptRefs(StreamMarshaler streamHelper, CfgSerializedHeader pFH) { if (pFH.FormatId != _SPGDF_ContextFree) { return(null); } if (pFH.pszWords < Marshal.SizeOf(typeof(CfgSerializedHeader))) { return(null); } StringBlob stringBlob = LoadStringBlob(streamHelper, pFH.pszSymbols, pFH.cchSymbols); CfgScriptRef[] array = Load <CfgScriptRef>(streamHelper, pFH.pScripts, pFH.cScripts); ScriptRef[] array2 = new ScriptRef[array.Length]; for (int i = 0; i < array.Length; i++) { CfgScriptRef cfgScriptRef = array[i]; array2[i] = new ScriptRef(stringBlob[cfgScriptRef._idRule], stringBlob[cfgScriptRef._idMethod], cfgScriptRef._method); } return(array2); }
internal static bool LoadIL(Stream stream, out byte[] assemblyContent, out byte[] assemblyDebugSymbols, out ScriptRef[] scripts) { assemblyContent = (assemblyDebugSymbols = null); scripts = null; using (StreamMarshaler streamMarshaler = new StreamMarshaler(stream)) { CfgSerializedHeader cfgSerializedHeader = new CfgSerializedHeader(); streamMarshaler.ReadStream(cfgSerializedHeader); scripts = LoadScriptRefs(streamMarshaler, cfgSerializedHeader); if (scripts == null) { return(false); } if (cfgSerializedHeader.cIL == 0) { return(false); } assemblyContent = Load <byte>(streamMarshaler, cfgSerializedHeader.pIL, cfgSerializedHeader.cIL); assemblyDebugSymbols = ((cfgSerializedHeader.cPDB > 0) ? Load <byte>(streamMarshaler, cfgSerializedHeader.pPDB, cfgSerializedHeader.cPDB) : null); } return(true); }
internal float Serialize(StreamMarshaler streamBuffer, bool isLast, uint arcIndex) { CfgArc A = new(); A.LastArc = isLast; A.HasSemanticTag = SemanticTagCount > 0; A.NextStartArcIndex = (uint)(_end != null ? _end.SerializeId : 0); if (_ruleRef != null) { A.RuleRef = true; A.TransitionIndex = (uint)_ruleRef._iSerialize; //_pFirstState.SerializeId; } else { A.RuleRef = false; if (_specialTransitionIndex != 0) { A.TransitionIndex = (uint)_specialTransitionIndex; } else { A.TransitionIndex = (uint)_iWord; } } A.LowConfRequired = (_confidence < 0); A.HighConfRequired = (_confidence > 0); A.MatchMode = (uint)_matchMode; // For new arcs SerializeId is INFINITE so we set it correctly here. // For existing states we preserve the index from loading, // unless new states have been added in, in which case the arc index, // and hence the transition id have changed. There is a workaround in ReloadCmd // to invalidate rules in this case. _iSerialize = arcIndex; streamBuffer.WriteStream(A); return(_flWeight); }
internal void Serialize(StreamMarshaler streamBuffer) { _cfgRule.FirstArcIndex = (uint)((_firstState != null && !_firstState.OutArcs.IsEmpty) ? _firstState.SerializeId : 0); _cfgRule.DirtyRule = true; streamBuffer.WriteStream(_cfgRule); }
internal void SerializeStateEntries(StreamMarshaler streamBuffer, bool tagsCannotSpanOverMultipleArcs, float[] pWeights, ref uint iArcOffset, ref int iOffset) { // The arcs must be sorted before being written to disk. List <Arc> outArcs = _outArcs.ToList(); outArcs.Sort(); Arc lastArc = outArcs.Count > 0 ? outArcs[outArcs.Count - 1] : null; IEnumerator <Arc> enumArcs = ((IEnumerable <Arc>)outArcs).GetEnumerator(); enumArcs.MoveNext(); uint nextAvailableArc = (uint)outArcs.Count + iArcOffset; uint saveNextAvailableArc = nextAvailableArc; // Write the arc of the first epsilon arc with an arc has more than one semantic tag foreach (Arc arc in outArcs) { // Create the first arc. int cSemantics = arc.SemanticTagCount; // Set the semantic property reference for the first arc if (cSemantics > 0) { arc.SetArcIndexForTag(0, iArcOffset, tagsCannotSpanOverMultipleArcs); } // Serialize the arc if (cSemantics <= 1) { pWeights[iOffset++] = arc.Serialize(streamBuffer, lastArc == arc, iArcOffset++); } else { // update the position of the current arc ++iArcOffset; // more than one arc, create an epsilon transition pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, arc, lastArc == arc, nextAvailableArc); // reset the position of the next available slop for an arc nextAvailableArc += (uint)cSemantics - 1; } } enumArcs = ((IEnumerable <Arc>)outArcs).GetEnumerator(); enumArcs.MoveNext(); // revert the position for the new arc nextAvailableArc = saveNextAvailableArc; // write the additional arcs if we have more than one semantic tag foreach (Arc arc in outArcs) { int cSemantics = arc.SemanticTagCount; if (cSemantics > 1) { // If more than 2 arcs insert extra new epsilon states, one per semantic tag for (int i = 1; i < cSemantics - 1; i++) { // Set the semantic property reference arc.SetArcIndexForTag(i, iArcOffset, tagsCannotSpanOverMultipleArcs); // reset the position of the next available slop for an arc nextAvailableArc++; // create an epsilon transition pWeights[iOffset++] = Arc.SerializeExtraEpsilonWithTag(streamBuffer, arc, true, nextAvailableArc); // update the position of the current arc ++iArcOffset; } // Set the semantic property reference arc.SetArcIndexForTag(cSemantics - 1, iArcOffset, tagsCannotSpanOverMultipleArcs); // Add the real arc at the end pWeights[iOffset++] = arc.Serialize(streamBuffer, true, iArcOffset++); // reset the position of the next available slop for an arc nextAvailableArc++; } } }
internal void Serialize(StreamMarshaler streamBuffer) { streamBuffer.WriteStream(_cfgTag); }
private static object CompileStream(int iCfg, ISrgsParser srgsParser, string srgsPath, string filename, Stream stream, bool fOutputCfg, StringBuilder innerCode, object cfgResources, out CultureInfo culture, string[] referencedAssemblies, string keyFile) { Backend backend = new Backend(); CustomGrammar customGrammar = new CustomGrammar(); SrgsElementCompilerFactory srgsElementCompilerFactory = (SrgsElementCompilerFactory)(srgsParser.ElementFactory = new SrgsElementCompilerFactory(backend, customGrammar)); srgsParser.Parse(); backend.Optimize(); culture = ((backend.LangId == 21514) ? new CultureInfo("es-us") : new CultureInfo(backend.LangId)); if (customGrammar._codebehind.Count > 0 && !string.IsNullOrEmpty(srgsPath)) { for (int i = 0; i < customGrammar._codebehind.Count; i++) { if (!File.Exists(customGrammar._codebehind[i])) { customGrammar._codebehind[i] = srgsPath + "\\" + customGrammar._codebehind[i]; } } } if (referencedAssemblies != null) { foreach (string item in referencedAssemblies) { customGrammar._assemblyReferences.Add(item); } } customGrammar._keyFile = keyFile; backend.ScriptRefs = customGrammar._scriptRefs; if (!fOutputCfg) { CustomGrammar.CfgResource cfgResource = new CustomGrammar.CfgResource(); cfgResource.data = BuildCfg(backend).ToArray(); cfgResource.name = iCfg.ToString(CultureInfo.InvariantCulture) + ".CFG"; ((List <CustomGrammar.CfgResource>)cfgResources).Add(cfgResource); innerCode.Append(customGrammar.CreateAssembly(iCfg, filename, culture)); return(customGrammar); } if (customGrammar._scriptRefs.Count > 0 && !customGrammar.HasScript) { XmlParser.ThrowSrgsException(SRID.NoScriptsForRules); } CreateAssembly(backend, customGrammar); if (!string.IsNullOrEmpty(filename)) { stream = new FileStream(filename, FileMode.Create, FileAccess.Write); } try { using (StreamMarshaler streamBuffer = new StreamMarshaler(stream)) { backend.Commit(streamBuffer); return(customGrammar); } } finally { if (!string.IsNullOrEmpty(filename)) { stream.Close(); } } }
internal Backend(StreamMarshaler streamHelper) { InitFromBinaryGrammar(streamHelper); }
internal void Commit(StreamMarshaler streamBuffer) { long position = streamBuffer.Stream.Position; List <State> list = new List <State>(_states); _states = null; list.Sort(); ValidateAndTagRules(); CheckLeftRecursion(list); int num = (_basePath != null) ? (_basePath.Length + 1) : 0; int idWord = 0; if (_globalTags.Count > 0) { StringBuilder stringBuilder = new StringBuilder(); foreach (string globalTag in _globalTags) { stringBuilder.Append(globalTag); } _symbols.Add(stringBuilder.ToString(), out idWord); idWord = _symbols.OffsetFromId(idWord); if (idWord > 65535) { throw new OverflowException(SR.Get(SRID.TooManyRulesWithSemanticsGlobals)); } } foreach (ScriptRef scriptRef in _scriptRefs) { _symbols.Add(scriptRef._sMethod, out scriptRef._idSymbol); } int cArcs; float[] pWeights; CfgGrammar.CfgSerializedHeader o = BuildHeader(list, num, (ushort)idWord, out cArcs, out pWeights); streamBuffer.WriteStream(o); streamBuffer.WriteArrayChar(_words.SerializeData(), _words.SerializeSize()); streamBuffer.WriteArrayChar(_symbols.SerializeData(), _symbols.SerializeSize()); foreach (Rule rule in _rules) { rule.Serialize(streamBuffer); } if (num > 0) { streamBuffer.WriteArrayChar(_basePath.ToCharArray(), _basePath.Length); streamBuffer.WriteArrayChar(_achZero, 1); streamBuffer.WriteArray(_abZero3, (num * 2) & 3); } streamBuffer.WriteStream(default(CfgArc)); int iOffset = 1; uint iArcOffset = 1u; bool flag = (GrammarOptions & GrammarOptions.MssV1) == GrammarOptions.MssV1; foreach (State item in list) { item.SerializeStateEntries(streamBuffer, flag, pWeights, ref iArcOffset, ref iOffset); } if (_fNeedWeightTable) { streamBuffer.WriteArray(pWeights, cArcs); } if (!flag) { foreach (State item2 in list) { item2.SetEndArcIndexForTags(); } } for (int num2 = _tags.Count - 1; num2 >= 0; num2--) { if (_tags[num2]._cfgTag.ArcIndex == 0) { _tags.RemoveAt(num2); } } _tags.Sort(); foreach (Tag tag in _tags) { tag.Serialize(streamBuffer); } foreach (ScriptRef scriptRef2 in _scriptRefs) { scriptRef2.Serialize(_symbols, streamBuffer); } if (_il != null && _il.Length != 0) { streamBuffer.Stream.Write(_il, 0, _il.Length); } if (_pdb != null && _pdb.Length != 0) { streamBuffer.Stream.Write(_pdb, 0, _pdb.Length); } }
internal static CfgHeader ConvertCfgHeader(StreamMarshaler streamHelper, bool includeAllGrammarData, bool loadSymbols, out CfgSerializedHeader cfgSerializedHeader) { cfgSerializedHeader = new CfgSerializedHeader(streamHelper.Stream); // // Because in 64-bit code, pointers != sizeof(ULONG) we copy each member explicitly. // CfgHeader header = new(); header.FormatId = cfgSerializedHeader.FormatId; header.GrammarGUID = cfgSerializedHeader.GrammarGUID; header.langId = cfgSerializedHeader.LangID; header.pszGlobalTags = cfgSerializedHeader.pszSemanticInterpretationGlobals; header.cArcsInLargestState = cfgSerializedHeader.cArcsInLargestState; // read all the common fields header.rules = Load <CfgRule>(streamHelper, cfgSerializedHeader.pRules, cfgSerializedHeader.cRules); if (includeAllGrammarData || loadSymbols) { header.pszSymbols = LoadStringBlob(streamHelper, cfgSerializedHeader.pszSymbols, cfgSerializedHeader.cchSymbols); } if (includeAllGrammarData) { header.pszWords = LoadStringBlob(streamHelper, cfgSerializedHeader.pszWords, cfgSerializedHeader.cchWords); header.arcs = Load <CfgArc>(streamHelper, cfgSerializedHeader.pArcs, cfgSerializedHeader.cArcs); header.tags = Load <CfgSemanticTag>(streamHelper, cfgSerializedHeader.tags, cfgSerializedHeader.cTags); header.weights = Load <float>(streamHelper, cfgSerializedHeader.pWeights, cfgSerializedHeader.cArcs); } //We know that in SAPI 5.0 grammar format pszWords follows header immediately. if (cfgSerializedHeader.pszWords < Marshal.SizeOf <CfgSerializedHeader>()) { //This is SAPI 5.0 and SAPI 5.1 grammar format header.ulRootRuleIndex = 0xFFFFFFFF; header.GrammarOptions = GrammarOptions.KeyValuePairs; header.BasePath = null; header.GrammarMode = GrammarType.VoiceGrammar; } else { //This is SAPI 5.2 and beyond grammar format header.ulRootRuleIndex = cfgSerializedHeader.ulRootRuleIndex; header.GrammarOptions = cfgSerializedHeader.GrammarOptions; header.GrammarMode = (GrammarType)cfgSerializedHeader.GrammarMode; if (includeAllGrammarData) { header.scripts = Load <CfgScriptRef>(streamHelper, cfgSerializedHeader.pScripts, cfgSerializedHeader.cScripts); } // The BasePath string is written after the rules - no offset is provided // Get the chars and build the string if (cfgSerializedHeader.cBasePath > 0) { streamHelper.Stream.Position = (int)cfgSerializedHeader.pRules + (header.rules.Length * Marshal.SizeOf <CfgRule>()); header.BasePath = streamHelper.ReadNullTerminatedString(); } } // Check the content - should be valid for both SAPI 5.0 and SAPI 5.2 grammars CheckValidCfgFormat(cfgSerializedHeader, header, includeAllGrammarData); return(header); }
// // This helper converts a serialized CFG grammar header into an in-memory header // internal static CfgHeader ConvertCfgHeader(StreamMarshaler streamHelper) { CfgSerializedHeader cfgSerializedHeader = null; return(ConvertCfgHeader(streamHelper, true, true, out cfgSerializedHeader)); }
internal void InitFromBinaryGrammar(StreamMarshaler streamHelper) { CfgGrammar.CfgHeader header = CfgGrammar.ConvertCfgHeader(streamHelper); _words = header.pszWords; _symbols = header.pszSymbols; _grammarOptions = header.GrammarOptions; State[] array = new State[header.arcs.Length]; SortedDictionary <int, Rule> sortedDictionary = new SortedDictionary <int, Rule>(); int count = _rules.Count; BuildRulesFromBinaryGrammar(header, array, sortedDictionary, count); Arc[] array2 = new Arc[header.arcs.Length]; bool flag = true; CfgArc cfgArc = default(CfgArc); State state = null; IEnumerator <KeyValuePair <int, Rule> > enumerator = sortedDictionary.GetEnumerator(); if (enumerator.MoveNext()) { KeyValuePair <int, Rule> current = enumerator.Current; Rule value = current.Value; for (int i = 1; i < header.arcs.Length; i++) { CfgArc cfgArc2 = header.arcs[i]; if (cfgArc2.RuleRef) { value._listRules.Add(_rules[(int)cfgArc2.TransitionIndex]); } if (current.Key == i) { value = current.Value; if (enumerator.MoveNext()) { current = enumerator.Current; } } if (flag || cfgArc.LastArc) { if (array[i] == null) { uint nextHandle = CfgGrammar.NextHandle; array[i] = new State(value, nextHandle, i); AddState(array[i]); } state = array[i]; } int nextStartArcIndex = (int)cfgArc2.NextStartArcIndex; State end = null; if (state != null && nextStartArcIndex != 0) { if (array[nextStartArcIndex] == null) { uint nextHandle2 = CfgGrammar.NextHandle; array[nextStartArcIndex] = new State(value, nextHandle2, nextStartArcIndex); AddState(array[nextStartArcIndex]); } end = array[nextStartArcIndex]; } float flWeight = (header.weights != null) ? header.weights[i] : 1f; Arc arc; if (cfgArc2.RuleRef) { Rule ruleRef = _rules[(int)cfgArc2.TransitionIndex]; arc = new Arc(null, ruleRef, _words, flWeight, 0, null, MatchMode.AllWords, ref _fNeedWeightTable); } else { int transitionIndex = (int)cfgArc2.TransitionIndex; int num = (transitionIndex == 4194302 || transitionIndex == 4194301 || transitionIndex == 4194303) ? transitionIndex : 0; arc = new Arc((int)((num == 0) ? cfgArc2.TransitionIndex : 0), flWeight, cfgArc2.LowConfRequired ? (-1) : (cfgArc2.HighConfRequired ? 1 : 0), num, MatchMode.AllWords, ref _fNeedWeightTable); } arc.Start = state; arc.End = end; AddArc(arc); array2[i] = arc; flag = false; cfgArc = cfgArc2; } } int j = 1; int k = 0; for (; j < header.arcs.Length; j++) { CfgArc cfgArc3 = header.arcs[j]; if (!cfgArc3.HasSemanticTag) { continue; } for (; k < header.tags.Length && header.tags[k].StartArcIndex == j; k++) { CfgSemanticTag cfgTag = header.tags[k]; Tag tag = new Tag(this, cfgTag); _tags.Add(tag); array2[tag._cfgTag.StartArcIndex].AddStartTag(tag); array2[tag._cfgTag.EndArcIndex].AddEndTag(tag); if (cfgTag._nameOffset > 0) { tag._cfgTag._nameOffset = _symbols.OffsetFromId(_symbols.Find(_symbols.FromOffset(cfgTag._nameOffset))); } else { tag._cfgTag._valueOffset = _symbols.OffsetFromId(_symbols.Find(_symbols.FromOffset(cfgTag._valueOffset))); } } } _fNeedWeightTable = true; if (header.BasePath != null) { SetBasePath(header.BasePath); } _guid = header.GrammarGUID; _langId = header.langId; _grammarMode = header.GrammarMode; _fLoadedFromBinary = true; }