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");
}
}
