/// <summary> /// Generate the code that we will use to access this array. Loop symantics in this framework are basically "foreach" rather than "for" - so /// we return an object that can be used to reference each array element. /// </summary> /// <param name="env"></param> /// <param name="context"></param> /// <param name="indexName"></param> /// <param name="popVariableContext"></param> /// <returns></returns> public Tuple <Expression, IDeclaredParameter> AddLoop(IGeneratedQueryCode env, ICodeContext context, CompositionContainer container) { /// /// First, we will need to know the length of this array /// var lenExpression = Expression.ArrayLength(_arrayExpression); var lenTranslation = ExpressionToCPP.GetExpression(lenExpression, env, context, container); /// /// Next, generate the expression that forms the basis of the index lookup. We don't /// translate this - that only gets to happen when one is actually looking at a final result. /// var loopVariable = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var indexExpression = Expression.MakeBinary(ExpressionType.ArrayIndex, _arrayExpression, loopVariable); /// /// Now the for loop statement! /// env.Add(new StatementForLoop(loopVariable, lenTranslation)); /// /// Return the index expression - the thing that can be used to replace all expressions and /// reference the item we are looping over. /// return(Tuple.Create <Expression, IDeclaredParameter>(indexExpression, loopVariable)); }
/// <summary> /// We have an enumerable range expression. Process it! :-) /// </summary> /// <param name="expr"></param> /// <param name="gc"></param> /// <param name="cc"></param> /// <param name="container"></param> /// <param name="ReGetIArrayInfo"></param> /// <returns></returns> private IArrayInfo ProcessEnumerableRangeExpression(Expression expr, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container, Func <Expression, IArrayInfo> ReGetIArrayInfo) { var er = expr as EnumerableRangeExpression; var minVal = ExpressionToCPP.GetExpression(er.LowBoundary, gc, cc, container); var maxVal = ExpressionToCPP.GetExpression(er.HighBoundary, gc, cc, container); return(new EnumerableRangeArrayInfo(minVal, maxVal)); }
/// <summary> /// We only support a sub-class of expressions for now - so we'd better make sure we are protected! /// </summary> /// <param name="expression"></param> /// <returns></returns> protected override Expression VisitConditional(ConditionalExpression expression) { // We can support complex sub-expressions so long as they don't leak out of the // comparison. if (expression.Type.IsClass && ( CheckForSubQueries.CheckExpression(expression.IfFalse) || CheckForSubQueries.CheckExpression(expression.IfTrue)) ) { throw new NotSupportedException(string.Format("Complex true/false clauses in a conditional expression are not supported: '{0}'", expression.ToString())); } // If this is a class as a result, then we can't do much extra processing here. So skip. if (expression.Type.IsClass) { return(base.VisitConditional(expression)); } // Run the code for the test, and then create the if/then/else that will support it. var testExpression = base.Visit(expression.Test); var testExpressionEvaluation = ExpressionToCPP.GetExpression(testExpression, GeneratedCode, CodeContext, MEFContainer); var testBoolInCode = testExpressionEvaluation is DeclarableParameter p ? p : DeclarableParameter.CreateDeclarableParameterExpression(typeof(bool)); if (testBoolInCode != testExpressionEvaluation) { GeneratedCode.Add(testBoolInCode); GeneratedCode.Add(new Statements.StatementAssign(testBoolInCode, testExpressionEvaluation)); } // The result var conditionalResult = DeclarableParameter.CreateDeclarableParameterExpression(expression.Type); GeneratedCode.Add(conditionalResult); // Do the if true statement var topScope = GeneratedCode.CurrentScope; GeneratedCode.Add(new Statements.StatementFilter(testBoolInCode)); var iftrueExpression = Visit(expression.IfTrue); GeneratedCode.Add(new Statements.StatementAssign(conditionalResult, ExpressionToCPP.GetExpression(iftrueExpression, GeneratedCode, CodeContext, MEFContainer))); GeneratedCode.CurrentScope = topScope; // Do the if false statement GeneratedCode.Add(new Statements.StatementFilter(ExpressionToCPP.GetExpression(Expression.Not(testBoolInCode), GeneratedCode, CodeContext, MEFContainer))); var ifFalseExpression = Visit(expression.IfFalse); GeneratedCode.Add(new Statements.StatementAssign(conditionalResult, ExpressionToCPP.GetExpression(ifFalseExpression, GeneratedCode, CodeContext, MEFContainer))); GeneratedCode.CurrentScope = topScope; // Consider this expression now transformed, so return the result, not // the conditional expression itself. return(conditionalResult); }