public object ConstructScope(string inputTemplateName, List <object> args)
{
var templateName = ParseTemplateName(inputTemplateName).pureTemplateName;
if (!TemplateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
var parameters = TemplateMap[templateName].Parameters;
var currentScope = CurrentTarget().Scope;
if (args.Count == 0)
{
// no args to construct, inherit from current scope
return(currentScope);
}
var newScope = parameters.Zip(args, (k, v) => new { k, v })
.ToDictionary(x => x.k, x => x.v);
var memory = currentScope as CustomizedMemory;
if (memory == null)
{
throw new Exception(LGErrors.InvalidMemory);
}
// inherit current memory's global scope
return(new CustomizedMemory(memory.GlobalMemory, new SimpleObjectMemory(newScope)));
}
public AnalyzerResult AnalyzeTemplate(string templateName)
{
if (!templateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
if (evaluationTargetStack.Any(e => e.TemplateName == templateName))
{
throw new Exception($"{LGErrors.LoopDetected} {string.Join(" => ", evaluationTargetStack.Reverse().Select(e => e.TemplateName))} => {templateName}");
}
// Using a stack to track the evaluation trace
evaluationTargetStack.Push(new EvaluationTarget(templateName, null));
// we don't exclude parameters any more
// because given we don't track down for templates have parameters
// the only scenario that we are still analyzing an parameterized template is
// this template is root template to analyze, in this we also don't have exclude parameters
var dependencies = Visit(templateMap[templateName].ParseTree);
evaluationTargetStack.Pop();
return(dependencies);
}
/// <summary>
/// Expand the results of a template with given name and scope.
/// </summary>
/// <param name="templateName">Given template name.</param>
/// <param name="scope">Given scope.</param>
/// <returns>All possiable results.</returns>
public List <string> ExpandTemplate(string templateName, object scope)
{
if (!(scope is CustomizedMemory))
{
scope = new CustomizedMemory(SimpleObjectMemory.Wrap(scope));
}
if (!TemplateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
if (evaluationTargetStack.Any(e => e.TemplateName == templateName))
{
throw new Exception($"{LGErrors.LoopDetected} {string.Join(" => ", evaluationTargetStack.Reverse().Select(e => e.TemplateName))} => {templateName}");
}
// Using a stack to track the evaluation trace
evaluationTargetStack.Push(new EvaluationTarget(templateName, scope));
var result = Visit(TemplateMap[templateName].ParseTree);
evaluationTargetStack.Pop();
return(result);
}
private void CheckTemplateReference(string templateName, IEnumerable <Expression> children)
{
if (!this.TemplateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
var expectedArgsCount = this.TemplateMap[templateName].Parameters.Count();
var actualArgsCount = children.Count();
if (actualArgsCount != 0 && expectedArgsCount != actualArgsCount)
{
throw new Exception(LGErrors.ArgumentMismatch(templateName, expectedArgsCount, actualArgsCount));
}
}
/// <summary>
/// Evaluate a template with given name and scope.
/// </summary>
/// <param name="inputTemplateName">template name.</param>
/// <param name="scope">scope.</param>
/// <returns>Evaluate result.</returns>
public object EvaluateTemplate(string inputTemplateName, object scope)
{
if (!(scope is CustomizedMemory))
{
scope = new CustomizedMemory(SimpleObjectMemory.Wrap(scope));
}
(var reExecute, var templateName) = ParseTemplateName(inputTemplateName);
if (!TemplateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
if (evaluationTargetStack.Any(e => e.TemplateName == templateName))
{
throw new Exception($"{LGErrors.LoopDetected} {string.Join(" => ", evaluationTargetStack.Reverse().Select(e => e.TemplateName))} => {templateName}");
}
var templateTarget = new EvaluationTarget(templateName, scope);
var currentEvaluateId = templateTarget.GetId();
EvaluationTarget previousEvaluateTarget = null;
if (evaluationTargetStack.Count != 0)
{
previousEvaluateTarget = evaluationTargetStack.Peek();
if (!reExecute && previousEvaluateTarget.EvaluatedChildren.ContainsKey(currentEvaluateId))
{
return(previousEvaluateTarget.EvaluatedChildren[currentEvaluateId]);
}
}
// Using a stack to track the evaluation trace
evaluationTargetStack.Push(templateTarget);
var result = Visit(TemplateMap[templateName].ParseTree);
if (previousEvaluateTarget != null)
{
previousEvaluateTarget.EvaluatedChildren[currentEvaluateId] = result;
}
evaluationTargetStack.Pop();
return(result);
}
private void ValidTemplateReference(Expression expression)
{
var templateName = expression.Type;
if (!this.TemplateMap.ContainsKey(templateName))
{
throw new Exception(LGErrors.TemplateNotExist(templateName));
}
var expectedArgsCount = this.TemplateMap[templateName].Parameters.Count();
var actualArgsCount = expression.Children.Length;
if (expectedArgsCount != actualArgsCount)
{
throw new Exception(LGErrors.ArgumentMismatch(templateName, expectedArgsCount, actualArgsCount));
}
}