private static Rule Rule_get_state_WITHOUT_AlwaysTrue_property_for_reevaluation()
{
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("SampleFlow.StaticClass"), "GetState", new CodeExpression[] { new CodeThisReferenceExpression() }),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("OR")
};
CodeMethodInvokeExpression setDiscount = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("SampleFlow.StaticClass"), "SetDiscount", new CodeExpression[] { new CodeThisReferenceExpression(), new CodePrimitiveExpression(102m) });
Rule rule15 = new Rule("Rule15")
{
Condition = new RuleExpressionCondition(ruleStateTest),
Priority = 100
};
rule15.ThenActions.Add(new RuleStatementAction(setDiscount));
return(rule15);
}
private static CodeStatement CreateCompareRevisionStatement(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var ccs = new CodeConditionStatement();
var left1 = new CodeVariableReferenceExpression("verifyRevision");
var right1 = new CodePrimitiveExpression(true);
var left = new CodeBinaryOperatorExpression(left1, CodeBinaryOperatorType.IdentityEquality, right1);
var left2 = new CodeCastExpression(typeof(int), new CodePrimitiveExpression(generationInfo.Revision));
var right2 = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataSet"), "revision");
var right = new CodeBinaryOperatorExpression(left2, CodeBinaryOperatorType.IdentityInequality, right2);
ccs.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BooleanAnd, right);
var message = string.Format("데이터의 리비전 코드 리비전({0})과 다릅니다.", generationInfo.Revision);
var exception = new CodeObjectCreateExpression("Error", new CodePrimitiveExpression(message));
ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(ccs);
}
private static CodeStatement AddCommitDataMethodFinalHelper(DataFieldDescriptor dataFieldDescriptor, IEnumerable <CodeStatement> statements)
{
// CODEGEN:
// if (this._isSet_email && this._emailNullable != null) {
// [statements]
// _isSet_email = false;
// }
string fieldName = CreateNullableFieldName(dataFieldDescriptor);
// this._isSet_email
var fieldIsSetFieldReference =
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
IsSetFieldName(dataFieldDescriptor)
);
// this._emailNullable != null
var expression2 = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
fieldName
),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)
);
return(new CodeConditionStatement(
new CodeBinaryOperatorExpression(
fieldIsSetFieldReference, CodeBinaryOperatorType.BooleanAnd, expression2),
statements.Concat(new [] {
// CODEGEN:
// this._isSetEmail = false;
new CodeAssignStatement(
fieldIsSetFieldReference,
new CodePrimitiveExpression(false)
)
}).ToArray()
));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
Enum[] enums = null;
TypeConverter converter = TypeDescriptor.GetConverter(value);
if (converter.CanConvertTo(typeof(Enum[])))
{
enums = (Enum[])converter.ConvertTo(value, typeof(Enum[]));
}
else
{
enums = new Enum[] { (Enum)value }
};
CodeExpression left = null;
CodeExpression right = null;
foreach (Enum e in enums)
{
right = GetEnumExpression(e);
if (left == null) // just the first time
{
left = right;
}
else
{
left = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BitwiseOr, right);
}
}
return(left);
}
private void CheckOccurrence(CodeStatementCollection getStatements)
{
string str;
Debug.Assert(!this.IsList);
CodeStatement returnStatement = null;
if (!(!this.IsNullable ? true : this.DefaultValue != null))
{
if (this.typeRef.IsValueType)
{
returnStatement = new CodeMethodReturnStatement(new CodePrimitiveExpression(null));
}
}
else if (this.VerifyRequired)
{
Debug.Assert(this.occursInSchema == Occurs.One);
if (this.propertyOrigin == SchemaOrigin.Element)
{
str = "Element";
}
else if (this.propertyOrigin == SchemaOrigin.Attribute)
{
str = "Attribute";
}
else
{
str = null;
}
string origin = str;
CodeExpression[] codePrimitiveExpression = new CodeExpression[] { new CodePrimitiveExpression(string.Concat("Missing required ", origin)) };
returnStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression("LinqToXsdException", codePrimitiveExpression));
}
if (returnStatement != null)
{
CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("x"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeStatement[] codeStatementArray = new CodeStatement[] { returnStatement };
getStatements.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeStatementArray));
}
}
/// <summary>
/// charType == SourceCodeCharType.Letter|| charType == SourceCodeCharType.UnderLine
/// <para>获取类似如上的代码</para>
/// </summary>
/// <returns></returns>
public CodeExpression GetCondition()
{
// charType == SourceCodeCharType.Letter
// || charType == SourceCodeCharType.UnderLine
var first = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("charType"),
CodeBinaryOperatorType.IdentityEquality,
new CodeSnippetExpression("SourceCodeCharType." + this.charTypeList[0]));
for (int i = 1; i < this.charTypeList.Count; i++)
{
var expression = new CodeBinaryOperatorExpression(
first, CodeBinaryOperatorType.BooleanOr,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("charType"),
CodeBinaryOperatorType.IdentityEquality,
new CodeSnippetExpression("SourceCodeCharType." + this.charTypeList[i])));
first = expression;
}
return(first);
}
private static BinaryOperatorType CreateInstanceForType(Type l, CodeBinaryOperatorExpression code, object right, object left)
{
if (l == typeof(Int32))
{
return(new BinaryOperatorTypeInt32(code, right, left));
}
if (l == typeof(Int16))
{
return(new BinaryOperatorTypeInt16(code, right, left));
}
if (l == typeof(Int64))
{
return(new BinaryOperatorTypeInt64(code, right, left));
}
if (l == typeof(sbyte))
{
return(new BinaryOperatorTypeSbyte(code, right, left));
}
if (l == typeof(float))
{
return(new BinaryOperatorTypeFloat(code, right, left));
}
if (l == typeof(char))
{
return(new BinaryOperatorTypeChar(code, right, left));
}
if (l == typeof(byte))
{
return(new BinaryOperatorTypeByte(code, right, left));
}
throw new InvalidOperationException("Type not suported as binary operator");
}
private static Rule Rule_set_state_WITH_update_action_set_targeting_AlwaysTrue_property()
{
CodeBinaryOperatorExpression ruleDiscountTest = new CodeBinaryOperatorExpression
{
Left = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("SampleFlow.StaticClass"), "GetDiscount", new CodeExpression[] { new CodeThisReferenceExpression() }),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression(103m)
};
CodeMethodInvokeExpression setState = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("SampleFlow.StaticClass"), "SetState", new CodeExpression[] { new CodeThisReferenceExpression(), new CodePrimitiveExpression("WA") });
Rule rule16 = new Rule("Rule16")
{
Condition = new RuleExpressionCondition(ruleDiscountTest),
Priority = 0
};
rule16.ThenActions.Add(new RuleStatementAction(setState));
rule16.ThenActions.Add(new RuleUpdateAction("this/AlwaysTrue"));
return(rule16);
}
private static Rule Rule_with_list_initialization()
{
// define first predicate: this.State == "SC"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("SC")
};
//this.SetCollection(new System.Collections.ObjectModel.Collection<object>(new object[] { "AValue", "BValue"}))
CodeMethodInvokeExpression methodInvokeSetCollection = new CodeMethodInvokeExpression
(
new CodeThisReferenceExpression(),
"SetCollection",
new CodeObjectCreateExpression
(
new CodeTypeReference
(
"System.Collections.ObjectModel.Collection",
new CodeTypeReference[] { new CodeTypeReference("System.Object") }
),
new CodeArrayCreateExpression
(
"System.Object",
new CodeExpression[] { new CodePrimitiveExpression("AValue"), new CodePrimitiveExpression("BValue") }
)
)
);
Rule rule9 = new Rule("Rule9")
{
Condition = new RuleExpressionCondition(ruleStateTest)
};
rule9.ThenActions.Add(new RuleStatementAction(methodInvokeSetCollection));
return(rule9);
}
public override CodeExpression ExportCode(IMethodCompile method)
{
MathNode.Trace("{0}.ExportCode", this.GetType().Name);
CodeVariableReferenceExpression sum = new CodeVariableReferenceExpression(((IVariable)this[4]).CodeVariableName);
this[2].AssignCodeExp(this.GetParameterCode(method, 0), ((MathNodeVariable)this[3]).CodeVariableName);
CodeExpression fa = this.GetParameterCode(method, 2);
this[2].AssignCodeExp(this.GetParameterCode(method, 1), ((MathNodeVariable)this[3]).CodeVariableName);
CodeExpression fb = this.GetParameterCode(method, 2);
this[2].AssignCodeExp(null, ((MathNodeVariable)this[3]).CodeVariableName);
CodeExpression f2 = new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(fa, CodeBinaryOperatorType.Add, fb), CodeBinaryOperatorType.Divide,
new CodePrimitiveExpression(2.0));
CodeExpression f = new CodeBinaryOperatorExpression(f2, CodeBinaryOperatorType.Add, sum);
CodeExpression ba = new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(this.GetParameterCode(method, 1), CodeBinaryOperatorType.Subtract, this.GetParameterCode(method, 0)),
CodeBinaryOperatorType.Divide, new CodePrimitiveExpression(_intervals));
return(new CodeBinaryOperatorExpression(ba, CodeBinaryOperatorType.Multiply, f));
}
private static string ConvertNodesToStringExpression(FilterExpressionNodeCollection nodes)
{
FilterExpressionNodeCollection newNodes = EliminateEmptyNodes(nodes);
// If not nodes found return null
if (newNodes.Count == 0)
{
return(null);
}
// If only one node, return it as an expression
if (newNodes.Count == 1)
{
return(ConvertNodeToStringExpression(newNodes[0]));
}
// Start processing more than 1 node
string masterExpression = String.Empty;
foreach (FilterExpressionNode node in newNodes)
{
CodeBinaryOperatorExpression currentExpression = new CodeBinaryOperatorExpression();
if (node.NodeType == FilterExpressionNodeType.Element)
{
masterExpression = AddStringExpression(masterExpression, "&&", ConvertNodeToStringExpression(node));
}
else if (node.NodeType == FilterExpressionNodeType.AndBlock)
{
masterExpression = AddStringExpression(masterExpression, "&&", ConvertNodesToStringExpression(node.ChildNodes));
}
else if (node.NodeType == FilterExpressionNodeType.OrBlock)
{
masterExpression = AddStringExpression(masterExpression, "||", ConvertNodesToStringExpression(node.ChildNodes));
}
}
return(masterExpression);
}
protected virtual void CreateConstructor(CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
mainClass.Members.Add(ctor);
if (localVars != null)
{
ctor.Statements.AddRange(localVars);
}
AssignAppRelativeVirtualPath(ctor);
CodeFieldReferenceExpression initialized = GetMainClassFieldReferenceExpression("__initialized");
CodeBinaryOperatorExpression bin;
bin = new CodeBinaryOperatorExpression(initialized,
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(false));
CodeAssignStatement assign = new CodeAssignStatement(initialized,
new CodePrimitiveExpression(true));
CodeConditionStatement cond = new CodeConditionStatement();
cond.Condition = bin;
if (trueStmt != null)
{
cond.TrueStatements.AddRange(trueStmt);
}
cond.TrueStatements.Add(assign);
ctor.Statements.Add(cond);
AddStatementsToConstructor(ctor);
}
public static CodeMemberMethod CreateXRootMethod(string returnType, string methodName, string[][] paramList)
{
CodeTypeReference xRootType = new CodeTypeReference(returnType);
CodeMemberMethod staticMethod = new CodeMemberMethod()
{
Name = methodName,
Attributes = MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public,
ReturnType = xRootType
};
CodeExpression[] parameterExp = new CodeExpression[(int)paramList.Length];
for (int i = 0; i < (int)paramList.Length; i++)
{
string[] paramRef = paramList[i];
staticMethod.Parameters.Add(CodeDomHelper.CreateParameter(paramRef[1], paramRef[0]));
parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]);
}
CodeExpression rootExp = new CodeVariableReferenceExpression("root");
CodeExpression doc = new CodeFieldReferenceExpression(rootExp, "doc");
staticMethod.Statements.Add(new CodeVariableDeclarationStatement(xRootType, "root", new CodeObjectCreateExpression(xRootType, new CodeExpression[0])));
staticMethod.Statements.Add(new CodeAssignStatement(doc, CodeDomHelper.CreateMethodCall(new CodeTypeReferenceExpression("XDocument"), methodName, parameterExp)));
CodeStatementCollection statements = staticMethod.Statements;
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices");
CodeExpression[] codePropertyReferenceExpression = new CodeExpression[] { new CodePropertyReferenceExpression(doc, "Root"), CodeDomHelper.SingletonTypeManager() };
statements.Add(new CodeVariableDeclarationStatement("XTypedElement", "typedRoot", CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "ToXTypedElement", codePropertyReferenceExpression)));
CodeStatementCollection codeStatementCollection = staticMethod.Statements;
CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("typedRoot"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeStatement[] codeThrowExceptionStatement = new CodeStatement[1];
codePropertyReferenceExpression = new CodeExpression[] { new CodePrimitiveExpression("Invalid root element in xml document.") };
codeThrowExceptionStatement[0] = new CodeThrowExceptionStatement(new CodeObjectCreateExpression("LinqToXsdException", codePropertyReferenceExpression));
codeStatementCollection.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeThrowExceptionStatement));
staticMethod.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(rootExp, "rootObject"), new CodeVariableReferenceExpression("typedRoot")));
staticMethod.Statements.Add(new CodeMethodReturnStatement(rootExp));
return(staticMethod);
}
private static Rule Rule_with_child_and_granchild_reference()
{
// define first predicate: this.State == "GA"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("GA")
};
//this.FirstClass.SecondClass.Property1 = "This Value"
CodeAssignStatement setProperty1Action = new CodeAssignStatement
(
new CodePropertyReferenceExpression
(
new CodePropertyReferenceExpression
(
new CodePropertyReferenceExpression
(
new CodeThisReferenceExpression(),
"FirstClass"
),
"SecondClass"
),
"Property1"
),
new CodePrimitiveExpression("This Value")
);
Rule rule10 = new Rule("Rule10")
{
Condition = new RuleExpressionCondition(ruleStateTest)
};
rule10.ThenActions.Add(new RuleStatementAction(setProperty1Action));
return(rule10);
}
private static Rule Rule_with_generic_object_initialization()
{
// define first predicate: this.State == "TN"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("TN")
};
//this.SetGenericObject(new SampleFlow.GenericClass<string>(7, "VName", "Stay", "ObjectData")
CodeMethodInvokeExpression methodInvokeSetGenericObject = new CodeMethodInvokeExpression
(
new CodeThisReferenceExpression(),
"SetGenericObject",
new CodeObjectCreateExpression
(
new CodeTypeReference
(
"SampleFlow.GenericClass",
new CodeTypeReference[] { new CodeTypeReference("System.String") }
),
new CodePrimitiveExpression(7),
new CodePrimitiveExpression("VName"),
new CodePrimitiveExpression("Stay"),
new CodePrimitiveExpression("ObjectData")
)
);
Rule rule11 = new Rule("Rule11")
{
Condition = new RuleExpressionCondition(ruleStateTest)
};
rule11.ThenActions.Add(new RuleStatementAction(methodInvokeSetGenericObject));
return(rule11);
}
private void ImplementIXmlSerializable()
{
string interfaceName = "IXmlSerializable";
string typeManagerName = NameGenerator.GetServicesClassName();
string methodName = string.Concat(this.clrTypeInfo.clrtypeName, "SchemaProvider");
CodeMemberMethod schemaProviderMethod = CodeDomHelper.CreateMethod(methodName, MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, null);
schemaProviderMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlSchemaSet", "schemas"));
CodeStatementCollection statements = schemaProviderMethod.Statements;
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(typeManagerName);
CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression("schemas") };
statements.Add(CodeDomHelper.CreateMethodCall(codeTypeReferenceExpression, "AddSchemas", codeVariableReferenceExpression));
codeVariableReferenceExpression = new CodeExpression[] { new CodePrimitiveExpression(this.clrTypeInfo.schemaName), new CodePrimitiveExpression(this.clrTypeInfo.schemaNs) };
CodeExpression qNameExp = new CodeObjectCreateExpression("XmlQualifiedName", codeVariableReferenceExpression);
if (this.clrTypeInfo.typeOrigin != SchemaOrigin.Element)
{
schemaProviderMethod.ReturnType = new CodeTypeReference("XmlQualifiedName");
schemaProviderMethod.Statements.Add(new CodeMethodReturnStatement(qNameExp));
}
else
{
CodeStatementCollection codeStatementCollection = schemaProviderMethod.Statements;
CodePropertyReferenceExpression codePropertyReferenceExpression = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("schemas"), "GlobalElements");
codeVariableReferenceExpression = new CodeExpression[] { qNameExp };
codeStatementCollection.Add(new CodeVariableDeclarationStatement("XmlSchemaElement", "element", new CodeCastExpression("XmlSchemaElement", new CodeIndexerExpression(codePropertyReferenceExpression, codeVariableReferenceExpression))));
CodeStatementCollection statements1 = schemaProviderMethod.Statements;
CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("element"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeStatement[] codeMethodReturnStatement = new CodeStatement[] { new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("element"), "ElementSchemaType")) };
statements1.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeMethodReturnStatement));
schemaProviderMethod.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
schemaProviderMethod.ReturnType = new CodeTypeReference("XmlSchemaType");
}
this.decl.CustomAttributes.Add(CodeDomHelper.SchemaProviderAttribute(this.clrTypeInfo.clrtypeName));
this.decl.BaseTypes.Add(interfaceName);
this.decl.Members.Add(schemaProviderMethod);
}
/// <summary>
/// Converts the nodes to expression.
/// </summary>
/// <param name="nodes">The nodes.</param>
/// <returns></returns>
protected virtual CodeBinaryOperatorExpression ConvertNodesToExpression(FilterExpressionNodeCollection nodes)
{
FilterExpressionNodeCollection newNodes = EliminateEmptyNodes(nodes);
// If not nodes found return null
if (newNodes.Count == 0)
{
return(null);
}
// If only one node, return it as an expression
if (newNodes.Count == 1)
{
return(ConvertNodeToExpression(newNodes[0]));
}
// Start processing more than 1 node
CodeBinaryOperatorExpression masterExpression = null;
foreach (FilterExpressionNode node in newNodes)
{
CodeBinaryOperatorExpression currentExpression = new CodeBinaryOperatorExpression();
if (node.NodeType == FilterExpressionNodeType.Element)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanAnd, ConvertNodeToExpression(node));
}
else if (node.NodeType == FilterExpressionNodeType.AndBlock)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanAnd, ConvertNodesToExpression(node.ChildNodes));
}
else if (node.NodeType == FilterExpressionNodeType.OrBlock)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanOr, ConvertNodesToExpression(node.ChildNodes));
}
}
return(masterExpression);
}
private CodeMemberProperty CreateUntypedProperty(CodeFieldReferenceExpression fieldRef)
{
CodeMemberProperty xElementProperty = CodeDomHelper.CreateProperty(new CodeTypeReference("XElement"), true);
xElementProperty.Name = "Untyped";
xElementProperty.Attributes = MemberAttributes.Override | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public;
CodePropertyReferenceExpression baseUntyped = new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), "Untyped");
xElementProperty.GetStatements.Add(new CodeMethodReturnStatement(baseUntyped));
xElementProperty.SetStatements.Add(new CodeAssignStatement(baseUntyped, CodeDomHelper.SetValue()));
if (!this.clrTypeInfo.IsSubstitutionHead)
{
xElementProperty.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(fieldRef, "Untyped"), CodeDomHelper.SetValue()));
}
else
{
CodeStatementCollection setStatements = xElementProperty.SetStatements;
CodeBinaryOperatorExpression codeBinaryOperatorExpression = new CodeBinaryOperatorExpression(fieldRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeStatement[] codeAssignStatement = new CodeStatement[] { new CodeAssignStatement(new CodePropertyReferenceExpression(fieldRef, "Untyped"), CodeDomHelper.SetValue()) };
setStatements.Add(new CodeConditionStatement(codeBinaryOperatorExpression, codeAssignStatement));
}
return(xElementProperty);
}
public void Visit(WhenLiteralStatement statement)
{
CodeStatementCollection collection = new CodeStatementCollection();
var arg = VisitChild(statement.Literal);
var condition = new CodeConditionStatement();
if (arg.Tag != null) //this is a null literal
{
condition.Condition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("var"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
}
else
{
var preCondition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("var"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
condition.Condition = new CodeBinaryOperatorExpression(preCondition, CodeBinaryOperatorType.BooleanAnd, new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("var"), "Equals", arg.CodeExpression));
}
var then = VisitChild(statement.Then);
condition.TrueStatements.Add(new CodeMethodReturnStatement(then.CodeExpression));
_codeStack.Peek().Tag = then.Tag;
_codeStack.Peek().ParentStatements.Add(condition);
}
public override void AddBind(IShaderDom shader, Action <CodeStatement, string> add)
{
//call the preshaders
if (vertexPreShader != null)
{
CodeExpression call = new CodeMethodInvokeExpression(shader.Instance, "vspre");
CodeExpression condition = new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(shader.VertexPreShaderRegistersRef, "change"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
CodeStatement invoke = new CodeConditionStatement(condition, shader.ETS(call));
add(invoke, "run the vertex preshader");
}
//pixel
if (pixelPreShader != null)
{
CodeExpression call = new CodeMethodInvokeExpression(shader.Instance, "pspre");
CodeExpression condition = new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(shader.PixelPreShaderRegistersRef, "change"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
CodeStatement invoke = new CodeConditionStatement(condition, shader.ETS(call));
add(invoke, "run the pixel preshader");
}
}
private static Rule Rule_with_multiple_conditions()
{
// define first predicate: this.State == "MD"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("MD")
};
//this.boolMethod()
CodeMethodInvokeExpression boolMethodInvoke = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "BoolMethod", new CodeExpression[] { });
//combine both expressions this.state == "MD" && this.boolMethod()
CodeBinaryOperatorExpression codeBothExpression = new CodeBinaryOperatorExpression
{
Left = ruleStateTest,
Operator = CodeBinaryOperatorType.BooleanAnd,
Right = boolMethodInvoke
};
//discount action this.Discount = 400
CodeAssignStatement discountAction = new CodeAssignStatement
(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Discount"),
new CodePrimitiveExpression(400)
);
Rule rule4 = new Rule("Rule4")
{
Condition = new RuleExpressionCondition(codeBothExpression)
};
rule4.ThenActions.Add(new RuleStatementAction(discountAction));
return(rule4);
}
public static CodeTypeDeclaration EncapsulateField(this CodeTypeDeclaration typeDeclaration,
CodeMemberField field, string name, CodeExpression lazyValue, CodeExpression lazyCondition = null)
{
var p = new CodeMemberProperty
{
Name = name,
Type = field.Type,
HasGet = true,
Attributes = MemberAttributes.Public
};
typeDeclaration.Members.Add(p);
var r = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
var lazyConditionStatement = new CodeConditionStatement();
CodeExpression finalLazyCondition = lazyCondition;
if (finalLazyCondition == null)
{
var defaultConditionStatement =
new CodeBinaryOperatorExpression(
r,
CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("null"));
finalLazyCondition = defaultConditionStatement;
}
lazyConditionStatement.Condition = finalLazyCondition;
lazyConditionStatement.TrueStatements.Add(new CodeAssignStatement(r, lazyValue));
p.GetStatements.Add(lazyConditionStatement);
p.GetStatements.Add(
new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
field.Name)));
return(typeDeclaration);
}
public void Test_Rule_method_invocation_missing_required_parameter_throws_InvalidOperationException()
{
//Arrange
RuleSet ruleSet = new RuleSet {
Name = "MyRuleSet", ChainingBehavior = RuleChainingBehavior.Full
};
ruleSet.Rules.Add(BuildRule());
//Act
Assert.Throws <InvalidOperationException>(() => CreateRuleEngine(ruleSet));
Rule BuildRule()
{
// define first predicate: this.State == "MA"
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("MA")
};
//action SampleFlow.FlowEntity.SetDefaultState("NH")
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression
(
new CodeThisReferenceExpression(),
"SetValues",
new CodeExpression[] { new CodePrimitiveExpression("AAA") }
);
return(new Rule("Rule1")
{
Condition = new RuleExpressionCondition(ruleStateTest),
ThenActions = { new RuleStatementAction(methodInvoke) }
});
}
}
public void TypeReferenceExpressionTest()
{
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
parentField.TargetObject = thisRef;
parentField.FieldName = "Parent";
CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
parentField,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
Assert.AreEqual("(Not (Me.Parent) Is Nothing)", Generate(expression, sw), "#1");
sw.Close();
}
sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
parentField.TargetObject = thisRef;
parentField.FieldName = "Parent";
CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(null),
CodeBinaryOperatorType.IdentityInequality,
parentField);
Assert.AreEqual("(Not (Me.Parent) Is Nothing)", Generate(expression, sw), "#2");
sw.Close();
}
}
internal static CodeMemberMethod AddAsyncMethod(CodeTypeDeclaration codeClass, string methodName,
string[] parameterTypeNames, string[] parameterNames, string callbackMember, string callbackName, string userState)
{
CodeMemberMethod asyncCodeMethod = WebCodeGenerator.AddMethod(codeClass, methodName,
new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
asyncCodeMethod.Comments.Add(new CodeCommentStatement(Res.GetString(Res.CodeRemarks), true));
CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), methodName);
for (int i = 0; i < parameterNames.Length; i++)
{
invoke.Parameters.Add(new CodeArgumentReferenceExpression(parameterNames[i]));
}
invoke.Parameters.Add(new CodePrimitiveExpression(null));
asyncCodeMethod.Statements.Add(invoke);
asyncCodeMethod = WebCodeGenerator.AddMethod(codeClass, methodName,
new CodeFlags[parameterNames.Length], parameterTypeNames, parameterNames, typeof(void).FullName, null, CodeFlags.IsPublic);
asyncCodeMethod.Comments.Add(new CodeCommentStatement(Res.GetString(Res.CodeRemarks), true));
asyncCodeMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userState));
CodeFieldReferenceExpression member = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), callbackMember);
CodeBinaryOperatorExpression checkIfNull = new CodeBinaryOperatorExpression(member, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeDelegateCreateExpression createDelegate = new CodeDelegateCreateExpression();
createDelegate.DelegateType = new CodeTypeReference(typeof(SendOrPostCallback));
createDelegate.TargetObject = new CodeThisReferenceExpression();
createDelegate.MethodName = callbackName;
CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(member, createDelegate) };
asyncCodeMethod.Statements.Add(new CodeConditionStatement(checkIfNull, trueStatements, new CodeStatement[0]));
return(asyncCodeMethod);
}
/// <summary>
/// Generates the generic Equals method implementing Equals
/// </summary>
/// <param name="input">The NMeta data type</param>
/// <param name="context">The transformation context</param>
protected virtual CodeMemberMethod CreateGenericEquals(IDataType input, CodeTypeDeclaration output, ITransformationContext context)
{
var thisTypeRef = output.GetReferenceForType();
var equals = new CodeMemberMethod()
{
Name = "Equals",
ReturnType = new CodeTypeReference(typeof(bool)),
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
equals.Parameters.Add(new CodeParameterDeclarationExpression(thisTypeRef, "other"));
equals.WriteDocumentation("Determines whether this structure and the given struct should be treated as equivalent",
"True, if this structure and the given other object are equivalent", new Dictionary <string, string>()
{
{ "other", "The other object" }
});
var argRef = new CodeArgumentReferenceExpression("other");
var expressions = input.Attributes.Select(prop =>
{
var propName = prop.Name.ToPascalCase();
var thisRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propName);
var otherRef = new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("other"), propName);
return(new CodeBinaryOperatorExpression(thisRef, CodeBinaryOperatorType.IdentityEquality, otherRef));
}).ToArray();
var exp = expressions[0];
for (int i = 0; i < expressions.Length; i++)
{
exp = new CodeBinaryOperatorExpression(exp, CodeBinaryOperatorType.BooleanAnd, expressions[i]);
}
equals.Statements.Add(new CodeMethodReturnStatement(exp));
return(equals);
}
private void GenerateBitVectorPropertySet(CodeMemberProperty prop, string fieldName, uint mask, int offset, NativeBitVector bitVector)
{
prop.HasSet = true;
// Shift it
CodeExpression exprShift = default(CodeExpression);
if (offset != 0)
{
exprShift = new CodeBinaryOperatorExpression(new CodePropertySetValueReferenceExpression(), CodeBinaryOperatorType.Multiply, new CodePrimitiveExpression(Math.Pow(2, offset)));
}
else
{
exprShift = new CodePropertySetValueReferenceExpression();
}
// Or it with the current
CodeBinaryOperatorExpression exprOr = new CodeBinaryOperatorExpression(exprShift, CodeBinaryOperatorType.BitwiseOr, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName));
// Assign it to the field
CodeAssignStatement asg = new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), new CodeCastExpression(new CodeTypeReference(typeof(uint)), exprOr));
prop.SetStatements.Add(asg);
}
private static Rule Rule_call_method_in_static_generic_class()
{
CodeBinaryOperatorExpression ruleStateTest = new CodeBinaryOperatorExpression
{
Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "State"),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = new CodePrimitiveExpression("AZ")
};
CodePropertyReferenceExpression myArrayRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "MyArray");
CodePropertyReferenceExpression myListRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "MyList");
CodeAssignStatement convertListToArray = new CodeAssignStatement
(
myArrayRef,
new CodeMethodInvokeExpression
(
new CodeTypeReferenceExpression
(
new CodeTypeReference("SampleFlow.ListConverter",
new CodeTypeReference[] { new CodeTypeReference("System.String") })
),
"StaticMethod",
myListRef
)
);
Rule rule13 = new Rule("Rule13")
{
Condition = new RuleExpressionCondition(ruleStateTest)
};
rule13.ThenActions.Add(new RuleStatementAction(convertListToArray));
return(rule13);
}
private void ValidateBinaryOperatorExpression(CodeBinaryOperatorExpression e)
{
ValidateExpression(e.Left);
ValidateExpression(e.Right);
}
protected virtual void GenerateBinaryOperatorExpression(CodeBinaryOperatorExpression e)
{
bool indentedExpression = false;
Output.Write('(');
GenerateExpression(e.Left);
Output.Write(' ');
if (e.Left is CodeBinaryOperatorExpression || e.Right is CodeBinaryOperatorExpression)
{
// In case the line gets too long with nested binary operators, we need to output them on
// different lines. However we want to indent them to maintain readability, but this needs
// to be done only once;
if (!_inNestedBinary)
{
indentedExpression = true;
_inNestedBinary = true;
Indent += 3;
}
ContinueOnNewLine("");
}
OutputOperator(e.Operator);
Output.Write(' ');
GenerateExpression(e.Right);
Output.Write(')');
if (indentedExpression)
{
Indent -= 3;
_inNestedBinary = false;
}
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace nspace = new CodeNamespace ("NSPC");
nspace.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (nspace);
// declare class with fields
// GENERATES (C#):
// public class ClassWithFields {
// // only if provider supports GeneratorSupport.PublicStaticMembers
// public static string Microsoft = "hi";
// public static int StaticPublicField = 5;
// // ---
//
// public int NonStaticPublicField = 6;
// private int PrivateField = 7;
// public int UsePrivateField(int i) {
// this.PrivateField = i;
// return this.PrivateField;
// }
// }
CodeTypeDeclaration cd = new CodeTypeDeclaration ("ClassWithFields");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeMemberField field;
if (Supports (provider, GeneratorSupport.PublicStaticMembers)) {
field = new CodeMemberField ("System.String", "Microsoft");
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.InitExpression = new CodePrimitiveExpression ("hi");
cd.Members.Add (field);
field = new CodeMemberField ();
field.Name = "StaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (5);
cd.Members.Add (field);
}
field = new CodeMemberField ();
field.Name = "NonStaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Final;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (6);
cd.Members.Add (field);
field = new CodeMemberField ();
field.Name = "PrivateField";
field.Attributes = MemberAttributes.Private | MemberAttributes.Final;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (7);
cd.Members.Add (field);
// create a method to test access to private field
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "UsePrivateField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "PrivateField"), new CodeArgumentReferenceExpression ("i")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "PrivateField")));
cd.Members.Add (cmm);
// GENERATES (C#):
// public class TestFields {
// public static int UseFields(int i) {
// ClassWithFields number = new ClassWithFields();
// return ((number.NonStaticPublicField + number.UsePrivateField(i))
// + ClassWithFields.StaticPublicField); // <-- only if supported
// }
// }
cd = new CodeTypeDeclaration ("TestFields");
cd.IsClass = true;
nspace.Types.Add (cd);
AddScenario ("CheckUseFields");
cmm = new CodeMemberMethod ();
cmm.Name = "UseFields";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("ClassWithFields"), "number", new CodeObjectCreateExpression ("ClassWithFields")));
CodeBinaryOperatorExpression binaryOpExpression = new CodeBinaryOperatorExpression (new CodeFieldReferenceExpression
(new CodeVariableReferenceExpression ("number"), "NonStaticPublicField"), CodeBinaryOperatorType.Add,
new CodeMethodInvokeExpression (
new CodeVariableReferenceExpression ("number"), "UsePrivateField", new CodeArgumentReferenceExpression ("i")));
if (Supports (provider, GeneratorSupport.PublicStaticMembers))
binaryOpExpression = new CodeBinaryOperatorExpression (binaryOpExpression,
CodeBinaryOperatorType.Add, new CodeFieldReferenceExpression (
new CodeTypeReferenceExpression ("ClassWithFields"), "StaticPublicField"));
cmm.Statements.Add (new CodeMethodReturnStatement (binaryOpExpression));
cd.Members.Add (cmm);
}
// Generate code for a binary operator expression.
protected virtual void GenerateBinaryOperatorExpression
(CodeBinaryOperatorExpression e)
{
Output.Write("(");
GenerateExpression(e.Left);
Output.Write(" ");
OutputOperator(e.Operator);
Output.Write(" ");
GenerateExpression(e.Right);
Output.Write(")");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// create a namespace
CodeNamespace ns = new CodeNamespace ("NS");
ns.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (ns);
// create a class
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "Test";
class1.IsClass = true;
ns.Types.Add (class1);
if (Supports (provider, GeneratorSupport.TryCatchStatements)) {
// try catch statement with just finally
// GENERATE (C#):
// public static int FirstScenario(int a) {
// try {
// }
// finally {
// a = (a + 5);
// }
// return a;
// }
AddScenario ("CheckFirstScenario");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement ();
tcfstmt.FinallyStatements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), new
CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (5))));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// in VB (a = a/a) generates an warning if a is integer. Cast the expression just for VB language.
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Divide, new CodeArgumentReferenceExpression ("a"));
CodeAssignStatement assignStatement = null;
if (provider is Microsoft.VisualBasic.VBCodeProvider)
assignStatement = new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), new CodeCastExpression (typeof (int), cboExpression));
else
assignStatement = new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), cboExpression);
// try catch statement with just catch
// GENERATE (C#):
// public static int SecondScenario(int a, string exceptionMessage) {
// try {
// a = (a / a);
// }
// catch (System.Exception e) {
// a = 3;
// exceptionMessage = e.ToString();
// }
// finally {
// a = (a + 1);
// }
// return a;
// }
AddScenario ("CheckSecondScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement ();
CodeCatchClause catchClause = new CodeCatchClause ("e");
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (3)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("e"), "ToString")));
tcfstmt.CatchClauses.Add (catchClause);
tcfstmt.FinallyStatements.Add (CDHelper.CreateIncrementByStatement (new CodeArgumentReferenceExpression ("a"), 1));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// try catch statement with multiple catches
// GENERATE (C#):
// public static int ThirdScenario(int a, string exceptionMessage) {
// try {
// a = (a / a);
// }
// catch (System.ArgumentNullException e) {
// a = 10;
// exceptionMessage = e.ToString();
// }
// catch (System.DivideByZeroException f) {
// exceptionMessage = f.ToString();
// a = 9;
// }
// return a;
// }
AddScenario ("CheckThirdScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement ();
catchClause = new CodeCatchClause ("e", new CodeTypeReference (typeof (ArgumentNullException)));
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (9)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("e"), "ToString")));
tcfstmt.CatchClauses.Add (catchClause);
// add a second catch clause
catchClause = new CodeCatchClause ("f", new CodeTypeReference (typeof (Exception)));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("exceptionMessage"),
new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("f"), "ToString")));
catchClause.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (9)));
tcfstmt.CatchClauses.Add (catchClause);
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
// catch throws exception
// GENERATE (C#):
// public static int FourthScenario(int a) {
// try {
// a = (a / a);
// }
// catch (System.Exception e) {
// // Error handling
// throw e;
// }
// return a;
// }
AddScenario ("CheckFourthScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
tcfstmt = new CodeTryCatchFinallyStatement ();
catchClause = new CodeCatchClause ("e");
tcfstmt.TryStatements.Add (assignStatement);
catchClause.Statements.Add (new CodeCommentStatement ("Error handling"));
catchClause.Statements.Add (new CodeThrowExceptionStatement (new CodeArgumentReferenceExpression ("e")));
tcfstmt.CatchClauses.Add (catchClause);
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
}
}
//ParallelRunning parallelRunning = context.ParallelRunning;
//context.ContextParallel = parallelRunning;
//parallelRunning.ActiveState = 2;
//parallelRunning.CallBase01ContextAlice.EnterInitialState();
//parallelRunning.CallBase01ContextBob.EnterInitialState();
private void WriteOnEntryParallel(CodeMemberMethod method, StateType state)
{
if (state.parallel == null)
{
return;
}
string parallelClassName = GetParallelClassName(state);
string parallelLocalVariableName = GetParallelLocalVariableName(state);
// ParallelRunning parallelRunning = context.ParallelRunning;
method.Statements.Add(new CodeVariableDeclarationStatement(parallelClassName, parallelLocalVariableName));
method.Statements.Add(new CodeAssignStatement(
new CodeVariableReferenceExpression(parallelLocalVariableName),
new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(Model.settings.context.instance), parallelClassName)));
// context.ContextParallel
var contextDotObserver = new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(Model.settings.context.instance),
"ContextParallel");
//context.ContextParallel = parallelRunning;
method.Statements.Add(new CodeAssignStatement(contextDotObserver,
new CodeVariableReferenceExpression(parallelLocalVariableName)));
// parallelRunning.ActiveState;
var parallelRunningDotActiveState = new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(parallelLocalVariableName),
"ActiveState");
//parallelRunning.ActiveState == 0
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(
parallelRunningDotActiveState,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(0));
CodeConditionStatement conditionalStatement = new CodeConditionStatement(condition);
// parallelRunning.ActiveState = 2;
CodeStatement parallelRunningActiveStateSet = new CodeAssignStatement(parallelRunningDotActiveState,
new CodePrimitiveExpression(state.parallel.state.Length));
if (state.HasParentStateHistory( ))
{
method.Statements.Add(conditionalStatement);
conditionalStatement.TrueStatements.Add(parallelRunningActiveStateSet);
}
else
{
method.Statements.Add(parallelRunningActiveStateSet);
}
//parallelRunning.CallBase01ContextAlice.EnterInitialState();
//parallelRunning.CallBase01ContextBob.EnterInitialState();
foreach (StateType stateOrthogonal in state.parallel.state)
{
string contextOrthogonalClassName = GetContextClassName(stateOrthogonal);
string stateOrthogonalClassName = GetStateClassName(stateOrthogonal);
// parallelRunning.CallBase01ContextAlice
var parallelStateNameDotContextOrthogonal = new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(parallelLocalVariableName),
contextOrthogonalClassName);
//parallelRunning.CallBase01ContextAlice.EnterInitialState();
var enterInitialStateInvoke = new CodeMethodInvokeExpression(
parallelStateNameDotContextOrthogonal,
"EnterInitialState");
//parallelRunning.CallBase01ContextAlice.EnterHistoryState();
var enterInitialHistoryStateInvoke = new CodeMethodInvokeExpression(
parallelStateNameDotContextOrthogonal,
"EnterHistoryState");
if (state.HasParentStateHistory( ))
{
conditionalStatement.TrueStatements.Add(enterInitialStateInvoke);
conditionalStatement.FalseStatements.Add(enterInitialHistoryStateInvoke);
}
else
{
method.Statements.Add(enterInitialStateInvoke);
}
}
}
public void ProviderSupports()
{
CodeDomProvider provider = GetProvider();
CodeCompileUnit cu = new CodeCompileUnit();
CodeNamespace nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
nspace.Imports.Add(new CodeNamespaceImport("System.Drawing"));
nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(nspace);
CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
// Arrays of Arrays
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
if (provider.Supports(GeneratorSupport.ArraysOfArrays))
{
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])),
"arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]),
new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)),
new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) }))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0))
, new CodePrimitiveExpression(1))));
}
else
{
throw new Exception("not supported");
}
cd.Members.Add(cmm);
// assembly attributes
if (provider.Supports(GeneratorSupport.AssemblyAttributes))
{
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new
CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly"))));
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new
CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2"))));
}
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
if (provider.Supports(GeneratorSupport.ChainedConstructorArguments))
{
class1.Name = "Test2";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "accessStringField";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(String));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"stringField")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new
CodeThisReferenceExpression(), "stringField"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeConstructor cctor = new CodeConstructor();
cctor.Attributes = MemberAttributes.Public;
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString"));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
class1.Members.Add(cctor);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3"));
cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "stringField"), new CodeVariableReferenceExpression("p1")));
class1.Members.Add(cc);
// verify chained constructors work
cmm = new CodeMemberMethod();
cmm.Name = "ChainedConstructorUse";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(String));
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "accessStringField")));
cd.Members.Add(cmm);
}
// complex expressions
if (provider.Supports(GeneratorSupport.ComplexExpressions))
{
cmm = new CodeMemberMethod();
cmm.Name = "ComplexExpressions";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(3)))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEnums))
{
CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum");
ce.IsEnum = true;
nspace.Types.Add(ce);
// things to enumerate
for (int k = 0; k < 5; k++)
{
CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString());
Field.InitExpression = new CodePrimitiveExpression(k);
ce.Members.Add(Field);
}
cmm = new CodeMemberMethod();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement(
new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareInterfaces))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("InterfaceA");
class1.IsInterface = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
class1.Members.Add(cmm);
if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers))
{
CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB");
classDecl.IsInterface = true;
nspace.Types.Add(classDecl);
cmm = new CodeMemberMethod();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
classDecl.Members.Add(cmm);
CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp");
class2.BaseTypes.Add(new CodeTypeReference("System.Object"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceB"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class2.IsClass = true;
nspace.Types.Add(class2);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class2.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp")));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA",
new CodeVariableReferenceExpression("t"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB",
new CodeVariableReferenceExpression("t"))));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add(cmm);
}
class1 = new CodeTypeDeclaration("TestSingleInterfaceImp");
class1.BaseTypes.Add(new CodeTypeReference("System.Object"));
class1.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class1.IsClass = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class1.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareValueTypes))
{
CodeTypeDeclaration structA = new CodeTypeDeclaration("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration("structB");
structB.Attributes = MemberAttributes.Public;
structB.IsStruct = true;
CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1");
firstInt.Attributes = MemberAttributes.Public;
structB.Members.Add(firstInt);
CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct");
innerStruct.Attributes = MemberAttributes.Public;
structA.Members.Add(structB);
structA.Members.Add(innerStruct);
nspace.Types.Add(structA);
CodeMemberMethod nestedStructMethod = new CodeMemberMethod();
nestedStructMethod.Name = "NestedStructMethod";
nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int));
nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA");
nestedStructMethod.Statements.Add(varStructA);
nestedStructMethod.Statements.Add
(
new CodeAssignStatement
(
/* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"),
/* Expression1 */ new CodePrimitiveExpression(3)
)
);
nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1")));
cd.Members.Add(nestedStructMethod);
}
if (provider.Supports(GeneratorSupport.EntryPointMethod))
{
CodeEntryPointMethod cep = new CodeEntryPointMethod();
cd.Members.Add(cep);
}
// goto statements
if (provider.Supports(GeneratorSupport.GotoStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "GoToMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)),
new CodeGotoStatement("comehere"));
cmm.Statements.Add(condstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6)));
cmm.Statements.Add(new CodeLabeledStatement("comehere",
new CodeMethodReturnStatement(new CodePrimitiveExpression(7))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.NestedTypes))
{
cmm = new CodeMemberMethod();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t",
new CodeObjectCreateExpression(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"),
"publicNestedClassesMethod",
new CodeVariableReferenceExpression("i"))));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("PublicNestedClassA");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
class1.Members.Add(nestedClass);
nestedClass = new CodeTypeDeclaration("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
class1.Members.Add(nestedClass);
CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC");
innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic;
innerNestedClass.IsClass = true;
nestedClass.Members.Add(innerNestedClass);
cmm = new CodeMemberMethod();
cmm.Name = "publicNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
innerNestedClass.Members.Add(cmm);
}
// Parameter Attributes
if (provider.Supports(GeneratorSupport.ParameterAttributes))
{
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "MyMethod";
method1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah");
param1.CustomAttributes.Add(
new CodeAttributeDeclaration(
"System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument(
"Form",
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument(
"IsNullable",
new CodePrimitiveExpression(false))));
method1.Parameters.Add(param1);
cd.Members.Add(method1);
}
// public static members
if (provider.Supports(GeneratorSupport.PublicStaticMembers))
{
cmm = new CodeMemberMethod();
cmm.Name = "PublicStaticMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
}
// reference parameters
if (provider.Supports(GeneratorSupport.ReferenceParameters))
{
cmm = new CodeMemberMethod();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference("System.void");
cmm.Attributes = MemberAttributes.Static;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
param.Direction = FieldDirection.Ref;
cmm.Parameters.Add(param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression(typeof(int), "j");
param.Direction = FieldDirection.Out;
cmm.Parameters.Add(param);
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4))));
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"),
new CodePrimitiveExpression(5)));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(parames);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(10)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression("a"));
methodinvoked.Parameters.Add(parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b"));
methodinvoked.Parameters.Add(parameter);
cmm.Statements.Add(methodinvoked);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression
(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.ReturnTypeAttributes))
{
CodeMemberMethod function1 = new CodeMemberMethod();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference(typeof(string));
function1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
function1.ReturnTypeCustomAttributes.Add(new
CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new
CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe"))));
function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return")));
cd.Members.Add(function1);
}
if (provider.Supports(GeneratorSupport.StaticConstructors))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestStaticConstructor";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4")));
// set then get number
cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i")
, new CodeVariableReferenceExpression("a")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "i")));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration();
class1.Name = "Test4";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "i";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(int));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeTypeConstructor ctc = new CodeTypeConstructor();
class1.Members.Add(ctc);
}
if (provider.Supports(GeneratorSupport.TryCatchStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "TryCatchMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEvents))
{
CodeNamespace ns = new CodeNamespace();
ns.Name = "MyNamespace";
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(ns);
class1 = new CodeTypeDeclaration("Test");
class1.IsClass = true;
class1.BaseTypes.Add(new CodeTypeReference("Form"));
ns.Types.Add(class1);
CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button"));
class1.Members.Add(mfield);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"),
new CodePrimitiveExpression(600), new CodePrimitiveExpression(600))));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Text"), new CodePrimitiveExpression("Test")));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"TabIndex"), new CodePrimitiveExpression(0)));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"),
new CodePrimitiveExpression(400), new CodePrimitiveExpression(525))));
ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new
CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler")
, new CodeThisReferenceExpression(), "b_Click")));
class1.Members.Add(ctor);
CodeMemberEvent evt = new CodeMemberEvent();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
class1.Members.Add(evt);
cmm = new CodeMemberMethod();
cmm.Name = "b_Click";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
class1.Members.Add(cmm);
}
AssertEqual(cu,
@"'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:4.0.30319.42000
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict Off
Option Explicit On
Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Windows.Forms
<Assembly: System.Reflection.AssemblyTitle(""MyAssembly""), _
Assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")>
Namespace NSPC
Public Class TEST
Public Function ArraysOfArrays() As Integer
Dim arrayOfArrays()() As Integer = New Integer()() {New Integer() {3, 4}, New Integer() {1}}
Return arrayOfArrays(0)(1)
End Function
Public Shared Function ChainedConstructorUse() As String
Dim t As Test2 = New Test2()
Return t.accessStringField
End Function
Public Function ComplexExpressions(ByVal i As Integer) As Integer
i = (i _
* (i + 3))
Return i
End Function
Public Shared Function OutputDecimalEnumVal(ByVal i As Integer) As Integer
If (i = 3) Then
Return CType(DecimalEnum.Num3,Integer)
End If
If (i = 4) Then
Return CType(DecimalEnum.Num4,Integer)
End If
If (i = 2) Then
Return CType(DecimalEnum.Num2,Integer)
End If
If (i = 1) Then
Return CType(DecimalEnum.Num1,Integer)
End If
If (i = 0) Then
Return CType(DecimalEnum.Num0,Integer)
End If
Return (i + 10)
End Function
Public Shared Function TestSingleInterface(ByVal i As Integer) As Integer
Dim t As TestSingleInterfaceImp = New TestSingleInterfaceImp()
Return t.InterfaceMethod(i)
End Function
Public Shared Function TestMultipleInterfaces(ByVal i As Integer) As Integer
Dim t As TestMultipleInterfaceImp = New TestMultipleInterfaceImp()
Dim interfaceAobject As InterfaceA = CType(t,InterfaceA)
Dim interfaceBobject As InterfaceB = CType(t,InterfaceB)
Return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i))
End Function
Public Shared Function NestedStructMethod() As Integer
Dim varStructA As structA
varStructA.innerStruct.int1 = 3
Return varStructA.innerStruct.int1
End Function
Public Shared Sub Main()
End Sub
Public Function GoToMethod(ByVal i As Integer) As Integer
If (i < 1) Then
goto comehere
End If
Return 6
comehere:
Return 7
End Function
Public Shared Function CallingPublicNestedScenario(ByVal i As Integer) As Integer
Dim t As PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC = New PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC()
Return t.publicNestedClassesMethod(i)
End Function
Public Sub MyMethod(<System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal blah As String)
End Sub
Public Shared Function PublicStaticMethod() As Integer
Return 16
End Function
Shared Sub Work(ByRef i As Integer, ByRef j As Integer)
i = (i + 4)
j = 5
End Sub
Public Shared Function CallingWork(ByVal a As Integer) As Integer
a = 10
Dim b As Integer
TEST.Work(a, b)
Return (a + b)
End Function
Public Function MyFunction() As <System.Xml.Serialization.XmlIgnoreAttribute(), System.Xml.Serialization.XmlRootAttribute([Namespace]:=""Namespace Value"", ElementName:=""Root, hehehe"")> String
Return ""Return""
End Function
Public Shared Function TestStaticConstructor(ByVal a As Integer) As Integer
Dim t As Test4 = New Test4()
t.i = a
Return t.i
End Function
Public Shared Function TryCatchMethod(ByVal a As Integer) As Integer
Try
Finally
a = (a + 5)
End Try
Return a
End Function
End Class
Public Class Test2
Private stringField As String
Public Sub New()
Me.New(""testingString"", Nothing, Nothing)
End Sub
Public Sub New(ByVal p1 As String, ByVal p2 As String, ByVal p3 As String)
MyBase.New
Me.stringField = p1
End Sub
Public Property accessStringField() As String
Get
Return Me.stringField
End Get
Set
Me.stringField = value
End Set
End Property
End Class
Public Enum DecimalEnum
Num0 = 0
Num1 = 1
Num2 = 2
Num3 = 3
Num4 = 4
End Enum
Public Interface InterfaceA
Function InterfaceMethod(ByVal a As Integer) As Integer
End Interface
Public Interface InterfaceB
Function InterfaceMethod(ByVal a As Integer) As Integer
End Interface
Public Class TestMultipleInterfaceImp
Inherits Object
Implements InterfaceB, InterfaceA
Public Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod , InterfaceB.InterfaceMethod
Return a
End Function
End Class
Public Class TestSingleInterfaceImp
Inherits Object
Implements InterfaceA
Public Overridable Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod
Return a
End Function
End Class
Public Structure structA
Public innerStruct As structB
Public Structure structB
Public int1 As Integer
End Structure
End Structure
Public Class PublicNestedClassA
Public Class PublicNestedClassB1
End Class
Public Class PublicNestedClassB2
Public Class PublicNestedClassC
Public Function publicNestedClassesMethod(ByVal a As Integer) As Integer
Return a
End Function
End Class
End Class
End Class
Public Class Test4
Private number As Integer
Shared Sub New()
End Sub
Public Property i() As Integer
Get
Return number
End Get
Set
number = value
End Set
End Property
End Class
End Namespace
Namespace MyNamespace
Public Class Test
Inherits Form
Private b As Button = New Button()
Public Sub New()
MyBase.New
Me.Size = New Size(600, 600)
b.Text = ""Test""
b.TabIndex = 0
b.Location = New Point(400, 525)
AddHandler MyEvent, AddressOf Me.b_Click
End Sub
Public Event MyEvent As System.EventHandler
Private Sub b_Click(ByVal sender As Object, ByVal e As System.EventArgs)
End Sub
End Class
End Namespace");
}
public void Visit(CodeBinaryOperatorExpression o)
{
g.GenerateBinaryOperatorExpression(o);
}
public void BinaryOperators()
{
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
class1.BaseTypes.Add(new CodeTypeReference(typeof(object)));
ns.Types.Add(class1);
CodeMemberMethod retMethod = new CodeMemberMethod();
retMethod.Name = "ReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(18),
CodeBinaryOperatorType.Divide,
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(6),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(4))),
CodeBinaryOperatorType.Multiply,
new CodeArgumentReferenceExpression("intInput"));
CodeVariableDeclarationStatement variableDeclaration = null;
variableDeclaration = new CodeVariableDeclarationStatement(typeof(int), "x1", cboExpression);
retMethod.Statements.Add(variableDeclaration);
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x2",
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(19),
CodeBinaryOperatorType.Modulus,
new CodePrimitiveExpression(8))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x3",
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(15),
CodeBinaryOperatorType.BitwiseAnd,
new CodePrimitiveExpression(35)),
CodeBinaryOperatorType.BitwiseOr,
new CodePrimitiveExpression(129))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x4",
new CodePrimitiveExpression(0)));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanOr,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(129))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 1) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 2) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(-1)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(5000))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 4) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 8) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(1))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 16) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 32) }));
retMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x1"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("x4"))))));
class1.Members.Add(retMethod);
retMethod = new CodeMemberMethod();
retMethod.Name = "SecondReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
retMethod.Statements.Add(new CodeCommentStatement("To test CodeBinaryOperatorType.IdentiEquality operator"));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeCastExpression("Object",
new CodeVariableReferenceExpression("intInput")),
CodeBinaryOperatorType.IdentityEquality, new CodeCastExpression("Object",
new CodePrimitiveExpression(5))),
new CodeStatement[] { new CodeMethodReturnStatement(new
CodePrimitiveExpression(5)) }, new CodeStatement[] { new
CodeMethodReturnStatement(new CodePrimitiveExpression(4))}));
class1.Members.Add(retMethod);
AssertEqual(ns,
@"namespace Namespace1 {
using System;
public class Class1 : object {
public int ReturnMethod(int intInput) {
int x1 = ((18 / (6 - 4)) * intInput);
int x2 = (19 % 8);
int x3 = ((15 & 35) | 129);
int x4 = 0;
if (((x2 == 3) || (x3 < 129))) {
x4 = (x4 + 1);
}
else {
x4 = (x4 + 2);
}
if (((x2 > -1) && (x3 >= 5000))) {
x4 = (x4 + 4);
}
else {
x4 = (x4 + 8);
}
if (((x2 <= 3) && (x3 != 1))) {
x4 = (x4 + 16);
}
else {
x4 = (x4 + 32);
}
return (x1 + (x2 + (x3 + x4)));
}
public int SecondReturnMethod(int intInput) {
// To test CodeBinaryOperatorType.IdentiEquality operator
if ((((Object)(intInput)) == ((Object)(5)))) {
return 5;
}
else {
return 4;
}
}
}
}");
}
public void ProviderSupports()
{
CodeDomProvider provider = GetProvider();
var cu = new CodeCompileUnit();
var nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
nspace.Imports.Add(new CodeNamespaceImport("System.Drawing"));
nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(nspace);
var cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
// Arrays of Arrays
var cmm = new CodeMemberMethod();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
if (provider.Supports(GeneratorSupport.ArraysOfArrays))
{
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])),
"arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]),
new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)),
new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) }))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0))
, new CodePrimitiveExpression(1))));
}
else
{
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(0)));
}
cd.Members.Add(cmm);
// assembly attributes
if (provider.Supports(GeneratorSupport.AssemblyAttributes))
{
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new
CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly"))));
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new
CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2"))));
}
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
if (provider.Supports(GeneratorSupport.ChainedConstructorArguments))
{
class1.Name = "Test2";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "accessStringField";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(String));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"stringField")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new
CodeThisReferenceExpression(), "stringField"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeConstructor cctor = new CodeConstructor();
cctor.Attributes = MemberAttributes.Public;
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString"));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
class1.Members.Add(cctor);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3"));
cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "stringField"), new CodeVariableReferenceExpression("p1")));
class1.Members.Add(cc);
// verify chained constructors work
cmm = new CodeMemberMethod();
cmm.Name = "ChainedConstructorUse";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(String));
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "accessStringField")));
cd.Members.Add(cmm);
}
// complex expressions
if (provider.Supports(GeneratorSupport.ComplexExpressions))
{
cmm = new CodeMemberMethod();
cmm.Name = "ComplexExpressions";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(3)))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEnums))
{
CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum");
ce.IsEnum = true;
nspace.Types.Add(ce);
// things to enumerate
for (int k = 0; k < 5; k++)
{
CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString());
Field.InitExpression = new CodePrimitiveExpression(k);
ce.Members.Add(Field);
}
cmm = new CodeMemberMethod();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement(
new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareInterfaces))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("InterfaceA");
class1.IsInterface = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
class1.Members.Add(cmm);
if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers))
{
CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB");
classDecl.IsInterface = true;
nspace.Types.Add(classDecl);
cmm = new CodeMemberMethod();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
classDecl.Members.Add(cmm);
CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp");
class2.BaseTypes.Add(new CodeTypeReference("System.Object"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceB"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class2.IsClass = true;
nspace.Types.Add(class2);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class2.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp")));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA",
new CodeVariableReferenceExpression("t"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB",
new CodeVariableReferenceExpression("t"))));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add(cmm);
}
class1 = new CodeTypeDeclaration("TestSingleInterfaceImp");
class1.BaseTypes.Add(new CodeTypeReference("System.Object"));
class1.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class1.IsClass = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class1.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareValueTypes))
{
CodeTypeDeclaration structA = new CodeTypeDeclaration("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration("structB");
structB.Attributes = MemberAttributes.Public;
structB.IsStruct = true;
CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1");
firstInt.Attributes = MemberAttributes.Public;
structB.Members.Add(firstInt);
CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct");
innerStruct.Attributes = MemberAttributes.Public;
structA.Members.Add(structB);
structA.Members.Add(innerStruct);
nspace.Types.Add(structA);
CodeMemberMethod nestedStructMethod = new CodeMemberMethod();
nestedStructMethod.Name = "NestedStructMethod";
nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int));
nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA");
nestedStructMethod.Statements.Add(varStructA);
nestedStructMethod.Statements.Add
(
new CodeAssignStatement
(
/* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"),
/* Expression1 */ new CodePrimitiveExpression(3)
)
);
nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1")));
cd.Members.Add(nestedStructMethod);
}
if (provider.Supports(GeneratorSupport.EntryPointMethod))
{
CodeEntryPointMethod cep = new CodeEntryPointMethod();
cd.Members.Add(cep);
}
// goto statements
if (provider.Supports(GeneratorSupport.GotoStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "GoToMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)),
new CodeGotoStatement("comehere"));
cmm.Statements.Add(condstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6)));
cmm.Statements.Add(new CodeLabeledStatement("comehere",
new CodeMethodReturnStatement(new CodePrimitiveExpression(7))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.NestedTypes))
{
cmm = new CodeMemberMethod();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t",
new CodeObjectCreateExpression(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"),
"publicNestedClassesMethod",
new CodeVariableReferenceExpression("i"))));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("PublicNestedClassA");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
class1.Members.Add(nestedClass);
nestedClass = new CodeTypeDeclaration("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
class1.Members.Add(nestedClass);
CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC");
innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic;
innerNestedClass.IsClass = true;
nestedClass.Members.Add(innerNestedClass);
cmm = new CodeMemberMethod();
cmm.Name = "publicNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
innerNestedClass.Members.Add(cmm);
}
// Parameter Attributes
if (provider.Supports(GeneratorSupport.ParameterAttributes))
{
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "MyMethod";
method1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah");
param1.CustomAttributes.Add(
new CodeAttributeDeclaration(
"System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument(
"Form",
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument(
"IsNullable",
new CodePrimitiveExpression(false))));
method1.Parameters.Add(param1);
cd.Members.Add(method1);
}
// public static members
if (provider.Supports(GeneratorSupport.PublicStaticMembers))
{
cmm = new CodeMemberMethod();
cmm.Name = "PublicStaticMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
}
// reference parameters
if (provider.Supports(GeneratorSupport.ReferenceParameters))
{
cmm = new CodeMemberMethod();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference("System.void");
cmm.Attributes = MemberAttributes.Static;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
param.Direction = FieldDirection.Ref;
cmm.Parameters.Add(param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression(typeof(int), "j");
param.Direction = FieldDirection.Out;
cmm.Parameters.Add(param);
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4))));
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"),
new CodePrimitiveExpression(5)));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(parames);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(10)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression("a"));
methodinvoked.Parameters.Add(parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b"));
methodinvoked.Parameters.Add(parameter);
cmm.Statements.Add(methodinvoked);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression
(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.ReturnTypeAttributes))
{
CodeMemberMethod function1 = new CodeMemberMethod();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference(typeof(string));
function1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
function1.ReturnTypeCustomAttributes.Add(new
CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new
CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe"))));
function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return")));
cd.Members.Add(function1);
}
if (provider.Supports(GeneratorSupport.StaticConstructors))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestStaticConstructor";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4")));
// set then get number
cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i")
, new CodeVariableReferenceExpression("a")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "i")));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration();
class1.Name = "Test4";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "i";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(int));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeTypeConstructor ctc = new CodeTypeConstructor();
class1.Members.Add(ctc);
}
if (provider.Supports(GeneratorSupport.TryCatchStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "TryCatchMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEvents))
{
CodeNamespace ns = new CodeNamespace();
ns.Name = "MyNamespace";
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(ns);
class1 = new CodeTypeDeclaration("Test");
class1.IsClass = true;
class1.BaseTypes.Add(new CodeTypeReference("Form"));
ns.Types.Add(class1);
CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button"));
class1.Members.Add(mfield);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"),
new CodePrimitiveExpression(600), new CodePrimitiveExpression(600))));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Text"), new CodePrimitiveExpression("Test")));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"TabIndex"), new CodePrimitiveExpression(0)));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"),
new CodePrimitiveExpression(400), new CodePrimitiveExpression(525))));
ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new
CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler")
, new CodeThisReferenceExpression(), "b_Click")));
class1.Members.Add(ctor);
CodeMemberEvent evt = new CodeMemberEvent();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
class1.Members.Add(evt);
cmm = new CodeMemberMethod();
cmm.Name = "b_Click";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
class1.Members.Add(cmm);
}
AssertEqual(cu,
@"//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
[assembly: System.Reflection.AssemblyTitle(""MyAssembly"")]
[assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")]
namespace NSPC {
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
public class TEST {
public int ArraysOfArrays() {
int[][] arrayOfArrays = new int[][] {
new int[] { 3, 4},
new int[] { 1}};
return arrayOfArrays[0][1];
}
public static string ChainedConstructorUse() {
Test2 t = new Test2();
return t.accessStringField;
}
public int ComplexExpressions(int i) {
i = (i * (i + 3));
return i;
}
public static int OutputDecimalEnumVal(int i) {
if ((i == 3)) {
return ((int)(DecimalEnum.Num3));
}
if ((i == 4)) {
return ((int)(DecimalEnum.Num4));
}
if ((i == 2)) {
return ((int)(DecimalEnum.Num2));
}
if ((i == 1)) {
return ((int)(DecimalEnum.Num1));
}
if ((i == 0)) {
return ((int)(DecimalEnum.Num0));
}
return (i + 10);
}
public static int TestSingleInterface(int i) {
TestSingleInterfaceImp t = new TestSingleInterfaceImp();
return t.InterfaceMethod(i);
}
public static int TestMultipleInterfaces(int i) {
TestMultipleInterfaceImp t = new TestMultipleInterfaceImp();
InterfaceA interfaceAobject = ((InterfaceA)(t));
InterfaceB interfaceBobject = ((InterfaceB)(t));
return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i));
}
public static int NestedStructMethod() {
structA varStructA;
varStructA.innerStruct.int1 = 3;
return varStructA.innerStruct.int1;
}
public static void Main() { }
public int GoToMethod(int i) {
if ((i < 1)) {
goto comehere;
}
return 6;
comehere:
return 7;
}
public static int CallingPublicNestedScenario(int i) {
PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC t = new PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC();
return t.publicNestedClassesMethod(i);
}
public void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah) {
}
public static int PublicStaticMethod() {
return 16;
}
static void Work(ref int i, out int j) {
i = (i + 4);
j = 5;
}
public static int CallingWork(int a) {
a = 10;
int b;
TEST.Work(ref a, out b);
return (a + b);
}
[return: System.Xml.Serialization.XmlIgnoreAttribute()]
[return: System.Xml.Serialization.XmlRootAttribute(Namespace=""Namespace Value"", ElementName=""Root, hehehe"")]
public string MyFunction() {
return ""Return"";
}
public static int TestStaticConstructor(int a) {
Test4 t = new Test4();
t.i = a;
return t.i;
}
public static int TryCatchMethod(int a) {
try {
}
finally {
a = (a + 5);
}
return a;
}
}
public class Test2 {
private string stringField;
public Test2() :
this(""testingString"", null, null) {
}
public Test2(string p1, string p2, string p3) {
this.stringField = p1;
}
public string accessStringField {
get {
return this.stringField;
}
set {
this.stringField = value;
}
}
}
public enum DecimalEnum {
Num0 = 0,
Num1 = 1,
Num2 = 2,
Num3 = 3,
Num4 = 4,
}
public interface InterfaceA {
int InterfaceMethod(int a);
}
public interface InterfaceB {
int InterfaceMethod(int a);
}
public class TestMultipleInterfaceImp : object, InterfaceB, InterfaceA {
public int InterfaceMethod(int a) {
return a;
}
}
public class TestSingleInterfaceImp : object, InterfaceA {
public virtual int InterfaceMethod(int a) {
return a;
}
}
public struct structA {
public structB innerStruct;
public struct structB {
public int int1;
}
}
public class PublicNestedClassA {
public class PublicNestedClassB1 { }
public class PublicNestedClassB2 {
public class PublicNestedClassC {
public int publicNestedClassesMethod(int a) {
return a;
}
}
}
}
public class Test4 {
private int number;
static Test4() {
}
public int i {
get {
return number;
}
set {
number = value;
}
}
}
}
namespace MyNamespace {
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
public class Test : Form {
private Button b = new Button();
public Test() {
this.Size = new Size(600, 600);
b.Text = ""Test"";
b.TabIndex = 0;
b.Location = new Point(400, 525);
this.MyEvent += new EventHandler(this.b_Click);
}
public event System.EventHandler MyEvent;
private void b_Click(object sender, System.EventArgs e) {
}
}
}");
}
public void TryCatchThrow()
{
var cd = new CodeTypeDeclaration();
cd.Name = "Test";
cd.IsClass = true;
// try catch statement with just finally
var cmm = new CodeMemberMethod();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Divide, new CodeVariableReferenceExpression("a"));
CodeAssignStatement assignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("a"), cboExpression);
// try catch statement with just catch
cmm = new CodeMemberMethod();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
CodeCatchClause catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(3)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
tcfstmt.FinallyStatements.Add(CreateVariableIncrementExpression("a", 1));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// try catch statement with multiple catches
cmm = new CodeMemberMethod();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e", new CodeTypeReference(typeof(ArgumentNullException)));
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
// add a second catch clause
catchClause = new CodeCatchClause("f", new CodeTypeReference(typeof(Exception)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "ToString")));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// catch throws exception
cmm = new CodeMemberMethod();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeCommentStatement("Error handling"));
catchClause.Statements.Add(new CodeThrowExceptionStatement(new CodeArgumentReferenceExpression("e")));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
AssertEqual(cd,
@"public class Test {
public static int FirstScenario(int a) {
try {
}
finally {
a = (a + 5);
}
return a;
}
public static int SecondScenario(int a, string exceptionMessage) {
try {
a = (a / a);
}
catch (System.Exception e) {
a = 3;
exceptionMessage = e.ToString();
}
finally {
a = (a + 1);
}
return a;
}
public static int ThirdScenario(int a, string exceptionMessage) {
try {
a = (a / a);
}
catch (System.ArgumentNullException e) {
a = 9;
exceptionMessage = e.ToString();
}
catch (System.Exception f) {
exceptionMessage = f.ToString();
a = 9;
}
return a;
}
public static int FourthScenario(int a) {
try {
a = (a / a);
}
catch (System.Exception e) {
// Error handling
throw e;
}
return a;
}
}");
}
protected virtual void GenerateBinaryOperatorExpression(CodeBinaryOperatorExpression e)
{
// CLEANUP: This has been cleaned up so that the code it generates looks better.
// Namely by eliminating unneeded grouping symbols.
// Should eventually expand this to work based on order of operations, so that
// "a + b - c" can generate as "a + b - c" rather than as either "(a + b) - c"
// or "a + (b - c)" as it is generated now.
if (e.NeedsGrouping)
output.Write('(');
if (e.Left is CodeCastExpression)
((CodeCastExpression)e.Left).NeedsGrouping = false;
else if (e.Left is CodeBinaryOperatorExpression && ((CodeBinaryOperatorExpression)e.Left).Operator == e.Operator)
((CodeBinaryOperatorExpression)e.Left).NeedsGrouping = false;
GenerateExpression(e.Left);
output.Write(' ');
OutputOperator(e.Operator);
output.Write(' ');
if (e.Right is CodeCastExpression)
((CodeCastExpression)e.Right).NeedsGrouping = false;
else if (e.Right is CodeBinaryOperatorExpression && ((CodeBinaryOperatorExpression)e.Right).Operator == e.Operator)
((CodeBinaryOperatorExpression)e.Right).NeedsGrouping = false;
GenerateExpression(e.Right);
if (e.NeedsGrouping)
output.Write(')');
}
public void TryCatchThrow()
{
var cd = new CodeTypeDeclaration();
cd.Name = "Test";
cd.IsClass = true;
// try catch statement with just finally
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "FirstScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Divide, new CodeVariableReferenceExpression("a"));
CodeAssignStatement assignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("a"), cboExpression);
// try catch statement with just catch
cmm = new CodeMemberMethod();
cmm.Name = "SecondScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
CodeCatchClause catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(3)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
tcfstmt.FinallyStatements.Add(CreateVariableIncrementExpression("a", 1));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// try catch statement with multiple catches
cmm = new CodeMemberMethod();
cmm.Name = "ThirdScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "exceptionMessage"));
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e", new CodeTypeReference(typeof(ArgumentNullException)));
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("e"), "ToString")));
tcfstmt.CatchClauses.Add(catchClause);
// add a second catch clause
catchClause = new CodeCatchClause("f", new CodeTypeReference(typeof(Exception)));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("exceptionMessage"),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("f"), "ToString")));
catchClause.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(9)));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
// catch throws exception
cmm = new CodeMemberMethod();
cmm.Name = "FourthScenario";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
tcfstmt = new CodeTryCatchFinallyStatement();
catchClause = new CodeCatchClause("e");
tcfstmt.TryStatements.Add(assignStatement);
catchClause.Statements.Add(new CodeCommentStatement("Error handling"));
catchClause.Statements.Add(new CodeThrowExceptionStatement(new CodeArgumentReferenceExpression("e")));
tcfstmt.CatchClauses.Add(catchClause);
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
AssertEqual(cd,
@"Public Class Test
Public Shared Function FirstScenario(ByVal a As Integer) As Integer
Try
Finally
a = (a + 5)
End Try
Return a
End Function
Public Shared Function SecondScenario(ByVal a As Integer, ByVal exceptionMessage As String) As Integer
Try
a = (a / a)
Catch e As System.Exception
a = 3
exceptionMessage = e.ToString
Finally
a = (a + 1)
End Try
Return a
End Function
Public Shared Function ThirdScenario(ByVal a As Integer, ByVal exceptionMessage As String) As Integer
Try
a = (a / a)
Catch e As System.ArgumentNullException
a = 9
exceptionMessage = e.ToString
Catch f As System.Exception
exceptionMessage = f.ToString
a = 9
End Try
Return a
End Function
Public Shared Function FourthScenario(ByVal a As Integer) As Integer
Try
a = (a / a)
Catch e As System.Exception
'Error handling
Throw e
End Try
Return a
End Function
End Class");
}
public void VisitBinary(CodeBinaryOperatorExpression bin)
{
var prec = operatorPrecedence[bin.Operator];
if (prec < precedence)
{
writer.Write("(");
}
Write(bin.Left, prec);
writer.Write(" {0} ", OpToString(bin.Operator));
Write(bin.Right, prec);
if (prec < precedence)
{
writer.Write(")");
}
}
public void OperatingOnFields()
{
var cd = new CodeTypeDeclaration("TestFields") { IsClass = true };
var cmm = new CodeMemberMethod();
cmm.Name = "UseFields";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("ClassWithFields"), "number", new CodeObjectCreateExpression("ClassWithFields")));
var binaryOpExpression = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression("number"), "NonStaticPublicField"), CodeBinaryOperatorType.Add,
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("number"), "UsePrivateField", new CodeVariableReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
binaryOpExpression, CodeBinaryOperatorType.Add, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("ClassWithFields"), "StaticPublicField"))));
cd.Members.Add(cmm);
AssertEqual(cd,
@"Public Class TestFields
Public Shared Function UseFields(ByVal i As Integer) As Integer
Dim number As ClassWithFields = New ClassWithFields()
Return ((number.NonStaticPublicField + number.UsePrivateField(i)) _
+ ClassWithFields.StaticPublicField)
End Function
End Class");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
ns.Types.Add (cd);
if (Supports (provider, GeneratorSupport.DeclareEnums)) {
// GENERATE (C#):
// public enum DecimalEnum {
// Num0 = 0,
// Num1 = 1,
// Num2 = 2,
// Num3 = 3,
// Num4 = 4,
// }
CodeTypeDeclaration ce = new CodeTypeDeclaration ("DecimalEnum");
ce.IsEnum = true;
ns.Types.Add (ce);
// things to enumerate
for (int k = 0; k < 5; k++) {
CodeMemberField Field = new CodeMemberField ("System.Int32", "Num" + (k).ToString ());
//Field.InitExpression = new CodePrimitiveExpression (k);
ce.Members.Add (Field);
}
// GENERATE (C#):
// public enum BinaryEnum {
// Bin1 = 1,
// Bin2 = 2,
// Bin3 = 4,
// Bin4 = 8,
// Bin5 = 16,
// }
ce = new CodeTypeDeclaration ("BinaryEnum");
ce.IsEnum = true;
ns.Types.Add (ce);
// things to enumerate
int i = 0x01;
for (int k = 1; k < 6; k++) {
CodeMemberField Field = new CodeMemberField (typeof (int), "Bin" + (k).ToString ());
Field.InitExpression = new CodePrimitiveExpression (i);
i = i * 2;
ce.Members.Add (Field);
}
#if WHIDBEY
// GENERATE (C#):
// public enum MyEnum: System.UInt64 {
// small = 0,
// medium = Int64.MaxValue/10,
// large = Int64.MaxValue,
// }
ce = new CodeTypeDeclaration ("MyEnum");
ce.BaseTypes.Add (new CodeTypeReference (typeof (UInt64)));
ce.IsEnum = true;
ns.Types.Add (ce);
// Add fields
ce.Members.Add (CreateFieldMember ("Small", 0));
ce.Members.Add (CreateFieldMember ("Medium", Int64.MaxValue / 10));
ce.Members.Add (CreateFieldMember ("Large", Int64.MaxValue));
#endif
// GENERATE (C#):
// public int OutputDecimalEnumVal(int i) {
// if ((i == 3)) {
// return ((int)(DecimalEnum.Num3));
// }
// if ((i == 4)) {
// return ((int)(DecimalEnum.Num4));
// }
// if ((i == 2)) {
// return ((int)(DecimalEnum.Num2));
// }
// if ((i == 1)) {
// return ((int)(DecimalEnum.Num1));
// }
// if ((i == 0)) {
// return ((int)(DecimalEnum.Num0));
// }
// return (i + 10);
// }
// generate 5 scenarios for OutputDecimalEnumVal
for (int k = 0; k < 5; k++)
AddScenario ("CheckOutputDecimalEnumVal" + k);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement (
new CodeCastExpression (typeof (int),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (4));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (2));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (1));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (0));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
// GENERATE (C#):
// public int OutputBinaryEnumVal(int i) {
// if ((i == 3)) {
// return ((int)(BinaryEnum.Bin3));
// }
// if ((i == 4)) {
// return ((int)(BinaryEnum.Bin4));
// }
// if ((i == 2)) {
// return ((int)(BinaryEnum.Bin2));
// }
// if ((i == 1)) {
// return ((int)(BinaryEnum.Bin1));
// }
// if ((i == 5)) {
// return ((int)(BinaryEnum.Bin5));
// }
// return (i + 10);
// }
// generate 6 scenarios for OutputBinaryEnumVal
for (int k = 1; k < 6; k++)
AddScenario ("CheckOutputBinaryEnumVal" + k);
AddScenario ("CheckOutputBinaryEnumValRet17", "Check for a return value of 17");
cmm = new CodeMemberMethod ();
cmm.Name = "OutputBinaryEnumVal";
cmm.Attributes = MemberAttributes.Public;
param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (3));
truestmt = new CodeMethodReturnStatement (
new CodeCastExpression (typeof (int),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin3")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (4));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin4")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (2));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin2")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (1));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin1")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (5));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin5")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
#if WHIDBEY
// GENERATE (C#):
// public long VerifyMyEnumExists(int num) {
// if ((num == Int32.MaxValue)) {
// return ((int)(MyEnum.Large));
// }
// return 0;
// }
AddScenario ("CheckVerifyMyEnumExists");
cmm = new CodeMemberMethod ();
cmm.Name = "VerifyMyEnumExists";
cmm.Attributes = MemberAttributes.Public;
param = new CodeParameterDeclarationExpression (typeof (int), "num");
cmm.Parameters.Add (param);
cmm.ReturnType = new CodeTypeReference ("System.Int64");
eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("num"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (Int32.MaxValue));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (long),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("MyEnum"),
"Large")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (0)));
cd.Members.Add (cmm);
#endif
}
}
public void BinaryOperators()
{
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
class1.BaseTypes.Add(new CodeTypeReference(typeof(object)));
ns.Types.Add(class1);
CodeMemberMethod retMethod = new CodeMemberMethod();
retMethod.Name = "ReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(18),
CodeBinaryOperatorType.Divide,
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(6),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(4))),
CodeBinaryOperatorType.Multiply,
new CodeArgumentReferenceExpression("intInput"));
CodeVariableDeclarationStatement variableDeclaration = null;
variableDeclaration = new CodeVariableDeclarationStatement(typeof(int), "x1", cboExpression);
retMethod.Statements.Add(variableDeclaration);
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x2",
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(19),
CodeBinaryOperatorType.Modulus,
new CodePrimitiveExpression(8))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x3",
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(15),
CodeBinaryOperatorType.BitwiseAnd,
new CodePrimitiveExpression(35)),
CodeBinaryOperatorType.BitwiseOr,
new CodePrimitiveExpression(129))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x4",
new CodePrimitiveExpression(0)));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanOr,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(129))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 1) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 2) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(-1)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(5000))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 4) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 8) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(1))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 16) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 32) }));
retMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x1"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("x4"))))));
class1.Members.Add(retMethod);
retMethod = new CodeMemberMethod();
retMethod.Name = "SecondReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
retMethod.Statements.Add(new CodeCommentStatement("To test CodeBinaryOperatorType.IdentiEquality operator"));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeCastExpression("Object",
new CodeVariableReferenceExpression("intInput")),
CodeBinaryOperatorType.IdentityEquality, new CodeCastExpression("Object",
new CodePrimitiveExpression(5))),
new CodeStatement[] { new CodeMethodReturnStatement(new
CodePrimitiveExpression(5)) }, new CodeStatement[] { new
CodeMethodReturnStatement(new CodePrimitiveExpression(4))}));
class1.Members.Add(retMethod);
AssertEqual(ns,
@"Imports System
Namespace Namespace1
Public Class Class1
Inherits Object
Public Function ReturnMethod(ByVal intInput As Integer) As Integer
Dim x1 As Integer = ((18 _
/ (6 - 4)) _
* intInput)
Dim x2 As Integer = (19 Mod 8)
Dim x3 As Integer = ((15 And 35) _
Or 129)
Dim x4 As Integer = 0
If ((x2 = 3) _
OrElse (x3 < 129)) Then
x4 = (x4 + 1)
Else
x4 = (x4 + 2)
End If
If ((x2 > -1) _
AndAlso (x3 >= 5000)) Then
x4 = (x4 + 4)
Else
x4 = (x4 + 8)
End If
If ((x2 <= 3) _
AndAlso (x3 <> 1)) Then
x4 = (x4 + 16)
Else
x4 = (x4 + 32)
End If
Return (x1 _
+ (x2 _
+ (x3 + x4)))
End Function
Public Function SecondReturnMethod(ByVal intInput As Integer) As Integer
'To test CodeBinaryOperatorType.IdentiEquality operator
If (CType(intInput,[Object]) Is CType(5,[Object])) Then
Return 5
Else
Return 4
End If
End Function
End Class
End Namespace");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
// namespace Namespace1 {
// using System;
//
//
// public class Class1 : object {
//
// public int ReturnMethod(int intInput) {
CodeNamespace ns = new CodeNamespace ("Namespace1");
ns.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (ns);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "Class1";
class1.BaseTypes.Add (new CodeTypeReference (typeof (object)));
ns.Types.Add (class1);
AddScenario ("CheckReturnMethod", "Tests varying operators.");
CodeMemberMethod retMethod = new CodeMemberMethod ();
retMethod.Name = "ReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference (typeof (int));
retMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "intInput"));
// GENERATES (C#):
// int x1 = ((18
// / (6 - 4))
// * intInput);
//
// in VB (a = a/a) generates an warning if a is integer. Cast the expression just for VB language.
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression (
new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (18),
CodeBinaryOperatorType.Divide,
new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (6),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression (4))),
CodeBinaryOperatorType.Multiply,
new CodeArgumentReferenceExpression ("intInput"));
CodeVariableDeclarationStatement variableDeclaration = null;
if (provider is Microsoft.VisualBasic.VBCodeProvider)
variableDeclaration = new CodeVariableDeclarationStatement (typeof (int), "x1", new CodeCastExpression (typeof (int), cboExpression));
else
variableDeclaration = new CodeVariableDeclarationStatement (typeof (int), "x1", cboExpression);
retMethod.Statements.Add (variableDeclaration);
// GENERATES (C#):
// int x2 = (19 % 8);
retMethod.Statements.Add (
new CodeVariableDeclarationStatement (
typeof (int),
"x2",
new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (19),
CodeBinaryOperatorType.Modulus,
new CodePrimitiveExpression (8))));
// GENERATES (C#):
// int x3 = ((15 & 35)
// | 129);
retMethod.Statements.Add (
new CodeVariableDeclarationStatement (
typeof (int),
"x3",
new CodeBinaryOperatorExpression (
new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (15),
CodeBinaryOperatorType.BitwiseAnd,
new CodePrimitiveExpression (35)),
CodeBinaryOperatorType.BitwiseOr,
new CodePrimitiveExpression (129))));
// GENERATES (C#):
// int x4 = 0;
retMethod.Statements.Add (
new CodeVariableDeclarationStatement (
typeof (int),
"x4",
new CodePrimitiveExpression (0)));
// GENERATES (C#):
// if (((x2 == 3)
// || (x3 < 129))) {
// x4 = (x4 + 1);
// }
// else {
// x4 = (x4 + 2);
// }
retMethod.Statements.Add (
new CodeConditionStatement (
new CodeBinaryOperatorExpression (
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x2"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (3)),
CodeBinaryOperatorType.BooleanOr,
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x3"),
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression (129))),
CDHelper.CreateIncrementByStatement ("x4", 1),
CDHelper.CreateIncrementByStatement ("x4", 2)));
// GENERATES (C#):
// if (((x2 > -1)
// && (x3 >= 5000))) {
// x4 = (x4 + 4);
// }
// else {
// x4 = (x4 + 8);
// }
retMethod.Statements.Add (
new CodeConditionStatement (
new CodeBinaryOperatorExpression (
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x2"),
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression (-1)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x3"),
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression (5000))),
CDHelper.CreateIncrementByStatement ("x4", 4),
CDHelper.CreateIncrementByStatement ("x4", 8)));
// GENERATES (C#):
// if (((x2 <= 3)
// && (x3 != 1))) {
// x4 = (x4 + 16);
// }
// else {
// x4 = (x4 + 32);
// }
retMethod.Statements.Add (
new CodeConditionStatement (
new CodeBinaryOperatorExpression (
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x2"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression (3)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x3"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression (1))),
CDHelper.CreateIncrementByStatement ("x4", 16),
CDHelper.CreateIncrementByStatement ("x4", 32)));
// GENERATES (C#):
// return (x1
// + (x2
// + (x3 + x4)));
// }
retMethod.Statements.Add (
new CodeMethodReturnStatement (
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x1"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x2"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression (
new CodeVariableReferenceExpression ("x3"),
CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression ("x4"))))));
class1.Members.Add (retMethod);
//
// GENERATES (C#):
// public int SecondReturnMethod(int intInput) {
// // To test CodeBinaryOperatorType.IdentityEquality operator
// if ((((Object)(intInput)) == ((Object)(5)))) {
// return 5;
// }
// else {
// return 4;
// }
// }
// }
AddScenario ("CheckSecondReturnMethod", "Tests identity equality.");
retMethod = new CodeMemberMethod ();
retMethod.Name = "SecondReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference (typeof (int));
retMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "intInput"));
retMethod.Statements.Add (new CodeCommentStatement ("To test CodeBinaryOperatorType.IdentiEquality operator"));
retMethod.Statements.Add (
new CodeConditionStatement (
new CodeBinaryOperatorExpression (new CodeCastExpression ("Object",
new CodeArgumentReferenceExpression ("intInput")),
CodeBinaryOperatorType.IdentityEquality, new CodeCastExpression ("Object",
new CodePrimitiveExpression (5))),
new CodeStatement[] {new CodeMethodReturnStatement (new
CodePrimitiveExpression (5))}, new CodeStatement[] {new
CodeMethodReturnStatement (new CodePrimitiveExpression (4))}));
class1.Members.Add (retMethod);
// GENERATES (C#):
// public class Class2 : object {
// }
// }
/*class1 = new CodeTypeDeclaration ();
class1.Name = "Class2";
class1.BaseTypes.Add (new CodeTypeReference (typeof (object)));
ns.Types.Add (class1);*/
}
public void GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, CodeExpression expression, string strValueName)
{
GetGradientDatas();
if (GradientDatas.Count > 1)
{
for (int i = 1; i < GradientDatas.Count; i++)
{
var value = expression;
var offset1 = GradientDatas[i - 1].Offset;
var color1 = GradientDatas[i - 1].GradientColor;
var offset2 = GradientDatas[i].Offset;
var color2 = GradientDatas[i].GradientColor;
CodeObjectCreateExpression color1obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Alpha));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Red));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Green));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Blue));
CodeObjectCreateExpression color2obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Alpha));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Red));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Green));
color2obj.Parameters.Add(new CodePrimitiveExpression(color2.Blue));
//"t = (value - offset1) / (offset2 - offset1) "
CodeBinaryOperatorExpression v1 = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(offset2));
CodeBinaryOperatorExpression v2 = new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(offset1),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(offset2));
CodeBinaryOperatorExpression v3 = new CodeBinaryOperatorExpression(
v1,
CodeBinaryOperatorType.Divide,
v2);
var typeref = new System.CodeDom.CodeTypeReferenceExpression("EngineNS.Color4");
//Lerp( Color4 color1, Color4 color2, float amount )
var methodInvoke = new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(
// targetObject that contains the method to invoke.
typeref,
// methodName indicates the method to invoke.
"Lerp",
// parameters array contains the parameters for the method.
new CodeExpression[] { color2obj, color1obj, v3 });
CodeAssignStatement result = new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), methodInvoke);
// CodeBinaryOperatorExpression result = new CodeBinaryOperatorExpression(
//new CodeVariableReferenceExpression(strValueName),
// CodeBinaryOperatorType.Assign,
// methodInvoke);
var greaterthan = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(offset2));
var lessthan = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(offset1));
if (i == GradientDatas.Count - 1)
{
var first = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(offset2));
codeStatementCollection.Add(new CodeConditionStatement(
first,
new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color2obj)));
}
if (i == 1)
{
var last = new CodeBinaryOperatorExpression(
value,
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(offset1));
codeStatementCollection.Add(new CodeConditionStatement(
last,
new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color1obj)));
}
codeStatementCollection.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(greaterthan, CodeBinaryOperatorType.BooleanAnd, lessthan),
result));
}
}
else if (GradientDatas.Count == 1)
{
var color1 = GradientDatas[0].GradientColor;
CodeObjectCreateExpression color1obj = new CodeObjectCreateExpression("EngineNS.Color4", new CodeExpression[] { });
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Alpha));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Red));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Green));
color1obj.Parameters.Add(new CodePrimitiveExpression(color1.Blue));
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strValueName), color1obj));
}
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu)
{
CodeNamespace nspace = new CodeNamespace ("NSPC");
nspace.Imports.Add (new CodeNamespaceImport ("System"));
nspace.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
nspace.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
nspace.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
cu.Namespaces.Add (nspace);
cu.ReferencedAssemblies.Add ("System.Drawing.dll");
cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");
cu.ReferencedAssemblies.Add ("System.Xml.dll");
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeMemberMethod cmm;
// Arrays of Arrays
#if !WHIDBEY
// Everett VB code provider doesn't support array of array initialization
if (!(provider is Microsoft.VisualBasic.VBCodeProvider)) {
#endif
if (Supports (provider, GeneratorSupport.ArraysOfArrays)) {
AddScenario ("CheckArrayOfArrays");
cmm = new CodeMemberMethod ();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int[][])),
"arrayOfArrays", new CodeArrayCreateExpression (typeof (int[][]),
new CodeArrayCreateExpression (typeof (int[]), new CodePrimitiveExpression (3), new CodePrimitiveExpression (4)),
new CodeArrayCreateExpression (typeof (int[]), new CodeExpression[] {new CodePrimitiveExpression (1)}))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArrayIndexerExpression (
new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayOfArrays"), new CodePrimitiveExpression (0)),
new CodePrimitiveExpression (1))));
cd.Members.Add (cmm);
}
#if !WHIDBEY
}
#endif
// assembly attributes
if (Supports (provider, GeneratorSupport.AssemblyAttributes)) {
AddScenario ("CheckAssemblyAttributes");
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyTitle", new
CodeAttributeArgument (new CodePrimitiveExpression ("MyAssembly"))));
attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyVersion", new
CodeAttributeArgument (new CodePrimitiveExpression ("1.0.6.2"))));
}
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
if (Supports (provider, GeneratorSupport.ChainedConstructorArguments)) {
AddScenario ("CheckChainedConstructorArgs");
class1.Name = "Test2";
class1.IsClass = true;
nspace.Types.Add (class1);
class1.Members.Add (new CodeMemberField (new CodeTypeReference (typeof (String)), "stringField"));
CodeMemberProperty prop = new CodeMemberProperty ();
prop.Name = "accessStringField";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference (typeof (String));
prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (),
"stringField")));
prop.SetStatements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new
CodeThisReferenceExpression (), "stringField"),
new CodePropertySetValueReferenceExpression ()));
class1.Members.Add (prop);
CodeConstructor cctor = new CodeConstructor ();
cctor.Attributes = MemberAttributes.Public;
cctor.ChainedConstructorArgs.Add (new CodePrimitiveExpression ("testingString"));
cctor.ChainedConstructorArgs.Add (new CodePrimitiveExpression (null));
cctor.ChainedConstructorArgs.Add (new CodePrimitiveExpression (null));
class1.Members.Add (cctor);
CodeConstructor cc = new CodeConstructor ();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded;
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "p1"));
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "p2"));
cc.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "p3"));
cc.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression ()
, "stringField"), new CodeArgumentReferenceExpression ("p1")));
class1.Members.Add (cc);
// verify chained constructors work
cmm = new CodeMemberMethod ();
cmm.Name = "ChainedConstructorUse";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference (typeof (String));
// utilize constructor
cmm.Statements.Add (new CodeVariableDeclarationStatement ("Test2", "t", new CodeObjectCreateExpression ("Test2")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (
new CodeVariableReferenceExpression ("t"), "accessStringField")));
cd.Members.Add (cmm);
}
// complex expressions
if (Supports (provider, GeneratorSupport.ComplexExpressions)) {
AddScenario ("CheckComplexExpressions");
cmm = new CodeMemberMethod ();
cmm.Name = "ComplexExpressions";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("i"),
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (3)))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("i")));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareEnums)) {
AddScenario ("CheckDeclareEnums");
CodeTypeDeclaration ce = new CodeTypeDeclaration ("DecimalEnum");
ce.IsEnum = true;
nspace.Types.Add (ce);
// things to enumerate
for (int k = 0; k < 5; k++)
{
CodeMemberField Field = new CodeMemberField ("System.Int32", "Num" + (k).ToString ());
Field.InitExpression = new CodePrimitiveExpression (k);
ce.Members.Add (Field);
}
cmm = new CodeMemberMethod ();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement (
new CodeCastExpression (typeof (int),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (4));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (2));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (1));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (0));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
AddScenario ("CheckDeclareInterfaces");
cmm = new CodeMemberMethod ();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression ("TestSingleInterfaceImp")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
class1 = new CodeTypeDeclaration ("InterfaceA");
class1.IsInterface = true;
nspace.Types.Add (class1);
cmm = new CodeMemberMethod ();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
class1.Members.Add (cmm);
if (Supports (provider, GeneratorSupport.MultipleInterfaceMembers)) {
AddScenario ("CheckMultipleInterfaceMembers");
CodeTypeDeclaration classDecl = new CodeTypeDeclaration ("InterfaceB");
classDecl.IsInterface = true;
nspace.Types.Add (classDecl);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
classDecl.Members.Add (cmm);
CodeTypeDeclaration class2 = new CodeTypeDeclaration ("TestMultipleInterfaceImp");
class2.BaseTypes.Add (new CodeTypeReference ("System.Object"));
class2.BaseTypes.Add (new CodeTypeReference ("InterfaceB"));
class2.BaseTypes.Add (new CodeTypeReference ("InterfaceA"));
class2.IsClass = true;
nspace.Types.Add (class2);
cmm = new CodeMemberMethod ();
cmm.ImplementationTypes.Add (new CodeTypeReference ("InterfaceA"));
cmm.ImplementationTypes.Add (new CodeTypeReference ("InterfaceB"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class2.Members.Add (cmm);
cmm = new CodeMemberMethod ();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression ("TestMultipleInterfaceImp")));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("InterfaceA", "interfaceAobject", new CodeCastExpression ("InterfaceA",
new CodeVariableReferenceExpression ("t"))));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("InterfaceB", "interfaceBobject", new CodeCastExpression ("InterfaceB",
new CodeVariableReferenceExpression ("t"))));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("interfaceAobject")
, "InterfaceMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add (cmm);
}
class1 = new CodeTypeDeclaration ("TestSingleInterfaceImp");
class1.BaseTypes.Add (new CodeTypeReference ("System.Object"));
class1.BaseTypes.Add (new CodeTypeReference ("InterfaceA"));
class1.IsClass = true;
nspace.Types.Add (class1);
cmm = new CodeMemberMethod ();
cmm.ImplementationTypes.Add (new CodeTypeReference ("InterfaceA"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
}
/*if (Supports (provider, GeneratorSupport.DeclareValueTypes)) {
AddScenario ("CheckDeclareValueTypes");
// create first struct to test nested structs
// GENERATE (C#):
// public struct structA {
// public structB innerStruct;
// public struct structB {
// public int int1;
// }
// }
CodeTypeDeclaration structA = new CodeTypeDeclaration ("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration ("structB");
structB.TypeAttributes = TypeAttributes.NestedPublic;
structB.Attributes = MemberAttributes.Public;
structB.IsStruct = true;
CodeMemberField firstInt = new CodeMemberField (typeof (int), "int1");
firstInt.Attributes = MemberAttributes.Public;
structB.Members.Add (firstInt);
CodeMemberField innerStruct = new CodeMemberField ("structB", "innerStruct");
innerStruct.Attributes = MemberAttributes.Public;
structA.Members.Add (structB);
structA.Members.Add (innerStruct);
nspace.Types.Add (structA);
CodeMemberMethod nestedStructMethod = new CodeMemberMethod ();
nestedStructMethod.Name = "NestedStructMethod";
nestedStructMethod.ReturnType = new CodeTypeReference (typeof (int));
nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement ("structA", "varStructA");
nestedStructMethod.Statements.Add (varStructA);
nestedStructMethod.Statements.Add
(
new CodeAssignStatement
(
new CodeFieldReferenceExpression (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("varStructA"), "innerStruct"), "int1"),
new CodePrimitiveExpression (3)
)
);
nestedStructMethod.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("varStructA"), "innerStruct"), "int1")));
cd.Members.Add (nestedStructMethod);
}*/
if (Supports (provider, GeneratorSupport.EntryPointMethod)) {
AddScenario ("CheckEntryPointMethod");
CodeEntryPointMethod cep = new CodeEntryPointMethod ();
cd.Members.Add (cep);
}
// goto statements
if (Supports (provider, GeneratorSupport.GotoStatements)) {
AddScenario ("CheckGotoStatements");
cmm = new CodeMemberMethod ();
cmm.Name = "GoToMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeConditionStatement condstmt = new CodeConditionStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (1)),
new CodeGotoStatement ("comehere"));
cmm.Statements.Add (condstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (6)));
cmm.Statements.Add (new CodeLabeledStatement ("comehere",
new CodeMethodReturnStatement (new CodePrimitiveExpression (7))));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
AddScenario ("CheckNestedTypes");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t",
new CodeObjectCreateExpression (new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"),
"publicNestedClassesMethod",
new CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
class1 = new CodeTypeDeclaration ("PublicNestedClassA");
class1.IsClass = true;
nspace.Types.Add (class1);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration ("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
class1.Members.Add (nestedClass);
nestedClass = new CodeTypeDeclaration ("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
class1.Members.Add (nestedClass);
CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration ("PublicNestedClassC");
innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic;
innerNestedClass.IsClass = true;
nestedClass.Members.Add (innerNestedClass);
cmm = new CodeMemberMethod ();
cmm.Name = "publicNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
innerNestedClass.Members.Add (cmm);
}
// Parameter Attributes
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
AddScenario ("CheckParameterAttributes");
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.Name = "MyMethod";
method1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (typeof (string), "blah");
param1.CustomAttributes.Add (
new CodeAttributeDeclaration (
"System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument (
"Form",
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument (
"IsNullable",
new CodePrimitiveExpression (false))));
method1.Parameters.Add (param1);
cd.Members.Add (method1);
}
// public static members
if (Supports (provider, GeneratorSupport.PublicStaticMembers)) {
AddScenario ("CheckPublicStaticMembers");
cmm = new CodeMemberMethod ();
cmm.Name = "PublicStaticMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (16)));
cd.Members.Add (cmm);
}
// reference parameters
if (Supports (provider, GeneratorSupport.ReferenceParameters)) {
AddScenario ("CheckReferenceParameters");
cmm = new CodeMemberMethod ();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference ("System.void");
cmm.Attributes = MemberAttributes.Static;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
param.Direction = FieldDirection.Ref;
cmm.Parameters.Add (param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression (typeof (int), "j");
param.Direction = FieldDirection.Out;
cmm.Parameters.Add (param);
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("i"),
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression (4))));
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("j"),
new CodePrimitiveExpression (5)));
cd.Members.Add (cmm);
cmm = new CodeMemberMethod ();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (parames);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (10)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression (new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression ("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression (FieldDirection.Ref,
new CodeArgumentReferenceExpression ("a"));
methodinvoked.Parameters.Add (parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression (FieldDirection.Out, new CodeVariableReferenceExpression ("b"));
methodinvoked.Parameters.Add (parameter);
cmm.Statements.Add (methodinvoked);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression
(new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression ("b"))));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.ReturnTypeAttributes)) {
AddScenario ("CheckReturnTypeAttributes");
CodeMemberMethod function1 = new CodeMemberMethod ();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference (typeof (string));
function1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
function1.ReturnTypeCustomAttributes.Add (new
CodeAttributeDeclaration ("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument ("Namespace", new CodePrimitiveExpression ("Namespace Value")), new
CodeAttributeArgument ("ElementName", new CodePrimitiveExpression ("Root, hehehe"))));
function1.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression ("Return")));
cd.Members.Add (function1);
}
if (Supports (provider, GeneratorSupport.StaticConstructors)) {
AddScenario ("CheckStaticConstructors");
cmm = new CodeMemberMethod ();
cmm.Name = "TestStaticConstructor";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference (typeof (int));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
// utilize constructor
cmm.Statements.Add (new CodeVariableDeclarationStatement ("Test4", "t", new CodeObjectCreateExpression ("Test4")));
// set then get number
cmm.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeVariableReferenceExpression ("t"), "i")
, new CodeArgumentReferenceExpression ("a")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (
new CodeVariableReferenceExpression ("t"), "i")));
cd.Members.Add (cmm);
class1 = new CodeTypeDeclaration ();
class1.Name = "Test4";
class1.IsClass = true;
nspace.Types.Add (class1);
class1.Members.Add (new CodeMemberField (new CodeTypeReference (typeof (int)), "number"));
CodeMemberProperty prop = new CodeMemberProperty ();
prop.Name = "i";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference (typeof (int));
prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (null, "number")));
prop.SetStatements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (null, "number"),
new CodePropertySetValueReferenceExpression ()));
class1.Members.Add (prop);
CodeTypeConstructor ctc = new CodeTypeConstructor ();
class1.Members.Add (ctc);
}
if (Supports (provider, GeneratorSupport.TryCatchStatements)) {
AddScenario ("CheckTryCatchStatements");
cmm = new CodeMemberMethod ();
cmm.Name = "TryCatchMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement ();
tcfstmt.FinallyStatements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"), new
CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (5))));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
AddScenario ("CheckDeclareEvents");
CodeNamespace ns = new CodeNamespace ();
ns.Name = "MyNamespace";
ns.Imports.Add (new CodeNamespaceImport ("System"));
ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
cu.Namespaces.Add (ns);
class1 = new CodeTypeDeclaration ("Test");
class1.IsClass = true;
class1.BaseTypes.Add (new CodeTypeReference ("Form"));
ns.Types.Add (class1);
CodeMemberField mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
class1.Members.Add (mfield);
CodeConstructor ctor = new CodeConstructor ();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (),
"Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Text"), new CodePrimitiveExpression ("Test")));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"TabIndex"), new CodePrimitiveExpression (0)));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
, new CodeThisReferenceExpression (), "b_Click")));
class1.Members.Add (ctor);
CodeMemberEvent evt = new CodeMemberEvent ();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference ("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
class1.Members.Add (evt);
cmm = new CodeMemberMethod ();
cmm.Name = "b_Click";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
class1.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.MultidimensionalArrays)) {
// no codedom language represents declaration of multidimensional arrays
}
}
