/// <summary>
///
/// </summary>
/// <returns></returns>
private Tag[] ParseTag()
{
TemplateLexer lexer = new TemplateLexer(this._content);
TemplateParser parser = new TemplateParser(lexer.Parse());
return(parser.ToArray());
}
public void checkTokens(string template, string expected, char delimiterStartChar, char delimiterStopChar)
{
TemplateLexer lexer =
new TemplateLexer(TemplateGroup.DefaultErrorManager,
new ANTLRStringStream(template),
null,
delimiterStartChar,
delimiterStopChar);
CommonTokenStream tokens = new CommonTokenStream(lexer);
StringBuilder buf = new StringBuilder();
buf.Append("[");
int i = 1;
IToken t = tokens.LT(i);
while (t.Type != CharStreamConstants.EndOfFile)
{
if (i > 1)
{
buf.Append(", ");
}
buf.Append(t);
i++;
t = tokens.LT(i);
}
buf.Append("]");
string result = buf.ToString();
Assert.AreEqual(expected, result);
}
private Editor()
{
shadowClass = new ShadowClass();
contexts = new Contexts(shadowClass);
codeLexer = new CodeLexer(contexts);
templateLexer = new TemplateLexer(contexts);
}
private Editor()
{
shadowClass = new ShadowClass();
contexts = new Contexts(shadowClass);
_codeLexerTst = new CodeLexer(contexts);
_codeLexerTstX = new TstXCodeLexer(contexts);
_templateLexerTst = new TemplateLexer(contexts);
_templateLexerTstX = new TstXTemplateLexer(contexts);
}
/// <summary>
/// 从模板代码初始化模板对象。
/// </summary>
/// <param name="name">指定模板名称。</param>
/// <param name="data">包含模板代码的字符串。</param>
/// <returns>Template</returns>
public static Template FromString(string name, string data)
{
TemplateLexer lexer = new TemplateLexer(data);
TemplateParser parser = new TemplateParser(lexer);
List <Element> elems = parser.Parse();
TagParser tagParser = new TagParser(elems);
elems = tagParser.CreateHierarchy();
return(new Template(name, elems));
}
public override void Parse(TemplateContext context, System.IO.TextWriter writer)
{
String path = this.Path.Parse(context).ToString();
if (!String.IsNullOrEmpty(path))
{
TemplateLexer lexer = new TemplateLexer(Resources.LoadResource(context.Paths.ToArray(), path, context.Charset));
TemplateParser parser = new TemplateParser(lexer.Parse(), context.Analyzer);
while (parser.MoveNext())
{
parser.Current.Parse(context, writer);
}
}
}
public string Build()
{
var lexer = new TemplateLexer(new AntlrInputStream(File.ReadAllText(path)));
var parser = new TemplateParser(new CommonTokenStream(lexer));
var document = parser.document();
document.Accept <int>(this);
var txt = output.ToString();
Console.WriteLine(txt);
return(txt);
}
protected void Render(TemplateContext context, TextWriter writer)
{
if (context == null)
{
writer.Write(this.TemplateContent);
return;
}
if (!String.IsNullOrEmpty(this.TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(this.TemplateContent);
TemplateParser parser = new TemplateParser(lexer.Parse());
while (parser.MoveNext())
{
try
{
parser.Current.Parse(context, writer);
}
catch (Exception.TemplateException e)
{
if (context.ThrowExceptions)
{
throw e;
}
else
{
context.AddError(e);
writer.Write(parser.Current.ToString());
}
}
catch (System.Exception e)
{
System.Exception baseException = e.GetBaseException();
Exception.ParseException ex = new Exception.ParseException(baseException.Message, baseException);
if (context.ThrowExceptions)
{
throw ex;
}
else
{
context.AddError(ex);
writer.Write(parser.Current.ToString());
}
}
}
}
}
protected void Render(TemplateContext context, StringBuilder writer)
{
if (!String.IsNullOrEmpty(this.TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(this.TemplateContent);
TemplateParser parser = new TemplateParser(lexer.Parse());
while (parser.MoveNext())
{
//try
//{
parser.Current.Parse(context, writer);
//}
//catch (Exception.TemplateException e)
//{
// if (context.ThrowExceptions)
// {
// throw e;
// }
// else
// {
// context.AddError(e);
// writer.Append(parser.Current.ToString());
// }
//}
//catch (System.Exception e)
//{
// System.Exception baseException = e.GetBaseException();
// Exception.ParseException ex = new Exception.ParseException(baseException.Message, baseException);
// if (context.ThrowExceptions)
// {
// throw ex;
// }
// else
// {
// context.AddError(ex);
// writer.Append(parser.Current.ToString());
// }
//}
}
}
}
protected void Eval(TemplateContext context)
{
if (context != null)
{
if (!string.IsNullOrEmpty(this.TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(this.TemplateContent);
TemplateParser parser = new TemplateParser(context, lexer.Parse());
while (parser.MoveNext())
{
try
{
parser.Current.Parse(context);
}
catch (TemplateException e)
{
if (context.ThrowExceptions)
{
throw e;
}
else
{
context.AddError(e);
}
}
catch (Exception e)
{
Exception baseException = e.GetBaseException();
ParseException ex = new ParseException(baseException.Message, baseException);
if (context.ThrowExceptions)
{
throw ex;
}
else
{
context.AddError(ex);
}
}
}
}
}
}
public void CheckTokens(string template, string expected, char delimiterStartChar, char delimiterStopChar)
{
TemplateLexer lexer = new TemplateLexer(new ANTLRStringStream(template), delimiterStartChar, delimiterStopChar);
CommonTokenStream tokens = new CommonTokenStream(lexer);
StringBuilder buf = new StringBuilder();
buf.Append("[");
int i = 1;
IToken t = tokens.LT(i);
while (t.Type != CharStreamConstants.EndOfFile)
{
if (i > 1)
buf.Append(", ");
buf.Append(t);
i++;
t = tokens.LT(i);
}
buf.Append("]");
string result = buf.ToString();
Assert.AreEqual(expected, result);
}
static void Main(string[] args)
{
Start:
Console.Write("> ");
string data = Console.ReadLine();
TemplateLexer lexer = new TemplateLexer(data);
do
{
Token token = lexer.Next();
Console.WriteLine("{0} ({1}, {2}): {3}", token.TokenKind.ToString(), token.Line, token.Col
, token.Data);
if (token.TokenKind == TokenKind.EOF)
{
break;
}
} while (true);
goto Start;
}
private void FlagAllHiddenToken(ITextSnapshot snapshot, TemplateLexer lexer)
{
IToken open = null;
lexer.Reset();
foreach (var token in lexer.GetAllTokens())
{
if (token.Type == TemplateLexer.COMMENT)
{
ClassfificationList.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1)), ClassificationComment));
}
else if (token.Type == TemplateLexer.OPEN)
{
if (open == null)
{
open = token;
}
ClassfificationList.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1)), ClassificationTag));
}
else if (token.Type == TemplateLexer.CLOSE)
{
ClassfificationList.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1)), ClassificationTag));
if (open != null)
{
OutlineList.Add(open.StopIndex + 1);
OutlineList.Add(token.StartIndex - open.StopIndex - 1);
}
open = null;
}
else if (token.Type == TemplateLexer.TEXT)
{
ClassfificationList.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1)), ClassificationText));
}
else if (token.Type == TemplateLexer.BREAK || token.Type == TemplateLexer.CONTINUE || token.Type == TemplateLexer.RETURN)
{
ClassfificationList.Add(new ClassificationSpan(new SnapshotSpan(snapshot, new Span(token.StartIndex, token.StopIndex - token.StartIndex + 1)), ClassificationKeyword));
}
}
lexer.Reset();
}
private void RebuidTokens()
{
CommentTable.Clear();
ClassfificationList.Clear();
StructNameList.Clear();
BracePairList.Clear();
OutlineList.Clear();
ErrorList.Clear();
var snapshot = this.Buffer.CurrentSnapshot;
var lexer = new TemplateLexer(new AntlrInputStream(snapshot.GetText()));
var parser = new TemplateParser(new CommonTokenStream(lexer));
//parser.ErrorHandler = classificationErrorHandler;
//parser.RemoveErrorListeners();
//parser.AddErrorListener(classificationErrorListener);
parser.document().Accept <int>(classificationVisitor);
FlagAllHiddenToken(snapshot, lexer);
//ClassificationChanged?.Invoke(this, new ClassificationChangedEventArgs(new SnapshotSpan(snapshot, 0, snapshot.Length)));
}
/// <summary>
/// 呈现标签
/// </summary>
/// <param name="context">上下文</param>
/// <param name="writer">writer</param>
protected void Render(TemplateContext context, TextWriter writer)
{
//缓存功能，待添加
if (context == null)
{
writer.Write(this.TemplateContent);
return;
}
Tag[] collection;
if (!String.IsNullOrEmpty(this.TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(this.TemplateContent, context.Config.TagFlag, context.Config.TagPrefix, context.Config.TagSuffix);
TemplateParser parser = new TemplateParser(lexer.Parse(), context.Config.Resolver);
collection = parser.ToArray();
}
else
{
collection = new Tag[0];
}
if (collection.Length > 0)
{
for (Int32 i = 0; i < collection.Length; i++)
{
try
{
collection[i].Parse(context, writer);
}
catch (Exception.TemplateException e)
{
if (context.ThrowExceptions)
{
throw e;
}
else
{
context.AddError(e);
writer.Write(collection[i].ToString());
}
}
catch (System.Exception e)
{
System.Exception baseException = e.GetBaseException();
Exception.ParseException ex = new Exception.ParseException(baseException.Message, baseException);
if (context.ThrowExceptions)
{
throw ex;
}
else
{
context.AddError(ex);
writer.Write(collection[i].ToString());
}
}
}
}
}
public TemplateParser(TemplateLexer lexer)
{
this.lexer = lexer;
this.elements = new List<Element>();
}
public CompiledTemplate Compile(string template,
char delimiterStartChar,
char delimiterStopChar)
{
int initialSize = Math.Max(5, (int)(template.Length / CODE_SIZE_FACTOR));
instrs = new byte[initialSize];
sourceMap = new Interval[initialSize];
code.template = template;
TemplateLexer lexer = new TemplateLexer(new ANTLRStringStream(template), delimiterStartChar, delimiterStopChar);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TemplateParser parser = new TemplateParser(tokens, this, enclosingTemplateName);
try
{
parser.templateAndEOF(); // parse, trigger compile actions for single expr
}
catch (RecognitionException re)
{
ThrowTemplateException(tokens, parser, re);
}
if (strings != null)
code.strings = strings.ToArray();
code.codeSize = ip;
code.instrs = new byte[code.codeSize];
code.sourceMap = new Interval[code.codeSize];
Array.Copy(instrs, 0, code.instrs, 0, code.codeSize);
Array.Copy(sourceMap, 0, code.sourceMap, 0, code.codeSize);
return code;
}
public TemplateParser(TemplateLexer lexer)
{
this.lexer = lexer;
this.elements = new List <Element>();
}
public string Process()
{
if (Elements == null)
{
lexer = new TemplateLexer(this.Content);
parser = new TemplateParser(lexer);
tagParser = new TagParser(parser);
//TagParser tagParser=new TagParser(parser);
//List<Element> elements = tagParser.Parse();
Elements = tagParser.Parse();
}
for (int i = 0; i < Elements.Count; i++)
{
if (Elements[i] is Function)
{
sw.Write(ProcessFunction(Elements[i] as Function));
}
else if (Elements[i] is TagFunction)
{
var item = Elements[i] as TagFunction;
if (item.FunctionName == "Include")
{
string templateName = string.Empty;
Expression attrExp = item.GetAttribute("file");
templateName = EvalExpression(attrExp).ToString();
var temp = new Template(templateName, ProcessTagFunction(item));
for (int j = 0; j < Variables.Count; j++)
{
string key = Variables.GetKey(j);
string value = Variables.GetValue(j).ToString();
temp.SetValue(Variables.GetKey(j), Variables.GetValue(j));
}
sw.Write(temp.Process());
}
else
sw.Write(ProcessTagFunction(Elements[i] as TagFunction));
}
else if (Elements[i] is Text)
{
sw.Write((Elements[i] as Text).Data);
}
else if (Elements[i] is Field)
{
sw.Write(EvalField(Elements[i] as Field));
}
else if(Elements[i] is Variable)
{
sw.Write(GetVariableValue((Elements[i] as Variable).Name));
}
else if (Elements[i] is TagClose)
{
}
}
return sw.GetStringBuilder().ToString();
}
