public ErrorList SetTargetObject(
Interpreter terp,
ITemplateType source)
{
Errors.Clear();
Interpreter = terp;
InternalSetTargetObject((CommonTree) T.Children[0], source);
return Errors;
}
protected override void OnEval(out ITemplateType o)
{
o = StringType.Empty();
foreach (var arg in T.Children)
{
var directive = arg.Text;
SetDirective(directive);
}
}
protected override void OnEval(
out ITemplateType o)
{
o = LogicalOr(T);
if (o == null && !Errors.ContainsError()
&& !Errors.ContainsWarning())
{
Errors.ErrorRuntimeError();
}
}
public static ITemplateType ApplyBinary(ITemplateType lhs, ITemplateType rhs, int id, ErrorList errors)
{
if (rhs == null || lhs == null)
return null;
var op = (Operator) id;
try
{
var rt = lhs.ApplyBinary(op, rhs);
return PrimitiveType.Create(rt);
}
catch (Exception e)
{
errors.ErrorRuntimeError(e);
}
return null;
}
public ErrorList Eval(
Context ctx,
Interpreter interpreter,
out ITemplateType o)
{
if (T == null || T.Type == 0)
{
Errors.ErrorParse((CommonErrorNode) T);
o = null;
return Errors;
}
Ctx = ctx;
Interpreter = interpreter;
Errors.Clear();
OnEval(out o);
return Errors;
}
protected override void OnEval(out ITemplateType o)
{
var c = (CommonTree) T.Children[0];
switch (c.Type)
{
case 0:
{
Errors.ErrorParse((CommonErrorNode) c);
o = null;
break;
}
case TemplateLexer.MPass:
case TemplateLexer.EPass:
{
o = EvalPassThrough(c);
if (c.Type == TemplateLexer.MPass)
{
string obj;
if (!o.TryConvert(out obj))
{
Errors.ErrorMacrosOnlyAcceptStrings(c.Text);
return;
}
var i = new Interpreter(obj);
var result = i.Apply(S);
Errors.AddRange(result.Errors);
o = Errors.ContainsError()
? StringType.Empty()
: StringType.New(result.Output);
}
break;
}
default:
{
o = StringType.Empty();
break;
}
}
}
private void SetIndex(
ITemplateType that,
ITemplateType source,
CommonTree argTree)
{
var type = that.UnderlyingType;
var indexer = type.GetProperty("Item");
if (indexer == null)
{
Errors.WarningPropertyNotFound(type, "'Index based property'");
return;
}
var args = GetArgs(argTree);
try
{
indexer.SetValue(that.RawValue, source.RawValue, args);
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
}
}
private IEnumerator PrimeIter(ITemplateType t)
{
var iter = (IEnumerable) t.RawValue;
return iter.GetEnumerator();
}
private bool InvokeFunc(
ITemplateType that,
string name,
CommonTree argTree,
out ITemplateType result)
{
var type = that.UnderlyingType;
var method = type.GetMethod(name);
if (method == null)
{
Errors.ErrorFunctionNotFound(type, name);
result = StringType.Empty();
return false;
}
var args = GetArgs(argTree);
if (method.ReturnType == typeof (void))
{
try
{
method.Invoke(that.RawValue, args);
result = new VoidType();
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
try
{
var rt = method.Invoke(that.RawValue, args);
result = PrimitiveType.Create(rt);
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
private void Set(
ITemplateType that,
string name,
ITemplateType source)
{
var type = that.UnderlyingType;
var prop = type.GetProperty(name);
if (prop == null)
{
Errors.WarningPropertyNotFound(type, name);
return;
}
try
{
prop.SetValue(that.RawValue, source.RawValue, null);
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
}
}
private ITemplateType EvalMacro(ITemplateType source)
{
if (source == null) return StringType.Empty();
string obj;
if (!source.TryConvert(out obj))
{
_errors.ErrorMacrosOnlyAcceptStrings(source.UnderlyingType, string.Empty);
return StringType.Empty();
}
var i = new Interpreter.Interpreter(obj, Cache);
var result = i.Apply(_state);
_errors.AddRange(result.Errors);
return StringType.New(result.Output);
}
private bool InvokeDelegate(
ITemplateType d,
CommonTree argTree,
out ITemplateType result)
{
var func = (Delegate) d.RawValue;
var args = GetArgs(argTree);
if (func.Method.ReturnType == typeof (void))
{
try
{
func.DynamicInvoke(args);
result = new VoidType();
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
try
{
var rt = func.DynamicInvoke(args);
result = PrimitiveType.Create(rt);
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
private bool Get(
ITemplateType that,
string name,
out ITemplateType result)
{
var type = that.UnderlyingType;
var prop = type.GetProperty(name);
if (prop == null)
{
Errors.WarningPropertyNotFound(type, name);
result = StringType.Empty();
return false;
}
try
{
result = PrimitiveType.Create(prop.GetValue(that.RawValue, null));
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
protected void OnChild(
Evaluator child,
out ITemplateType o)
{
var e = child.Eval(Ctx, Interpreter, out o);
Errors.AddRange(e);
}
private void AppendToBuffer(ITemplateType t)
{
if (t == null)
return;
if (_buffer == null)
return;
t.WriteTo(_buffer);
}
private void SetState(
string name,
ITemplateType rvalue)
{
if (string.IsNullOrEmpty(name)
|| rvalue == null)
return;
_state.SetValue(name, rvalue);
}
private bool TryPrimary(CommonTree tree, out ITemplateType o)
{
switch (tree.Type)
{
case 0:
{
Errors.ErrorParse((CommonErrorNode) tree);
o = null;
return true;
}
case TemplateParser.DynamicString:
{
Errors.AddRange(new DynamicString(tree).Eval(Ctx, Interpreter, out o));
return true;
}
case TemplateParser.Constant:
{
Errors.AddRange(new Constant(tree).Eval(Ctx, Interpreter, out o));
return true;
}
case TemplateParser.Statement:
{
Errors.AddRange(new Statement(tree).Eval(Ctx, Interpreter, out o));
return true;
}
case TemplateParser.Passthrough:
{
Errors.AddRange(new Passthrough(tree).Eval(Ctx, Interpreter, out o));
return true;
}
case TemplateParser.Nested:
{
var expression = (CommonTree) tree.Children[0];
o = LogicalOr(expression);
return true;
}
case TemplateParser.Error:
{
Errors.ErrorUnknownKeyword(tree.Children[0].Text);
o = null;
return true;
}
default:
{
o = null;
return false;
}
}
}
private ITemplateType InvokeFunction5(
ITemplateType that,
string name,
ITemplateType arg0,
ITemplateType arg1,
ITemplateType arg2,
ITemplateType arg3,
ITemplateType arg4)
{
if (that == null)
return null;
var type = that.UnderlyingType;
var method = type.GetMethod(name);
if (method == null)
{
_errors.ErrorFunctionNotFound(type, name);
return null;
}
var isVoid = method.ReturnType == typeof (void);
FixedArgsCallSite site;
if (!TryGetCompiledFixedArgs(type, name, out site))
{
site = new FixedArgsCallSite(5, method);
SetCompiledFixedArgs(type, name, site);
}
try
{
var rt = site.Invoke(
that.RawValue,
arg0.RawValue,
arg1.RawValue,
arg2.RawValue,
arg3.RawValue,
arg4.RawValue);
return isVoid ? new VoidType() : PrimitiveType.Create(rt);
}
catch (Exception e)
{
_errors.ErrorRuntimeError(e);
return null;
}
}
private ITemplateType InvokeFunction(
ITemplateType that,
string name,
ITemplateType[] args)
{
if (that == null)
return null;
var type = that.UnderlyingType;
var method = type.GetMethod(name);
if (method == null)
{
_errors.ErrorFunctionNotFound(type, name);
return null;
}
var isVoid = method.ReturnType == typeof (void);
if ((OptimizeLevel & OptimizeLevel.Callsite) == OptimizeLevel.Callsite)
{
CallSite site;
if (!TryGetCompiledFunctionCall(type, name, out site))
{
site = new MemberFunctionCallSite(method);
SetCompiledFunctionCall(type, name, site);
}
try
{
var rt = site.Invoke(that.RawValue, args.ToRaw());
return isVoid ? new VoidType() : PrimitiveType.Create(rt);
}
catch (Exception e)
{
_errors.ErrorRuntimeError(e);
return null;
}
}
try
{
var rt = method.Invoke(that.RawValue, args.ToRaw());
return isVoid ? new VoidType() : PrimitiveType.Create(rt);
}
catch (Exception e)
{
_errors.ErrorRuntimeError(e);
return null;
}
}
public static ITemplateType ApplyUnary(ITemplateType lhs, int id, ErrorList errors)
{
if (lhs == null)
return null;
var op = (Operator) id;
try
{
return PrimitiveType.Create(lhs.ApplyUnary(op));
}
catch (Exception e)
{
errors.ErrorRuntimeError(e);
}
return null;
}
private bool Index(
ITemplateType that,
CommonTree argTree,
out ITemplateType result)
{
var type = that.UnderlyingType;
var indexer = type.GetProperty("Item");
if (indexer == null)
{
Errors.WarningPropertyNotFound(type, "'Index based property'");
result = StringType.Empty();
return false;
}
var args = GetArgs(argTree);
try
{
var item = indexer.GetValue(that.RawValue, args);
result = PrimitiveType.Create(item);
return true;
}
catch (Exception e)
{
Errors.ErrorRuntimeError(e);
result = null;
return false;
}
}
public static int UnwrapBooleanType(ITemplateType operand)
{
if (operand == null)
return 0;
bool flag;
if (!operand.TryConvert(out flag))
{
return 0;
}
return flag ? 1 : 0;
}
private void InternalSetTargetObject(
CommonTree s,
ITemplateType source)
{
var root = s.Children[0].Text;
if (s.Children.Count < 2)
{
S.SetValue(root, source);
return;
}
ITemplateType r;
if (!S.TryGetValue(root, out r))
{
Errors.ErrorMissingItemInChain(S.GetType(), root);
return;
}
var that = r;
for (var i = 1; i < s.Children.Count; i++)
{
var current = (CommonTree) s.Children[i];
ITemplateType result;
switch (current.Type)
{
case 0:
{
Errors.ErrorParse((CommonErrorNode) current);
return;
}
case TemplateParser.Invoke:
{
if (i == s.Children.Count - 1)
{
Errors.ErrorUnableToSetIntoFunctionResult(
that.UnderlyingType.Name, current.Text);
return;
}
//that should be a delegate
if (!that.CanInvoke())
{
Errors.ErrorNonInvokableObject(that.ToString());
return;
}
if (!InvokeDelegate(that, current, out result))
{
return;
}
that = result;
break;
}
case TemplateParser.Indexer:
{
if (i == s.Children.Count - 1)
{
SetIndex(that, source, current);
return;
}
if (!Index(that, current, out result))
{
return;
}
that = result;
break;
}
case TemplateParser.Prop:
{
if (i == s.Children.Count - 1)
{
Set(that, current.Text, source);
return;
}
var next = (CommonTree) s.Children[i + 1];
switch (next.Type)
{
case TemplateParser.Invoke:
{
//consume this prop and the args
// then invoke
var funcName = current.Text;
var args = next;
if (!InvokeFunc(
that,
funcName,
args,
out result))
{
return;
}
that = result;
i++; //move to args
break;
}
default:
{
if (!Get(
that,
current.Text,
out result))
{
return;
}
that = result;
break;
}
}
break;
}
}
}
Errors.ErrorUnableToSetIntoFunctionResult(
that.UnderlyingType.Name,
s.Children[s.Children.Count - 2].Text);
}
protected abstract void OnEval(out ITemplateType o);
private int CheckIsEnumerable(ITemplateType t)
{
if (t.RawValue is IEnumerable)
{
return 1;
}
_errors.ErrorIEnumerableRequired(t.UnderlyingType.Name);
return 0;
}
