public static LambdaExpression Analzye(AnalysisContext analysisContext, Function function)
{
analysisContext.CurrentOutputExpression = Expression.Parameter(typeof(TextWriter), AnalysisContext.CurrentOutputIdentifier);
List<Expression> outerExpressions = new List<Expression>
{
Expression.Assign(
analysisContext.CurrentOutputExpression,
Expression.Property(analysisContext.RuntimeContextExpression,
analysisContext.OutputWriterProperty))
};
using (analysisContext.ScopeStack.TrackPush(function.ParameterList.SymbolTable))
{
//Create return target
analysisContext.ReturnLabelTarget = Expression.Label(typeof(object), "lambdaReturn");
LabelExpression returnLabel = Expression.Label(analysisContext.ReturnLabelTarget, Expression.Default(typeof(object)));
outerExpressions.Add(StatementBlockAnalyzer.Analyze(analysisContext, function.Body));
outerExpressions.Add(returnLabel);
BlockExpression completeFunctionBody = Expression.Block(new[] { analysisContext.CurrentOutputExpression }, outerExpressions);
LambdaExpression lambda = Expression.Lambda(completeFunctionBody, function.Name.Text, function.ParameterList.SymbolTable.GetParameterExpressions());
return lambda;
}
}
public static Expression Analyze(AnalysisContext analysisContext, StatementNodeBase node)
{
var analyzer = new StatementAnalyzer(analysisContext);
node.Accept(analyzer);
if(analyzer._result == null)
throw new InternalException("StatementAnalyzer did not handle a " + node.GetType() + " which is a descendant of StatementNodeBase");
return analyzer._result;
}
public static Expression Analyze(AnalysisContext analysisContext, StatementBlock statementBlock)
{
var analyzer = new StatementBlockAnalyzer(analysisContext);
statementBlock.Accept(analyzer);
if (analyzer._result == null)
throw new InternalException("A StatementBlockAnalyzer did not generate a _result");
return analyzer._result;
}
public static Expression Analyze(AnalysisContext analysisContext, ExpressionNodeBase node)
{
var analyzer = new ExpressionAnalyzer(analysisContext);
node.Accept(analyzer);
if (analyzer._result == null)
throw new InternalException("Node type " + node.NodeKind + " not recognized by " + analyzer.GetType().FullName);
return analyzer._result;
}
public HappyScriptCode Analyze(Module module, SourceUnit sourceUnit)
{
Init();
//This List<Expression> becomes the global scope initializer
var rootNamespaces = LoadAllAssemblies(module.LoadDirectives);
ExpandoObject importScope = new ExpandoObject();
foreach (HappyNamespaceTracker tracker in rootNamespaces.Values)
DynamicObjectHelpers.SetMember(importScope, tracker.Name, tracker);
#if WRITE_AST
AstWriter writer = new AstWriter(Console.Out);
module.WriteString(writer);
#endif
var getRuntimeContextExpr = Expression.Dynamic(_languageContext.CreateGetMemberBinder(RuntimeContextIdentifier, false), typeof(object), _globalScopeExp);
UnaryExpression runtimeContextExpression = Expression.Convert(getRuntimeContextExpr, typeof(HappyRuntimeContext));
var errorCollector = new ErrorCollector(_languageContext.ErrorSink);
_analysisContext = new AnalysisContext(errorCollector, _languageContext, runtimeContextExpression, _globalScopeExp);
RunAllVisitors(module, rootNamespaces);
List<Expression> body = new List<Expression>();
//Initialize globals
using (_scopeStack.TrackPush(module.SymbolTable))
{
foreach (VariableDef def in module.GlobalDefStatements.SelectMany(defStmt => defStmt.VariableDefs))
{
Expression initialValue = def.InitializerExpression != null ? ExpressionAnalyzer.Analyze(_analysisContext, def.InitializerExpression) : Expression.Constant(null, typeof(object));
HappySymbolBase symbol = module.SymbolTable.Items[def.Name.Text];
body.Add(symbol.GetSetExpression(initialValue));
}
}
body.AddRange(module.Functions.Select(
func => _analysisContext.PropertyOrFieldSet(func.Name.Text, _globalScopeExp, FunctionAnalyzer.Analzye(_analysisContext, func))));
//At this point analysis has completed and all of our stacks should be empty
DebugAssert.AreEqual(0, _scopeStack.Count, "scope stack not empty after analysis");
//Add an empty expression--prevents an exception by Expression.Lambda when body is empty.
//This allows compilation of empty template sets.
if(body.Count == 0)
body.Add(Expression.Empty());
LambdaExpression globalScopeInitializer = Expression.Lambda(typeof(Action<IDynamicMetaObjectProvider>),
Expression.Block(body), new[] { _globalScopeExp });
HappyScriptCode output = new HappyScriptCode(sourceUnit, globalScopeInitializer.Compile());
return output;
}
public static Expression Analyze(AnalysisContext analysisContext, OutputStatement node)
{
List<Expression> expressionsToWrite = new List<Expression>();
foreach (var expr in node.ExpressionsToWrite)
{
Expression expressionToWrite = ExpressionAnalyzer.Analyze(analysisContext, expr);
Expression writeToOutputExpression = analysisContext.CreateWriteToOutputExpression(expressionToWrite);
expressionsToWrite.Add(writeToOutputExpression);
}
DebugAssert.IsGreater(0, expressionsToWrite.Count, "number of output expressions should have been > 0");
return Expression.Block(expressionsToWrite);
}
StatementBlockAnalyzer(AnalysisContext analysisContext)
: base(VisitorMode.VisitNodeAndChildren)
{
_analysisContext = analysisContext;
}
public static Expression Analyze(AnalysisContext analysisContext, IfStatement node)
{
var analyzer = new IfStatementAnalyzer(analysisContext);
node.Accept(analyzer);
return analyzer._result;
}
protected IfStatementAnalyzer(AnalysisContext analysisContext)
: base(VisitorMode.VisitNodeAndChildren)
{
_analysisContext = analysisContext;
}
ExpressionAnalyzer(AnalysisContext analysisContext)
: base(VisitorMode.VisitNodeOnly)
{
_analysisContext = analysisContext;
}
protected StatementAnalyzer(AnalysisContext analysisContext)
: base(VisitorMode.VisitNodeOnly)
{
_analysisContext = analysisContext;
}
