internal static CompiledTemplate LoadTemplate(JinjaEnvironment environment, string templateText, IDictionary <string, object?> variableTemplate, string templateName, string?templatePath)
{
var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate);
var expr = ToExpression(templateName, environment, templateText, rootScope);
return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), templateName, templatePath));
}
internal Expression ToExpression(string expressionText, CompiledScope scope)
{
var tokens = Lexer.Tokenize(expressionText).ToArray();
var astNode = Parser.Parse(tokens);
var transformer = new ExpressionTreeTransformer(LanguageDefinition, scope);
return(astNode.Transform(transformer));
}
internal object?Evaluate(string expressionText, IDictionary <string, object?> variables)
{
variables = variables ?? throw new ArgumentNullException(nameof(variables));
var rootScope = CompiledScope.CreateRootScope("root", variables);
var data = Dynamic(expressionText, rootScope);
return(data.Evaluate(variables));
}
internal CompiledTemplate GetTemplate <T>(string templateText, CompiledScope scope, string templateName, string?templatePath)
{
Settings.IsReadOnly = true;
if (Settings.DynamicTemplates)
{
throw new NotImplementedException();
}
return(CompiledTemplate.LoadTemplate(this, templateText, scope, templateName, templatePath));
}
internal static CompiledTemplate FromBlockNode(string templateName, JinjaEnvironment environment, BlockNode blockNode, IDictionary <string, object?> variableTemplate)
{
var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate);
#if DEBUG
var expr = NewASTCompiler.ToExpression(templateName, environment, blockNode, out var newcompiler, rootScope);
return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), blockNode.Name, null));
#else
throw new NotImplementedException();
#endif
}
internal static ExpressionData CreateDynamic(Expression expression, CompiledScope scope)
{
var parameterExpressions = scope.Variables.ToArray();
var parameterInfo = parameterExpressions.Select(param => new ParameterInfo(param.Name, param.Type)).ToArray();
var parameterTypes = parameterExpressions.Select(param => param.Type).ToArray();
var funcType = GetDelegateType(expression.Type, parameterTypes, out var genericTypes);
var lambda = GetLambdaMethod(funcType).Invoke(null, new object[] { expression, parameterExpressions });
var compileMethod = lambda.GetType().GetMethod("Compile", Type.EmptyTypes);
var compiled = compileMethod.Invoke(lambda, Array.Empty <object>());
if (!(compiled is Delegate compiledDelegate))
{
throw new NotImplementedException();
}
return(new ExpressionData(expression.Type, parameterInfo, expression, compiledDelegate, true));
}
private CompiledScope ReadNetExtType()
{
int pos = br.ReadInt32();
string s = pcu_file.ref_assemblies[pos];
Assembly a = (Assembly)assemblies[s];
if (a == null)
{
string tmp = s.Substring(0, s.IndexOf(','));
string name_with_path = Compiler.GetReferenceFileName(tmp + ".dll");
//a = Assembly.LoadFrom(name_with_path);
a = PascalABCCompiler.NetHelper.NetHelper.LoadAssembly(name_with_path);
PascalABCCompiler.NetHelper.NetHelper.init_namespaces(a);
assemblies[s] = a;
}
//Type t = NetHelper.NetHelper.FindTypeByHandle(a,br.ReadInt32());//íàõîäèì åãî ïî òîêåíó
Type t = FindTypeByHandle(br.ReadInt32());
CompiledScope cs = TypeTable.get_compiled_type(new SymInfo(t.Name, SymbolKind.Class, t.FullName), t);
return(cs);
}
internal Expression GetTemplateExpression(string templateName, CompiledScope scope)
{
var templateInfo = GetTemplateInfo(templateName);
return(CompiledTemplate.ToExpression(templateName, this, templateInfo.Source, scope));
}
//internal static Template LoadTemplate(JinjaEnvironment environment, string templateText, IDictionary<string, object?> variableTemplate, string? templateName, string? templatePath)
//{
// var expr = ToExpression(environment, templateText, variableTemplate, out var compiler);
// return new Template(environment, compiler.Compile(expr), templateName, templatePath);
//}
internal static CompiledTemplate LoadTemplate(JinjaEnvironment environment, string templateText, CompiledScope scope, string templateName, string?templatePath)
{
var expr = ToExpression(templateName, environment, templateText, scope);
return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, scope), templateName, templatePath));
}
//internal static Expression ToExpression(JinjaEnvironment environment, string templateText, IDictionary<string, object?> variableTemplate, out ASTCompiler compiler)
//{
// var lexer = new Lexer(environment);
// var tokens = lexer.Tokenize(templateText).ToArray();
// var parsed = Parser.Parse(tokens).ToArray();
// var environmentTrimmed = EnvironmentTrimming.EnvironmentTrim(parsed, environment.Settings).ToArray();
// var templateNode = ASTGenerator.ParseTemplate(environmentTrimmed);
// var commentsRemoved = templateNode.Transform(CommentRemoverTransformer.Instance);
// var controlledWhiteSpace = WhiteSpaceController.ControlWhiteSpace(commentsRemoved);
// var containerAssembled = controlledWhiteSpace.Transform(TemplateContainerAssembler.Instance);
// var finished = NewASTCompiler.ToExpression(environment, containerAssembled, variableTemplate, out var newcompiler);
// throw new NotImplementedException();
//}
internal static Expression ToExpression(string templateName, JinjaEnvironment environment, string templateText, CompiledScope rootScope)
{
var containerAssembled = ASTNode.GetTemplateNode(environment, templateText);
#if DEBUG
var finished = NewASTCompiler.ToExpression(templateName, environment, containerAssembled, out var newcompiler, rootScope);
return(finished);
#else
throw new NotImplementedException();
#endif
}
internal static ExpressionData CreateCompiled(Expression expression, CompiledScope scope)
{
return(CreateDynamic(expression, scope));
}
internal static Expression ToExpression(string templateName, JinjaEnvironment environment, ASTNode node, out NewASTCompiler compiler, CompiledScope rootScope)
{
compiler = new NewASTCompiler(environment, rootScope);
compiler.PushScope(SCOPE_NAME_INTERNAL);
var internalVariableAssignments = new Expression[]
{
CreateVariable(compiler, VARNAME_STRING_BUILDER, Expression.New(typeof(StringBuilder))),
CreateVariable(compiler, VARNAME_STRING_SELF, Expression.New(typeof(CompiledSelf)))
};
compiler.PushScope(string.Format(CultureInfo.InvariantCulture, SCOPE_NAME_TEMPLATE, templateName));
var compiledNodes = node.Transform(compiler);
var contentBlock = compiler.PopScope(string.Format(CultureInfo.InvariantCulture, SCOPE_NAME_TEMPLATE, templateName), compiledNodes);
var toString = ExpressionEx.Object.ToStringEx(compiler.StringBuilderVar);
var internalContent = internalVariableAssignments
.Concat(contentBlock)
.Concat(toString);
var internalBlock = compiler.PopScope(SCOPE_NAME_INTERNAL, internalContent);
return(internalBlock);
internal ExpressionTreeTransformer(ILanguageDefinition languageDefinition, CompiledScope scope)
{
LanguageDefinition = languageDefinition;
OperatorTransformer = new ExpressionTreeOperatorTransformer(this, languageDefinition);
Scopes.Push(scope);
}
internal ExpressionData Dynamic(string expressionText, CompiledScope scope)
{
var expression = ToExpression(expressionText, scope);
return(ExpressionData.CreateDynamic(expression, scope));
}
