public TypescriptBaseReferenceExpression( CodeBaseReferenceExpression codeExpression, CodeGeneratorOptions options) { _codeExpression = codeExpression; _options = options; System.Diagnostics.Debug.WriteLine("TypescriptBaseReferenceExpression Created"); }
private void ValidateBaseReferenceExpression(CodeBaseReferenceExpression e) { // Nothing to validate }
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))); }
protected override void GenerateBaseReferenceExpression (CodeBaseReferenceExpression e) { }
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) { base.Output.Write("MyBase"); }
public override void BuildCodeDomTree (CodeCompileUnit compileUnit) { CodeThisReferenceExpression @this = new CodeThisReferenceExpression (); CodeBaseReferenceExpression @base = new CodeBaseReferenceExpression (); CodeTypeReferenceExpression thisType = new CodeTypeReferenceExpression (new CodeTypeReference (GeneratedTypeName)); CodeTypeReference uriType = new CodeTypeReference (typeof(Uri)); CodeMemberField executableField = new CodeMemberField { Name = "_Executable", Type = new CodeTypeReference(typeof(XsltExecutable)), Attributes = MemberAttributes.Private | MemberAttributes.Static }; // methods // cctor CodeTypeConstructor cctor = new CodeTypeConstructor { CustomAttributes = { new CodeAttributeDeclaration(DebuggerNonUserCodeTypeReference) } }; CodeVariableDeclarationStatement procVar = new CodeVariableDeclarationStatement { Name = "proc", Type = new CodeTypeReference(typeof(IXsltProcessor)), InitExpression = new CodeIndexerExpression { TargetObject = new CodePropertyReferenceExpression { PropertyName = "Xslt", TargetObject = new CodeTypeReferenceExpression(typeof(Processors)) }, Indices = { new CodePrimitiveExpression(parser.ProcessorName) } } }; CodeVariableDeclarationStatement sourceVar = new CodeVariableDeclarationStatement { Name = "source", Type = new CodeTypeReference(typeof(Stream)), InitExpression = new CodePrimitiveExpression(null) }; CodeVariableDeclarationStatement sourceUriVar = new CodeVariableDeclarationStatement { Name = "sourceUri", Type = uriType, InitExpression = new CodeObjectCreateExpression { CreateType = uriType, Parameters = { new CodePrimitiveExpression(ValidatorUri.AbsoluteUri) } } }; CodeVariableDeclarationStatement resolverVar = new CodeVariableDeclarationStatement { Name = "resolver", Type = new CodeTypeReference(typeof(XmlResolver)), InitExpression = new CodeObjectCreateExpression(typeof(XmlEmbeddedResourceResolver)) }; CodeTryCatchFinallyStatement trySt = new CodeTryCatchFinallyStatement { TryStatements = { new CodeAssignStatement { Left = new CodeVariableReferenceExpression(sourceVar.Name), Right = new CodeCastExpression { TargetType = new CodeTypeReference(typeof(Stream)), Expression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "GetEntity", TargetObject = new CodeVariableReferenceExpression(resolverVar.Name) }, Parameters = { new CodeVariableReferenceExpression(sourceUriVar.Name), new CodePrimitiveExpression(null), new CodeTypeOfExpression(typeof(Stream)) } } } } } }; CodeVariableDeclarationStatement optionsVar = new CodeVariableDeclarationStatement { Name = "options", Type = new CodeTypeReference(typeof(XsltCompileOptions)), }; optionsVar.InitExpression = new CodeObjectCreateExpression (optionsVar.Type); trySt.TryStatements.Add (optionsVar); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodePropertyReferenceExpression { PropertyName = "BaseUri", TargetObject = new CodeVariableReferenceExpression(optionsVar.Name) }, Right = new CodeVariableReferenceExpression(sourceUriVar.Name) }); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodeFieldReferenceExpression { FieldName = executableField.Name, TargetObject = thisType }, Right = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression { MethodName = "Compile", TargetObject = new CodeVariableReferenceExpression(procVar.Name) }, new CodeVariableReferenceExpression(sourceVar.Name), new CodeVariableReferenceExpression(optionsVar.Name) ) }); CodeConditionStatement disposeIf = new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression { Left = new CodeVariableReferenceExpression(sourceVar.Name), Operator = CodeBinaryOperatorType.IdentityInequality, Right = new CodePrimitiveExpression(null) }, TrueStatements = { new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "Dispose", TargetObject = new CodeVariableReferenceExpression(sourceVar.Name) } } } }; trySt.FinallyStatements.Add (disposeIf); cctor.Statements.AddRange (new CodeStatement[] { procVar, sourceVar, sourceUriVar, resolverVar, trySt }); // ctor CodeConstructor ctor = new CodeConstructor { Attributes = MemberAttributes.Public, CustomAttributes = { new CodeAttributeDeclaration(DebuggerNonUserCodeTypeReference) }, BaseConstructorArgs = { new CodeFieldReferenceExpression { FieldName = executableField.Name, TargetObject = thisType } } }; // class CodeTypeDeclaration codeType = new CodeTypeDeclaration { Name = GeneratedTypeName, IsClass = true, BaseTypes = { typeof(SchematronXsltValidator) }, Members = { cctor, ctor, executableField } }; CodeNamespace codeNamespace = new CodeNamespace { Name = GeneratedTypeNamespace, Types = { codeType } }; compileUnit.Namespaces.Add (codeNamespace); }
public void Visit (CodeBaseReferenceExpression o) { g.GenerateBaseReferenceExpression (o); }
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) { Write("super(type(self), self)"); }
private void Write(CodeBaseReferenceExpression e){ this.writer.Write("base"); }
CodeExpression ParseExpression(CodeSegment tokenSegment, out CodeSegment nextToParse, CodeTypeDeclarationEx enclosingType) { CodeExpression expression = null; nextToParse = tokenSegment.Next; if(tokenSegment.Token == Token.Identifier && tokenSegment.Next != null && tokenSegment.Next.Token == Token.LiteralBracketOpen) { bool ismethodDeclaration = false; var closingliteral = tokenSegment.Next.FindClosingBracked(true); if(closingliteral != null) { //ensure that it is not a defect method declaration var bra = closingliteral.NextOmit(whitespacetokenNewLines); if(bra != null && bra.Token == Token.BlockOpen) { // it is a method indeed ismethodDeclaration = true; } } else { RegisterError(_document, tokenSegment.Next, "Missing: )"); } #region Parse for Method Invokes if(!ismethodDeclaration) { CodeTypeDeclarationEx methodContext = null; if(tokenSegment.Previous != null && tokenSegment.Previous.Previous != null && tokenSegment.Previous.Token == Token.MemberInvoke) { var invoker = tokenSegment.Previous.Previous; #region adjust Method Context if(_document.CodeLanguage.SELFREF_CAN_BE_OMITTED) methodContext = enclosingType; if(invoker.CodeDOMObject is CodeBaseReferenceExpression) { foreach(CodeTypeReferenceEx bt in enclosingType.BaseTypes) { var typedeclaration = bt.ResolveTypeDeclarationCache(); if(typedeclaration != null && typedeclaration.IsClass) { methodContext = typedeclaration; break; } } } else if(invoker.CodeDOMObject is CodeThisReferenceExpression) { methodContext = enclosingType; } else if(invoker.Token == Token.Identifier) { invoker.CodeDOMObject = CodeTypeDeclarationDynamic.Default; methodContext = CodeTypeDeclarationDynamic.Default; } #endregion } var invokeExpression = new CodeMethodInvokeExpression(); var methodRef = new CodeMethodReferenceExpressionExAHK(_document, null, tokenSegment.TokenString, methodContext); invokeExpression.Method = methodRef; tokenSegment.CodeDOMObject = methodRef; expression = invokeExpression; } nextToParse = tokenSegment.Next.Next; #endregion } else if(tokenSegment.Token == Token.KeyWord) { #region Parse Keywords if(tokenSegment.TokenString.Equals("new", _document.CodeLanguage.NameComparisation)) { #region NEW parse for new Object Expressions var newObjectInvoke = tokenSegment.NextOmit(whitespacetokenNewLines); if(newObjectInvoke != null && newObjectInvoke.Token == Token.Identifier) { var objectinstangicing = new CodeObjectCreateExpression(); objectinstangicing.CreateType = new CodeTypeReferenceEx(_document, newObjectInvoke.TokenString, enclosingType); tokenSegment.CodeDOMObject = objectinstangicing; newObjectInvoke.CodeDOMObject = objectinstangicing.CreateType; expression = objectinstangicing; nextToParse = newObjectInvoke.Next; } #endregion } else if(tokenSegment.TokenString.Equals("this", _document.CodeLanguage.NameComparisation)) { var thisrefExpression = new CodeThisReferenceExpression(); tokenSegment.CodeDOMObject = thisrefExpression; expression = thisrefExpression; } else if(tokenSegment.TokenString.Equals("base", _document.CodeLanguage.NameComparisation)) { var baserefExpression = new CodeBaseReferenceExpression(); tokenSegment.CodeDOMObject = baserefExpression; expression = baserefExpression; } #endregion } else if(tokenSegment.Token == Token.Identifier && tokenSegment.Previous != null && tokenSegment.Previous.Token == Token.MemberInvoke) { #region Parse MemberInvoke (Dot) Class.Member var context = tokenSegment.Previous.Previous; if(context == null) { //unexpected! var err = "Unexpected Member Invoke!"; RegisterError(_document, tokenSegment, err); RegisterError(_document, tokenSegment.Previous, err); nextToParse = tokenSegment.Next; } else if(context.Token == Token.KeyWord && context.TokenString.Equals("this", _document.CodeLanguage.NameComparisation)) { var propRef = new CodePropertyReferenceExpressionEx(_document, null, tokenSegment.TokenString, enclosingType); tokenSegment.CodeDOMObject = propRef; } else if(context.Token == Token.KeyWord && context.TokenString.Equals("base", _document.CodeLanguage.NameComparisation)) { CodeTypeDeclarationEx typedeclaration = null; foreach(CodeTypeReferenceEx bt in enclosingType.BaseTypes) { typedeclaration = bt.ResolveTypeDeclarationCache(); if(typedeclaration != null && typedeclaration.IsClass) { break; } } var propRef = new CodePropertyReferenceExpressionEx(_document, null, tokenSegment.TokenString, typedeclaration); tokenSegment.CodeDOMObject = propRef; } else if(context.Token == Token.Identifier) { // we currently not supprt real expression parsing, so leave here... context.CodeDOMObject = CodeTypeDeclarationDynamic.Default; var propRef = new CodePropertyReferenceExpressionEx(_document, null, tokenSegment.TokenString, CodeTypeDeclarationDynamic.Default); tokenSegment.CodeDOMObject = propRef; } #region Parse for one hirarchy this/base Property/Field Invokes #endregion #endregion } else if(tokenSegment.Token == Token.TraditionalCommandInvoke) { #region Parse Traditional Command Invoke var members = from m in _languageRoot.Members.Cast<CodeTypeMember>() let methd = m as CodeMemberMethodExAHK where methd != null && methd.IsTraditionalCommand && methd.Name.Equals(tokenSegment.TokenString, StringComparison.InvariantCultureIgnoreCase) select methd; if(members.Any()) { var invokeExpression = new CodeMethodInvokeExpression(); var methodRef = new CodeMethodReferenceExpressionExAHK(_document, members.First()); tokenSegment.CodeDOMObject = methodRef; expression = invokeExpression; } else { RegisterError(_document, tokenSegment, string.Format("Unknown traditional Command '{0}'", tokenSegment.TokenString)); } #endregion } else if(tokenSegment.Token == Token.LiteralString) { if(tokenSegment.TokenString[tokenSegment.TokenString.Length - 1] != '"') { RegisterError(_document, tokenSegment, "Missing string end Quote"); } } if(!(nextToParse != null && nextToParse.LineNumber == tokenSegment.LineNumber)) { nextToParse = null; } return expression; }
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; //} }
protected virtual CodeBaseReferenceExpression Rewrite(CodeBaseReferenceExpression source, ref bool didRewrite) { if (source == null) { return source; } bool didChildRewrite = false; CodeBaseReferenceExpression result = new CodeBaseReferenceExpression(); this.Rewrite(result.UserData, source.UserData, ref didChildRewrite); if (didChildRewrite) { didRewrite = true; return result; } else { return source; } }
private Expression Translate(CodeBaseReferenceExpression expr){ if (expr == null) return null; return new Base(); }
/// <summary> /// Visits a <see cref="CodeBaseReferenceExpression"/>. /// </summary> /// <param name="codeBaseReferenceExpression">The <see cref="CodeBaseReferenceExpression"/> to visit.</param> protected virtual void VisitCodeBaseReferenceExpression(CodeBaseReferenceExpression codeBaseReferenceExpression) { }
/// <devdoc> /// <para> /// Generates /// code for the specified CodeDom based base reference expression /// representation. /// </para> /// </devdoc> private void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) { Output.Write("base"); }
protected override void GenerateBaseReferenceExpression(System.CodeDom.CodeBaseReferenceExpression e) { throw new Exception("The method or operation is not implemented."); }
private CodeExpression BuildExpression(XSharpParser.PrimaryExpressionContext expression) { CodeExpression expr = null; XSharpParser.PrimaryContext ctx = expression.Expr; // if (ctx is XSharpParser.SelfExpressionContext) // Self { expr = new CodeThisReferenceExpression(); } else if (ctx is XSharpParser.SuperExpressionContext) // Super { expr = new CodeBaseReferenceExpression(); } else if (ctx is XSharpParser.LiteralExpressionContext) { XSharpParser.LiteralExpressionContext lit = (XSharpParser.LiteralExpressionContext)ctx; expr = BuildLiteralValue(lit.Literal); } else if (ctx is XSharpParser.LiteralArrayExpressionContext) // { expr [, expr] } { XSharpParser.LiteralArrayContext arr = ((XSharpParser.LiteralArrayExpressionContext)ctx).LiteralArray; // Typed Array ? if (arr.Type != null) { List<CodeExpression> exprlist = new List<CodeExpression>(); foreach (var Element in arr._Elements) { exprlist.Add(BuildExpression(Element.Expr,true)); } expr = new CodeArrayCreateExpression(BuildDataType(arr.Type), exprlist.ToArray()); } else { expr = new CodeSnippetExpression(arr.GetText()); } } else if (ctx is XSharpParser.DelegateCtorCallContext) { XSharpParser.DelegateCtorCallContext delg = (XSharpParser.DelegateCtorCallContext)ctx; // CodeTypeReference ctr = BuildDataType(delg.Type); CodeExpression ce = BuildExpression(delg.Obj,false); // expr = new CodeDelegateCreateExpression(BuildDataType(delg.Type), BuildExpression(delg.Obj,false), delg.Func.GetText()); } else if (ctx is XSharpParser.CtorCallContext) { XSharpParser.CtorCallContext ctor = (XSharpParser.CtorCallContext)ctx; CodeTypeReference ctr = BuildDataType(ctor.Type); List<CodeExpression> exprlist = new List<CodeExpression>(); if (ctor.ArgList != null) { foreach (var arg in ctor.ArgList._Args) { // We should handle arg.Name if arg.ASSIGN_OP is not null... exprlist.Add(BuildExpression(arg.Expr,false)); } } expr = new CodeObjectCreateExpression(ctr.BaseType, exprlist.ToArray()); } else if (ctx is XSharpParser.TypeOfExpressionContext) { CodeTypeReference ctr = BuildDataType(((XSharpParser.TypeOfExpressionContext)ctx).Type); expr = new CodeTypeOfExpression(ctr); } else if (ctx is XSharpParser.NameExpressionContext) { String name = ((XSharpParser.NameExpressionContext)ctx).Name.Id.GetText(); // Sometimes, we will need to do it that way.... if (name.ToLower() == "self") { expr = new CodeThisReferenceExpression(); } else if (name.ToLower() == "super") { expr = new CodeBaseReferenceExpression(); } else { CodeTypeReference ctr = BuildSimpleName(((XSharpParser.NameExpressionContext)ctx).Name); expr = new CodeVariableReferenceExpression(name); } } else { expr = new CodeSnippetExpression(ctx.GetText()); } return expr; }
public void Generate(CodeBaseReferenceExpression expression) { Write("super"); }
void CallBaseFrameworkInitialize (CodeMemberMethod method) { CodeBaseReferenceExpression baseRef = new CodeBaseReferenceExpression (); CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (baseRef, "FrameworkInitialize"); method.Statements.Add (invoke); }
/// <summary> /// Generates code for the specified base reference expression. /// </summary> /// <remarks><c>parent</c></remarks> protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) { Output.Write(SpecialWords.Parent); }
protected abstract void GenerateBaseReferenceExpression (CodeBaseReferenceExpression e);
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; }
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)); } }
protected override void GenerateBaseReferenceExpression (CodeBaseReferenceExpression expression) { Output.Write ("base"); }
protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e) { Output.Write("[CodeBaseReferenceExpression: {0}]", e.ToString()); }
private CodeMemberMethod GetInitCleanupMethod(Type methodAttributeType, MultiDirectionTestClass testClass) { bool isStatic = false; string generatedMetholdName = string.Empty; string methodToInvokeName = string.Empty; CodeParameterDeclarationExpression parameterDec = null; if (methodAttributeType == typeof(ClassInitializeAttribute)) { isStatic = true; generatedMetholdName = GodeGeneratorConst.ClassInitMethodName; methodToInvokeName = testClass.ClassInit.Name; parameterDec = new CodeParameterDeclarationExpression(typeof(TestContext), "testContext"); } else if (methodAttributeType == typeof(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(methodAttributeType)); 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; }