Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Speech / Src / Internal / SrgsCompiler / backend.cs / 1 / backend.cs
//------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Description:
// CFG Grammar backend
//
// History:
// 5/1/2004 jeanfp Created from the Sapi Managed code
//-----------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;
using System.IO;
using System.Speech.Internal.SrgsParser;
namespace System.Speech.Internal.SrgsCompiler
{
///
/// Summary description for GrammarBackEnd.
///
internal sealed partial class Backend
{
//*******************************************************************
//
// Constructors
//
//*******************************************************************
#region Constructors
internal Backend ()
{
_words = new StringBlob ();
_symbols = new StringBlob ();
}
internal Backend (StreamMarshaler streamHelper)
{
InitFromBinaryGrammar (streamHelper);
}
#endregion
//********************************************************************
//
// Internal Methods
//
//*******************************************************************
#region Internal Methods
///
/// Optimizes the grammar network by removing the epsilon states and merging
/// duplicate transitions. See GrammarOptimization.doc for details.
///
internal void Optimize ()
{
//DumpGrammarStatistics ("GrammarOptimization: Pre optimize");
_states.Optimize ();
//DumpGrammarStatistics ("GrammarOptimization: Post optimize");
// Most likely, there will be an arc with a weight != 1. So we need a weight table.
_fNeedWeightTable = true;
}
///
/// Performs consistency checks of the grammar structure, creates the
/// serialized format and either saves it to the stream provided by SetSaveOptions,
/// or reloads it into the CFG engine.
///
///
internal void Commit (StreamMarshaler streamBuffer)
{
// For debugging purpose, assert if the position is not it is assumed it should be
// Keep the start position in the stream
long startStreamPostion = streamBuffer.Stream.Position;
// put all states State into a sorted array by rule parent index and serialized index
List sortedStates = new List (_states);
// Release the memory for the original list of states
_states = null;
sortedStates.Sort ();
// Validate the grammar
ValidateAndTagRules ();
CheckLeftRecursion (sortedStates);
// Include null terminator
int cBasePath = _basePath != null ? _basePath.Length + 1 : 0;
float [] pWeights;
int cArcs;
// Add the top level semantic interpreatation tag
// This should be set as the first symbol in the symbol string blog since it must hold on a 16 bits value.
int semanticInterpretationGlobals = 0;
if (_globalTags.Count > 0)
{
StringBuilder sb = new StringBuilder ();
foreach (string s in _globalTags)
{
sb.Append (s);
}
_symbols.Add (sb.ToString (), out semanticInterpretationGlobals);
semanticInterpretationGlobals = _symbols.OffsetFromId (semanticInterpretationGlobals);
if (semanticInterpretationGlobals > UInt16.MaxValue)
{
throw new OverflowException (SR.Get (SRID.TooManyRulesWithSemanticsGlobals));
}
}
#if !NO_STG
// Write the method names as symbols
foreach (ScriptRef script in _scriptRefs)
{
_symbols.Add (script._sMethod, out script._idSymbol);
}
#endif
// get the header
CfgGrammar.CfgSerializedHeader header = BuildHeader (sortedStates, cBasePath, unchecked ((UInt16) semanticInterpretationGlobals), out cArcs, out pWeights);
streamBuffer.WriteStream (header);
//
// For the string blobs, we must explicitly report I/O error since the blobs don't
// use the error log facility.
//
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pszWords);
streamBuffer.WriteArrayChar (_words.SerializeData (), _words.SerializeSize ());
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pszSymbols);
streamBuffer.WriteArrayChar (_symbols.SerializeData (), _symbols.SerializeSize ());
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pRules);
foreach (Rule rule in _rules)
{
rule.Serialize (streamBuffer);
}
if (cBasePath > 0)
{
streamBuffer.WriteArrayChar (_basePath.ToCharArray (), _basePath.Length);
// Add a zero to be compatible with SAPI 5
System.Diagnostics.Debug.Assert (_basePath.Length + 1 == cBasePath);
streamBuffer.WriteArrayChar (_achZero, 1);
// Zero-pad to align following structures
streamBuffer.WriteArray (_abZero3, cBasePath * Helpers._sizeOfChar & 3);
}
//
// Write a dummy 0 index state entry
//
CfgArc dummyArc = new CfgArc ();
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pArcs);
streamBuffer.WriteStream (dummyArc);
int ulWeightOffset = 1;
uint arcOffset = 1;
bool semanticInterpretation = (GrammarOptions & GrammarOptions.MssV1) == GrammarOptions.MssV1;
foreach (State state in sortedStates)
{
state.SerializeStateEntries (streamBuffer, semanticInterpretation, pWeights, ref arcOffset, ref ulWeightOffset);
}
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pWeights);
if (_fNeedWeightTable)
{
streamBuffer.WriteArray (pWeights, cArcs);
}
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.tags);
if (!semanticInterpretation)
{
foreach (State state in sortedStates)
{
state.SetEndArcIndexForTags ();
}
}
// Remove the orphaned arcs
// This could happen in the case of a -
for (int i = _tags.Count - 1; i >= 0; i--)
{
// When arc are created the index is set to zero. This value changes during serialization
// if an arc references it
if (_tags [i]._cfgTag.ArcIndex == 0)
{
_tags.RemoveAt (i);
}
}
// Sort the _tags array by ArcIndex
_tags.Sort ();
// Write the _tags array
foreach (Tag tag in _tags)
{
tag.Serialize (streamBuffer);
}
#if !NO_STG
// Write the script references and the IL write after the header so getting it for the grammar
// Does not require a seek to the end of the file
System.Diagnostics.Debug.Assert (header.pScripts == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pScripts);
foreach (ScriptRef script in _scriptRefs)
{
script.Serialize (_symbols, streamBuffer);
}
// Write the assembly bits
System.Diagnostics.Debug.Assert (header.pIL == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pIL);
if (_il != null && _il.Length > 0)
{
streamBuffer.Stream.Write (_il, 0, _il.Length);
}
System.Diagnostics.Debug.Assert (header.pPDB == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pPDB);
if (_pdb != null && _pdb.Length > 0)
{
streamBuffer.Stream.Write (_pdb, 0, _pdb.Length);
}
#endif
}
///
/// Description:
/// Combine the current data in a grammar with one comming from a CFG
///
///
///
///
internal static Backend CombineGrammar (string ruleName, Backend org, Backend extra)
{
//
Backend be = new Backend ();
be._fLoadedFromBinary = true;
be._fNeedWeightTable = org._fNeedWeightTable;
be._grammarMode = org._grammarMode;
be._grammarOptions = org._grammarOptions;
// Hash source state to destination state
Dictionary srcToDestHash = new Dictionary ();
// Find the rule
foreach (Rule orgRule in org._rules)
{
if (orgRule.Name == ruleName)
{
be.CloneSubGraph (orgRule, org, extra, srcToDestHash, true);
}
}
return be;
}
internal State CreateNewState (Rule rule)
{
return _states.CreateNewState (rule);
}
internal void DeleteState (State state)
{
_states.DeleteState (state);
}
internal void MoveInputTransitionsAndDeleteState (State from, State to)
{
_states.MoveInputTransitionsAndDeleteState (from, to);
}
internal void MoveOutputTransitionsAndDeleteState (State from, State to)
{
_states.MoveOutputTransitionsAndDeleteState (from, to);
}
///
/// Tries to find the rule's initial state handle. If both a name and an id
/// are provided, then both have to match in order for this call to succeed.
/// If the rule doesn't already exist then we define it if fCreateIfNotExists,
/// otherwise we return an error ().
///
/// - pszRuleName name of rule to find/define (null: don't care)
/// - ruleId id of rule to find/define (0: don't care)
/// - dwAttribute rule attribute for defining the rule
/// - fCreateIfNotExists creates the rule using name, id, and attributes
/// in case the rule doesn't already exist
///
/// throws:
/// S_OK, E_INVALIDARG, E_OUTOFMEMORY
/// SPERR_RULE_NOT_FOUND -- no rule found and we don't create a new one
/// SPERR_RULE_NAME_ID_CONFLICT -- rule name and id don't match
///
///
///
///
/// Internal method for finding rule in rule list
///
///
///
/// Adds a word transition from hFromState to hToState. If hToState == null
/// then the arc will be to the (implicit) terminal state. If psz == null then
/// we add an epsilon transition. Properties are pushed back to the
/// first un-ambiguous arc in case we can share a common initial state path.
/// The weight will be placed on the first arc (if there exists an arc with
/// the same word but different weight we will create a new arc).
///
internal Arc WordTransition (string sWord, float flWeight, int requiredConfidence)
{
return CreateTransition (sWord, flWeight, requiredConfidence);
}
internal Arc SubsetTransition (string text, MatchMode matchMode)
{
// Performs white space normalization in place
text = NormalizeTokenWhiteSpace (text);
return new Arc (text, null, _words, 1.0f, CfgGrammar.SP_NORMAL_CONFIDENCE, null, matchMode, ref _fNeedWeightTable);
}
///
/// Adds a rule (reference) transition from hFromState to hToState.
/// hRule can also be one of these special transition handles:
/// SPRULETRANS_WILDCARD : "WILDCARD" transition
/// SPRULETRANS_DICTATION : single word from dictation
/// SPRULETRANS_TEXTBUFFER : "TEXTBUFFER" transition
///
/// must be initial state of rule
/// Rule calling the ruleref
///
internal Arc RuleTransition (Rule rule, Rule parentRule, float flWeight)
{
//CfgGrammar.TraceInformation ("BackEnd::AddRuleTransition");
Rule ruleToTransitionTo = null;
if (flWeight < 0.0f)
{
XmlParser.ThrowSrgsException (SRID.UnsupportedFormat);
}
Rule specialRuleTrans = null;
if (rule == CfgGrammar.SPRULETRANS_WILDCARD || rule == CfgGrammar.SPRULETRANS_DICTATION || rule == CfgGrammar.SPRULETRANS_TEXTBUFFER)
{
specialRuleTrans = rule;
}
else
{
ruleToTransitionTo = rule;
}
bool fNeedWeightTable = false;
Arc arc = new Arc (null, ruleToTransitionTo, _words, flWeight, '\0', specialRuleTrans, MatchMode.AllWords, ref fNeedWeightTable);
AddArc (arc);
if (ruleToTransitionTo != null && parentRule != null)
{
ruleToTransitionTo._listRules.Insert (0, parentRule);
}
return arc;
}
///
/// Adds a word transition from hFromState to hToState. If hToState == null
/// then the arc will be to the (implicit) terminal state. If psz == null then
/// we add an epsilon transition. Properties are pushed back to the
/// first un-ambiguous arc in case we can share a common initial state path.
/// The weight will be placed on the first arc (if there exists an arc with
/// the same word but different weight we will create a new arc).
///
///
///
/// Traverse the graph starting from SrcStartState, cloning each state as we go along,
/// cloning each transition except ones originating from SrcEndState, and return
/// the cloned state corresponding to SrcEndState.
///
///
///
///
/// SrcToDestHash = new Dictionary (); // Hash source state to destination state
Stack CloneStack = new Stack (); // States to process
Dictionary tags = new Dictionary ();
// Add initial state to CloneStack and SrcToDestHash.
SrcToDestHash.Add (srcFromState, destFromState);
CloneStack.Push (srcFromState);
// While there are still states on the CloneStack (ToDo collection)
while (CloneStack.Count > 0)
{
srcFromState = CloneStack.Pop ();
destFromState = SrcToDestHash [srcFromState];
System.Diagnostics.Debug.Assert (destFromState != null);
// For each transition from srcFromState (except SrcEndState)
foreach (Arc arc in srcFromState.OutArcs)
{
// - Lookup the DestToState corresponding to SrcToState
State srcToState = arc.End;
State destToState = null;
if (srcToState != null)
{
// - If not found, clone a new DestToState, add SrcToState.DestToState to SrcToDestHash, and add SrcToState to CloneStack.
if (!SrcToDestHash.ContainsKey (srcToState))
{
destToState = CreateNewState (srcToState.Rule);
SrcToDestHash.Add (srcToState, destToState);
CloneStack.Push (srcToState);
}
else
{
destToState = SrcToDestHash [srcToState]; ;
}
}
// - Clone the transition from SrcFromState.SrcToState at DestFromState.DestToState
// -- Clone Arc
Arc newArc = new Arc (arc, destFromState, destToState);
AddArc (newArc);
// -- Clone SemanticTag
newArc.CloneTags (arc, _tags, tags, null);
// -- Add Arc
newArc.ConnectStates ();
}
}
System.Diagnostics.Debug.Assert (tags.Count == 0);
return SrcToDestHash [srcEndState];
}
///
/// Traverse the graph starting from SrcStartState, cloning each state as we go along,
/// cloning each transition except ones originating from SrcEndState, and return
/// the cloned state corresponding to SrcEndState.
///
///
///
///
///
///
/// srcToDestHash, bool fromOrg)
{
Backend beSrc = fromOrg ? org : extra;
List CloneStack = new List (); // States to process
Dictionary tags = new Dictionary ();
// Push all the state for the top level rule
CloneState (rule._firstState, CloneStack, srcToDestHash);
// While there are still states on the CloneStack (ToDo collection)
while (CloneStack.Count > 0)
{
State srcFromState = CloneStack [0];
CloneStack.RemoveAt (0);
State destFromState = srcToDestHash [srcFromState];
// For each transition from srcFromState (except SrcEndState)
foreach (Arc arc in srcFromState.OutArcs)
{
// - Lookup the DestToState corresponding to SrcToState
State srcToState = arc.End;
State destToState = null;
if (srcToState != null)
{
if (!srcToDestHash.ContainsKey (srcToState))
{
// - If not found, then it is a new rule, just clown it.
CloneState (srcToState, CloneStack, srcToDestHash);
}
destToState = srcToDestHash [srcToState];
}
// - Clone the transition from SrcFromState.SrcToState at DestFromState.DestToState
// -- Clone Arc
int newWordId = arc.WordId;
if (beSrc != null && arc.WordId > 0)
{
_words.Add (beSrc.Words [arc.WordId], out newWordId);
}
Arc newArc = new Arc (arc, destFromState, destToState, newWordId);
// -- Clone SemanticTag
newArc.CloneTags (arc, _tags, tags, this);
// For rule ref push the first state of the ruleref
if (arc.RuleRef != null)
{
string ruleName;
// Check for DYNAMIC grammars
if (arc.RuleRef.Name.IndexOf ("URL:DYNAMIC#", StringComparison.Ordinal) == 0)
{
ruleName = arc.RuleRef.Name.Substring (12);
if (fromOrg == true && FindInRules (ruleName) == null)
{
Rule ruleExtra = extra.FindInRules (ruleName);
if (ruleExtra == null)
{
XmlParser.ThrowSrgsException (SRID.DynamicRuleNotFound, ruleName);
}
CloneSubGraph (ruleExtra, org, extra, srcToDestHash, false);
}
}
else if (arc.RuleRef.Name.IndexOf ("URL:STATIC#", StringComparison.Ordinal) == 0)
{
ruleName = arc.RuleRef.Name.Substring (11);
if (fromOrg == false && FindInRules (ruleName) == null)
{
Rule ruleOrg = org.FindInRules (ruleName);
if (ruleOrg == null)
{
XmlParser.ThrowSrgsException (SRID.DynamicRuleNotFound, ruleName);
}
CloneSubGraph (ruleOrg, org, extra, srcToDestHash, true);
}
}
else
{
ruleName = arc.RuleRef.Name;
Rule ruleExtra = org.FindInRules (ruleName);
if (fromOrg == false)
{
CloneSubGraph (arc.RuleRef, org, extra, srcToDestHash, true);
}
}
Rule refRule = FindInRules (ruleName);
if (refRule == null)
{
refRule = CloneState (arc.RuleRef._firstState, CloneStack, srcToDestHash);
}
newArc.RuleRef = refRule;
}
// -- Add Arc
newArc.ConnectStates ();
}
}
System.Diagnostics.Debug.Assert (tags.Count == 0);
}
///
/// Delete disconnected subgraph starting at hState.
/// Traverse the graph starting from SrcStartState, and delete each state as we go along.
///
///
internal void DeleteSubGraph (State state)
{
// Add initial state to DeleteStack.
Stack stateToProcess = new Stack (); // States to delete
Collection arcsToDelete = new Collection ();
Collection statesToDelete = new Collection ();
stateToProcess.Push (state);
// While there are still states on the listDelete (ToDo collection)
while (stateToProcess.Count > 0)
{
// For each transition from state,
state = stateToProcess.Pop ();
statesToDelete.Add (state);
arcsToDelete.Clear ();
// Accumulate the arcs to delete and add new states to the stack of states to process
foreach (Arc arc in state.OutArcs)
{
// Add EndState to listDelete, if unique
State endState = arc.End;
// Add this state to the list of states to delete
if (endState != null && !stateToProcess.Contains (endState) && !statesToDelete.Contains (endState))
{
stateToProcess.Push (endState);
}
arcsToDelete.Add (arc);
}
// Clear up the arcs
foreach (Arc arc in arcsToDelete)
{
arc.Start = arc.End = null;
}
}
foreach (State stateToDelete in statesToDelete)
{
// Delete state and remove from listDelete
System.Diagnostics.Debug.Assert (stateToDelete != null);
System.Diagnostics.Debug.Assert (stateToDelete.InArcs.IsEmpty);
System.Diagnostics.Debug.Assert (stateToDelete.OutArcs.IsEmpty);
DeleteState (stateToDelete);
}
}
///
/// Modify the placeholder rule attributes after it has been created.
/// This is only safe to use in the context of SRGSGrammarCompiler.
///
///
///
///
/// Set the path from which relative grammar imports are calculated. As specified by xml:base / meta base
/// Null or empty string will clear any existing base path.
///
///
internal void SetBasePath (string sBasePath)
{
if (!string.IsNullOrEmpty (sBasePath))
{
// Validate base path.
Uri uri = new Uri (sBasePath, UriKind.RelativeOrAbsolute);
//Url Canonicalized
_basePath = uri.ToString ();
}
else
{
_basePath = null;
}
}
///
/// Perform white space normalization in place.
/// - Trim leading/trailing white spaces.
/// - Collapse white space sequences to a single ' '.
///
///
///
/// Description:
/// Load compiled grammar data. This overwrites any existing data in the grammar
/// We end up with containers of words, symbols, rules, arcs, states and state handles, etc.
///
///
#if true
internal void InitFromBinaryGrammar (StreamMarshaler streamHelper)
{
//CfgGrammar.TraceInformation ("BackEnd::InitFromBinaryGrammar");
CfgGrammar.CfgHeader header = CfgGrammar.ConvertCfgHeader (streamHelper);
_words = header.pszWords;
_symbols = header.pszSymbols;
_grammarOptions = header.GrammarOptions;
//
// Build up the internal representation
//
State [] apStateTable = new State [header.arcs.Length];
SortedDictionary ruleFirstArcs = new SortedDictionary ();
//
// Initialize the rules
//
int previousCfgLastRules = _rules.Count;
BuildRulesFromBinaryGrammar (header, apStateTable, ruleFirstArcs, previousCfgLastRules);
//
// Initialize the arcs
//
Arc [] apArcTable = new Arc [header.arcs.Length];
bool fLastArcNull = true;
CfgArc pLastArc = new CfgArc ();
State currentState = null;
IEnumerator> ieFirstArcs = ruleFirstArcs.GetEnumerator ();
// If no rules, then we have no arcs
if (ieFirstArcs.MoveNext ())
{
KeyValuePair kvFirstArc = ieFirstArcs.Current;
Rule ruleCur = kvFirstArc.Value;
// We repersist the static AND dynamic parts for now. This allows the grammar to be queried
// with the automation interfaces
for (int k = 1; k < header.arcs.Length; k++)
{
CfgArc arc = header.arcs [k];
// Reset the Transition index based on the compbined stringblobs
if (arc.RuleRef)
{
// for a ruleref offset the rule index
ruleCur._listRules.Add (_rules [(int) arc.TransitionIndex]);
}
if (kvFirstArc.Key == k)
{
// we are entering a new rule now
ruleCur = kvFirstArc.Value;
// Reset to zero once we have read the last rule.
if (ieFirstArcs.MoveNext ())
{
kvFirstArc = ieFirstArcs.Current;
}
}
// new currentState?
if (fLastArcNull || pLastArc.LastArc)
{
if (apStateTable [k] == null)
{
uint hNewState = CfgGrammar.NextHandle;
apStateTable [k] = new State (ruleCur, hNewState, k);
AddState (apStateTable [k]);
}
currentState = apStateTable [k];
}
//
// now get the arc
//
int iNextArc = (int) (arc.NextStartArcIndex);
Arc newArc;
State targetState = null;
if (currentState != null && iNextArc != 0)
{
if (apStateTable [iNextArc] == null)
{
uint hNewState = CfgGrammar.NextHandle;
apStateTable [iNextArc] = new State (ruleCur, hNewState, iNextArc);
AddState (apStateTable [iNextArc]);
}
targetState = apStateTable [iNextArc];
}
float flWeight = header.weights != null ? header.weights [k] : CfgGrammar.DEFAULT_WEIGHT;
// determine properties of the arc now ...
if (arc.RuleRef)
{
Rule ruleToTransitionTo = _rules [(int) arc.TransitionIndex];
newArc = new Arc (null, ruleToTransitionTo, _words, flWeight, CfgGrammar.SP_NORMAL_CONFIDENCE, null, MatchMode.AllWords, ref _fNeedWeightTable);
}
else
{
int transitionIndex = (int) arc.TransitionIndex;
int ulSpecialTransitionIndex = (int) ((transitionIndex == CfgGrammar.SPWILDCARDTRANSITION || transitionIndex == CfgGrammar.SPDICTATIONTRANSITION || transitionIndex == CfgGrammar.SPTEXTBUFFERTRANSITION) ? transitionIndex : 0);
newArc = new Arc ((ulSpecialTransitionIndex != 0) ? 0 : (int) arc.TransitionIndex, flWeight, arc.LowConfRequired ? CfgGrammar.SP_LOW_CONFIDENCE : arc.HighConfRequired ? CfgGrammar.SP_HIGH_CONFIDENCE : CfgGrammar.SP_NORMAL_CONFIDENCE, ulSpecialTransitionIndex, MatchMode.AllWords, ref _fNeedWeightTable);
}
newArc.Start = currentState;
newArc.End = targetState;
AddArc (newArc);
apArcTable [k] = newArc;
fLastArcNull = false;
pLastArc = arc;
}
}
// Initialize the Semantics tags
for (int k = 1, iCurTag = 0; k < header.arcs.Length; k++)
{
CfgArc arc = header.arcs [k];
if (arc.HasSemanticTag)
{
System.Diagnostics.Debug.Assert (header.tags [iCurTag].StartArcIndex == k);
while (iCurTag < header.tags.Length && header.tags [iCurTag].StartArcIndex == k)
{
// we should already point to the tag
CfgSemanticTag semTag = header.tags [iCurTag];
Tag tag = new Tag (this, semTag);
_tags.Add (tag);
apArcTable [tag._cfgTag.StartArcIndex].AddStartTag (tag);
apArcTable [tag._cfgTag.EndArcIndex].AddEndTag (tag);
// If we have ms-properties than _nameOffset != overwise it is w3c tags.
if (semTag._nameOffset > 0)
{
tag._cfgTag._nameOffset = _symbols.OffsetFromId (_symbols.Find (_symbols.FromOffset (semTag._nameOffset)));
}
else
{
// The offset of the JScrip expression is stored in the value field.
tag._cfgTag._valueOffset = _symbols.OffsetFromId (_symbols.Find (_symbols.FromOffset (semTag._valueOffset)));
}
iCurTag++;
}
}
}
//
_fNeedWeightTable = true;
if (header.BasePath != null)
{
SetBasePath (header.BasePath);
}
_guid = header.GrammarGUID;
_langId = header.langId;
_grammarMode = header.GrammarMode;
_fLoadedFromBinary = true;
// Save Last ArcIndex
#if VSCOMPILE && DEBUG
DumpGrammarStatistics ("InitFromBinaryGrammar");
#endif
}
private Arc CreateTransition (string sWord, float flWeight, int requiredConfidence)
{
// epsilon transition for empty words
return AddSingleWordTransition (!string.IsNullOrEmpty (sWord) ? sWord : null, flWeight, requiredConfidence);
}
///
///
///
///
///
///
///
///
/// sortedStates, int cBasePath, UInt16 iSemanticGlobals, out int cArcs, out float [] pWeights)
{
cArcs = 1; // Start with offset one! (0 indicates dead state).
pWeights = null;
int cSemanticTags = 0;
int cLargest = 0;
foreach (State state in sortedStates)
{
// For new states 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.
state.SerializeId = cArcs;
int thisState = state.NumArcs;
#if DEBUG
if (thisState == 0 && state.InArcs.IsEmpty && state.Rule._cStates > 1)
{
XmlParser.ThrowSrgsException (SRID.StateWithNoArcs);
}
#endif
cArcs += thisState;
if (cLargest < thisState)
{
cLargest = thisState;
}
cSemanticTags += state.NumSemanticTags;
}
CfgGrammar.CfgSerializedHeader header = new CfgGrammar.CfgSerializedHeader ();
uint ulOffset = (uint) Marshal.SizeOf (typeof (CfgGrammar.CfgSerializedHeader));
header.FormatId = CfgGrammar._SPGDF_ContextFree;
_guid = Guid.NewGuid ();
header.GrammarGUID = _guid;
header.LangID = (UInt16) _langId;
header.pszSemanticInterpretationGlobals = iSemanticGlobals;
header.cArcsInLargestState = cLargest;
header.cchWords = _words.StringSize ();
header.cWords = _words.Count;
// For compat with SAPI 5.x add one to cWords if there's more than one word.
// The CFGEngine code assumes cWords includes the initial empty-string word.
// See PS 11491 and 61982.
if (header.cWords > 0)
{
header.cWords++;
}
header.pszWords = ulOffset;
ulOffset += (uint) _words.SerializeSize () * Helpers._sizeOfChar;
header.cchSymbols = _symbols.StringSize ();
header.pszSymbols = ulOffset;
ulOffset += (uint) _symbols.SerializeSize () * Helpers._sizeOfChar;
header.cRules = _rules.Count;
header.pRules = ulOffset;
ulOffset += (uint) (_rules.Count * Marshal.SizeOf (typeof (CfgRule)));
header.cBasePath = cBasePath > 0 ? ulOffset : 0; //If there is no base path offset is set to zero
ulOffset += (uint) (((int) cBasePath * Helpers._sizeOfChar + 3) & ~3);
header.cArcs = cArcs;
header.pArcs = ulOffset;
ulOffset += (uint) (cArcs * Marshal.SizeOf (typeof (CfgArc)));
if (_fNeedWeightTable)
{
header.pWeights = ulOffset;
ulOffset += (uint) (cArcs * Marshal.SizeOf (typeof (float)));
pWeights = new float [cArcs];
pWeights [0] = 0.0f;
}
else
{
header.pWeights = 0;
ulOffset += 0;
}
if (_rootRule != null)
{
//We have a root rule
header.ulRootRuleIndex = (uint) _rootRule._iSerialize;
}
else
{
//-1 means there is no root rule
header.ulRootRuleIndex = 0xFFFFFFFF;
}
header.GrammarOptions = _grammarOptions | ((_alphabet == AlphabetType.Sapi) ? 0 : GrammarOptions.IpaPhoneme);
#if !NO_STG
header.GrammarOptions |= _scriptRefs.Count > 0 ? GrammarOptions.STG | GrammarOptions.KeyValuePairSrgs : 0;
#endif
header.GrammarMode = (uint) _grammarMode;
header.cTags = cSemanticTags;
header.tags = ulOffset;
ulOffset += (uint) (cSemanticTags * Marshal.SizeOf (typeof (CfgSemanticTag)));
#if !NO_STG
header.cScripts = _scriptRefs.Count;
header.pScripts = header.cScripts > 0 ? ulOffset : 0;
ulOffset += (uint) (_scriptRefs.Count * Marshal.SizeOf (typeof (CfgScriptRef)));
header.cIL = _il != null ? _il.Length : 0;
header.pIL = header.cIL > 0 ? ulOffset : 0;
ulOffset += (uint) (header.cIL * Marshal.SizeOf (typeof (byte)));
header.cPDB = _pdb != null ? _pdb.Length : 0;
header.pPDB = header.cPDB > 0 ? ulOffset : 0;
ulOffset += (uint) (header.cPDB * Marshal.SizeOf (typeof (byte)));
#endif
header.ulTotalSerializedSize = ulOffset;
return header;
}
private CfgGrammar.CfgHeader BuildRulesFromBinaryGrammar (CfgGrammar.CfgHeader header, State [] apStateTable, SortedDictionary ruleFirstArcs, int previousCfgLastRules)
{
for (int i = 0; i < header.rules.Length; i++)
{
// Check if the rule does not exist already
CfgRule cfgRule = header.rules [i];
int firstArc = (int) cfgRule.FirstArcIndex;
cfgRule._nameOffset = _symbols.OffsetFromId (_symbols.Find (header.pszSymbols.FromOffset (cfgRule._nameOffset)));
Rule rule = new Rule (this, _symbols.FromOffset (cfgRule._nameOffset), cfgRule, i + previousCfgLastRules, _grammarOptions & GrammarOptions.TagFormat, ref _cImportedRules);
rule._firstState = _states.CreateNewState (rule);
_rules.Add (rule);
// Add the rule to the list of firstArc/rule
if (firstArc > 0)
{
ruleFirstArcs.Add ((int) cfgRule.FirstArcIndex, rule);
}
rule._fStaticRule = (cfgRule.Dynamic) ? false : true;
rule._cfgRule.DirtyRule = false;
// by default loaded static rules have an exist
rule._fHasExitPath = (rule._fStaticRule) ? true : false;
// or they wouldn't be there in the first place
if (firstArc != 0)
{
System.Diagnostics.Debug.Assert (apStateTable [firstArc] == null);
rule._firstState.SerializeId = (int) cfgRule.FirstArcIndex;
apStateTable [firstArc] = rule._firstState;
}
if (rule._cfgRule.HasResources)
{
throw new NotImplementedException ();
}
if (header.ulRootRuleIndex == i)
{
_rootRule = rule;
}
// Add rule to RuleListByName and RuleListByID hash tables.
if (rule._cfgRule._nameOffset != 0)
{
// Look for the rule in the original CFG and map it in the combined string blobs
_nameOffsetRules.Add (rule._cfgRule._nameOffset, rule);
}
}
return header;
}
#endif
private Rule CloneState (State srcToState, List CloneStack, Dictionary srcToDestHash)
{
bool newRule = false;
int posDynamic = srcToState.Rule.Name.IndexOf ("URL:DYNAMIC#", StringComparison.Ordinal);
string ruleName = posDynamic != 0 ? srcToState.Rule.Name : srcToState.Rule.Name.Substring (12);
Rule dstRule = FindInRules (ruleName);
// Clone this rule into this GrammarBuilder if it does not exist yet
if (dstRule == null)
{
dstRule = srcToState.Rule.Clone (_symbols, ruleName);
_rules.Add (dstRule);
newRule = true;
}
// Should not exist yet
System.Diagnostics.Debug.Assert (!srcToDestHash.ContainsKey (srcToState));
// push all the states for that rule
State newState = CreateNewState (dstRule);
srcToDestHash.Add (srcToState, newState);
CloneStack.Add (srcToState);
if (newRule)
{
dstRule._firstState = newState;
}
return dstRule;
}
private Rule FindInRules (string ruleName)
{
foreach (Rule rule in _rules)
{
if (rule.Name == ruleName)
{
return rule;
}
}
return null;
}
private static void LogError (string rule, SRID srid, params object [] args)
{
string sError = SR.Get (srid, args);
throw new FormatException (string.Format (CultureInfo.InvariantCulture, "Rule=\"{0}\" - ", rule) + sError);
}
///
/// Connect arc to the state graph.
///
///
#if DEBUG
private
#else
private static
#endif
void AddArc (Arc arc)
{
#if DEBUG
arc.Backend = this;
#endif
}
///
///
///
/// states)
{
bool fReachedEndState;
foreach (State state in states)
{
state.CheckLeftRecursion (out fReachedEndState);
}
}
///
///
///
///
///
///
private Arc AddSingleWordTransition (string s, float flWeight, int requiredConfidence)
{
//CfgGrammar.TraceInformation ("BackEnd::CGramComp::AddSingleWordTransition");
Arc arc = new Arc (s, null, _words, flWeight, requiredConfidence, null, MatchMode.AllWords, ref _fNeedWeightTable);
AddArc (arc);
return arc;
}
internal void AddState (State state)
{
_states.Add (state);
}
#if VSCOMPILE && DEBUG
///
internal void DumpStateTable (string sTitle)
{
List states = new List (_states);
DumpStateTable (sTitle, states.ToArray ());
}
internal void DumpStateTable (string sTitle, State [] states)
{
CfgGrammar.TraceInformation2 (sTitle);
int iHandle2 = 0;
for (int iState = 0; iState < states.Length; iState++)
{
State state = states [iState];
if (state == null)
{
continue;
}
//string s = state.OutArcs.Count > 0 ? state.OutArcs.First.WordId > 0 ? _words [state.OutArcs.First.WordId] : string.Empty : string.Empty;
string s = _symbols.FromOffset (state.Rule._cfgRule._nameOffset);
CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "{0}: {1} {2} {3} '", iHandle2, state.Id, state.SerializeId, s));
foreach (Arc arc2 in state.OutArcs)
{
int iWord = arc2.WordId;
string sWord = arc2.RuleRef != null ? _symbols.FromOffset (arc2.RuleRef._cfgRule._nameOffset) : iWord > 0 ? _words [iWord] : string.Empty;
//CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "{0}{1} [{2}]", (fFirst ? string.Empty : ", "), sWord, arc2.Id));
//if (arc2._tag != null)
//{
// CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "({0}, {1}, {2})", _symbols.FromOffset (arc2._tag._cfgTag._valueOffset), arc2._tag._startArc.Id, arc2._tag._endArc.Id));
//}
}
CfgGrammar.TraceInformation2 ("'");
}
}
internal void DumpStateMachine (TextWriter tw)
{
tw.WriteLine ("Word Blobs");
for (int i = 1; i < _words.Count; i++)
{
tw.WriteLine (" \"" + _words [i] + "\"");
}
tw.WriteLine ("\nSymbols Blobs");
for (int i = 1; i < _symbols.Count; i++)
{
tw.WriteLine (" \"" + _symbols [i] + "\"");
}
tw.WriteLine ("\nRules");
foreach (Rule rule in _rules)
{
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " \"{0}\" id: {1} flags: {2}", rule.Name, rule._cfgRule._id, rule._cfgRule._flag.ToString ("x", CultureInfo.InvariantCulture)));
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " States: {0}", rule._cStates));
}
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, "\nStates:\n Count: {0}", _states.Count));
foreach (State state in _states)
{
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " \"{0}\"", state.Rule.Name));
}
}
//GrammarOptimization
///
/// Dump grammar statistics to debug window. (Debug only)
///
///
void DumpGrammarStatistics (string title)
{
int iNumStates = 0;
int iNumArcs = 0;
int iNumEpsilonArcs = 0;
int iMaxBranch = 0;
int iNumProperties = 0;
foreach (State state in _states)
{
iNumStates++;
int cArcs = 0;
foreach (Arc arc in state.OutArcs)
{
cArcs++;
if (arc.IsEpsilonTransition)
{
iNumEpsilonArcs++;
}
//if (arc._tag != null)
//{
// iNumProperties++;
//}
}
if (iMaxBranch < cArcs)
iMaxBranch = cArcs;
iNumArcs += cArcs;
}
Console.WriteLine (title);
Console.WriteLine (string.Format (CultureInfo.InvariantCulture, "{0}\n NumStates = {0}\n NumArcs = {1}\n NumEpsilons = {2}\n", iNumStates, iNumArcs, iNumEpsilonArcs));
Console.WriteLine (string.Format (CultureInfo.InvariantCulture, " MaxBranch = {0}\n" + " NumProperties = {1}\n", iMaxBranch, iNumProperties));
}
#endif
#endregion
//*******************************************************************
//
// Internal Properties
//
//*******************************************************************
#region Internal Properties
internal int LangId
{
get
{
return _langId;
}
set
{
_langId = value;
}
}
internal GrammarOptions GrammarOptions
{
get
{
return _grammarOptions;
}
set
{
_grammarOptions = value;
}
}
internal GrammarType GrammarMode
{
set
{
_grammarMode = value;
}
}
internal AlphabetType Alphabet
{
set
{
_alphabet = value;
}
get
{
return _alphabet;
}
}
internal Collection GlobalTags
{
get
{
return _globalTags;
}
set
{
_globalTags = value;
}
}
#if !NO_STG
internal Collection ScriptRefs
{
set
{
_scriptRefs = value;
}
}
internal byte [] IL
{
set
{
_il = value;
}
}
internal byte [] PDB
{
set
{
_pdb = value;
}
}
#endif
#endregion
//*******************************************************************
//
// Private Fields
//
//********************************************************************
#region Private Fields
private int _langId = CultureInfo.CurrentUICulture.LCID;
private StringBlob _words;
private StringBlob _symbols;
//private int _cResources;
private Guid _guid;
private bool _fNeedWeightTable;
private Graph _states = new Graph ();
private List _rules = new List ();
private int _ruleIndex;
private Dictionary _nameOffsetRules = new Dictionary ();
private Rule _rootRule;
#if !SPEECHSERVER
private GrammarOptions _grammarOptions = GrammarOptions.KeyValuePairs;
#else
private GrammarOptions _grammarOptions = GrammarOptions.W3cV1;
#endif
// It is used sequentially. So there is no thread issue
private int _ulRecursiveDepth;
// Path from which relative grammar imports are calculated. As specified by xml:base
private string _basePath;
// Collection of all SemanticTags in the grammar (sorted by StartArc)
private List _tags = new List ();
// Voice or DTMF
private GrammarType _grammarMode = GrammarType.VoiceGrammar;
// Pron information is either IPA or SAPI
private AlphabetType _alphabet = AlphabetType.Sapi;
// Global value for the semantic interpretation tags
private Collection _globalTags = new Collection ();
//
private static byte [] _abZero3 = new byte [] { 0, 0, 0 };
private static char [] _achZero = new char [] { '\0' };
//
private const uint SPGF_RESET_DIRTY_FLAG = 0x80000000;
private int _cImportedRules;
#if !NO_STG
// List of cd /reference Rule->rule 'on'method-> .Net method
private Collection _scriptRefs = new Collection ();
// Grammar code assembly
private byte [] _il;
// Grammar debug symbols
private byte [] _pdb;
#endif
private bool _fLoadedFromBinary;
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Description:
// CFG Grammar backend
//
// History:
// 5/1/2004 jeanfp Created from the Sapi Managed code
//-----------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;
using System.IO;
using System.Speech.Internal.SrgsParser;
namespace System.Speech.Internal.SrgsCompiler
{
///
/// Summary description for GrammarBackEnd.
///
internal sealed partial class Backend
{
//*******************************************************************
//
// Constructors
//
//*******************************************************************
#region Constructors
internal Backend ()
{
_words = new StringBlob ();
_symbols = new StringBlob ();
}
internal Backend (StreamMarshaler streamHelper)
{
InitFromBinaryGrammar (streamHelper);
}
#endregion
//********************************************************************
//
// Internal Methods
//
//*******************************************************************
#region Internal Methods
///
/// Optimizes the grammar network by removing the epsilon states and merging
/// duplicate transitions. See GrammarOptimization.doc for details.
///
internal void Optimize ()
{
//DumpGrammarStatistics ("GrammarOptimization: Pre optimize");
_states.Optimize ();
//DumpGrammarStatistics ("GrammarOptimization: Post optimize");
// Most likely, there will be an arc with a weight != 1. So we need a weight table.
_fNeedWeightTable = true;
}
///
/// Performs consistency checks of the grammar structure, creates the
/// serialized format and either saves it to the stream provided by SetSaveOptions,
/// or reloads it into the CFG engine.
///
///
internal void Commit (StreamMarshaler streamBuffer)
{
// For debugging purpose, assert if the position is not it is assumed it should be
// Keep the start position in the stream
long startStreamPostion = streamBuffer.Stream.Position;
// put all states State into a sorted array by rule parent index and serialized index
List sortedStates = new List (_states);
// Release the memory for the original list of states
_states = null;
sortedStates.Sort ();
// Validate the grammar
ValidateAndTagRules ();
CheckLeftRecursion (sortedStates);
// Include null terminator
int cBasePath = _basePath != null ? _basePath.Length + 1 : 0;
float [] pWeights;
int cArcs;
// Add the top level semantic interpreatation tag
// This should be set as the first symbol in the symbol string blog since it must hold on a 16 bits value.
int semanticInterpretationGlobals = 0;
if (_globalTags.Count > 0)
{
StringBuilder sb = new StringBuilder ();
foreach (string s in _globalTags)
{
sb.Append (s);
}
_symbols.Add (sb.ToString (), out semanticInterpretationGlobals);
semanticInterpretationGlobals = _symbols.OffsetFromId (semanticInterpretationGlobals);
if (semanticInterpretationGlobals > UInt16.MaxValue)
{
throw new OverflowException (SR.Get (SRID.TooManyRulesWithSemanticsGlobals));
}
}
#if !NO_STG
// Write the method names as symbols
foreach (ScriptRef script in _scriptRefs)
{
_symbols.Add (script._sMethod, out script._idSymbol);
}
#endif
// get the header
CfgGrammar.CfgSerializedHeader header = BuildHeader (sortedStates, cBasePath, unchecked ((UInt16) semanticInterpretationGlobals), out cArcs, out pWeights);
streamBuffer.WriteStream (header);
//
// For the string blobs, we must explicitly report I/O error since the blobs don't
// use the error log facility.
//
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pszWords);
streamBuffer.WriteArrayChar (_words.SerializeData (), _words.SerializeSize ());
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pszSymbols);
streamBuffer.WriteArrayChar (_symbols.SerializeData (), _symbols.SerializeSize ());
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pRules);
foreach (Rule rule in _rules)
{
rule.Serialize (streamBuffer);
}
if (cBasePath > 0)
{
streamBuffer.WriteArrayChar (_basePath.ToCharArray (), _basePath.Length);
// Add a zero to be compatible with SAPI 5
System.Diagnostics.Debug.Assert (_basePath.Length + 1 == cBasePath);
streamBuffer.WriteArrayChar (_achZero, 1);
// Zero-pad to align following structures
streamBuffer.WriteArray (_abZero3, cBasePath * Helpers._sizeOfChar & 3);
}
//
// Write a dummy 0 index state entry
//
CfgArc dummyArc = new CfgArc ();
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pArcs);
streamBuffer.WriteStream (dummyArc);
int ulWeightOffset = 1;
uint arcOffset = 1;
bool semanticInterpretation = (GrammarOptions & GrammarOptions.MssV1) == GrammarOptions.MssV1;
foreach (State state in sortedStates)
{
state.SerializeStateEntries (streamBuffer, semanticInterpretation, pWeights, ref arcOffset, ref ulWeightOffset);
}
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.pWeights);
if (_fNeedWeightTable)
{
streamBuffer.WriteArray (pWeights, cArcs);
}
System.Diagnostics.Debug.Assert (streamBuffer.Stream.Position - startStreamPostion == header.tags);
if (!semanticInterpretation)
{
foreach (State state in sortedStates)
{
state.SetEndArcIndexForTags ();
}
}
// Remove the orphaned arcs
// This could happen in the case of a -
for (int i = _tags.Count - 1; i >= 0; i--)
{
// When arc are created the index is set to zero. This value changes during serialization
// if an arc references it
if (_tags [i]._cfgTag.ArcIndex == 0)
{
_tags.RemoveAt (i);
}
}
// Sort the _tags array by ArcIndex
_tags.Sort ();
// Write the _tags array
foreach (Tag tag in _tags)
{
tag.Serialize (streamBuffer);
}
#if !NO_STG
// Write the script references and the IL write after the header so getting it for the grammar
// Does not require a seek to the end of the file
System.Diagnostics.Debug.Assert (header.pScripts == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pScripts);
foreach (ScriptRef script in _scriptRefs)
{
script.Serialize (_symbols, streamBuffer);
}
// Write the assembly bits
System.Diagnostics.Debug.Assert (header.pIL == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pIL);
if (_il != null && _il.Length > 0)
{
streamBuffer.Stream.Write (_il, 0, _il.Length);
}
System.Diagnostics.Debug.Assert (header.pPDB == 0 || streamBuffer.Stream.Position - startStreamPostion == header.pPDB);
if (_pdb != null && _pdb.Length > 0)
{
streamBuffer.Stream.Write (_pdb, 0, _pdb.Length);
}
#endif
}
///
/// Description:
/// Combine the current data in a grammar with one comming from a CFG
///
///
///
///
internal static Backend CombineGrammar (string ruleName, Backend org, Backend extra)
{
//
Backend be = new Backend ();
be._fLoadedFromBinary = true;
be._fNeedWeightTable = org._fNeedWeightTable;
be._grammarMode = org._grammarMode;
be._grammarOptions = org._grammarOptions;
// Hash source state to destination state
Dictionary srcToDestHash = new Dictionary ();
// Find the rule
foreach (Rule orgRule in org._rules)
{
if (orgRule.Name == ruleName)
{
be.CloneSubGraph (orgRule, org, extra, srcToDestHash, true);
}
}
return be;
}
internal State CreateNewState (Rule rule)
{
return _states.CreateNewState (rule);
}
internal void DeleteState (State state)
{
_states.DeleteState (state);
}
internal void MoveInputTransitionsAndDeleteState (State from, State to)
{
_states.MoveInputTransitionsAndDeleteState (from, to);
}
internal void MoveOutputTransitionsAndDeleteState (State from, State to)
{
_states.MoveOutputTransitionsAndDeleteState (from, to);
}
///
/// Tries to find the rule's initial state handle. If both a name and an id
/// are provided, then both have to match in order for this call to succeed.
/// If the rule doesn't already exist then we define it if fCreateIfNotExists,
/// otherwise we return an error ().
///
/// - pszRuleName name of rule to find/define (null: don't care)
/// - ruleId id of rule to find/define (0: don't care)
/// - dwAttribute rule attribute for defining the rule
/// - fCreateIfNotExists creates the rule using name, id, and attributes
/// in case the rule doesn't already exist
///
/// throws:
/// S_OK, E_INVALIDARG, E_OUTOFMEMORY
/// SPERR_RULE_NOT_FOUND -- no rule found and we don't create a new one
/// SPERR_RULE_NAME_ID_CONFLICT -- rule name and id don't match
///
///
///
///
/// Internal method for finding rule in rule list
///
///
///
/// Adds a word transition from hFromState to hToState. If hToState == null
/// then the arc will be to the (implicit) terminal state. If psz == null then
/// we add an epsilon transition. Properties are pushed back to the
/// first un-ambiguous arc in case we can share a common initial state path.
/// The weight will be placed on the first arc (if there exists an arc with
/// the same word but different weight we will create a new arc).
///
internal Arc WordTransition (string sWord, float flWeight, int requiredConfidence)
{
return CreateTransition (sWord, flWeight, requiredConfidence);
}
internal Arc SubsetTransition (string text, MatchMode matchMode)
{
// Performs white space normalization in place
text = NormalizeTokenWhiteSpace (text);
return new Arc (text, null, _words, 1.0f, CfgGrammar.SP_NORMAL_CONFIDENCE, null, matchMode, ref _fNeedWeightTable);
}
///
/// Adds a rule (reference) transition from hFromState to hToState.
/// hRule can also be one of these special transition handles:
/// SPRULETRANS_WILDCARD : "WILDCARD" transition
/// SPRULETRANS_DICTATION : single word from dictation
/// SPRULETRANS_TEXTBUFFER : "TEXTBUFFER" transition
///
/// must be initial state of rule
/// Rule calling the ruleref
///
internal Arc RuleTransition (Rule rule, Rule parentRule, float flWeight)
{
//CfgGrammar.TraceInformation ("BackEnd::AddRuleTransition");
Rule ruleToTransitionTo = null;
if (flWeight < 0.0f)
{
XmlParser.ThrowSrgsException (SRID.UnsupportedFormat);
}
Rule specialRuleTrans = null;
if (rule == CfgGrammar.SPRULETRANS_WILDCARD || rule == CfgGrammar.SPRULETRANS_DICTATION || rule == CfgGrammar.SPRULETRANS_TEXTBUFFER)
{
specialRuleTrans = rule;
}
else
{
ruleToTransitionTo = rule;
}
bool fNeedWeightTable = false;
Arc arc = new Arc (null, ruleToTransitionTo, _words, flWeight, '\0', specialRuleTrans, MatchMode.AllWords, ref fNeedWeightTable);
AddArc (arc);
if (ruleToTransitionTo != null && parentRule != null)
{
ruleToTransitionTo._listRules.Insert (0, parentRule);
}
return arc;
}
///
/// Adds a word transition from hFromState to hToState. If hToState == null
/// then the arc will be to the (implicit) terminal state. If psz == null then
/// we add an epsilon transition. Properties are pushed back to the
/// first un-ambiguous arc in case we can share a common initial state path.
/// The weight will be placed on the first arc (if there exists an arc with
/// the same word but different weight we will create a new arc).
///
///
///
/// Traverse the graph starting from SrcStartState, cloning each state as we go along,
/// cloning each transition except ones originating from SrcEndState, and return
/// the cloned state corresponding to SrcEndState.
///
///
///
///
/// SrcToDestHash = new Dictionary (); // Hash source state to destination state
Stack CloneStack = new Stack (); // States to process
Dictionary tags = new Dictionary ();
// Add initial state to CloneStack and SrcToDestHash.
SrcToDestHash.Add (srcFromState, destFromState);
CloneStack.Push (srcFromState);
// While there are still states on the CloneStack (ToDo collection)
while (CloneStack.Count > 0)
{
srcFromState = CloneStack.Pop ();
destFromState = SrcToDestHash [srcFromState];
System.Diagnostics.Debug.Assert (destFromState != null);
// For each transition from srcFromState (except SrcEndState)
foreach (Arc arc in srcFromState.OutArcs)
{
// - Lookup the DestToState corresponding to SrcToState
State srcToState = arc.End;
State destToState = null;
if (srcToState != null)
{
// - If not found, clone a new DestToState, add SrcToState.DestToState to SrcToDestHash, and add SrcToState to CloneStack.
if (!SrcToDestHash.ContainsKey (srcToState))
{
destToState = CreateNewState (srcToState.Rule);
SrcToDestHash.Add (srcToState, destToState);
CloneStack.Push (srcToState);
}
else
{
destToState = SrcToDestHash [srcToState]; ;
}
}
// - Clone the transition from SrcFromState.SrcToState at DestFromState.DestToState
// -- Clone Arc
Arc newArc = new Arc (arc, destFromState, destToState);
AddArc (newArc);
// -- Clone SemanticTag
newArc.CloneTags (arc, _tags, tags, null);
// -- Add Arc
newArc.ConnectStates ();
}
}
System.Diagnostics.Debug.Assert (tags.Count == 0);
return SrcToDestHash [srcEndState];
}
///
/// Traverse the graph starting from SrcStartState, cloning each state as we go along,
/// cloning each transition except ones originating from SrcEndState, and return
/// the cloned state corresponding to SrcEndState.
///
///
///
///
///
///
/// srcToDestHash, bool fromOrg)
{
Backend beSrc = fromOrg ? org : extra;
List CloneStack = new List (); // States to process
Dictionary tags = new Dictionary ();
// Push all the state for the top level rule
CloneState (rule._firstState, CloneStack, srcToDestHash);
// While there are still states on the CloneStack (ToDo collection)
while (CloneStack.Count > 0)
{
State srcFromState = CloneStack [0];
CloneStack.RemoveAt (0);
State destFromState = srcToDestHash [srcFromState];
// For each transition from srcFromState (except SrcEndState)
foreach (Arc arc in srcFromState.OutArcs)
{
// - Lookup the DestToState corresponding to SrcToState
State srcToState = arc.End;
State destToState = null;
if (srcToState != null)
{
if (!srcToDestHash.ContainsKey (srcToState))
{
// - If not found, then it is a new rule, just clown it.
CloneState (srcToState, CloneStack, srcToDestHash);
}
destToState = srcToDestHash [srcToState];
}
// - Clone the transition from SrcFromState.SrcToState at DestFromState.DestToState
// -- Clone Arc
int newWordId = arc.WordId;
if (beSrc != null && arc.WordId > 0)
{
_words.Add (beSrc.Words [arc.WordId], out newWordId);
}
Arc newArc = new Arc (arc, destFromState, destToState, newWordId);
// -- Clone SemanticTag
newArc.CloneTags (arc, _tags, tags, this);
// For rule ref push the first state of the ruleref
if (arc.RuleRef != null)
{
string ruleName;
// Check for DYNAMIC grammars
if (arc.RuleRef.Name.IndexOf ("URL:DYNAMIC#", StringComparison.Ordinal) == 0)
{
ruleName = arc.RuleRef.Name.Substring (12);
if (fromOrg == true && FindInRules (ruleName) == null)
{
Rule ruleExtra = extra.FindInRules (ruleName);
if (ruleExtra == null)
{
XmlParser.ThrowSrgsException (SRID.DynamicRuleNotFound, ruleName);
}
CloneSubGraph (ruleExtra, org, extra, srcToDestHash, false);
}
}
else if (arc.RuleRef.Name.IndexOf ("URL:STATIC#", StringComparison.Ordinal) == 0)
{
ruleName = arc.RuleRef.Name.Substring (11);
if (fromOrg == false && FindInRules (ruleName) == null)
{
Rule ruleOrg = org.FindInRules (ruleName);
if (ruleOrg == null)
{
XmlParser.ThrowSrgsException (SRID.DynamicRuleNotFound, ruleName);
}
CloneSubGraph (ruleOrg, org, extra, srcToDestHash, true);
}
}
else
{
ruleName = arc.RuleRef.Name;
Rule ruleExtra = org.FindInRules (ruleName);
if (fromOrg == false)
{
CloneSubGraph (arc.RuleRef, org, extra, srcToDestHash, true);
}
}
Rule refRule = FindInRules (ruleName);
if (refRule == null)
{
refRule = CloneState (arc.RuleRef._firstState, CloneStack, srcToDestHash);
}
newArc.RuleRef = refRule;
}
// -- Add Arc
newArc.ConnectStates ();
}
}
System.Diagnostics.Debug.Assert (tags.Count == 0);
}
///
/// Delete disconnected subgraph starting at hState.
/// Traverse the graph starting from SrcStartState, and delete each state as we go along.
///
///
internal void DeleteSubGraph (State state)
{
// Add initial state to DeleteStack.
Stack stateToProcess = new Stack (); // States to delete
Collection arcsToDelete = new Collection ();
Collection statesToDelete = new Collection ();
stateToProcess.Push (state);
// While there are still states on the listDelete (ToDo collection)
while (stateToProcess.Count > 0)
{
// For each transition from state,
state = stateToProcess.Pop ();
statesToDelete.Add (state);
arcsToDelete.Clear ();
// Accumulate the arcs to delete and add new states to the stack of states to process
foreach (Arc arc in state.OutArcs)
{
// Add EndState to listDelete, if unique
State endState = arc.End;
// Add this state to the list of states to delete
if (endState != null && !stateToProcess.Contains (endState) && !statesToDelete.Contains (endState))
{
stateToProcess.Push (endState);
}
arcsToDelete.Add (arc);
}
// Clear up the arcs
foreach (Arc arc in arcsToDelete)
{
arc.Start = arc.End = null;
}
}
foreach (State stateToDelete in statesToDelete)
{
// Delete state and remove from listDelete
System.Diagnostics.Debug.Assert (stateToDelete != null);
System.Diagnostics.Debug.Assert (stateToDelete.InArcs.IsEmpty);
System.Diagnostics.Debug.Assert (stateToDelete.OutArcs.IsEmpty);
DeleteState (stateToDelete);
}
}
///
/// Modify the placeholder rule attributes after it has been created.
/// This is only safe to use in the context of SRGSGrammarCompiler.
///
///
///
///
/// Set the path from which relative grammar imports are calculated. As specified by xml:base / meta base
/// Null or empty string will clear any existing base path.
///
///
internal void SetBasePath (string sBasePath)
{
if (!string.IsNullOrEmpty (sBasePath))
{
// Validate base path.
Uri uri = new Uri (sBasePath, UriKind.RelativeOrAbsolute);
//Url Canonicalized
_basePath = uri.ToString ();
}
else
{
_basePath = null;
}
}
///
/// Perform white space normalization in place.
/// - Trim leading/trailing white spaces.
/// - Collapse white space sequences to a single ' '.
///
///
///
/// Description:
/// Load compiled grammar data. This overwrites any existing data in the grammar
/// We end up with containers of words, symbols, rules, arcs, states and state handles, etc.
///
///
#if true
internal void InitFromBinaryGrammar (StreamMarshaler streamHelper)
{
//CfgGrammar.TraceInformation ("BackEnd::InitFromBinaryGrammar");
CfgGrammar.CfgHeader header = CfgGrammar.ConvertCfgHeader (streamHelper);
_words = header.pszWords;
_symbols = header.pszSymbols;
_grammarOptions = header.GrammarOptions;
//
// Build up the internal representation
//
State [] apStateTable = new State [header.arcs.Length];
SortedDictionary ruleFirstArcs = new SortedDictionary ();
//
// Initialize the rules
//
int previousCfgLastRules = _rules.Count;
BuildRulesFromBinaryGrammar (header, apStateTable, ruleFirstArcs, previousCfgLastRules);
//
// Initialize the arcs
//
Arc [] apArcTable = new Arc [header.arcs.Length];
bool fLastArcNull = true;
CfgArc pLastArc = new CfgArc ();
State currentState = null;
IEnumerator> ieFirstArcs = ruleFirstArcs.GetEnumerator ();
// If no rules, then we have no arcs
if (ieFirstArcs.MoveNext ())
{
KeyValuePair kvFirstArc = ieFirstArcs.Current;
Rule ruleCur = kvFirstArc.Value;
// We repersist the static AND dynamic parts for now. This allows the grammar to be queried
// with the automation interfaces
for (int k = 1; k < header.arcs.Length; k++)
{
CfgArc arc = header.arcs [k];
// Reset the Transition index based on the compbined stringblobs
if (arc.RuleRef)
{
// for a ruleref offset the rule index
ruleCur._listRules.Add (_rules [(int) arc.TransitionIndex]);
}
if (kvFirstArc.Key == k)
{
// we are entering a new rule now
ruleCur = kvFirstArc.Value;
// Reset to zero once we have read the last rule.
if (ieFirstArcs.MoveNext ())
{
kvFirstArc = ieFirstArcs.Current;
}
}
// new currentState?
if (fLastArcNull || pLastArc.LastArc)
{
if (apStateTable [k] == null)
{
uint hNewState = CfgGrammar.NextHandle;
apStateTable [k] = new State (ruleCur, hNewState, k);
AddState (apStateTable [k]);
}
currentState = apStateTable [k];
}
//
// now get the arc
//
int iNextArc = (int) (arc.NextStartArcIndex);
Arc newArc;
State targetState = null;
if (currentState != null && iNextArc != 0)
{
if (apStateTable [iNextArc] == null)
{
uint hNewState = CfgGrammar.NextHandle;
apStateTable [iNextArc] = new State (ruleCur, hNewState, iNextArc);
AddState (apStateTable [iNextArc]);
}
targetState = apStateTable [iNextArc];
}
float flWeight = header.weights != null ? header.weights [k] : CfgGrammar.DEFAULT_WEIGHT;
// determine properties of the arc now ...
if (arc.RuleRef)
{
Rule ruleToTransitionTo = _rules [(int) arc.TransitionIndex];
newArc = new Arc (null, ruleToTransitionTo, _words, flWeight, CfgGrammar.SP_NORMAL_CONFIDENCE, null, MatchMode.AllWords, ref _fNeedWeightTable);
}
else
{
int transitionIndex = (int) arc.TransitionIndex;
int ulSpecialTransitionIndex = (int) ((transitionIndex == CfgGrammar.SPWILDCARDTRANSITION || transitionIndex == CfgGrammar.SPDICTATIONTRANSITION || transitionIndex == CfgGrammar.SPTEXTBUFFERTRANSITION) ? transitionIndex : 0);
newArc = new Arc ((ulSpecialTransitionIndex != 0) ? 0 : (int) arc.TransitionIndex, flWeight, arc.LowConfRequired ? CfgGrammar.SP_LOW_CONFIDENCE : arc.HighConfRequired ? CfgGrammar.SP_HIGH_CONFIDENCE : CfgGrammar.SP_NORMAL_CONFIDENCE, ulSpecialTransitionIndex, MatchMode.AllWords, ref _fNeedWeightTable);
}
newArc.Start = currentState;
newArc.End = targetState;
AddArc (newArc);
apArcTable [k] = newArc;
fLastArcNull = false;
pLastArc = arc;
}
}
// Initialize the Semantics tags
for (int k = 1, iCurTag = 0; k < header.arcs.Length; k++)
{
CfgArc arc = header.arcs [k];
if (arc.HasSemanticTag)
{
System.Diagnostics.Debug.Assert (header.tags [iCurTag].StartArcIndex == k);
while (iCurTag < header.tags.Length && header.tags [iCurTag].StartArcIndex == k)
{
// we should already point to the tag
CfgSemanticTag semTag = header.tags [iCurTag];
Tag tag = new Tag (this, semTag);
_tags.Add (tag);
apArcTable [tag._cfgTag.StartArcIndex].AddStartTag (tag);
apArcTable [tag._cfgTag.EndArcIndex].AddEndTag (tag);
// If we have ms-properties than _nameOffset != overwise it is w3c tags.
if (semTag._nameOffset > 0)
{
tag._cfgTag._nameOffset = _symbols.OffsetFromId (_symbols.Find (_symbols.FromOffset (semTag._nameOffset)));
}
else
{
// The offset of the JScrip expression is stored in the value field.
tag._cfgTag._valueOffset = _symbols.OffsetFromId (_symbols.Find (_symbols.FromOffset (semTag._valueOffset)));
}
iCurTag++;
}
}
}
//
_fNeedWeightTable = true;
if (header.BasePath != null)
{
SetBasePath (header.BasePath);
}
_guid = header.GrammarGUID;
_langId = header.langId;
_grammarMode = header.GrammarMode;
_fLoadedFromBinary = true;
// Save Last ArcIndex
#if VSCOMPILE && DEBUG
DumpGrammarStatistics ("InitFromBinaryGrammar");
#endif
}
private Arc CreateTransition (string sWord, float flWeight, int requiredConfidence)
{
// epsilon transition for empty words
return AddSingleWordTransition (!string.IsNullOrEmpty (sWord) ? sWord : null, flWeight, requiredConfidence);
}
///
///
///
///
///
///
///
///
/// sortedStates, int cBasePath, UInt16 iSemanticGlobals, out int cArcs, out float [] pWeights)
{
cArcs = 1; // Start with offset one! (0 indicates dead state).
pWeights = null;
int cSemanticTags = 0;
int cLargest = 0;
foreach (State state in sortedStates)
{
// For new states 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.
state.SerializeId = cArcs;
int thisState = state.NumArcs;
#if DEBUG
if (thisState == 0 && state.InArcs.IsEmpty && state.Rule._cStates > 1)
{
XmlParser.ThrowSrgsException (SRID.StateWithNoArcs);
}
#endif
cArcs += thisState;
if (cLargest < thisState)
{
cLargest = thisState;
}
cSemanticTags += state.NumSemanticTags;
}
CfgGrammar.CfgSerializedHeader header = new CfgGrammar.CfgSerializedHeader ();
uint ulOffset = (uint) Marshal.SizeOf (typeof (CfgGrammar.CfgSerializedHeader));
header.FormatId = CfgGrammar._SPGDF_ContextFree;
_guid = Guid.NewGuid ();
header.GrammarGUID = _guid;
header.LangID = (UInt16) _langId;
header.pszSemanticInterpretationGlobals = iSemanticGlobals;
header.cArcsInLargestState = cLargest;
header.cchWords = _words.StringSize ();
header.cWords = _words.Count;
// For compat with SAPI 5.x add one to cWords if there's more than one word.
// The CFGEngine code assumes cWords includes the initial empty-string word.
// See PS 11491 and 61982.
if (header.cWords > 0)
{
header.cWords++;
}
header.pszWords = ulOffset;
ulOffset += (uint) _words.SerializeSize () * Helpers._sizeOfChar;
header.cchSymbols = _symbols.StringSize ();
header.pszSymbols = ulOffset;
ulOffset += (uint) _symbols.SerializeSize () * Helpers._sizeOfChar;
header.cRules = _rules.Count;
header.pRules = ulOffset;
ulOffset += (uint) (_rules.Count * Marshal.SizeOf (typeof (CfgRule)));
header.cBasePath = cBasePath > 0 ? ulOffset : 0; //If there is no base path offset is set to zero
ulOffset += (uint) (((int) cBasePath * Helpers._sizeOfChar + 3) & ~3);
header.cArcs = cArcs;
header.pArcs = ulOffset;
ulOffset += (uint) (cArcs * Marshal.SizeOf (typeof (CfgArc)));
if (_fNeedWeightTable)
{
header.pWeights = ulOffset;
ulOffset += (uint) (cArcs * Marshal.SizeOf (typeof (float)));
pWeights = new float [cArcs];
pWeights [0] = 0.0f;
}
else
{
header.pWeights = 0;
ulOffset += 0;
}
if (_rootRule != null)
{
//We have a root rule
header.ulRootRuleIndex = (uint) _rootRule._iSerialize;
}
else
{
//-1 means there is no root rule
header.ulRootRuleIndex = 0xFFFFFFFF;
}
header.GrammarOptions = _grammarOptions | ((_alphabet == AlphabetType.Sapi) ? 0 : GrammarOptions.IpaPhoneme);
#if !NO_STG
header.GrammarOptions |= _scriptRefs.Count > 0 ? GrammarOptions.STG | GrammarOptions.KeyValuePairSrgs : 0;
#endif
header.GrammarMode = (uint) _grammarMode;
header.cTags = cSemanticTags;
header.tags = ulOffset;
ulOffset += (uint) (cSemanticTags * Marshal.SizeOf (typeof (CfgSemanticTag)));
#if !NO_STG
header.cScripts = _scriptRefs.Count;
header.pScripts = header.cScripts > 0 ? ulOffset : 0;
ulOffset += (uint) (_scriptRefs.Count * Marshal.SizeOf (typeof (CfgScriptRef)));
header.cIL = _il != null ? _il.Length : 0;
header.pIL = header.cIL > 0 ? ulOffset : 0;
ulOffset += (uint) (header.cIL * Marshal.SizeOf (typeof (byte)));
header.cPDB = _pdb != null ? _pdb.Length : 0;
header.pPDB = header.cPDB > 0 ? ulOffset : 0;
ulOffset += (uint) (header.cPDB * Marshal.SizeOf (typeof (byte)));
#endif
header.ulTotalSerializedSize = ulOffset;
return header;
}
private CfgGrammar.CfgHeader BuildRulesFromBinaryGrammar (CfgGrammar.CfgHeader header, State [] apStateTable, SortedDictionary ruleFirstArcs, int previousCfgLastRules)
{
for (int i = 0; i < header.rules.Length; i++)
{
// Check if the rule does not exist already
CfgRule cfgRule = header.rules [i];
int firstArc = (int) cfgRule.FirstArcIndex;
cfgRule._nameOffset = _symbols.OffsetFromId (_symbols.Find (header.pszSymbols.FromOffset (cfgRule._nameOffset)));
Rule rule = new Rule (this, _symbols.FromOffset (cfgRule._nameOffset), cfgRule, i + previousCfgLastRules, _grammarOptions & GrammarOptions.TagFormat, ref _cImportedRules);
rule._firstState = _states.CreateNewState (rule);
_rules.Add (rule);
// Add the rule to the list of firstArc/rule
if (firstArc > 0)
{
ruleFirstArcs.Add ((int) cfgRule.FirstArcIndex, rule);
}
rule._fStaticRule = (cfgRule.Dynamic) ? false : true;
rule._cfgRule.DirtyRule = false;
// by default loaded static rules have an exist
rule._fHasExitPath = (rule._fStaticRule) ? true : false;
// or they wouldn't be there in the first place
if (firstArc != 0)
{
System.Diagnostics.Debug.Assert (apStateTable [firstArc] == null);
rule._firstState.SerializeId = (int) cfgRule.FirstArcIndex;
apStateTable [firstArc] = rule._firstState;
}
if (rule._cfgRule.HasResources)
{
throw new NotImplementedException ();
}
if (header.ulRootRuleIndex == i)
{
_rootRule = rule;
}
// Add rule to RuleListByName and RuleListByID hash tables.
if (rule._cfgRule._nameOffset != 0)
{
// Look for the rule in the original CFG and map it in the combined string blobs
_nameOffsetRules.Add (rule._cfgRule._nameOffset, rule);
}
}
return header;
}
#endif
private Rule CloneState (State srcToState, List CloneStack, Dictionary srcToDestHash)
{
bool newRule = false;
int posDynamic = srcToState.Rule.Name.IndexOf ("URL:DYNAMIC#", StringComparison.Ordinal);
string ruleName = posDynamic != 0 ? srcToState.Rule.Name : srcToState.Rule.Name.Substring (12);
Rule dstRule = FindInRules (ruleName);
// Clone this rule into this GrammarBuilder if it does not exist yet
if (dstRule == null)
{
dstRule = srcToState.Rule.Clone (_symbols, ruleName);
_rules.Add (dstRule);
newRule = true;
}
// Should not exist yet
System.Diagnostics.Debug.Assert (!srcToDestHash.ContainsKey (srcToState));
// push all the states for that rule
State newState = CreateNewState (dstRule);
srcToDestHash.Add (srcToState, newState);
CloneStack.Add (srcToState);
if (newRule)
{
dstRule._firstState = newState;
}
return dstRule;
}
private Rule FindInRules (string ruleName)
{
foreach (Rule rule in _rules)
{
if (rule.Name == ruleName)
{
return rule;
}
}
return null;
}
private static void LogError (string rule, SRID srid, params object [] args)
{
string sError = SR.Get (srid, args);
throw new FormatException (string.Format (CultureInfo.InvariantCulture, "Rule=\"{0}\" - ", rule) + sError);
}
///
/// Connect arc to the state graph.
///
///
#if DEBUG
private
#else
private static
#endif
void AddArc (Arc arc)
{
#if DEBUG
arc.Backend = this;
#endif
}
///
///
///
/// states)
{
bool fReachedEndState;
foreach (State state in states)
{
state.CheckLeftRecursion (out fReachedEndState);
}
}
///
///
///
///
///
///
private Arc AddSingleWordTransition (string s, float flWeight, int requiredConfidence)
{
//CfgGrammar.TraceInformation ("BackEnd::CGramComp::AddSingleWordTransition");
Arc arc = new Arc (s, null, _words, flWeight, requiredConfidence, null, MatchMode.AllWords, ref _fNeedWeightTable);
AddArc (arc);
return arc;
}
internal void AddState (State state)
{
_states.Add (state);
}
#if VSCOMPILE && DEBUG
///
internal void DumpStateTable (string sTitle)
{
List states = new List (_states);
DumpStateTable (sTitle, states.ToArray ());
}
internal void DumpStateTable (string sTitle, State [] states)
{
CfgGrammar.TraceInformation2 (sTitle);
int iHandle2 = 0;
for (int iState = 0; iState < states.Length; iState++)
{
State state = states [iState];
if (state == null)
{
continue;
}
//string s = state.OutArcs.Count > 0 ? state.OutArcs.First.WordId > 0 ? _words [state.OutArcs.First.WordId] : string.Empty : string.Empty;
string s = _symbols.FromOffset (state.Rule._cfgRule._nameOffset);
CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "{0}: {1} {2} {3} '", iHandle2, state.Id, state.SerializeId, s));
foreach (Arc arc2 in state.OutArcs)
{
int iWord = arc2.WordId;
string sWord = arc2.RuleRef != null ? _symbols.FromOffset (arc2.RuleRef._cfgRule._nameOffset) : iWord > 0 ? _words [iWord] : string.Empty;
//CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "{0}{1} [{2}]", (fFirst ? string.Empty : ", "), sWord, arc2.Id));
//if (arc2._tag != null)
//{
// CfgGrammar.TraceInformation3 (string.Format (CultureInfo.InvariantCulture, "({0}, {1}, {2})", _symbols.FromOffset (arc2._tag._cfgTag._valueOffset), arc2._tag._startArc.Id, arc2._tag._endArc.Id));
//}
}
CfgGrammar.TraceInformation2 ("'");
}
}
internal void DumpStateMachine (TextWriter tw)
{
tw.WriteLine ("Word Blobs");
for (int i = 1; i < _words.Count; i++)
{
tw.WriteLine (" \"" + _words [i] + "\"");
}
tw.WriteLine ("\nSymbols Blobs");
for (int i = 1; i < _symbols.Count; i++)
{
tw.WriteLine (" \"" + _symbols [i] + "\"");
}
tw.WriteLine ("\nRules");
foreach (Rule rule in _rules)
{
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " \"{0}\" id: {1} flags: {2}", rule.Name, rule._cfgRule._id, rule._cfgRule._flag.ToString ("x", CultureInfo.InvariantCulture)));
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " States: {0}", rule._cStates));
}
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, "\nStates:\n Count: {0}", _states.Count));
foreach (State state in _states)
{
tw.WriteLine (string.Format (CultureInfo.InvariantCulture, " \"{0}\"", state.Rule.Name));
}
}
//GrammarOptimization
///
/// Dump grammar statistics to debug window. (Debug only)
///
///
void DumpGrammarStatistics (string title)
{
int iNumStates = 0;
int iNumArcs = 0;
int iNumEpsilonArcs = 0;
int iMaxBranch = 0;
int iNumProperties = 0;
foreach (State state in _states)
{
iNumStates++;
int cArcs = 0;
foreach (Arc arc in state.OutArcs)
{
cArcs++;
if (arc.IsEpsilonTransition)
{
iNumEpsilonArcs++;
}
//if (arc._tag != null)
//{
// iNumProperties++;
//}
}
if (iMaxBranch < cArcs)
iMaxBranch = cArcs;
iNumArcs += cArcs;
}
Console.WriteLine (title);
Console.WriteLine (string.Format (CultureInfo.InvariantCulture, "{0}\n NumStates = {0}\n NumArcs = {1}\n NumEpsilons = {2}\n", iNumStates, iNumArcs, iNumEpsilonArcs));
Console.WriteLine (string.Format (CultureInfo.InvariantCulture, " MaxBranch = {0}\n" + " NumProperties = {1}\n", iMaxBranch, iNumProperties));
}
#endif
#endregion
//*******************************************************************
//
// Internal Properties
//
//*******************************************************************
#region Internal Properties
internal int LangId
{
get
{
return _langId;
}
set
{
_langId = value;
}
}
internal GrammarOptions GrammarOptions
{
get
{
return _grammarOptions;
}
set
{
_grammarOptions = value;
}
}
internal GrammarType GrammarMode
{
set
{
_grammarMode = value;
}
}
internal AlphabetType Alphabet
{
set
{
_alphabet = value;
}
get
{
return _alphabet;
}
}
internal Collection GlobalTags
{
get
{
return _globalTags;
}
set
{
_globalTags = value;
}
}
#if !NO_STG
internal Collection ScriptRefs
{
set
{
_scriptRefs = value;
}
}
internal byte [] IL
{
set
{
_il = value;
}
}
internal byte [] PDB
{
set
{
_pdb = value;
}
}
#endif
#endregion
//*******************************************************************
//
// Private Fields
//
//********************************************************************
#region Private Fields
private int _langId = CultureInfo.CurrentUICulture.LCID;
private StringBlob _words;
private StringBlob _symbols;
//private int _cResources;
private Guid _guid;
private bool _fNeedWeightTable;
private Graph _states = new Graph ();
private List _rules = new List ();
private int _ruleIndex;
private Dictionary _nameOffsetRules = new Dictionary ();
private Rule _rootRule;
#if !SPEECHSERVER
private GrammarOptions _grammarOptions = GrammarOptions.KeyValuePairs;
#else
private GrammarOptions _grammarOptions = GrammarOptions.W3cV1;
#endif
// It is used sequentially. So there is no thread issue
private int _ulRecursiveDepth;
// Path from which relative grammar imports are calculated. As specified by xml:base
private string _basePath;
// Collection of all SemanticTags in the grammar (sorted by StartArc)
private List _tags = new List ();
// Voice or DTMF
private GrammarType _grammarMode = GrammarType.VoiceGrammar;
// Pron information is either IPA or SAPI
private AlphabetType _alphabet = AlphabetType.Sapi;
// Global value for the semantic interpretation tags
private Collection _globalTags = new Collection ();
//
private static byte [] _abZero3 = new byte [] { 0, 0, 0 };
private static char [] _achZero = new char [] { '\0' };
//
private const uint SPGF_RESET_DIRTY_FLAG = 0x80000000;
private int _cImportedRules;
#if !NO_STG
// List of cd /reference Rule->rule 'on'method-> .Net method
private Collection _scriptRefs = new Collection ();
// Grammar code assembly
private byte [] _il;
// Grammar debug symbols
private byte [] _pdb;
#endif
private bool _fLoadedFromBinary;
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- GeometryModel3D.cs
- AttachmentService.cs
- XmlSchemaSearchPattern.cs
- MsmqReceiveHelper.cs
- DecimalConverter.cs
- BuilderPropertyEntry.cs
- CodeDomConfigurationHandler.cs
- SoapSchemaImporter.cs
- DocumentEventArgs.cs
- WindowsFormsSectionHandler.cs
- DoubleConverter.cs
- CommandField.cs
- InternalControlCollection.cs
- SystemResources.cs
- Site.cs
- ArithmeticException.cs
- ActivityExecutorOperation.cs
- Trace.cs
- SplitContainer.cs
- ControllableStoryboardAction.cs
- DataGridViewColumnDesignTimeVisibleAttribute.cs
- XmlReader.cs
- StylusPointDescription.cs
- XmlQueryContext.cs
- TextWriterTraceListener.cs
- Accessible.cs
- FormsAuthenticationCredentials.cs
- WindowShowOrOpenTracker.cs
- QilIterator.cs
- Line.cs
- XmlObjectSerializer.cs
- UDPClient.cs
- StorageTypeMapping.cs
- CaseInsensitiveHashCodeProvider.cs
- PagesSection.cs
- SafeFileMappingHandle.cs
- ObjectSpanRewriter.cs
- JoinCqlBlock.cs
- DataGridBoundColumn.cs
- TableLayoutColumnStyleCollection.cs
- DataSourceIDConverter.cs
- SQLSingleStorage.cs
- CryptoKeySecurity.cs
- IntPtr.cs
- LocationSectionRecord.cs
- SchemaTableOptionalColumn.cs
- BoolExpression.cs
- MenuItem.cs
- DropShadowBitmapEffect.cs
- DbConnectionOptions.cs
- GeometryDrawing.cs
- FakeModelItemImpl.cs
- Deflater.cs
- HyperLinkDataBindingHandler.cs
- UnsafeNativeMethods.cs
- TransactionContextValidator.cs
- MulticastDelegate.cs
- SafeRightsManagementSessionHandle.cs
- ToolStripItemClickedEventArgs.cs
- WorkflowEventArgs.cs
- HeaderUtility.cs
- BinaryParser.cs
- EditorPartCollection.cs
- MdImport.cs
- WebPartDisplayModeCollection.cs
- XmlSchemaRedefine.cs
- GraphicsState.cs
- EdmEntityTypeAttribute.cs
- URLMembershipCondition.cs
- CacheModeValueSerializer.cs
- SizeValueSerializer.cs
- BamlTreeNode.cs
- ITextView.cs
- WorkItem.cs
- DependsOnAttribute.cs
- CheckBoxDesigner.cs
- Viewport3DAutomationPeer.cs
- ProgressBarRenderer.cs
- metadatamappinghashervisitor.cs
- Point3DAnimation.cs
- PageFunction.cs
- SBCSCodePageEncoding.cs
- DataGridViewLinkColumn.cs
- CodeEntryPointMethod.cs
- FamilyCollection.cs
- PasswordTextContainer.cs
- TableStyle.cs
- EdmItemCollection.OcAssemblyCache.cs
- SimpleTextLine.cs
- ParameterToken.cs
- TextComposition.cs
- EncodingDataItem.cs
- CodeDirectiveCollection.cs
- NumericExpr.cs
- StyleCollection.cs
- DesignerView.Commands.cs
- DataRowChangeEvent.cs
- RijndaelCryptoServiceProvider.cs
- DataGridViewLayoutData.cs
- PropertyMapper.cs