public virtual void removeImport(JSGFRuleName importName)
{
if (this.__imports.contains(importName))
{
this.__imports.remove(importName);
}
}
public virtual void resolveAllRules()
{
StringBuilder stringBuilder = new StringBuilder();
Iterator iterator = this.__imports.iterator();
while (iterator.hasNext())
{
JSGFRuleName jsgfruleName = (JSGFRuleName)iterator.next();
string fullGrammarName = jsgfruleName.getFullGrammarName();
if (this.manager.retrieveGrammar(fullGrammarName) == null)
{
stringBuilder.append("Undefined grammar ").append(fullGrammarName).append(" imported in ").append(this.name).append('\n');
}
}
if (stringBuilder.length() > 0)
{
string message = stringBuilder.toString();
throw new JSGFGrammarException(message);
}
iterator = this.__rules.values().iterator();
while (iterator.hasNext())
{
JSGFRuleGrammar.JSGFRuleState jsgfruleState = (JSGFRuleGrammar.JSGFRuleState)iterator.next();
this.resolveRule(jsgfruleState.rule);
}
}
private void loadFullQualifiedRules(JSGFRuleGrammar jsgfruleGrammar)
{
Iterator iterator = jsgfruleGrammar.getRuleNames().iterator();
while (iterator.hasNext())
{
string ruleName = (string)iterator.next();
string text = jsgfruleGrammar.getRule(ruleName).toString();
int i = 0;
while (i < String.instancehelper_length(text))
{
i = String.instancehelper_indexOf(text, 60, i);
if (i < 0)
{
break;
}
JSGFRuleName jsgfruleName = new JSGFRuleName(String.instancehelper_trim(String.instancehelper_substring(text, i + 1, String.instancehelper_indexOf(text, 62, i + 1))));
i = String.instancehelper_indexOf(text, 62, i) + 1;
if (jsgfruleName.getFullGrammarName() != null)
{
string fullGrammarName = jsgfruleName.getFullGrammarName();
JSGFRuleGrammar jsgfruleGrammar2 = this.getNamedRuleGrammar(fullGrammarName);
if (jsgfruleGrammar2 == null)
{
jsgfruleGrammar2 = this.loadNamedGrammar(fullGrammarName);
}
if (jsgfruleGrammar2 != null)
{
this.loadImports(jsgfruleGrammar2);
}
}
}
}
}
public virtual void addImport(JSGFRuleName importName)
{
if (!this.__imports.contains(importName))
{
this.__imports.add(importName);
}
}
public JSGFRuleName ImportRef()
{
String s;
bool all = false;
jj_consume_token(28);
s = Name();
switch ((_jj_ntk == -1) ? jj_ntk() : _jj_ntk)
{
case 29:
jj_consume_token(29);
jj_consume_token(30);
all = true;
break;
default:
jj_la1[25] = jj_gen;
break;
}
jj_consume_token(31);
if (all)
{
s = s + ".*";
}
JSGFRuleName rn = new JSGFRuleName(s);
{ if (true)
{
return(rn);
}
}
}
/**
* Import all rules or a specified rule from another grammar.
*
* @param importName
* the name of the rule(s) to import.
*/
public void AddImport(JSGFRuleName importName)
{
if (!Imports.Contains(importName))
{
Imports.Add(importName);
}
}
/**
* Remove an import.
*
* @param importName
* the name of the rule(s) to remove.
*/
public void RemoveImport(JSGFRuleName importName)
{
if (Imports.Contains(importName))
{
Imports.Remove(importName);
}
}
/**
* Parses the given RuleName into a network of GrammarNodes.
*
* @param initialRuleName
* the RuleName rule to parse
* @return a grammar graph
*/
private GrammarGraph ProcessRuleName(JSGFRuleName initialRuleName)
{
this.LogInfo("parseRuleName: " + initialRuleName);
GrammarGraph result = RuleStack.Contains(initialRuleName.GetRuleName());
if (result != null)
{ // its a recursive call
return(result);
}
else
{
result = new GrammarGraph(this);
RuleStack.Push(initialRuleName.GetRuleName(), result);
}
JSGFRuleName ruleName = _ruleGrammar.Resolve(initialRuleName);
if (ruleName == JSGFRuleName.Null)
{
result.StartNode.Add(result.EndNode, 0.0f);
}
else if (ruleName == JSGFRuleName.Void)
{
// no connection for void
}
else
{
if (ruleName == null)
{
throw new JSGFGrammarException("Can't resolve "
+ initialRuleName + " g "
+ initialRuleName.GetFullGrammarName());
}
JSGFRuleGrammar rg = Manager.RetrieveGrammar(ruleName
.GetFullGrammarName());
if (rg == null)
{
throw new JSGFGrammarException("Can't resolve grammar name "
+ ruleName.GetFullGrammarName());
}
JSGFRule rule = rg.GetRule(ruleName.GetSimpleRuleName());
if (rule == null)
{
throw new JSGFGrammarException("Can't resolve rule: "
+ ruleName.GetRuleName());
}
GrammarGraph ruleResult = ProcessRule(rule);
if (result != ruleResult)
{
result.StartNode.Add(ruleResult.StartNode, 0.0f);
ruleResult.EndNode.Add(result.EndNode, 0.0f);
}
}
RuleStack.Pop();
return(result);
}
public JSGFRuleName RuleRef()
{
String s;
jj_consume_token(28);
s = Name();
jj_consume_token(31);
JSGFRuleName rn = new JSGFRuleName(s);
{ if (true)
{
return(rn);
}
}
}
private JSGFGrammar.GrammarGraph processRuleName(JSGFRuleName jsgfruleName)
{
this.logger.fine(new StringBuilder().append("parseRuleName: ").append(jsgfruleName).toString());
JSGFGrammar.GrammarGraph grammarGraph = this.__ruleStack.contains(jsgfruleName.getRuleName());
if (grammarGraph != null)
{
return(grammarGraph);
}
grammarGraph = new JSGFGrammar.GrammarGraph(this);
this.__ruleStack.push(jsgfruleName.getRuleName(), grammarGraph);
JSGFRuleName jsgfruleName2 = this.ruleGrammar.resolve(jsgfruleName);
if (jsgfruleName2 == JSGFRuleName.__NULL)
{
grammarGraph.getStartNode().add(grammarGraph.getEndNode(), 0f);
}
else if (jsgfruleName2 != JSGFRuleName.__VOID)
{
if (jsgfruleName2 == null)
{
string message = new StringBuilder().append("Can't resolve ").append(jsgfruleName).append(" g ").append(jsgfruleName.getFullGrammarName()).toString();
throw new JSGFGrammarException(message);
}
JSGFRuleGrammar jsgfruleGrammar = this.manager.retrieveGrammar(jsgfruleName2.getFullGrammarName());
if (jsgfruleGrammar == null)
{
string message2 = new StringBuilder().append("Can't resolve grammar name ").append(jsgfruleName2.getFullGrammarName()).toString();
throw new JSGFGrammarException(message2);
}
JSGFRule rule = jsgfruleGrammar.getRule(jsgfruleName2.getSimpleRuleName());
if (rule == null)
{
string message3 = new StringBuilder().append("Can't resolve rule: ").append(jsgfruleName2.getRuleName()).toString();
throw new JSGFGrammarException(message3);
}
JSGFGrammar.GrammarGraph grammarGraph2 = this.processRule(rule);
if (grammarGraph != grammarGraph2)
{
grammarGraph.getStartNode().add(grammarGraph2.getStartNode(), 0f);
grammarGraph2.getEndNode().add(grammarGraph.getEndNode(), 0f);
}
}
this.__ruleStack.pop();
return(grammarGraph);
}
public void ImportDeclaration(JSGFRuleGrammar grammar)
{
bool all = false;
String name;
Token t = null;
t = jj_consume_token(Import);
jj_consume_token(28);
name = Name();
switch ((_jj_ntk == -1) ? jj_ntk() : _jj_ntk)
{
case 29:
jj_consume_token(29);
jj_consume_token(30);
all = true;
break;
default:
jj_la1[5] = jj_gen;
break;
}
jj_consume_token(31);
jj_consume_token(26);
// import all rules if .*
if (all)
{
name = name + ".*";
}
JSGFRuleName r = new JSGFRuleName(name);
if (grammar != null)
{
grammar.AddImport(r);
if (grammar is JSGFRuleGrammar && t != null && t.SpecialToken != null)
{
if (t.SpecialToken.Image != null && t.SpecialToken.Image.StartsWith("/**"))
{
JSGFRuleGrammar JG = grammar;
JG.AddImportDocComment(r, t.SpecialToken.Image);
}
}
}
}
private void loadImports(JSGFRuleGrammar jsgfruleGrammar)
{
Iterator iterator = jsgfruleGrammar.__imports.iterator();
while (iterator.hasNext())
{
JSGFRuleName jsgfruleName = (JSGFRuleName)iterator.next();
string fullGrammarName = jsgfruleName.getFullGrammarName();
JSGFRuleGrammar jsgfruleGrammar2 = this.getNamedRuleGrammar(fullGrammarName);
if (jsgfruleGrammar2 == null)
{
jsgfruleGrammar2 = this.loadNamedGrammar(jsgfruleName.getFullGrammarName());
}
if (jsgfruleGrammar2 != null)
{
this.loadImports(jsgfruleGrammar2);
}
}
this.loadFullQualifiedRules(jsgfruleGrammar);
}
protected internal virtual void dumpGrammar()
{
[email protected]("Imported rules { ");
Iterator iterator = this.ruleGrammar.getImports().iterator();
while (iterator.hasNext())
{
JSGFRuleName jsgfruleName = (JSGFRuleName)iterator.next();
[email protected](new StringBuilder().append(" Import ").append(jsgfruleName.getRuleName()).toString());
}
[email protected]("}");
[email protected]("Rulenames { ");
iterator = this.ruleGrammar.getRuleNames().iterator();
while (iterator.hasNext())
{
string text = (string)iterator.next();
[email protected](new StringBuilder().append(" Name ").append(text).toString());
}
[email protected]("}");
}
/**
* Load grammars imported by a fully qualified Rule Token if they are not
* already loaded.
*
* @param grammar
* @throws IOException
* @throws GrammarException
* @throws JSGFGrammarParseException
*/
private void LoadFullQualifiedRules(JSGFRuleGrammar grammar)
{
// Go through every rule
foreach (String ruleName in grammar.GetRuleNames())
{
String rule = grammar.GetRule(ruleName).ToString();
// check for rule-Tokens
int index = 0;
while (index < rule.Length)
{
index = rule.IndexOf('<', index);
if (index < 0)
{
break;
}
// Extract rule name
var endIndex = rule.IndexOf('>', index + 1);
JSGFRuleName extractedRuleName = new JSGFRuleName(rule
.Substring(index + 1, endIndex - (index + 1))
.Trim());
index = endIndex + 1;
// Check for full qualified rule name
if (extractedRuleName.GetFullGrammarName() != null)
{
String grammarName = extractedRuleName.GetFullGrammarName();
JSGFRuleGrammar importedGrammar = GetNamedRuleGrammar(grammarName);
if (importedGrammar == null)
{
importedGrammar = LoadNamedGrammar(grammarName);
}
if (importedGrammar != null)
{
LoadImports(importedGrammar);
}
}
}
}
}
/**
* Gets the fully resolved rule name
*
* @param ruleName
* the partial name
* @return the fully resolved name
* @throws JSGFGrammarException
*/
private String GetFullRuleName(String ruleName)
{
JSGFRuleName rname = _ruleGrammar.Resolve(new JSGFRuleName(ruleName));
return(rname.GetRuleName());
}
protected internal virtual void resolveRule(JSGFRule r)
{
if (r is JSGFRuleToken)
{
return;
}
if (r is JSGFRuleAlternatives)
{
Iterator iterator = ((JSGFRuleAlternatives)r).getRules().iterator();
while (iterator.hasNext())
{
JSGFRule jsgfrule = (JSGFRule)iterator.next();
this.resolveRule(jsgfrule);
}
return;
}
if (r is JSGFRuleSequence)
{
Iterator iterator = ((JSGFRuleSequence)r).getRules().iterator();
while (iterator.hasNext())
{
JSGFRule jsgfrule = (JSGFRule)iterator.next();
this.resolveRule(jsgfrule);
}
return;
}
if (r is JSGFRuleCount)
{
this.resolveRule(((JSGFRuleCount)r).getRule());
return;
}
if (r is JSGFRuleTag)
{
JSGFRuleTag jsgfruleTag = (JSGFRuleTag)r;
JSGFRule jsgfrule = jsgfruleTag.getRule();
string text = jsgfrule.toString();
object obj = (Collection)this.__ruleTags.get(text);
if ((Collection)obj == null)
{
obj = new HashSet();
this.__ruleTags.put(text, (HashSet)obj);
}
object obj2 = obj;
object tag = jsgfruleTag.getTag();
Collection collection;
if (obj2 != null)
{
if ((collection = (obj2 as Collection)) == null)
{
throw new IncompatibleClassChangeError();
}
}
else
{
collection = null;
}
collection.add(tag);
this.resolveRule(jsgfrule);
return;
}
if (!(r is JSGFRuleName))
{
string message = "Unknown rule type";
throw new JSGFGrammarException(message);
}
JSGFRuleName jsgfruleName = (JSGFRuleName)r;
JSGFRuleName jsgfruleName2 = this.resolve(jsgfruleName);
if (jsgfruleName2 == null)
{
string message2 = new StringBuilder().append("Unresolvable rulename in grammar ").append(this.name).append(": ").append(jsgfruleName).toString();
throw new JSGFGrammarException(message2);
}
jsgfruleName.resolvedRuleName = jsgfruleName2.getRuleName();
jsgfruleName.setRuleName(jsgfruleName2.getRuleName());
}
public virtual JSGFRuleName resolve(JSGFRuleName ruleName)
{
JSGFRuleName jsgfruleName = new JSGFRuleName(ruleName.getRuleName());
string simpleRuleName = jsgfruleName.getSimpleRuleName();
string simpleGrammarName = jsgfruleName.getSimpleGrammarName();
string packageName = jsgfruleName.getPackageName();
string fullGrammarName = jsgfruleName.getFullGrammarName();
if (packageName != null && simpleGrammarName == null)
{
string message = new StringBuilder().append("Error: badly formed rulename ").append(jsgfruleName).toString();
throw new JSGFGrammarException(message);
}
if (String.instancehelper_equals(ruleName.getSimpleRuleName(), "NULL"))
{
return(JSGFRuleName.__NULL);
}
if (String.instancehelper_equals(ruleName.getSimpleRuleName(), "VOID"))
{
return(JSGFRuleName.__VOID);
}
if (fullGrammarName == null && this.getRule(simpleRuleName) != null)
{
return(new JSGFRuleName(new StringBuilder().append(this.name).append('.').append(simpleRuleName).toString()));
}
if (fullGrammarName != null)
{
JSGFRuleGrammar jsgfruleGrammar = this.manager.retrieveGrammar(fullGrammarName);
if (jsgfruleGrammar != null && jsgfruleGrammar.getRule(simpleRuleName) != null)
{
return(new JSGFRuleName(new StringBuilder().append(fullGrammarName).append('.').append(simpleRuleName).toString()));
}
}
ArrayList arrayList = new ArrayList();
ArrayList arrayList2 = new ArrayList(this.__imports);
List list = arrayList2;
list.add(new JSGFRuleName(new StringBuilder().append(this.name).append(".*").toString()));
Iterator iterator = arrayList2.iterator();
while (iterator.hasNext())
{
JSGFRuleName jsgfruleName2 = (JSGFRuleName)iterator.next();
string simpleRuleName2 = jsgfruleName2.getSimpleRuleName();
string simpleGrammarName2 = jsgfruleName2.getSimpleGrammarName();
string fullGrammarName2 = jsgfruleName2.getFullGrammarName();
if (fullGrammarName2 == null)
{
string message2 = new StringBuilder().append("Error: badly formed import ").append(ruleName).toString();
throw new JSGFGrammarException(message2);
}
JSGFRuleGrammar jsgfruleGrammar2 = this.manager.retrieveGrammar(fullGrammarName2);
if (jsgfruleGrammar2 == null)
{
[email protected](new StringBuilder().append("Warning: import of unknown grammar ").append(ruleName).append(" in ").append(this.name).toString());
}
else if (!String.instancehelper_equals(simpleRuleName2, "*") && jsgfruleGrammar2.getRule(simpleRuleName2) == null)
{
[email protected](new StringBuilder().append("Warning: import of undefined rule ").append(ruleName).append(" in ").append(this.name).toString());
}
else if (String.instancehelper_equals(fullGrammarName2, fullGrammarName) || String.instancehelper_equals(simpleGrammarName2, fullGrammarName))
{
if (String.instancehelper_equals(simpleRuleName2, "*"))
{
if (jsgfruleGrammar2.getRule(simpleRuleName) != null)
{
List list2 = arrayList;
list2.add(new JSGFRuleName(new StringBuilder().append(fullGrammarName2).append('.').append(simpleRuleName).toString()));
}
}
else if (String.instancehelper_equals(simpleRuleName2, simpleRuleName))
{
List list3 = arrayList;
list3.add(new JSGFRuleName(new StringBuilder().append(fullGrammarName2).append('.').append(simpleRuleName).toString()));
}
}
else if (fullGrammarName == null)
{
if (String.instancehelper_equals(simpleRuleName2, "*"))
{
if (jsgfruleGrammar2.getRule(simpleRuleName) != null)
{
List list4 = arrayList;
list4.add(new JSGFRuleName(new StringBuilder().append(fullGrammarName2).append('.').append(simpleRuleName).toString()));
}
}
else if (String.instancehelper_equals(simpleRuleName2, simpleRuleName))
{
List list5 = arrayList;
list5.add(new JSGFRuleName(new StringBuilder().append(fullGrammarName2).append('.').append(simpleRuleName).toString()));
}
}
}
int num = arrayList.size();
if (num == 0)
{
return(null);
}
if (num == 1)
{
return((JSGFRuleName)arrayList.get(0));
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("Warning: ambiguous reference ").append(jsgfruleName).append(" in ").append(this.name).append(" to ");
Iterator iterator2 = arrayList.iterator();
while (iterator2.hasNext())
{
JSGFRuleName jsgfruleName3 = (JSGFRuleName)iterator2.next();
stringBuilder.append(jsgfruleName3).append(" and ");
}
stringBuilder.setLength(stringBuilder.length() - 5);
string message3 = stringBuilder.toString();
throw new JSGFGrammarException(message3);
}
private string getFullRuleName(string name)
{
JSGFRuleName jsgfruleName = this.ruleGrammar.resolve(new JSGFRuleName(name));
return(jsgfruleName.getRuleName());
}
public virtual void addImportDocComment(JSGFRuleName imp, string comment)
{
this.importDocComments.put(imp.toString(), comment);
}
public virtual string getImportDocComment(JSGFRuleName imp)
{
return(this.importDocComments.getProperty(imp.toString(), null));
}
/** Retrieve an import comment. */
public String GetImportDocComment(JSGFRuleName imp)
{
return(_importDocComments.getProperty(imp.ToString(), null));
}
/** Add a new import comment. */
public void AddImportDocComment(JSGFRuleName imp, String comment)
{
Java.Put(_importDocComments, imp.ToString(), comment);
}
/**
* Resolve a simple or qualified rule name as a full rule name.
*
* @param ruleName
* the name of the rule.
*/
public JSGFRuleName Resolve(JSGFRuleName ruleName)
{
// System.out.println ("Resolving " + ruleName);
JSGFRuleName rn = new JSGFRuleName(ruleName.GetRuleName());
String simpleName = rn.GetSimpleRuleName();
String grammarName = rn.GetSimpleGrammarName();
String packageName = rn.GetPackageName();
String fullGrammarName = rn.GetFullGrammarName();
// Check for badly formed RuleName
if (packageName != null && grammarName == null)
{
throw new JSGFGrammarException("Error: badly formed rulename " + rn);
}
if (ruleName.GetSimpleRuleName().Equals("NULL"))
{
return(JSGFRuleName.Null);
}
if (ruleName.GetSimpleRuleName().Equals("VOID"))
{
return(JSGFRuleName.Void);
}
// Check simple case: a local rule reference
if (fullGrammarName == null && GetRule(simpleName) != null)
{
return(new JSGFRuleName(_name + '.' + simpleName));
}
// Check for fully-qualified reference
if (fullGrammarName != null)
{
JSGFRuleGrammar g = _manager.RetrieveGrammar(fullGrammarName);
if (g != null)
{
if (g.GetRule(simpleName) != null)
{
// we have a successful resolution
return(new JSGFRuleName(fullGrammarName + '.' + simpleName));
}
}
}
// Collect all matching imports into a list. After trying to
// match rn to each import statement the vec will have
// size()=0 if rn is unresolvable
// size()=1 if rn is properly resolvable
// size()>1 if rn is an ambiguous reference
List <JSGFRuleName> matches = new List <JSGFRuleName>();
// Get list of imports
// Add local grammar to simply the case of checking for
// a qualified or fully-qualified local reference.
List <JSGFRuleName> imports = new List <JSGFRuleName>(this.Imports);
imports.Add(new JSGFRuleName(_name + ".*"));
// Check each import statement for a possible match
foreach (JSGFRuleName importName in imports)
{
// TO-DO: update for JSAPI 1.0
String importSimpleName = importName.GetSimpleRuleName();
String importGrammarName = importName.GetSimpleGrammarName();
String importFullGrammarName = importName.GetFullGrammarName();
// Check for badly formed import name
if (importFullGrammarName == null)
{
throw new JSGFGrammarException("Error: badly formed import " + ruleName);
}
// Get the imported grammar
JSGFRuleGrammar gref = _manager.RetrieveGrammar(importFullGrammarName);
if (gref == null)
{
Console.WriteLine("Warning: import of unknown grammar " + ruleName + " in " + _name);
continue;
}
// If import includes simpleName, test that it really exists
if (!importSimpleName.Equals("*") && gref.GetRule(importSimpleName) == null)
{
Console.WriteLine("Warning: import of undefined rule " + ruleName + " in " + _name);
continue;
}
// Check for fully-qualified or qualified reference
if (importFullGrammarName.Equals(fullGrammarName) || importGrammarName.Equals(fullGrammarName))
{
// Know that either
// import <ipkg.igram.???> matches <pkg.gram.???>
// OR
// import <ipkg.igram.???> matches <gram.???>
// (ipkg may be null)
if (importSimpleName.Equals("*"))
{
if (gref.GetRule(simpleName) != null)
{
// import <pkg.gram.*> matches <pkg.gram.rulename>
matches.Add(new JSGFRuleName(importFullGrammarName + '.' + simpleName));
}
continue;
}
else
{
// Now testing
// import <ipkg.igram.iRuleName> against <??.gram.ruleName>
//
if (importSimpleName.Equals(simpleName))
{
// import <pkg.gram.rulename> exact match for
// <???.gram.rulename>
matches.Add(new JSGFRuleName(importFullGrammarName + '.' + simpleName));
}
continue;
}
}
// If we get here and rulename is qualified or fully-qualified
// then the match failed - try the next import statement
if (fullGrammarName != null)
{
continue;
}
// Now test
// import <ipkg.igram.*> against <simpleName>
if (importSimpleName.Equals("*"))
{
if (gref.GetRule(simpleName) != null)
{
// import <pkg.gram.*> matches <simpleName>
matches.Add(new JSGFRuleName(importFullGrammarName + '.' + simpleName));
}
continue;
}
// Finally test
// import <ipkg.igram.iSimpleName> against <simpleName>
if (importSimpleName.Equals(simpleName))
{
matches.Add(new JSGFRuleName(importFullGrammarName + '.' + simpleName));
continue;
}
}
// The return behavior depends upon number of matches
switch (matches.Count)
{
case 0: // Return null if rulename is unresolvable
return(null);
case 1: // Return successfully
return(matches[0]);
default: // Throw exception if ambiguous reference
StringBuilder b = new StringBuilder();
b.Append("Warning: ambiguous reference ").Append(rn).Append(" in ").Append(_name).Append(" to ");
foreach (JSGFRuleName tmp in matches)
{
b.Append(tmp).Append(" and ");
}
b.Length = (b.Length - 5);
throw new JSGFGrammarException(b.ToString());
}
}
/** Resolve the given rule. */
protected void ResolveRule(JSGFRule r)
{
if (r is JSGFRuleToken)
{
return;
}
if (r is JSGFRuleAlternatives)
{
foreach (JSGFRule rule in ((JSGFRuleAlternatives)r).GetRules())
{
ResolveRule(rule);
}
return;
}
if (r is JSGFRuleSequence)
{
foreach (JSGFRule rule in ((JSGFRuleSequence)r).Rules)
{
ResolveRule(rule);
}
return;
}
if (r is JSGFRuleCount)
{
ResolveRule(((JSGFRuleCount)r).Rule);
return;
}
if (r is JSGFRuleTag)
{
JSGFRuleTag rt = (JSGFRuleTag)r;
JSGFRule rule = rt.Rule;
String ruleStr = rule.ToString();
// add the tag the tag-table
var tags = RuleTags.Get(ruleStr);
if (tags == null)
{
tags = new HashSet <String>();
RuleTags.Put(ruleStr, tags);
}
tags.Add(rt.Tag);
ResolveRule(rule);
return;
}
if (r is JSGFRuleName)
{
JSGFRuleName rn = (JSGFRuleName)r;
JSGFRuleName resolved = Resolve(rn);
if (resolved == null)
{
throw new JSGFGrammarException("Unresolvable rulename in grammar " + _name + ": " + rn);
}
else
{
// TODO: This forces all rule names to be fully resolved.
// This should be changed.
rn.ResolvedRuleName = resolved.GetRuleName();
rn.SetRuleName(resolved.GetRuleName());
return;
}
}
throw new JSGFGrammarException("Unknown rule type");
}
