internal void InitSpecialRuleRef(Backend backend, ParseElementCollection parent) { Rule rule = null; switch (_type) { case SpecialRuleRefType.Null: parent.AddArc(backend.EpsilonTransition(1f)); break; case SpecialRuleRefType.Void: rule = backend.FindRule("VOID"); if (rule == null) { rule = backend.CreateRule("VOID", (SPCFGRULEATTRIBUTES)0); ((IElement)rule).PostParse((IElement)parent); } parent.AddArc(backend.RuleTransition(rule, parent._rule, 1f)); break; case SpecialRuleRefType.Garbage: { OneOf oneOf = new OneOf(parent._rule, backend); oneOf.AddArc(backend.RuleTransition(CfgGrammar.SPRULETRANS_WILDCARD, parent._rule, 0.5f)); oneOf.AddArc(backend.EpsilonTransition(0.5f)); ((IElement)oneOf).PostParse((IElement)parent); break; } } }
/// <summary> /// Add transition corresponding to Special or Uri. /// </summary> internal RuleRef(ParseElementCollection parent, Backend backend, Uri uri, List <Rule> undefRules, string semanticKey, string initParameters) : base(parent._rule) { string id = uri.OriginalString; Rule ruleRef = null; int posPound = id.IndexOf('#'); // Get the initial state for the RuleRef. if (posPound == 0) { // Internal RuleRef. Get InitialState of RuleRef. // GetRuleRef() may temporarily create a Rule placeholder for later resolution. ruleRef = GetRuleRef(backend, id.Substring(1), undefRules); } else { // External RuleRef. Build URL:GrammarUri#RuleName StringBuilder sbExternalRuleUri = new("URL:"); // Add the parameters to initialize a rule if (!string.IsNullOrEmpty(initParameters)) { // look for the # and insert the parameters sbExternalRuleUri.Append(posPound > 0 ? id.Substring(0, posPound) : id); sbExternalRuleUri.Append('>'); sbExternalRuleUri.Append(initParameters); if (posPound > 0) { sbExternalRuleUri.Append(id.Substring(posPound)); } } else { sbExternalRuleUri.Append(id); } // Get InitialState of external RuleRef. string sExternalRuleUri = sbExternalRuleUri.ToString(); ruleRef = backend.FindRule(sExternalRuleUri); if (ruleRef == null) { ruleRef = backend.CreateRule(sExternalRuleUri, SPCFGRULEATTRIBUTES.SPRAF_Import); } } Arc rulerefArc = backend.RuleTransition(ruleRef, _rule, 1.0f); #pragma warning disable 0618 if (!string.IsNullOrEmpty(semanticKey)) { CfgGrammar.CfgProperty propertyInfo = new(); propertyInfo._pszName = "SemanticKey"; propertyInfo._comValue = semanticKey; propertyInfo._comType = VarEnum.VT_EMPTY; backend.AddPropertyTag(rulerefArc, rulerefArc, propertyInfo); } #pragma warning restore 0618 parent.AddArc(rulerefArc); }
private static Rule GetRuleRef(Backend backend, string sRuleId, List <Rule> undefRules) { Rule rule = backend.FindRule(sRuleId); if (rule == null) { rule = backend.CreateRule(sRuleId, (SPCFGRULEATTRIBUTES)0); undefRules.Insert(0, rule); } return(rule); }
internal RuleRef(ParseElementCollection parent, Backend backend, Uri uri, List <Rule> undefRules, string semanticKey, string initParameters) : base(parent._rule) { string originalString = uri.OriginalString; Rule rule = null; int num = originalString.IndexOf('#'); if (num == 0) { rule = GetRuleRef(backend, originalString.Substring(1), undefRules); } else { StringBuilder stringBuilder = new StringBuilder("URL:"); if (!string.IsNullOrEmpty(initParameters)) { stringBuilder.Append((num > 0) ? originalString.Substring(0, num) : originalString); stringBuilder.Append('>'); stringBuilder.Append(initParameters); if (num > 0) { stringBuilder.Append(originalString.Substring(num)); } } else { stringBuilder.Append(originalString); } string text = stringBuilder.ToString(); rule = backend.FindRule(text); if (rule == null) { rule = backend.CreateRule(text, SPCFGRULEATTRIBUTES.SPRAF_Import); } } Arc arc = backend.RuleTransition(rule, _rule, 1f); if (!string.IsNullOrEmpty(semanticKey)) { backend.AddPropertyTag(arc, arc, new CfgGrammar.CfgProperty { _pszName = "SemanticKey", _comValue = semanticKey, _comType = VarEnum.VT_EMPTY }); } parent.AddArc(arc); }
/// <summary> /// Return the initial state of the rule with the specified name. /// If the rule is not defined yet, create a placeholder Rule. /// </summary> private static Rule GetRuleRef(Backend backend, string sRuleId, List <Rule> undefRules) { System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(sRuleId)); // Get specified rule. Rule rule = backend.FindRule(sRuleId); if (rule == null) { // Rule doesn't exist. Create a placeholder rule and add StateHandle to UndefinedRules. rule = backend.CreateRule(sRuleId, 0); undefRules.Insert(0, rule); } return(rule); }
private Rule GetRule(string sRuleId, SPCFGRULEATTRIBUTES dwAttributes) { Rule rule = _backend.FindRule(sRuleId); if (rule != null) { int num = _undefRules.IndexOf(rule); if (num != -1) { _backend.SetRuleAttributes(rule, dwAttributes); _undefRules.RemoveAt(num); } else { XmlParser.ThrowSrgsException(SRID.RuleRedefinition, sRuleId); } } else { rule = _backend.CreateRule(sRuleId, dwAttributes); } return(rule); }
/// <summary> /// Returns the initial state of a special rule. /// For each type of special rule we make a rule with a numeric id and return a reference to it. /// </summary> internal void InitSpecialRuleRef(Backend backend, ParseElementCollection parent) { Rule rule = null; // Create a transition corresponding to Special or Uri switch (_type) { case SpecialRuleRefType.Null: parent.AddArc(backend.EpsilonTransition(1.0f)); break; case SpecialRuleRefType.Void: rule = backend.FindRule(szSpecialVoid); if (rule == null) { rule = backend.CreateRule(szSpecialVoid, 0); // Rule with no transitions is a void rule. ((IRule)rule).PostParse(parent); } parent.AddArc(backend.RuleTransition(rule, parent._rule, 1.0f)); break; case SpecialRuleRefType.Garbage: // Garbage transition is optional whereas Wildcard is not. So we need additional epsilon transition. OneOf oneOf = new(parent._rule, backend); // Add the garbage transition oneOf.AddArc(backend.RuleTransition(CfgGrammar.SPRULETRANS_WILDCARD, parent._rule, 0.5f)); // Add a parallel epsilon path oneOf.AddArc(backend.EpsilonTransition(0.5f)); ((IOneOf)oneOf).PostParse(parent); break; default: System.Diagnostics.Debug.Assert(false, "Unknown special ruleref type"); break; } }