public TypescriptBaseReferenceExpression(
CodeBaseReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptBaseReferenceExpression Created");
}
private bool HandleDynamic(CodeBaseReferenceExpression obj, Context ctx)
{
if (string.IsNullOrEmpty(BaseReferenceKeyword))
{
return(false);
}
ctx.Writer.Write(BaseReferenceKeyword);
return(true);
}
private CodeMemberMethod SetSubstitutionMember()
{
CodeMemberMethod setSubstMember = CodeDomHelper.CreateMethod("SetSubstitutionMember", MemberAttributes.Family, null);
setSubstMember.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), this.memberName));
setSubstMember.Statements.Add(new CodeAssignStatement(CodeDomHelper.CreateFieldReference("this", this.memberName), new CodeVariableReferenceExpression(this.memberName)));
if (this.clrTypeInfo.IsSubstitutionMember())
{
CodeStatementCollection statements = setSubstMember.Statements;
CodeBaseReferenceExpression codeBaseReferenceExpression = new CodeBaseReferenceExpression();
CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) };
statements.Add(CodeDomHelper.CreateMethodCall(codeBaseReferenceExpression, "SetSubstitutionMember", codeVariableReferenceExpression));
}
return(setSubstMember);
}
public override CodeExpression GetReferenceCode(IMethodCompile method, CodeStatementCollection statements, bool forValue)
{
CodeBaseReferenceExpression br = new CodeBaseReferenceExpression();
CodeMethodInvokeExpression cmi = new CodeMethodInvokeExpression(br, this.Name);
if (_parameterExpressions != null)
{
cmi.Parameters.AddRange(_parameterExpressions);
}
else
{
throw new DesignerException("Calling BaseMethod.GetReferenceCode without setting parameters");
}
return(cmi);
}
private void CreateClass(string classname, string NameSpacestring)
{
targetUnit = new CodeCompileUnit();
CodeNamespace samples = new CodeNamespace(NameSpacestring);
samples.Imports.Add(new CodeNamespaceImport("System"));
targetClass = new CodeTypeDeclaration(classname);
targetClass.IsClass = true;
targetClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Serializable;
thisReference = new CodeThisReferenceExpression();
baseReference = new CodeBaseReferenceExpression();
ImplementINotifyPropertyChanged(targetClass);
samples.Types.Add(targetClass);
targetUnit.Namespaces.Add(samples);
}
public override CodeExpression GetReferenceCode(IMethodCompile method, CodeStatementCollection statements, bool forValue)
{
if (Property != null)
{
bool inside = false;
SetterClass sc = method as SetterClass;
if (sc != null)
{
inside = sc.Property.IsSameObjectRef(Property);
}
else
{
GetterClass gc = method as GetterClass;
if (gc != null)
{
inside = gc.Property.IsSameObjectRef(Property);
}
}
if (inside)
{
CodeExpression ownerCode;
if (Property.IsStatic)
{
MathNodePropertyField.CheckDeclareField(Property.IsStatic, Property.FieldMemberName, Property.PropertyType, method.TypeDeclaration, Property.DefaultValue);
ownerCode = new CodeTypeReferenceExpression(Property.Holder.TypeString);
return(new CodeFieldReferenceExpression(ownerCode, Property.FieldMemberName));
}
else
{
ownerCode = new CodeBaseReferenceExpression();
return(new CodeFieldReferenceExpression(ownerCode, Property.Name));
}
}
else
{
Property.SetHolder(Holder);
return(Property.GetReferenceCode(method, statements, forValue));
}
}
return(null);
}
private CodeMemberMethod SetInnerType()
{
CodeMemberMethod setInnerType = CodeDomHelper.CreateMethod("SetInnerType", MemberAttributes.Private, null);
setInnerType.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), this.memberName));
CodeStatementCollection statements = setInnerType.Statements;
CodeFieldReferenceExpression codeFieldReferenceExpression = CodeDomHelper.CreateFieldReference("this", this.memberName);
string str = this.innerTypeName;
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression("XTypedServices");
CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) };
statements.Add(new CodeAssignStatement(codeFieldReferenceExpression, new CodeCastExpression(str, new CodeMethodInvokeExpression(codeTypeReferenceExpression, "GetCloneIfRooted", codeVariableReferenceExpression))));
setInnerType.Statements.Add(this.SetNameMethodCall());
if (this.clrTypeInfo.IsSubstitutionMember())
{
CodeStatementCollection codeStatementCollection = setInnerType.Statements;
CodeBaseReferenceExpression codeBaseReferenceExpression = new CodeBaseReferenceExpression();
codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression(this.memberName) };
codeStatementCollection.Add(CodeDomHelper.CreateMethodCall(codeBaseReferenceExpression, "SetSubstitutionMember", codeVariableReferenceExpression));
}
return(setInnerType);
}
public CodeExpression Visit(Expression exp)
{
//Expression c = new QueryVisitor((e) => e.NodeType == ExpressionType.Constant && e.Type.Name.StartsWith("<>c__DisplayClass")).Visit(exp);
//if (c != null)
//{
// object v = CodeDom.Eval(exp);
// return GetFromPrimitive(v);
//}
//else
//{
CodeExpression res = _Visit(exp);
if (res is CodeDom.CodeThisExpression)
{
res = new CodeThisReferenceExpression();
}
else if (res is CodeDom.CodeBaseExpression)
{
res = new CodeBaseReferenceExpression();
}
return(res);
//}
}
public void Visit(CodeBaseReferenceExpression o)
{
g.GenerateBaseReferenceExpression(o);
}
private void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
{
Output.Write("super");
}
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
{
Output.Write("[CodeBaseReferenceExpression: {0}]", e.ToString());
}
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
{
Output.Write("baseReference");
}
protected virtual void Visit(CodeBaseReferenceExpression expr)
{
}
private void ValidateBaseReferenceExpression(CodeBaseReferenceExpression e)
{
}
private void ValidateBaseReferenceExpression(CodeBaseReferenceExpression e) // Nothing to validate
{
}
private void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) => output.Write("super");
protected void GenerateExpression(CodeExpression e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
CodeArgumentReferenceExpression argref = e as CodeArgumentReferenceExpression;
if (argref != null)
{
GenerateArgumentReferenceExpression(argref);
return;
}
CodeArrayCreateExpression mkarray = e as CodeArrayCreateExpression;
if (mkarray != null)
{
GenerateArrayCreateExpression(mkarray);
return;
}
CodeArrayIndexerExpression arrayidx = e as CodeArrayIndexerExpression;
if (arrayidx != null)
{
GenerateArrayIndexerExpression(arrayidx);
return;
}
CodeBaseReferenceExpression baseref = e as CodeBaseReferenceExpression;
if (baseref != null)
{
GenerateBaseReferenceExpression(baseref);
return;
}
CodeBinaryOperatorExpression binary = e as CodeBinaryOperatorExpression;
if (binary != null)
{
GenerateBinaryOperatorExpression(binary);
return;
}
CodeCastExpression cast = e as CodeCastExpression;
if (cast != null)
{
GenerateCastExpression(cast);
return;
}
CodeDelegateCreateExpression mkdel = e as CodeDelegateCreateExpression;
if (mkdel != null)
{
GenerateDelegateCreateExpression(mkdel);
return;
}
CodeDelegateInvokeExpression delinvoke = e as CodeDelegateInvokeExpression;
if (delinvoke != null)
{
GenerateDelegateInvokeExpression(delinvoke);
return;
}
CodeDirectionExpression direction = e as CodeDirectionExpression;
if (direction != null)
{
GenerateDirectionExpression(direction);
return;
}
CodeEventReferenceExpression eventref = e as CodeEventReferenceExpression;
if (eventref != null)
{
GenerateEventReferenceExpression(eventref);
return;
}
CodeFieldReferenceExpression fieldref = e as CodeFieldReferenceExpression;
if (fieldref != null)
{
GenerateFieldReferenceExpression(fieldref);
return;
}
CodeIndexerExpression idx = e as CodeIndexerExpression;
if (idx != null)
{
GenerateIndexerExpression(idx);
return;
}
CodeMethodInvokeExpression methodinv = e as CodeMethodInvokeExpression;
if (methodinv != null)
{
GenerateMethodInvokeExpression(methodinv);
return;
}
CodeMethodReferenceExpression methodref = e as CodeMethodReferenceExpression;
if (methodref != null)
{
GenerateMethodReferenceExpression(methodref);
return;
}
CodeObjectCreateExpression objref = e as CodeObjectCreateExpression;
if (objref != null)
{
GenerateObjectCreateExpression(objref);
return;
}
CodeParameterDeclarationExpression param = e as CodeParameterDeclarationExpression;
if (param != null)
{
GenerateParameterDeclarationExpression(param);
return;
}
CodePrimitiveExpression primitive = e as CodePrimitiveExpression;
if (primitive != null)
{
GeneratePrimitiveExpression(primitive);
return;
}
CodePropertyReferenceExpression propref = e as CodePropertyReferenceExpression;
if (propref != null)
{
GeneratePropertyReferenceExpression(propref);
return;
}
CodePropertySetValueReferenceExpression propset = e as CodePropertySetValueReferenceExpression;
if (propset != null)
{
GeneratePropertySetValueReferenceExpression(propset);
return;
}
CodeSnippetExpression snippet = e as CodeSnippetExpression;
if (snippet != null)
{
GenerateSnippetExpression(snippet);
return;
}
CodeThisReferenceExpression thisref = e as CodeThisReferenceExpression;
if (thisref != null)
{
GenerateThisReferenceExpression(thisref);
return;
}
CodeTypeOfExpression typeOf = e as CodeTypeOfExpression;
if (typeOf != null)
{
GenerateTypeOfExpression(typeOf);
return;
}
CodeTypeReferenceExpression typeref = e as CodeTypeReferenceExpression;
if (typeref != null)
{
GenerateTypeReferenceExpression(typeref);
return;
}
CodeVariableReferenceExpression varref = e as CodeVariableReferenceExpression;
if (varref != null)
{
GenerateVariableReferenceExpression(varref);
return;
}
throw new ArgumentException("Element type " + e + " is not supported.", "e");
}
public void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
bool useOutput = false;
CodeExpression cmi;
CodeBaseReferenceExpression br = new CodeBaseReferenceExpression();
CodeMethodInvokeExpression cmim = new CodeMethodInvokeExpression(br, this.Name);
if (parameters != null)
{
cmim.Parameters.AddRange(parameters);
}
cmi = cmim;
if (!NoReturn && nextAction != null && nextAction.UseInput)
{
CodeVariableDeclarationStatement output = new CodeVariableDeclarationStatement(
currentAction.OutputType.TypeString, currentAction.OutputCodeName, cmi);
statements.Add(output);
cmi = new CodeVariableReferenceExpression(currentAction.OutputCodeName);
useOutput = true;
}
if (HasReturn && returnReceiver != null)
{
CodeExpression cr = returnReceiver.GetReferenceCode(methodToCompile, statements, true);
if (ReturnValue != null)
{
Type target;
IClassWrapper wrapper = returnReceiver as IClassWrapper;
if (wrapper != null)
{
target = wrapper.WrappedType;
}
else
{
target = returnReceiver.ObjectType;
}
Type dt;
if (useOutput)
{
dt = currentAction.OutputType.BaseClassType;
}
else
{
dt = ReturnValue.BaseClassType;
}
CompilerUtil.CreateAssignment(cr, target, cmi, dt, statements, true);
}
else
{
CodeAssignStatement cas = new CodeAssignStatement(cr, cmi);
statements.Add(cas);
}
}
else
{
if (!useOutput)
{
CodeExpressionStatement ces = new CodeExpressionStatement(cmi);
statements.Add(ces);
}
}
}
public bool ValidateCodeBaseReferenceExpression(CodeBaseReferenceExpression exp)
{
// could include code that looks up the location stack to see if there's a type member
// that has a MemberAttribute of Override
return(true);
}
private CodeMemberMethod GetInitCleanupMethod(Type methodAttributeType, MultiDirectionTestClass testClass)
{
bool isStatic = false;
string generatedMetholdName = string.Empty;
string methodToInvokeName = string.Empty;
CodeParameterDeclarationExpression parameterDec = null;
Type acctualAttributeType = methodAttributeType;
if (methodAttributeType == typeof(MSUnittest.ClassInitializeAttribute))
{
isStatic = true;
generatedMetholdName = GodeGeneratorConst.ClassInitMethodName;
methodToInvokeName = testClass.ClassInit.Name;
parameterDec = new CodeParameterDeclarationExpression(typeof(MSUnittest.TestContext), "testContext");
}
else if (methodAttributeType == typeof(MSUnittest.ClassCleanupAttribute))
{
isStatic = true;
generatedMetholdName = GodeGeneratorConst.ClassCleanupMethodName;
methodToInvokeName = testClass.ClassCleanup.Name;
}
else
{
throw new ArgumentException("methodAttributeType");
}
CodeMemberMethod result = new CodeMemberMethod();
result.Name = generatedMetholdName;
// Add parameter list if needed
if (parameterDec != null)
{
result.Parameters.Add(parameterDec);
}
CodeExpression callBase = null;
if (isStatic)
{
result.Attributes = MemberAttributes.Public | MemberAttributes.Static;
callBase = new CodeTypeReferenceExpression(testClass.ClassType.FullName);
}
else
{
result.Attributes = MemberAttributes.Public | MemberAttributes.Final;
callBase = new CodeBaseReferenceExpression();
}
// Add methold attribute
CodeAttributeDeclaration methodAttribute = new CodeAttributeDeclaration(
new CodeTypeReference(acctualAttributeType));
result.CustomAttributes.Add(methodAttribute);
// Add invoke statement
CodeMethodInvokeExpression invokeExp = null;
if (parameterDec != null)
{
CodeVariableReferenceExpression sourceParameter = new CodeVariableReferenceExpression(parameterDec.Name);
invokeExp = new CodeMethodInvokeExpression(callBase, methodToInvokeName, sourceParameter);
}
else
{
invokeExp = new CodeMethodInvokeExpression(callBase, methodToInvokeName);
}
result.Statements.Add(invokeExp);
return(result);
}
protected abstract void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e);
protected override void GenerateBaseReferenceExpression
(CodeBaseReferenceExpression e)
{
Output.Write("base");
}
public void FixupAsync()
{
var type = ml_context.ChannelType;
var od = context.Operation;
var baseExpr = new CodeBaseReferenceExpression();
var asyncResultType = new CodeTypeReference(typeof(IAsyncResult));
// BeginXxx() implementation
var cm = new CodeMemberMethod {
Name = "Begin" + od.Name,
// Analysis disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Final,
// Analysis restore BitwiseOperatorOnEnumWithoutFlags
ReturnType = asyncResultType
};
type.Members.Add(cm);
var inArgs = new List <CodeParameterDeclarationExpression> ();
foreach (CodeParameterDeclarationExpression p in context.BeginMethod.Parameters)
{
inArgs.Add(p);
cm.Parameters.Add(p);
}
inArgs.RemoveAt(inArgs.Count - 1);
inArgs.RemoveAt(inArgs.Count - 1);
var call = new CodeMethodInvokeExpression(
baseExpr,
"BeginInvoke",
new CodePrimitiveExpression(od.Name),
new CodeArrayCreateExpression(typeof(object), inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray()),
new CodeArgumentReferenceExpression("asyncCallback"),
new CodeArgumentReferenceExpression("userState"));
cm.Statements.Add(new CodeMethodReturnStatement(call));
// EndXxx() implementation
cm = new CodeMemberMethod {
Name = "End" + od.Name,
// Analysis disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Final,
// Analysis restore BitwiseOperatorOnEnumWithoutFlags
ReturnType = context.EndMethod.ReturnType
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(IAsyncResult), "result");
var outArgs = new List <CodeParameterDeclarationExpression> ();
string resultArgName = "result";
var argsDecl = new CodeVariableDeclarationStatement(
typeof(object []),
"args",
new CodeArrayCreateExpression(typeof(object), new CodePrimitiveExpression(outArgs.Count)));
cm.Statements.Add(argsDecl);
var ret = new CodeMethodInvokeExpression(
baseExpr,
"EndInvoke",
new CodePrimitiveExpression(od.Name),
new CodeVariableReferenceExpression("args"),
new CodeArgumentReferenceExpression(resultArgName));
if (cm.ReturnType.BaseType == "System.Void")
{
cm.Statements.Add(new CodeExpressionStatement(ret));
}
else
{
cm.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(context.EndMethod.ReturnType, ret)));
}
}
// no base keyword in boo -- use super instead
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression expression)
{
TextWriter output = Output;
output.Write("super");
}
void GenerateEventBasedAsyncSupport(CodeTypeDeclaration type, OperationDescription od, CodeNamespace cns)
{
var method = FindByName(type, od.Name) ?? FindByName(type, "Begin" + od.Name);
var endMethod = method.Name == od.Name ? null : FindByName(type, "End" + od.Name);
bool methodAsync = method.Name.StartsWith("Begin", StringComparison.Ordinal);
var resultType = endMethod != null ? endMethod.ReturnType : method.ReturnType;
var thisExpr = new CodeThisReferenceExpression();
var baseExpr = new CodeBaseReferenceExpression();
var nullExpr = new CodePrimitiveExpression(null);
var asyncResultType = new CodeTypeReference(typeof(IAsyncResult));
// OnBeginXxx() implementation
var cm = new CodeMemberMethod()
{
Name = "OnBegin" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = asyncResultType
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object []), "args");
AddMethodParam(cm, typeof(AsyncCallback), "asyncCallback");
AddMethodParam(cm, typeof(object), "userState");
var call = new CodeMethodInvokeExpression(
thisExpr,
"Begin" + od.Name);
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var p = method.Parameters [idx];
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name, new CodeCastExpression(p.Type, new CodeArrayIndexerExpression(new CodeArgumentReferenceExpression("args"), new CodePrimitiveExpression(idx)))));
call.Parameters.Add(new CodeVariableReferenceExpression(p.Name));
}
call.Parameters.Add(new CodeArgumentReferenceExpression("asyncCallback"));
call.Parameters.Add(new CodeArgumentReferenceExpression("userState"));
cm.Statements.Add(new CodeMethodReturnStatement(call));
// OnEndXxx() implementation
cm = new CodeMemberMethod()
{
Name = "OnEnd" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(object []))
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(IAsyncResult), "result");
var outArgRefs = new List <CodeVariableReferenceExpression> ();
for (int idx = 0; idx < method.Parameters.Count; idx++)
{
var p = method.Parameters [idx];
if (p.Direction != FieldDirection.In)
{
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name));
outArgRefs.Add(new CodeVariableReferenceExpression(p.Name)); // FIXME: should this work? They need "out" or "ref" modifiers.
}
}
call = new CodeMethodInvokeExpression(
thisExpr,
"End" + od.Name,
new CodeArgumentReferenceExpression("result"));
call.Parameters.AddRange(outArgRefs.Cast <CodeExpression> ().ToArray()); // questionable
var retCreate = new CodeArrayCreateExpression(typeof(object));
if (resultType.BaseType == "System.Void")
{
cm.Statements.Add(call);
}
else
{
cm.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "__ret", call));
retCreate.Initializers.Add(new CodeVariableReferenceExpression("__ret"));
}
foreach (var outArgRef in outArgRefs)
{
retCreate.Initializers.Add(new CodeVariableReferenceExpression(outArgRef.VariableName));
}
cm.Statements.Add(new CodeMethodReturnStatement(retCreate));
// OnXxxCompleted() implementation
cm = new CodeMemberMethod()
{
Name = "On" + od.Name + "Completed",
Attributes = MemberAttributes.Private | MemberAttributes.Final
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object), "state");
string argsname = identifiers.AddUnique(od.Name + "CompletedEventArgs", null);
var iaargs = new CodeTypeReference("InvokeAsyncCompletedEventArgs"); // avoid messy System.Type instance for generic nested type :|
var iaref = new CodeVariableReferenceExpression("args");
var methodEventArgs = new CodeObjectCreateExpression(new CodeTypeReference(argsname),
new CodePropertyReferenceExpression(iaref, "Results"),
new CodePropertyReferenceExpression(iaref, "Error"),
new CodePropertyReferenceExpression(iaref, "Cancelled"),
new CodePropertyReferenceExpression(iaref, "UserState"));
cm.Statements.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeEventReferenceExpression(thisExpr, od.Name + "Completed"), CodeBinaryOperatorType.IdentityInequality, nullExpr),
new CodeVariableDeclarationStatement(iaargs, "args", new CodeCastExpression(iaargs, new CodeArgumentReferenceExpression("state"))),
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisExpr, od.Name + "Completed", thisExpr, methodEventArgs))));
// delegate fields
type.Members.Add(new CodeMemberField(new CodeTypeReference("BeginOperationDelegate"), "onBegin" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference("EndOperationDelegate"), "onEnd" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(SendOrPostCallback)), "on" + od.Name + "CompletedDelegate"));
// XxxCompletedEventArgs class
var argsType = new CodeTypeDeclaration(argsname);
argsType.BaseTypes.Add(new CodeTypeReference(typeof(AsyncCompletedEventArgs)));
cns.Types.Add(argsType);
var argsCtor = new CodeConstructor()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object []), "results"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Exception), "error"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("error"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("cancelled"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("userState"));
var resultsField = new CodeFieldReferenceExpression(thisExpr, "results");
argsCtor.Statements.Add(new CodeAssignStatement(resultsField, new CodeArgumentReferenceExpression("results")));
argsType.Members.Add(argsCtor);
argsType.Members.Add(new CodeMemberField(typeof(object []), "results"));
if (resultType.BaseType != "System.Void")
{
var resultProp = new CodeMemberProperty {
Name = "Result",
Type = resultType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
resultProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(resultProp.Type, new CodeArrayIndexerExpression(resultsField, new CodePrimitiveExpression(0)))));
argsType.Members.Add(resultProp);
}
// event field
var handlerType = new CodeTypeReference(typeof(EventHandler <>));
handlerType.TypeArguments.Add(new CodeTypeReference(argsType.Name));
type.Members.Add(new CodeMemberEvent()
{
Name = od.Name + "Completed",
Type = handlerType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
});
// XxxAsync() implementations
bool hasAsync = false;
foreach (int __x in Enumerable.Range(0, 2))
{
cm = new CodeMemberMethod();
type.Members.Add(cm);
cm.Name = od.Name + "Async";
cm.Attributes = MemberAttributes.Public
| MemberAttributes.Final;
var inArgs = new List <CodeParameterDeclarationExpression> ();
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var pd = method.Parameters [idx];
inArgs.Add(pd);
cm.Parameters.Add(pd);
}
// First one is overload without asyncState arg.
if (!hasAsync)
{
call = new CodeMethodInvokeExpression(thisExpr, cm.Name, inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray());
call.Parameters.Add(nullExpr);
cm.Statements.Add(new CodeExpressionStatement(call));
hasAsync = true;
continue;
}
// Second one is the primary one.
cm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
// if (onBeginBarOperDelegate == null) onBeginBarOperDelegate = new BeginOperationDelegate (OnBeginBarOper);
// if (onEndBarOperDelegate == null) onEndBarOperDelegate = new EndOperationDelegate (OnEndBarOper);
// if (onBarOperCompletedDelegate == null) onBarOperCompletedDelegate = new BeginOperationDelegate (OnBarOperCompleted);
var beginOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onBegin" + od.Name + "Delegate");
var endOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onEnd" + od.Name + "Delegate");
var operCompletedDelegateRef = new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate");
var ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(beginOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(beginOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("BeginOperationDelegate"), thisExpr, "OnBegin" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(endOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(endOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("EndOperationDelegate"), thisExpr, "OnEnd" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(operCompletedDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(operCompletedDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SendOrPostCallback)), thisExpr, "On" + od.Name + "Completed")));
cm.Statements.Add(ifstmt);
// InvokeAsync (onBeginBarOperDelegate, inValues, onEndBarOperDelegate, onBarOperCompletedDelegate, userState);
inArgs.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
var args = new List <CodeExpression> ();
args.Add(beginOperDelegateRef);
args.Add(new CodeArrayCreateExpression(typeof(object), inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray()));
args.Add(endOperDelegateRef);
args.Add(new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate"));
args.Add(new CodeArgumentReferenceExpression("userState"));
call = new CodeMethodInvokeExpression(baseExpr, "InvokeAsync", args.ToArray());
cm.Statements.Add(new CodeExpressionStatement(call));
}
}
public void Visit(CodeBaseReferenceExpression o)
{
g.GenerateBaseReferenceExpression(o);
}
protected override void Visit(CodeBaseReferenceExpression expr)
{
base.Visit(expr);
}
protected abstract void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e);
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
{
}
private void ValidateBaseReferenceExpression(CodeBaseReferenceExpression e)
{ // Nothing to validate
}
