public void TestElseIfElse()
{
string template = "go: <if(name)>hi, foo<elseif(user)>a user<else>bye<endif>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, " +
"write, " +
"load_attr 1, " +
"brf 17, " +
"load_str 2, " +
"write, " +
"br 34, " +
"load_attr 3, " +
"brf 30, " +
"load_str 4, " +
"write, " +
"br 34, " +
"load_str 5, " +
"write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[go: , name, hi, foo, user, a user, bye]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestAnonMap()
{
string template = "hi <name:{n | <n>}>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, load_attr 1, load_str 2, map, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , name, /_sub1]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestAttr()
{
string template = "hi <name>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, " +
"write, " +
"load_attr 1, " +
"write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , name]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestEmbeddedRegion()
{
string template = "<@r>foo<@end>";
// compile as if in root dir and in template 'a'
CompiledTemplate code = new TemplateCompiler(TemplateName.Root, new TemplateName("a")).Compile(template);
string asmExpected =
"new 0, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[/region__a__r]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestRotMap()
{
string template = "hi <name:bold(),italics()>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, load_attr 1, load_str 2, load_str 3, rot_map 2, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , name, /bold, /italics]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestRegion()
{
string template = "x:<@r()>";
// compile as if in root dir and in template 'a'
CompiledTemplate code = new TemplateCompiler(TemplateName.Root, new TemplateName("a")).Compile(template);
string asmExpected =
"load_str 0, write, new 1, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[x:, /region__a__r]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public TemplateName CompileRegion(TemplateName enclosingTemplateName,
string regionName,
ITokenStream input,
RecognizerSharedState state)
{
TemplateCompiler c = new TemplateCompiler(templatePathPrefix, enclosingTemplateName);
CompiledTemplate sub = c.Compile(input, state);
TemplateName fullName = TemplateName.Combine(templatePathPrefix, TemplateGroup.GetMangledRegionName(enclosingTemplateName, regionName));
sub.isRegion = true;
sub.regionDefType = Template.RegionType.Embedded;
sub.Name = fullName;
if (code.implicitlyDefinedTemplates == null)
{
code.implicitlyDefinedTemplates = new List<CompiledTemplate>();
}
code.implicitlyDefinedTemplates.Add(sub);
return fullName;
}
public TemplateName CompileAnonTemplate(TemplateName enclosingTemplateName, ITokenStream input, IList<IToken> ids, RecognizerSharedState state)
{
TemplateCompiler c = new TemplateCompiler();
c.Compile(input, state);
return null;
}
public void TestOptions()
{
string template = "hi <name; anchor, wrap=foo(), separator=\", \">";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, " +
"write, " +
"load_attr 1, " +
"options, " +
"load_str 2, " +
"store_option 0, " +
"new 3, " +
"store_option 4, " +
"load_str 4, " +
"store_option 3, " +
"write_opt";
string stringsExpected = // the ", , ," is the ", " separator string
"[hi , name, true, /foo, , ]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
}
public void TestOptionAsTemplate()
{
string template = "hi <name; separator={, }>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, load_attr 1, options, new 2, store_option 3, write_opt";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , name, /_sub1]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestList()
{
string template = "<[a,b]>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected = "list, load_attr 0, add, load_attr 1, add, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[a, b]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestInclude()
{
string template = "hi <foo()>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, new 1, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , /foo]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public void TestIf()
{
string template = "go: <if(name)>hi, foo<endif>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, load_attr 1, brf 14, load_str 2, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[go: , name, hi, foo]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
// 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;
}
public void TestProp()
{
string template = "hi <a.b>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_str 0, write, load_attr 1, load_prop 2, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[hi , a, b]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
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;
}
public void TestProp2()
{
string template = "<u.id>: <u.name>";
CompiledTemplate code = new TemplateCompiler().Compile(template);
string asmExpected =
"load_attr 0, load_prop 1, write, load_str 2, write, " +
"load_attr 0, load_prop 3, write";
string asmResult = code.Instructions();
Assert.AreEqual(asmExpected, asmResult);
string stringsExpected = "[u, id, : , name]";
string stringsResult = code.strings.ToElementString();
Assert.AreEqual(stringsExpected, stringsResult);
}
public TemplateName CompileRegion(TemplateName enclosingTemplateName, string regionName, ITokenStream input, RecognizerSharedState state)
{
TemplateCompiler c = new TemplateCompiler();
c.Compile(input, state);
return null;
}
public TemplateName CompileAnonTemplate(TemplateName enclosingTemplateName,
ITokenStream input,
IList<IToken> argIDs,
RecognizerSharedState state)
{
subtemplateCount++;
TemplateName name = TemplateName.Combine(templatePathPrefix, Template.SubtemplatePrefix + subtemplateCount);
ITokenSource tokenSource = input.TokenSource;
TemplateLexer lexer = tokenSource as TemplateLexer;
int start = -1;
int stop = -1;
if (tokenSource != null)
start = lexer.input.Index;
TemplateCompiler c = new TemplateCompiler(templatePathPrefix, enclosingTemplateName);
CompiledTemplate sub = c.Compile(input, state);
sub.Name = name;
sub.IsSubtemplate = true;
if (lexer != null)
{
stop = lexer.input.Index;
//sub.template = lexer.input.Substring(start, stop - start - 1);
//Console.WriteLine(start + ".." + stop);
sub.embeddedStart = start;
sub.embeddedStop = stop - 1;
sub.template = lexer.input.Substring(0, lexer.input.Count - 1);
}
if (code.implicitlyDefinedTemplates == null)
code.implicitlyDefinedTemplates = new List<CompiledTemplate>();
code.implicitlyDefinedTemplates.Add(sub);
if (argIDs != null)
{
sub.formalArguments = new Dictionary<string, FormalArgument>();
foreach (IToken arg in argIDs)
{
string argName = arg.Text;
sub.formalArguments[argName] = new FormalArgument(argName);
}
}
return name;
}
