public virtual CompiledTemplate LookupTemplate(TemplateName name)
{
if (!alreadyLoaded)
Load();
CompiledTemplate code;
if (!templates.TryGetValue(name, out code))
{
code = LookupImportedTemplate(name);
}
return code;
}
public CompiledTemplate RawGetTemplate(TemplateName name)
{
CompiledTemplate template;
if (!templates.TryGetValue(name, out template))
return null;
return template;
}
/** The primary means of getting an instance of a template from this
* group. Must be absolute name like /a/b
*/
public virtual Template GetInstanceOf(TemplateName name)
{
if (!name.IsRooted)
name = TemplateName.Combine(TemplateName.Root, name);
//Console.WriteLine("GetInstanceOf(" + name + ")");
CompiledTemplate c = LookupTemplate(name);
if (c != null)
{
Template instanceST = CreateStringTemplate();
instanceST.groupThatCreatedThisInstance = this;
instanceST.code = c;
return instanceST;
}
return null;
}
// TODO: make this happen in background then flip ptr to new list of templates/dictionaries?
public virtual void LoadGroupFile(TemplateName prefix, string fileName)
{
string absoluteFileName = Path.Combine(fullyQualifiedRootDirName, fileName);
//Console.WriteLine("load group file " + absoluteFileName);
GroupParser parser = null;
try
{
ANTLRFileStream fs = new ANTLRFileStream(absoluteFileName, encoding);
GroupLexer lexer = new GroupLexer(fs);
CommonTokenStream tokens = new CommonTokenStream(lexer);
parser = new GroupParser(tokens);
parser.group(this, prefix);
}
#if false
catch (RecognitionException e)
{
if (e.Token.Type == TemplateLexer.EOF_TYPE)
ErrorManager.SyntaxError(ErrorType.SyntaxError, e, "premature EOF", absoluteFileName);
else
ErrorManager.SyntaxError(ErrorType.SyntaxError, e, absoluteFileName);
}
#endif
catch (Exception e)
{
if (ErrorManager.IsCriticalException(e))
throw;
ErrorManager.IOError(null, ErrorType.CantLoadGroupFile, e, absoluteFileName);
}
}
protected void _Load(TemplateName prefix)
{
if (prefix == null)
throw new ArgumentNullException("prefix");
if (!prefix.IsRooted)
throw new ArgumentException();
string relativePrefix = prefix.FullName.Substring(1);
string dir = Path.Combine(fullyQualifiedRootDirName, relativePrefix);
//Console.WriteLine("load dir '" + prefix + "' under " + fullyQualifiedRootDirName);
foreach (var d in Directory.GetDirectories(dir))
{
_Load(TemplateName.Combine(prefix, Path.GetFileName(d)));
}
foreach (var f in Directory.GetFiles(dir))
{
if (Path.GetExtension(f).Equals(".st", System.StringComparison.OrdinalIgnoreCase))
LoadTemplateFile(prefix, Path.GetFileName(f));
else if (Path.GetExtension(f).Equals(".stg", System.StringComparison.OrdinalIgnoreCase))
LoadGroupFile(TemplateName.Combine(prefix, Path.GetFileNameWithoutExtension(f)), Path.Combine(relativePrefix, Path.GetFileName(f)));
}
}
public virtual Template GetEmbeddedInstanceOf(Template enclosingInstance, int ip, TemplateName name)
{
Template st = GetInstanceOf(name);
if (st == null)
{
ErrorManager.RuntimeError(enclosingInstance, ip, ErrorType.NoSuchTemplate, name.Name);
return Template.Blank;
}
st.enclosingInstance = enclosingInstance;
return st;
}
// for testing
public CompiledTemplate DefineTemplate(TemplateName name, string template)
{
return DefineTemplate(TemplateName.Root, new CommonToken(GroupParser.ID, name.Name), FormalArgument.Unknown, template);
}
protected void RawDefineTemplate(TemplateName name, CompiledTemplate code, IToken definingToken)
{
CompiledTemplate prev;
if (templates.TryGetValue(name, out prev))
{
if (!prev.isRegion)
{
ErrorManager.CompileTimeError(ErrorType.TemplateRedefinition, definingToken);
return;
}
if (prev.isRegion && prev.regionDefType == Template.RegionType.Embedded)
{
ErrorManager.CompileTimeError(ErrorType.EmbeddedRegionRedefinition, definingToken, GetUnmangledTemplateName(name));
return;
}
else if (prev.isRegion && prev.regionDefType == Template.RegionType.Explicit)
{
ErrorManager.CompileTimeError(ErrorType.RegionRedefinition, definingToken, GetUnmangledTemplateName(name));
return;
}
}
templates[name] = code;
}
/// <summary>
/// Return "t.foo" from "region__t__foo"
/// </summary>
public static string GetUnmangledTemplateName(TemplateName mangledName)
{
string name = mangledName.Name;
string t = name.Substring("region__".Length, name.LastIndexOf("__") - "region__".Length);
string r = name.Substring(name.LastIndexOf("__") + 2);
return t + '.' + r;
}
public CompiledTemplate DefineRegion(TemplateName prefix,
TemplateName enclosingTemplateName,
IToken regionToken,
string template)
{
string name = regionToken.Text;
CompiledTemplate code = Compile(prefix, enclosingTemplateName, template);
code.Name = TemplateName.Combine(prefix, GetMangledRegionName(enclosingTemplateName, name));
code.isRegion = true;
code.regionDefType = Template.RegionType.Explicit;
RawDefineTemplate(code.Name, code, regionToken);
return code;
}
/** The "foo" of t() ::= "<@foo()>" is mangled to "region#t#foo" */
public static TemplateName GetMangledRegionName(TemplateName enclosingTemplateName,
string name)
{
return new TemplateName("region__" + enclosingTemplateName + "__" + name);
}
public static TemplateName Combine(TemplateName left, TemplateName right)
{
if (left == null)
throw new ArgumentNullException("left");
if (right == null)
throw new ArgumentNullException("right");
if (left == Root)
return right.IsRooted ? right : new TemplateName(TemplateDirectorySeparator + right.FullName);
if (right.IsRooted)
return new TemplateName(left.FullName + right.FullName);
else
return new TemplateName(left.FullName + TemplateDirectorySeparator + right.FullName);
}
public static TemplateName Combine(TemplateName left, string right)
{
return Combine(left, new TemplateName(right));
}
protected internal CompiledTemplate Compile(TemplateName prefix, TemplateName enclosingTemplateName, string template)
{
TemplateCompiler c = new TemplateCompiler(prefix, enclosingTemplateName);
CompiledTemplate code = c.Compile(template);
code.nativeGroup = this;
code.template = template;
return code;
}
// can't trap recog errors here; don't know where in file template is defined
public virtual CompiledTemplate DefineTemplate(TemplateName prefix, IToken nameToken, IDictionary<string, FormalArgument> args, string template)
{
if (nameToken == null)
throw new ArgumentNullException("nameToken");
TemplateName name = new TemplateName(nameToken.Text);
CompiledTemplate code = Compile(prefix, name, template);
code.Name = name;
code.formalArguments = args;
RawDefineTemplate(TemplateName.Combine(prefix, name), code, nameToken);
if (args != null)
{ // compile any default args
foreach (string a in args.Keys)
{
FormalArgument fa = args[a];
if (fa.defaultValueToken != null)
{
TemplateCompiler c2 = new TemplateCompiler(prefix, name);
string defArgTemplate = Misc.Strip(fa.defaultValueToken.Text, 1);
fa.compiledDefaultValue = c2.Compile(defArgTemplate);
fa.compiledDefaultValue.Name = new TemplateName(fa.name + "-default-value");
}
}
}
// define any anonymous subtemplates
DefineImplicitlyDefinedTemplates(code);
return code;
}
protected internal CompiledTemplate LookupImportedTemplate(TemplateName name)
{
//Console.WriteLine("look for " + name + " in " + imports);
if (imports == null)
return null;
foreach (var g in imports)
{
CompiledTemplate code = g.LookupTemplate(name);
if (code != null)
return code;
}
return null;
}
/** Make name and alias for target. Replace any previous def of name */
public CompiledTemplate DefineTemplateAlias(IToken aliasToken, IToken targetToken)
{
TemplateName alias = new TemplateName(aliasToken.Text);
TemplateName target = new TemplateName(targetToken.Text);
CompiledTemplate targetCode;
if (!templates.TryGetValue(target, out targetCode))
{
NoViableAltException e = null;
ErrorManager.SyntaxError(ErrorType.AliasTargetUndefined, e, alias.Name, target.Name);
return null;
}
templates[alias] = targetCode;
return targetCode;
}
public virtual CompiledTemplate DefineTemplate(TemplateName name,
List<string> args,
string template)
{
IDictionary<string, FormalArgument> margs = null;
if (args != null)
margs = args.ToDictionary(arg => arg, arg => new FormalArgument(arg));
return DefineTemplate(TemplateName.Root, name, margs, template);
}
public CompiledTemplate LoadTemplateFile(TemplateName prefix, string fileName)
{
if (prefix == null)
throw new ArgumentNullException("prefix");
if (fileName == null)
throw new ArgumentNullException("fileName");
if (!prefix.IsRooted)
throw new ArgumentException("Expected the prefix to be a rooted name.", "prefix");
TemplateName templateName = TemplateName.Combine(prefix, new TemplateName(Path.GetFileNameWithoutExtension(fileName)));
// load from disk
string absoluteFileName = Path.Combine(Path.Combine(fullyQualifiedRootDirName, prefix.FullName.Substring(1)), fileName);
//Console.WriteLine("load " + absoluteFileName);
if (!File.Exists(absoluteFileName))
{
// TODO: add tolerance check here
return null;
}
try
{
if (ErrorManager.CompatibilityMode)
{
string template = File.ReadAllText(absoluteFileName);
template = template.Trim();
DefineTemplate(prefix, new CommonToken(GroupParser.ID, templateName.Name), null, template);
}
else
{
ANTLRFileStream fs = new ANTLRFileStream(absoluteFileName, encoding);
GroupLexer lexer = new GroupLexer(fs);
CommonTokenStream tokens = new CommonTokenStream(lexer);
GroupParser parser = new GroupParser(tokens);
parser._group = this;
parser.templateDef(prefix);
}
CompiledTemplate code;
if (!templates.TryGetValue(templateName, out code))
return null;
return code;
}
catch (Exception e)
{
if (ErrorManager.IsCriticalException(e))
throw;
ErrorManager.IOError(null, ErrorType.CantLoadTemplateFile, e, absoluteFileName);
Console.Error.WriteLine(e.StackTrace);
}
return null;
}