private void RefactorFieldNamesInFieldReferences(CodeExpression expression, string newName) { // Do we have a field reference in the expression we are given? if (typeof(CodeFieldReferenceExpression) != expression.GetType()) { return; } CodeFieldReferenceExpression frefStatement = (CodeFieldReferenceExpression)expression; // Is target object of field reference referring to a variable declaration? if (typeof(CodeVariableReferenceExpression) == frefStatement.TargetObject.GetType()) { CodeVariableReferenceExpression vrefStatement = (CodeVariableReferenceExpression)frefStatement.TargetObject; // Get a reference to the variable declaration statement. CodeVariableDeclarationStatement vdeclStatement = stackVariables[vrefStatement.VariableName]; // Is this a variable of type we are modifying now? if (vdeclStatement.Type.BaseType == newName) { // Then we can convert the field names to PascalCase. frefStatement.FieldName = PascalCaseConverterHelper.GetPascalCaseName(frefStatement.FieldName); } } }
/// <summary> /// Rewrites references to entities with dictionary provider specific CodeDom to do the correct lookup. /// </summary> /// <param name="source">the CodeDom Expression to rewrite</param> /// <param name="didRewrite">indicates whether or not the expression was rewritten</param> /// <returns>the CodeDom expression appropriate for the dictionary provider</returns> protected override CodeExpression Rewrite(CodeExpression source, ref bool didRewrite) { var propertyRef = source as CodePropertyReferenceExpression; if (propertyRef != null) { return(this.RewritePropertyReference(propertyRef, ref didRewrite)); } var lambdaExpression = source as CodeLambdaExpression; if (lambdaExpression != null) { return(this.RewriteLambdaExpression(lambdaExpression, ref didRewrite)); } var arrayExpression = source as CodeAnonymousArrayExpression; if (arrayExpression != null) { return(this.RewriteAnonymousArray(arrayExpression, ref didRewrite)); } ExceptionUtilities.Assert( source.GetType().Namespace == typeof(CodeObject).Namespace, "Taupo-defined code expressions need to be explicitly handled or the base tree rewriter will lose them"); return(base.Rewrite(source, ref didRewrite)); }
public IExpression GetExpression(CodeExpression expression, CodeGeneratorOptions options) { if (expression == null) { throw new ArgumentNullException("expression"); } return(_expressionMap[expression.GetType()](expression, options)); }
public static T GetTypedCodeExpression <T>(CodeExpression expression) { if (typeof(T) == expression.GetType()) { return((T)(object)expression); } return(default(T)); }
private static object GetValue(RuleExecution execution, CodeExpression obj) { if (obj.GetType() == typeof(System.CodeDom.CodePrimitiveExpression)) { return(((System.CodeDom.CodePrimitiveExpression)obj).Value); } if (obj.GetType() == typeof(CodeFieldReferenceExpression)) { return(RuleExpressionCondition.CodeFieldReferenceValue(execution, obj)); } if (obj.GetType() == typeof(CodePropertyReferenceExpression)) { return(RuleExpressionCondition.CodePropertyReferenceValue(execution, obj)); } return(null); }
void AppendExpression(CodeExpression expression) { if (expression is CodeMethodInvokeExpression) { AppendMethodInvokeExpression((CodeMethodInvokeExpression)expression); } else if (expression is CodePropertyReferenceExpression) { AppendPropertyReferenceExpression((CodePropertyReferenceExpression)expression); } else if (expression is CodeObjectCreateExpression) { AppendObjectCreateExpression((CodeObjectCreateExpression)expression); } else if (expression is CodePrimitiveExpression) { AppendPrimitiveExpression((CodePrimitiveExpression)expression); } else if (expression is CodeFieldReferenceExpression) { AppendFieldReferenceExpression((CodeFieldReferenceExpression)expression); } else if (expression is CodeThisReferenceExpression) { AppendThisReferenceExpression(); } else if (expression is CodeTypeReferenceExpression) { AppendTypeReferenceExpression((CodeTypeReferenceExpression)expression); } else if (expression is CodeArrayCreateExpression) { AppendArrayCreateExpression((CodeArrayCreateExpression)expression); } else if (expression is CodeVariableReferenceExpression) { AppendVariableReferenceExpression((CodeVariableReferenceExpression)expression); } else if (expression is CodeDelegateCreateExpression) { AppendDelegateCreateExpression((CodeDelegateCreateExpression)expression); } else if (expression is CodeCastExpression) { AppendCastExpression((CodeCastExpression)expression); } else if (expression is CodeBinaryOperatorExpression) { AppendBinaryOperatorExpression((CodeBinaryOperatorExpression)expression); } else { Console.WriteLine("AppendExpression: " + expression.GetType().Name); } }
private static Operation GetPrecedence(CodeExpression expression) { ComputePrecedence precedence; Operation noParentheses = Operation.NoParentheses; if (precedenceMap.TryGetValue(expression.GetType(), out precedence)) { noParentheses = precedence(expression); } return(noParentheses); }
public void ExpressionContext_Constructor() { CodeExpression expression = new CodeExpression(); Type type = expression.GetType(); object owner = "owner"; object presetValue = null; var underTest = new ExpressionContext(expression, type, owner, presetValue); Assert.NotNull(underTest); Assert.Equal(expression, underTest.Expression); }
private static Operation GetPrecedence(CodeExpression expression) { // Assume the operation needs no parentheses. Operation operation = Operation.NoParentheses; if (precedenceMap.TryGetValue(expression.GetType(), out ComputePrecedence computePrecedence)) { operation = computePrecedence(expression); } return(operation); }
protected void GenerateExpression(CodeExpression e) { if (e == null) { throw new ArgumentNullException("e"); } try { e.Accept(visitor); } catch (NotImplementedException) { throw new ArgumentException("Element type " + e.GetType() + " is not supported.", "e"); } }
void EmitExpression(CodeExpression expr) { if (expr is CodeMethodInvokeExpression) { EmitInvoke((CodeMethodInvokeExpression)expr); } else if (expr is CodeArrayCreateExpression) { EmitArray((CodeArrayCreateExpression)expr); } else if (expr is CodePrimitiveExpression) { EmitPrimitive((CodePrimitiveExpression)expr); } else if (expr is CodeBinaryOperatorExpression) { EmitBinary((CodeBinaryOperatorExpression)expr); } else if (expr is CodeTernaryOperatorExpression) { EmitTernary((CodeTernaryOperatorExpression)expr); } else if (expr is CodeVariableReferenceExpression) { EmitVariableReference((CodeVariableReferenceExpression)expr); } else if (expr is CodeArgumentReferenceExpression) { EmitArgumentReference((CodeArgumentReferenceExpression)expr); } else if (expr is CodeFieldReferenceExpression) { EmitFieldReference((CodeFieldReferenceExpression)expr); } else if (expr is CodeTypeReferenceExpression) { EmitTypeReference((CodeTypeReferenceExpression)expr); } else if (expr is CodeArrayIndexerExpression) { EmitArrayIndexer((CodeArrayIndexerExpression)expr); } else if (expr is CodePropertyReferenceExpression) { EmitPropertyReference((CodePropertyReferenceExpression)expr); } else { throw new ArgumentException("Unrecognised expression: " + expr.GetType()); } }
void VisitCodeExpression(CodeExpression expression) { if (expression != null) { WriteLine("VisitCodeExpression: " + expression.GetType().Name); CodePrimitiveExpression primitiveExpression = expression as CodePrimitiveExpression; CodeFieldReferenceExpression fieldReferenceExpression = expression as CodeFieldReferenceExpression; CodeThisReferenceExpression thisReferenceExpression = expression as CodeThisReferenceExpression; CodeObjectCreateExpression createExpression = expression as CodeObjectCreateExpression; CodeBinaryOperatorExpression binaryExpression = expression as CodeBinaryOperatorExpression; CodeMethodReferenceExpression methodReferenceExpression = expression as CodeMethodReferenceExpression; CodeMethodInvokeExpression methodInvokeExpression = expression as CodeMethodInvokeExpression; CodeVariableReferenceExpression variableReferenceExpression = expression as CodeVariableReferenceExpression; if (primitiveExpression != null) { VisitCodePrimitiveExpression(primitiveExpression); } else if (fieldReferenceExpression != null) { VisitCodeFieldReferenceExpression(fieldReferenceExpression); } else if (thisReferenceExpression != null) { VisitCodeThisReferenceExpression(thisReferenceExpression); } else if (createExpression != null) { VisitObjectCreateExpression(createExpression); } else if (binaryExpression != null) { VisitCodeBinaryOperatorExpression(binaryExpression); } else if (methodReferenceExpression != null) { VisitCodeMethodReferenceExpression(methodReferenceExpression); } else if (methodInvokeExpression != null) { VisitCodeMethodInvokeExpression(methodInvokeExpression); } else if (variableReferenceExpression != null) { VisitCodeVariableReferenceExpression(variableReferenceExpression); } } else { WriteLine("VisitCodeExpression: Null"); } }
public static bool Match(CodeExpression firstExpression, CodeExpression secondExpression) { if ((firstExpression == null) && (secondExpression == null)) { return(true); } if ((firstExpression == null) || (secondExpression == null)) { return(false); } if (firstExpression.GetType() != secondExpression.GetType()) { return(false); } return(GetExpression(firstExpression).Match(firstExpression, secondExpression)); }
private static RuleExpressionInternal GetExpression(CodeExpression expression) { Type type = expression.GetType(); int length = typeWrappers.Length; for (int i = 0; i < length; i++) { TypeWrapperTuple tuple = typeWrappers[i]; if (type == tuple.codeDomType) { return(tuple.internalExpression); } } IRuleExpression ruleExpr = expression as IRuleExpression; if (ruleExpr != null) { return(new CustomExpressionWrapper(ruleExpr)); } return(null); }
private static RuleExpressionInternal GetExpression(CodeExpression expression) { Type exprType = expression.GetType(); int numTypeWrappers = typeWrappers.Length; for (int i = 0; i < numTypeWrappers; ++i) { TypeWrapperTuple tuple = typeWrappers[i]; if (exprType == tuple.codeDomType) { return(tuple.internalExpression); } } // It's not a builtin one... try a user extension expression. if (expression is IRuleExpression ruleExpr) { return(new CustomExpressionWrapper(ruleExpr)); } return(null); }
private static bool AreEqual(CodeExpression codeExpression, CodeExpression anotherCodeExpression) { if (codeExpression.GetType() != anotherCodeExpression.GetType()) { return(false); } if (codeExpression is CodePrimitiveExpression) { return (CodePrimitiveExpressionValue(codeExpression) .Equals(CodePrimitiveExpressionValue(anotherCodeExpression), StringComparison.InvariantCultureIgnoreCase)); } if (codeExpression is CodeArrayCreateExpression) { var codeExpressions = (CodeArrayCreateExpression)codeExpression; var anotherCodeExpressions = (CodeArrayCreateExpression)anotherCodeExpression; if (codeExpressions.CreateType.BaseType != anotherCodeExpressions.CreateType.BaseType || codeExpressions.Initializers.Count != anotherCodeExpressions.Initializers.Count) { return(false); } for (var i = 0; i < codeExpressions.Initializers.Count; i++) { if (!AreEqual(codeExpressions.Initializers[i], anotherCodeExpressions.Initializers[i])) { return(false); } } return(true); } return(false); }
public static bool Match(CodeExpression firstExpression, CodeExpression secondExpression) { // If they're both null, they match. if (firstExpression == null && secondExpression == null) { return(true); } // If only one of them is null, there's no match. if (firstExpression == null || secondExpression == null) { return(false); } if (firstExpression.GetType() != secondExpression.GetType()) { return(false); } RuleExpressionInternal ruleExpr1 = GetExpression(firstExpression); return(ruleExpr1.Match(firstExpression, secondExpression)); }
public override bool Evaluate(RuleExecution execution) { Type type = expression.GetType(); Console.WriteLine("RuleExpressionCondition.RuleExpressionCondition {0}", type); if (type == typeof(CodeBinaryOperatorExpression)) { return(RuleExpressionBinaryOperatorResolver.Evaluate(execution, expression)); } if (type == typeof(CodePropertyReferenceExpression)) { return((bool)CodePropertyReferenceValue(execution, expression)); } if (type == typeof(CodeFieldReferenceExpression)) { return((bool)CodePropertyReferenceValue(execution, expression)); } throw new InvalidOperationException(); }
/// <summary> /// If the provided code expression is one of the provided types or if generator option /// <see cref="GeneratorOptions.RemoveRedundantParenthesis"/> is false it will be wrapped with the provided strings /// </summary> /// <param name="obj"></param> /// <param name="ctx"></param> /// <param name="types"></param> /// <param name="preHandleWrapString"></param> /// <param name="postHandleWrapString"></param> public static void WrapIfIsTypeAndHandle(CodeExpression obj, Context ctx, IEnumerable <Type> types, string preHandleWrapString = "(", string postHandleWrapString = ")") { bool needsWrapping = true; if (ctx.Options.RemoveRedundantParenthesis) { Type objType = obj.GetType(); needsWrapping = types.Any((type) => type.IsAssignableFrom(objType)); } if (needsWrapping) { ctx.Writer.Write(preHandleWrapString); } ctx.HandlerProvider.ExpressionHandler.Handle(obj, ctx); if (needsWrapping) { ctx.Writer.Write(postHandleWrapString); } }
private CodeTypeReference GetCodeTypeReferenceInCodeExpression(CodeExpression expression) { if (typeof(CodeTypeOfExpression) == expression.GetType()) { return(((CodeTypeOfExpression)expression).Type); } if (typeof(CodeTypeReferenceExpression) == expression.GetType()) { return(((CodeTypeReferenceExpression)expression).Type); } if (typeof(CodeFieldReferenceExpression) == expression.GetType()) { return(GetCodeTypeReferenceInCodeExpression(((CodeFieldReferenceExpression)expression).TargetObject)); } if (typeof(CodeObjectCreateExpression) == expression.GetType()) { return(((CodeObjectCreateExpression)expression).CreateType); } if (typeof(CodeCastExpression) == expression.GetType()) { return(((CodeCastExpression)expression).TargetType); } if (typeof(CodeMethodInvokeExpression) == expression.GetType()) { return(GetCodeTypeReferenceInCodeExpression(((CodeMethodInvokeExpression)expression).Method)); } if (typeof(CodeMethodReferenceExpression) == expression.GetType()) { return(GetCodeTypeReferenceInCodeExpression(((CodeMethodReferenceExpression)expression).TargetObject)); } return(null); }
private CodeExpression TryGetCachedExpression(IDesignerSerializationManager manager, object value, CodeExpression parentExpression, object presetValue) { CodeExpression expression = null; if (value != null) // in order to support null value serialization { expression = base.GetExpression(manager, value); } if (expression == null) { if (parentExpression == null) { manager.Context.Push(new ExpressionContext(null, null, value, presetValue)); } else { manager.Context.Push(new ExpressionContext(parentExpression, parentExpression.GetType(), value, presetValue)); } expression = base.SerializeToExpression(manager, value); manager.Context.Pop(); } return(expression); }
private void ValidateExpression(CodeExpression e) { if (e is CodeArrayCreateExpression) { this.ValidateArrayCreateExpression((CodeArrayCreateExpression)e); } else if (e is CodeBaseReferenceExpression) { this.ValidateBaseReferenceExpression((CodeBaseReferenceExpression)e); } else if (e is CodeBinaryOperatorExpression) { this.ValidateBinaryOperatorExpression((CodeBinaryOperatorExpression)e); } else if (e is CodeCastExpression) { this.ValidateCastExpression((CodeCastExpression)e); } else if (e is CodeDefaultValueExpression) { ValidateDefaultValueExpression((CodeDefaultValueExpression)e); } else if (e is CodeDelegateCreateExpression) { this.ValidateDelegateCreateExpression((CodeDelegateCreateExpression)e); } else if (e is CodeFieldReferenceExpression) { this.ValidateFieldReferenceExpression((CodeFieldReferenceExpression)e); } else if (e is CodeArgumentReferenceExpression) { ValidateArgumentReferenceExpression((CodeArgumentReferenceExpression)e); } else if (e is CodeVariableReferenceExpression) { ValidateVariableReferenceExpression((CodeVariableReferenceExpression)e); } else if (e is CodeIndexerExpression) { this.ValidateIndexerExpression((CodeIndexerExpression)e); } else if (e is CodeArrayIndexerExpression) { this.ValidateArrayIndexerExpression((CodeArrayIndexerExpression)e); } else if (e is CodeSnippetExpression) { this.ValidateSnippetExpression((CodeSnippetExpression)e); } else if (e is CodeMethodInvokeExpression) { this.ValidateMethodInvokeExpression((CodeMethodInvokeExpression)e); } else if (e is CodeMethodReferenceExpression) { this.ValidateMethodReferenceExpression((CodeMethodReferenceExpression)e); } else if (e is CodeEventReferenceExpression) { this.ValidateEventReferenceExpression((CodeEventReferenceExpression)e); } else if (e is CodeDelegateInvokeExpression) { this.ValidateDelegateInvokeExpression((CodeDelegateInvokeExpression)e); } else if (e is CodeObjectCreateExpression) { this.ValidateObjectCreateExpression((CodeObjectCreateExpression)e); } else if (e is CodeParameterDeclarationExpression) { this.ValidateParameterDeclarationExpression((CodeParameterDeclarationExpression)e); } else if (e is CodeDirectionExpression) { this.ValidateDirectionExpression((CodeDirectionExpression)e); } else if (e is CodePrimitiveExpression) { this.ValidatePrimitiveExpression((CodePrimitiveExpression)e); } else if (e is CodePropertyReferenceExpression) { this.ValidatePropertyReferenceExpression((CodePropertyReferenceExpression)e); } else if (e is CodePropertySetValueReferenceExpression) { this.ValidatePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)e); } else if (e is CodeThisReferenceExpression) { this.ValidateThisReferenceExpression((CodeThisReferenceExpression)e); } else if (e is CodeTypeReferenceExpression) { ValidateTypeReference(((CodeTypeReferenceExpression)e).Type); } else if (e is CodeTypeOfExpression) { ValidateTypeOfExpression((CodeTypeOfExpression)e); } else { if (e == null) { throw new ArgumentNullException("e"); } throw new ArgumentException(SR.GetString("InvalidElementType", new object[] { e.GetType().FullName }), "e"); } }
private void GenerateExpression(CodeExpression expression) { if (expression is CodeArrayCreateExpression) { GenerateArrayCreateExpression((CodeArrayCreateExpression)expression); } else if (expression is CodeBaseReferenceExpression) { GenerateBaseReferenceExpression((CodeBaseReferenceExpression)expression); } else if (expression is CodeBinaryOperatorExpression) { GenerateBinaryOperatorExpression((CodeBinaryOperatorExpression)expression); } else if (expression is CodeCastExpression) { GenerateCastExpression((CodeCastExpression)expression); } else if (expression is CodeFieldReferenceExpression) { GenerateFieldReferenceExpression((CodeFieldReferenceExpression)expression); } else if (expression is CodeArgumentReferenceExpression) { GenerateArgumentReferenceExpression((CodeArgumentReferenceExpression)expression); } else if (expression is CodeVariableReferenceExpression) { GenerateVariableReferenceExpression((CodeVariableReferenceExpression)expression); } else if (expression is CodeArrayIndexerExpression) { GenerateArrayIndexerExpression((CodeArrayIndexerExpression)expression); } else if (expression is CodeSnippetExpression) { GenerateSnippetExpression((CodeSnippetExpression)expression); } else if (expression is CodeMethodInvokeExpression) { GenerateMethodInvokeExpression((CodeMethodInvokeExpression)expression); } else if (expression is CodeMethodReferenceExpression) { GenerateMethodReferenceExpression((CodeMethodReferenceExpression)expression); } else if (expression is CodeObjectCreateExpression) { GenerateObjectCreateExpression((CodeObjectCreateExpression)expression); } else if (expression is CodeParameterDeclarationExpression) { GenerateParameterDeclarationExpression((CodeParameterDeclarationExpression)expression); } else if (expression is CodePrimitiveExpression) { GeneratePrimitiveExpression((CodePrimitiveExpression)expression); } else if (expression is CodePropertyReferenceExpression) { GeneratePropertyReferenceExpression((CodePropertyReferenceExpression)expression); } else if (expression is CodePropertySetValueReferenceExpression) { GeneratePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)expression); } else if (expression is CodeThisReferenceExpression) { GenerateThisReferenceExpression((CodeThisReferenceExpression)expression); } else if (expression is CodeTypeReferenceExpression) { GenerateTypeReferenceExpression((CodeTypeReferenceExpression)expression); } else if (expression is CodeTypeOfExpression) { GenerateTypeOfExpression((CodeTypeOfExpression)expression); } else if (expression is CodeDefaultValueExpression) { GenerateDefaultValueExpression((CodeDefaultValueExpression)expression); } else { if (expression == null) { throw new ArgumentNullException("e"); } else { throw new ArgumentException("e is of an invalid type: " + expression.GetType().FullName, "e"); } } }
protected void GenerateExpression(CodeExpression e) { if (e is CodeArrayCreateExpression) { GenerateArrayCreateExpression((CodeArrayCreateExpression)e); } else if (e is CodeBaseReferenceExpression) { GenerateBaseReferenceExpression((CodeBaseReferenceExpression)e); } else if (e is CodeBinaryOperatorExpression) { GenerateBinaryOperatorExpression((CodeBinaryOperatorExpression)e); } else if (e is CodeCastExpression) { GenerateCastExpression((CodeCastExpression)e); } else if (e is CodeDelegateCreateExpression) { GenerateDelegateCreateExpression((CodeDelegateCreateExpression)e); } else if (e is CodeFieldReferenceExpression) { GenerateFieldReferenceExpression((CodeFieldReferenceExpression)e); } else if (e is CodeArgumentReferenceExpression) { GenerateArgumentReferenceExpression((CodeArgumentReferenceExpression)e); } else if (e is CodeVariableReferenceExpression) { GenerateVariableReferenceExpression((CodeVariableReferenceExpression)e); } else if (e is CodeIndexerExpression) { GenerateIndexerExpression((CodeIndexerExpression)e); } else if (e is CodeArrayIndexerExpression) { GenerateArrayIndexerExpression((CodeArrayIndexerExpression)e); } else if (e is CodeSnippetExpression) { GenerateSnippetExpression((CodeSnippetExpression)e); } else if (e is CodeMethodInvokeExpression) { GenerateMethodInvokeExpression((CodeMethodInvokeExpression)e); } else if (e is CodeMethodReferenceExpression) { GenerateMethodReferenceExpression((CodeMethodReferenceExpression)e); } else if (e is CodeEventReferenceExpression) { GenerateEventReferenceExpression((CodeEventReferenceExpression)e); } else if (e is CodeDelegateInvokeExpression) { GenerateDelegateInvokeExpression((CodeDelegateInvokeExpression)e); } else if (e is CodeObjectCreateExpression) { GenerateObjectCreateExpression((CodeObjectCreateExpression)e); } else if (e is CodeParameterDeclarationExpression) { GenerateParameterDeclarationExpression((CodeParameterDeclarationExpression)e); } else if (e is CodeDirectionExpression) { GenerateDirectionExpression((CodeDirectionExpression)e); } else if (e is CodePrimitiveExpression) { GeneratePrimitiveExpression((CodePrimitiveExpression)e); } else if (e is CodePropertyReferenceExpression) { GeneratePropertyReferenceExpression((CodePropertyReferenceExpression)e); } else if (e is CodePropertySetValueReferenceExpression) { GeneratePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)e); } else if (e is CodeThisReferenceExpression) { GenerateThisReferenceExpression((CodeThisReferenceExpression)e); } else if (e is CodeTypeReferenceExpression) { GenerateTypeReferenceExpression((CodeTypeReferenceExpression)e); } else if (e is CodeTypeOfExpression) { GenerateTypeOfExpression((CodeTypeOfExpression)e); } else if (e is CodeDefaultValueExpression) { GenerateDefaultValueExpression((CodeDefaultValueExpression)e); } else { if (e == null) { throw new ArgumentNullException(nameof(e)); } else { throw new ArgumentException(SR.Format(SR.InvalidElementType, e.GetType().FullName), nameof(e)); } } }
/// <summary> /// Track down the real type of a CodeExpression's target. /// </summary> /// <param name="targetObject"></param> /// <param name="thisType"></param> /// <returns></returns> private static Type FindTargetType(CodeExpression targetObject, Type thisType) { Type targetType = GetType(targetObject, false); if (targetType != null) { return(targetType); } else if (targetObject is CodeVariableReferenceExpression) { throw new ApplicationException("Cannot determine the type of a CodeVariableReferenceExpression: " + Serialize(targetObject)); } else if (targetObject is CodeTypeOfExpression) { // Results in a System.Type. return(typeof(Type)); } else if (targetObject is CodeThisReferenceExpression) { if (thisType == null) { throw new ApplicationException("There is a CodeThisReferenceExpression and the thisType supplied was null."); } return(thisType); } else if (targetObject is CodePrimitiveExpression) { return(((CodePrimitiveExpression)targetObject).Value.GetType()); } else if (targetObject is CodePropertyReferenceExpression) { Type toExamine = FindTargetType(((CodePropertyReferenceExpression)targetObject).TargetObject, thisType); PropertyInfo propInfo = toExamine.GetProperty(((CodePropertyReferenceExpression)targetObject).PropertyName); return(propInfo.PropertyType); } else if (targetObject is CodeMethodInvokeExpression) { Type toExamine = FindTargetType(((CodeMethodInvokeExpression)targetObject).Method.TargetObject, thisType); MethodInfo methodInfo = toExamine.GetMethod(((CodeMethodInvokeExpression)targetObject).Method.MethodName); return(methodInfo.ReturnType); } else if (targetObject is CodeFieldReferenceExpression) { Type toExamine = FindTargetType(((CodeFieldReferenceExpression)targetObject).TargetObject, thisType); String fieldName = ((CodeFieldReferenceExpression)targetObject).FieldName; FieldInfo fieldInfo = toExamine.GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); return(fieldInfo.FieldType); } else if (targetObject is CodeTypeReferenceExpression) { CodeTypeReference typeReference = ((CodeTypeReferenceExpression)targetObject).Type; return(thisType.Assembly.GetType(typeReference.BaseType)); } throw new NotSupportedException("Specified CodeExpression type is not currently supported: " + targetObject.GetType().FullName); }
private static void DumpExpression(CodeExpression e) { /* * System.CodeDom.CodeArgumentReferenceExpression * System.CodeDom.CodeArrayCreateExpression * System.CodeDom.CodeArrayIndexerExpression * System.CodeDom.CodeBaseReferenceExpression * System.CodeDom.CodeBinaryOperatorExpression * System.CodeDom.CodeCastExpression * System.CodeDom.CodeDefaultValueExpression * System.CodeDom.CodeDelegateCreateExpression * System.CodeDom.CodeDelegateInvokeExpression * System.CodeDom.CodeDirectionExpression * System.CodeDom.CodeEventReferenceExpression * System.CodeDom.CodeFieldReferenceExpression * System.CodeDom.CodeIndexerExpression * System.CodeDom.CodeMethodInvokeExpression * System.CodeDom.CodeMethodReferenceExpression * System.CodeDom.CodeObjectCreateExpression * System.CodeDom.CodeParameterDeclarationExpression * System.CodeDom.CodePrimitiveExpression * System.CodeDom.CodePropertyReferenceExpression * System.CodeDom.CodePropertySetValueReferenceExpression * System.CodeDom.CodeSnippetExpression * System.CodeDom.CodeThisReferenceExpression * System.CodeDom.CodeTypeOfExpression * System.CodeDom.CodeTypeReferenceExpression * System.CodeDom.CodeVariableReferenceExpression */ if (e == null) { return; } if (e is CodeFieldReferenceExpression cfre) { DumpExpression(cfre.TargetObject); WriteLineIndent("F: " + cfre.FieldName); } else if (e is CodeObjectCreateExpression coce) { var tr = coce.CreateType as CodeTypeReference; WriteLineIndent(tr.BaseType + "{}"); DumpExpressionList(coce.Parameters); } else if (e is CodeMethodInvokeExpression cmie) { DumpExpression(cmie.Method.TargetObject); WriteLineIndent("M: " + cmie.Method.MethodName); DumpExpressionList(cmie.Parameters); } else if (e is CodePropertyReferenceExpression cpre) { DumpExpression(cpre.TargetObject); WriteLineIndent("P: " + cpre.PropertyName); } else if (e is CodePrimitiveExpression cpe) { WriteLineIndent(cpe.ToString()); WriteLineIndent(cpe.Value.ToString()); } else if (e is CodeCastExpression cce) { WriteLineIndent(cce.TargetType.ToString()); DumpExpression(cce.Expression); } else if (e is CodeThisReferenceExpression) { WriteLineIndent("SELF"); } else if (e is CodeBinaryOperatorExpression cboe) { DumpExpression(cboe.Left); CodeBinaryOperatorType opType = cboe.Operator; WriteLineIndent(opType.ToString()); DumpExpression(cboe.Right); } else if (e is CodeTypeReferenceExpression ctre) { var tr = ctre.Type; WriteLineIndent(tr.BaseType); } else if (e is CodeBaseReferenceExpression) { WriteLineIndent("SUPER"); } else { WriteLineIndent(e.GetType().FullName); } }
internal bool Generate() { if (_runAsync) { return(GenerateAsync()); } var conditionTypes = new List <Type>(); _mainClassModelList = new List <RuleSetDomModel>(); for (int x = 0; x < _ruleDefinitions.RuleSets.Count; x++) { RuleSet ruleSet = _ruleDefinitions.RuleSets[x]; var mainClassModel = new RuleSetDomModel { Name = TransformName(ruleSet.Name), RuleSetName = ruleSet.Name, RuleSet = ruleSet }; _mainClassModelList.Add(mainClassModel); foreach (var rule in ruleSet.Rules) { try { if (rule.Active) { SendMessage("Extracting rule " + ruleSet.Name + " >> " + rule.Name, EventType.Output); } else { SendMessage("Extracting INACTIVE rule " + ruleSet.Name + " >> " + rule.Name, EventType.Output); } List <CodeStatement> thenStatements = GetCodeStatements(rule.ThenActions); List <CodeStatement> elseStatements = GetCodeStatements(rule.ElseActions); CodeExpression condition = ((RuleExpressionCondition)(rule.Condition)).Expression; Type expectedType = condition.GetType(); if (expectedType != typeof(CodeConditionStatement)) { conditionTypes.Add(expectedType); //if (conditionTypes.Contains(condition.GetType()) == false) //{ // Log.Info("Condition is " + condition.GetType()); // conditionTypes.Add(condition.GetType()); //} //else //{ // Type expectedType = condition.GetType(); // conditionTypes.Add(condition.GetType()); // //throw new NotImplementedException("No implementation found for condition type " + expectedType); //} } else { throw new NotImplementedException("No implementation found for condition type " + condition.GetType()); } mainClassModel.MethodsRuleDom.Add(new RulesDomModel(ruleSet) { Name = TransformName(rule.Name), Else = elseStatements, Then = thenStatements, Condition = condition, Comment = "", Comments = FormatComments(rule, ruleSet) }); } catch (Exception exception) { Log.Error("Exception occured while extracting a rule", exception); SendMessage(exception.Message, EventType.Error); } } ; } ; bool success = true; for (int i = 0; i < _generatorsTypes.Count; i++) { using (var instance = (RulesOutputGenerator)Activator.CreateInstance(_generatorsTypes[i].Type, MainClassModelList, _generatorsTypes[i].Output, _runAsync)) { SendMessage("Generating output " + instance.Name, EventType.Output); success &= instance.Generate(); } } SendMessage("Rules conversion completed", EventType.Complete); OnComplete(); return(success); }
protected void GenerateExpression(CodeExpression e) { if (e is CodeArrayCreateExpression) { GenerateArrayCreateExpression((CodeArrayCreateExpression)e); } else if (e is CodeBaseReferenceExpression) { GenerateBaseReferenceExpression((CodeBaseReferenceExpression)e); } else if (e is CodeBinaryOperatorExpression) { GenerateBinaryOperatorExpression((CodeBinaryOperatorExpression)e); } else if (e is CodeCastExpression) { GenerateCastExpression((CodeCastExpression)e); } else if (e is CodeDelegateCreateExpression) { GenerateDelegateCreateExpression((CodeDelegateCreateExpression)e); } else if (e is CodeFieldReferenceExpression) { GenerateFieldReferenceExpression((CodeFieldReferenceExpression)e); } else if (e is CodeArgumentReferenceExpression) { GenerateArgumentReferenceExpression((CodeArgumentReferenceExpression)e); } else if (e is CodeVariableReferenceExpression) { GenerateVariableReferenceExpression((CodeVariableReferenceExpression)e); } else if (e is CodeIndexerExpression) { GenerateIndexerExpression((CodeIndexerExpression)e); } else if (e is CodeArrayIndexerExpression) { GenerateArrayIndexerExpression((CodeArrayIndexerExpression)e); } else if (e is CodeMethodInvokeExpression) { GenerateMethodInvokeExpression((CodeMethodInvokeExpression)e); } else if (e is CodeMethodReferenceExpression) { GenerateMethodReferenceExpression((CodeMethodReferenceExpression)e); } else if (e is CodeEventReferenceExpression) { GenerateEventReferenceExpression((CodeEventReferenceExpression)e); } else if (e is CodeDelegateInvokeExpression) { GenerateDelegateInvokeExpression((CodeDelegateInvokeExpression)e); } else if (e is CodeObjectCreateExpression) { GenerateObjectCreateExpression((CodeObjectCreateExpression)e); } else if (e is CodeParameterDeclarationExpression) { GenerateParameterDeclarationExpression((CodeParameterDeclarationExpression)e); } else if (e is CodeDirectionExpression) { GenerateDirectionExpression((CodeDirectionExpression)e); } else if (e is CodePrimitiveExpression) { GeneratePrimitiveExpression((CodePrimitiveExpression)e); } else if (e is CodePropertyReferenceExpression) { GeneratePropertyReferenceExpression((CodePropertyReferenceExpression)e); } else if (e is CodePropertySetValueReferenceExpression) { GeneratePropertySetValueReferenceExpression((CodePropertySetValueReferenceExpression)e); } else if (e is CodeThisReferenceExpression) { GenerateThisReferenceExpression((CodeThisReferenceExpression)e); } else if (e is CodeTypeReferenceExpression) { GenerateTypeReferenceExpression((CodeTypeReferenceExpression)e); } else if (e is CodeTypeOfExpression) { GenerateTypeOfExpression((CodeTypeOfExpression)e); } else if (e is CodeDefaultValueExpression) { GenerateDefaultValueExpression((CodeDefaultValueExpression)e); } else { if (e == null) { throw new ArgumentNullException(nameof(e)); } else { throw new ArgumentException(string.Format(SR.InvalidElementType, e.GetType().FullName), nameof(e)); } } }
private void GenerateExpression(CodeExpression e) { switch (e) { case CodeArrayCreateExpression val: GenerateArrayCreateExpression(val); break; case CodePrimitiveArrayCreateExpression val: GenerateCodePrimitiveArrayCreateExpression(val); break; case CodeBaseReferenceExpression val: GenerateBaseReferenceExpression(); break; case CodeBinaryOperatorExpression val: GenerateBinaryOperatorExpression(val); break; case CodeCastExpression val: GenerateCastExpression(val); break; case CodeFieldReferenceExpression val: GenerateFieldReferenceExpression(val); break; case CodeArgumentReferenceExpression val: GenerateArgumentReferenceExpression(val); break; case CodeVariableReferenceExpression val: GenerateVariableReferenceExpression(val); break; case CodeArrayIndexerExpression val: GenerateArrayIndexerExpression(val); break; case CodeSnippetExpression val: GenerateSnippetExpression(val); break; case CodeSuperConstructorInvokeExpression val: GenerateSuperConstructorInvokeExpression(val); break; case CodeMethodInvokeExpression val: GenerateMethodInvokeExpression(val); break; case CodeMethodReferenceExpression val: GenerateMethodReferenceExpression(val); break; case CodeObjectCreateExpression val: GenerateObjectCreateExpression(val); break; case CodeParameterDeclarationExpression val: GenerateParameterDeclarationExpression(val); break; case CodePrimitiveExpression val: GeneratePrimitiveExpression(val); break; case CodeThisReferenceExpression val: GenerateThisReferenceExpression(); break; case CodeTypeReferenceExpression val: GenerateTypeReferenceExpression(val); break; case CodeInstanceOfExpression val: GenerateInstanceOfExpression(val); break; default: if (e == null) { throw new ArgumentNullException(nameof(e)); } else { throw new ArgumentException(InvalidElementType(e.GetType())); } } }
private static void dumpExpression(CodeExpression e) { /* * System.CodeDom.CodeArgumentReferenceExpression * System.CodeDom.CodeArrayCreateExpression * System.CodeDom.CodeArrayIndexerExpression * System.CodeDom.CodeBaseReferenceExpression * System.CodeDom.CodeBinaryOperatorExpression * System.CodeDom.CodeCastExpression * System.CodeDom.CodeDefaultValueExpression * System.CodeDom.CodeDelegateCreateExpression * System.CodeDom.CodeDelegateInvokeExpression * System.CodeDom.CodeDirectionExpression * System.CodeDom.CodeEventReferenceExpression * System.CodeDom.CodeFieldReferenceExpression * System.CodeDom.CodeIndexerExpression * System.CodeDom.CodeMethodInvokeExpression * System.CodeDom.CodeMethodReferenceExpression * System.CodeDom.CodeObjectCreateExpression * System.CodeDom.CodeParameterDeclarationExpression * System.CodeDom.CodePrimitiveExpression * System.CodeDom.CodePropertyReferenceExpression * System.CodeDom.CodePropertySetValueReferenceExpression * System.CodeDom.CodeSnippetExpression * System.CodeDom.CodeThisReferenceExpression * System.CodeDom.CodeTypeOfExpression * System.CodeDom.CodeTypeReferenceExpression * System.CodeDom.CodeVariableReferenceExpression */ if (e == null) { return; } if (e is CodeFieldReferenceExpression) { CodeFieldReferenceExpression exp = (CodeFieldReferenceExpression)e; dumpExpression(exp.TargetObject); writeLineIndent("F: " + exp.FieldName); } else if (e is CodeObjectCreateExpression) { var exp = (CodeObjectCreateExpression)e; var tr = exp.CreateType as CodeTypeReference; writeLineIndent(tr.BaseType + "{}"); dumpExpressionList(exp.Parameters); } else if (e is CodeMethodInvokeExpression) { var exp = (CodeMethodInvokeExpression)e; dumpExpression(exp.Method.TargetObject); writeLineIndent("M: " + exp.Method.MethodName); dumpExpressionList(exp.Parameters); } else if (e is CodePropertyReferenceExpression) { var exp = (CodePropertyReferenceExpression)e; dumpExpression(exp.TargetObject); writeLineIndent("P: " + exp.PropertyName); } else if (e is CodePrimitiveExpression) { var exp = (CodePrimitiveExpression)e; writeLineIndent(exp.ToString()); writeLineIndent(exp.Value.ToString()); } else if (e is CodeCastExpression) { var exp = (CodeCastExpression)e; writeLineIndent(exp.TargetType.ToString()); dumpExpression(exp.Expression); } else if (e is CodeThisReferenceExpression) { writeLineIndent("SELF"); } else if (e is CodeBinaryOperatorExpression) { var exp = (CodeBinaryOperatorExpression)e; dumpExpression(exp.Left); CodeBinaryOperatorType opType = exp.Operator; writeLineIndent(opType.ToString()); dumpExpression(exp.Right); } else if (e is CodeTypeReferenceExpression) { var exp = (CodeTypeReferenceExpression)e; var tr = exp.Type; writeLineIndent(tr.BaseType); } else if (e is CodeBaseReferenceExpression) { writeLineIndent("SUPER"); } else { writeLineIndent(e.GetType().FullName); } }
public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten) { if (validation == null) { throw new ArgumentNullException("validation"); } RuleExpressionInfo info = null; if (!isWritten) { info = validation.ExpressionInfo(expression); } if (info != null) { return(info); } RuleExpressionInternal ruleExpr = GetExpression(expression); if (ruleExpr == null) { ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression.GetType().FullName }), 0x548); item.UserData["ErrorObject"] = expression; if (validation.Errors == null) { string name = string.Empty; if ((validation.ThisType != null) && (validation.ThisType.Name != null)) { name = validation.ThisType.Name; } throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, new object[] { name })); } validation.Errors.Add(item); return(null); } return(validation.ValidateSubexpression(expression, ruleExpr, isWritten)); }
private static void ProcessExpr(CodeExpression codeExpression, CodeDomGenerator.Language language) { if (codeExpression == null) { return; } if (typeof(CodeArgumentReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeArrayCreateExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeArrayCreateExpression)codeExpression).Initializers, language); ProcessExpr(((CodeArrayCreateExpression)codeExpression).SizeExpression, language); } else if (typeof(CodeArrayIndexerExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeArrayIndexerExpression)codeExpression).Indices, language); } else if (typeof(CodeBaseReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeBinaryOperatorExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeBinaryOperatorExpression)codeExpression).Left, language); ProcessExpr(((CodeBinaryOperatorExpression)codeExpression).Right, language); } else if (typeof(CodeCastExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeCastExpression)codeExpression).Expression, language); } else if (typeof(CodeDefaultValueExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeDelegateCreateExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeDelegateCreateExpression)codeExpression).TargetObject, language); } else if (typeof(CodeDelegateInvokeExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeDelegateInvokeExpression)codeExpression).Parameters, language); ProcessExpr(((CodeDelegateInvokeExpression)codeExpression).TargetObject, language); } else if (typeof(CodeDirectionExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeDirectionExpression)codeExpression).Expression, language); } else if (typeof(CodeEventReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeEventReferenceExpression)codeExpression).TargetObject, language); } else if (typeof(CodeFieldReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeFieldReferenceExpression)codeExpression).TargetObject, language); } else if (typeof(CodeIndexerExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeIndexerExpression)codeExpression).Indices, language); ProcessExpr(((CodeIndexerExpression)codeExpression).TargetObject, language); } else if (typeof(CodeMethodInvokeExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeMethodInvokeExpression)codeExpression).Method, language); ProcessExpr(((CodeMethodInvokeExpression)codeExpression).Parameters, language); } else if (typeof(CodeMethodReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeMethodReferenceExpression)codeExpression).TargetObject, language); } else if (typeof(CodeObjectCreateExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeObjectCreateExpression)codeExpression).Parameters, language); } else if (typeof(CodeParameterDeclarationExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodePrimitiveExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodePropertyReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodePropertyReferenceExpression)codeExpression).TargetObject, language); } else if (typeof(CodePropertySetValueReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeThisReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeTypeOfExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeTypeReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeVariableReferenceExpression).IsAssignableFrom(codeExpression.GetType())) { } else if (typeof(CodeAssignExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeAssignExpression)codeExpression).Expression, language); } else if (typeof(CodeAsExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeAsExpression)codeExpression).Expression, language); } else if (typeof(CodeIsExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeIsExpression)codeExpression).Expression, language); } else if (typeof(CodeXorExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeXorExpression)codeExpression).Left, language); ProcessExpr(((CodeXorExpression)codeExpression).Right, language); } else if (typeof(CodeUnaryExpression).IsAssignableFrom(codeExpression.GetType())) { ProcessExpr(((CodeUnaryExpression)codeExpression).Expression, language); } ICustomCodeDomObject co = codeExpression as ICustomCodeDomObject; if (co != null) { co.GenerateCode(language); } }
protected void GenerateExpression(CodeExpression e) { if (e == null) throw new ArgumentNullException("e"); try { e.Accept(visitor); } catch (NotImplementedException) { throw new ArgumentException("Element type " + e.GetType() + " is not supported.", "e"); } }