public void Constructor0_Deny_Unrestricted () { CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement (); Assert.AreEqual (0, ctcfs.CatchClauses.Count, "CatchClauses"); Assert.AreEqual (0, ctcfs.FinallyStatements.Count, "FinallyStatements"); Assert.AreEqual (0, ctcfs.TryStatements.Count, "TryStatements"); }
// Generate a codedom exception handler statement public static CodeStatement Emit(ExceptionHandler ex) { // Create the codedom exception handler statement var codeTry = new CodeTryCatchFinallyStatement(); // Add the statements in the try block foreach (var e in ex.Try.ChildExpressions) codeTry.TryStatements.Add(CodeDomEmitter.EmitCodeStatement(e)); // Add all the catch clauses. foreach (var c in ex.CatchClauses) { // Create the codedom catch statement. var catchClause = new CodeCatchClause(); // To do: replace with non-test code catchClause.CatchExceptionType = new CodeTypeReference("System.Exception"); catchClause.LocalName = "ex"; codeTry.CatchClauses.Add(catchClause); // Add the statemnts in the catch block foreach(var e in c.ChildExpressions) catchClause.Statements.Add(CodeDomEmitter.EmitCodeStatement(e)); } // Add the statements in the finally block. foreach (var e in ex.Finally.ChildExpressions) codeTry.FinallyStatements.Add(CodeDomEmitter.EmitCodeStatement(e)); return codeTry; }
public void Constructor1_Deny_Unrestricted () { CodeStatement[] try_statements = new CodeStatement[1] { new CodeStatement () }; CodeCatchClause[] catch_clauses = new CodeCatchClause[1] { new CodeCatchClause () }; CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement (try_statements, catch_clauses); Assert.AreEqual (1, ctcfs.CatchClauses.Count, "CatchClauses"); Assert.AreEqual (0, ctcfs.FinallyStatements.Count, "FinallyStatements"); Assert.AreEqual (1, ctcfs.TryStatements.Count, "TryStatements"); }
public TypescriptTryCatchFinallyStatement( IStatementFactory statementFactory, IExpressionFactory expressionFactory, CodeTryCatchFinallyStatement statement, CodeGeneratorOptions options) { _statementFactory = statementFactory; _expressionFactory = expressionFactory; _statement = statement; _options = options; _typescriptTypeMapper = new TypescriptTypeMapper(); }
public static CodeTryCatchFinallyStatement Clone(this CodeTryCatchFinallyStatement statement) { if (statement == null) return null; CodeTryCatchFinallyStatement s = new CodeTryCatchFinallyStatement(); s.CatchClauses.AddRange(statement.CatchClauses.Clone()); s.EndDirectives.AddRange(statement.EndDirectives); s.FinallyStatements.AddRange(statement.FinallyStatements.Clone()); s.LinePragma = statement.LinePragma; s.StartDirectives.AddRange(statement.StartDirectives); s.TryStatements.AddRange(statement.TryStatements.Clone()); s.UserData.AddRange(statement.UserData); return s; }
/// <summary> /// /// </summary> /// <param name="member"></param> /// <param name="inner"></param> /// <param name="attrs"></param> /// <returns></returns> public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs) { Debug.Assert(member is MethodInfo); MethodInfo method = member as MethodInfo; CodeMemberMethod codeMethod = new CodeMemberMethod(); codeMethod.Name = method.Name; codeMethod.ReturnType = new CodeTypeReference(method.ReturnType); codeMethod.Attributes = attrs; // try CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement(); // decleare parameters List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>(); foreach (ParameterInfo codeParameter in method.GetParameters()) { CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name); codeMethod.Parameters.Add(codeParameterDeclare); codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name)); } // invoke CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression( inner, method.Name, codeParamiteRefrs.ToArray()); if (method.ReturnType.Name.ToLower() == "void") { tryCode.TryStatements.Add(invokeMethod); } else { CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod); //CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod); tryCode.TryStatements.Add(var); CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false); tryCode.TryStatements.Add(todo); CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject"); CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef); tryCode.TryStatements.Add(codeReturn); } // catch CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception)); CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef); catchClause.Statements.Add(new CodeThrowExceptionStatement()); tryCode.CatchClauses.Add(catchClause); codeMethod.Statements.Add(tryCode); return codeMethod; }
public override object VisitUsingStatement(UsingStatement usingStatement, object data) { // using (new expr) { stmts; } // // emulate with // object _dispose; // try // { // _dispose = new expr; // // stmts; // } // finally // { // if (((_dispose != null) // && (typeof(System.IDisposable).IsInstanceOfType(_dispose) == true))) // { // ((System.IDisposable)(_dispose)).Dispose(); // } // } // usingId++; // in case nested using() statements string name = "_dispose" + usingId.ToString(); CodeVariableDeclarationStatement disposable = new CodeVariableDeclarationStatement("System.Object", name, new CodePrimitiveExpression(null)); AddStmt(disposable); CodeTryCatchFinallyStatement tryStmt = new CodeTryCatchFinallyStatement(); CodeVariableReferenceExpression left1 = new CodeVariableReferenceExpression(name); codeStack.Push(NullStmtCollection); // send statements to nul Statement collection CodeExpression right1 = (CodeExpression)usingStatement.ResourceAcquisition.AcceptVisitor(this, data); codeStack.Pop(); CodeAssignStatement assign1 = new CodeAssignStatement(left1, right1); tryStmt.TryStatements.Add(assign1); tryStmt.TryStatements.Add(new CodeSnippetStatement()); codeStack.Push(tryStmt.TryStatements); usingStatement.EmbeddedStatement.AcceptChildren(this, data); codeStack.Pop(); CodeMethodInvokeExpression isInstanceOfType = new CodeMethodInvokeExpression(new CodeTypeOfExpression(typeof(IDisposable)), "IsInstanceOfType", new CodeExpression[] { left1 }); CodeConditionStatement if1 = new CodeConditionStatement(); if1.Condition = new CodeBinaryOperatorExpression(new CodeBinaryOperatorExpression(left1, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)), CodeBinaryOperatorType.BooleanAnd, new CodeBinaryOperatorExpression(isInstanceOfType, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true))); if1.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IDisposable),left1), "Dispose", new CodeExpression[] { })); tryStmt.FinallyStatements.Add(if1); // Add Statement to Current Statement Collection AddStmt(tryStmt); return null; }
protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement e) { }
protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement statement) { TextWriter output = Output; output.WriteLine ("Try "); ++Indent; GenerateStatements (statement.TryStatements); --Indent; foreach (CodeCatchClause clause in statement.CatchClauses) { output.Write ("Catch "); OutputTypeNamePair (clause.CatchExceptionType, clause.LocalName); output.WriteLine (); ++Indent; GenerateStatements (clause.Statements); --Indent; } CodeStatementCollection finallies = statement.FinallyStatements; if (finallies.Count > 0) { output.WriteLine ("Finally"); ++Indent; GenerateStatements (finallies); --Indent; } output.WriteLine("End Try"); }
public void Visit (CodeTryCatchFinallyStatement o) { g.GenerateTryCatchFinallyStatement (o); }
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); }
/// <include file='doc\CSharpCodeProvider.uex' path='docs/doc[@for="CSharpCodeGenerator.GenerateTryCatchFinallyStatement"]/*' /> /// <devdoc> /// <para> /// Generates code for the specified CodeDom based try catch finally /// statement representation. /// </para> /// </devdoc> protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e) { Output.Write("try"); OutputStartingBrace(); Indent++; GenerateStatements(e.TryStatements); Indent--; CodeCatchClauseCollection catches = e.CatchClauses; if (catches.Count > 0) { IEnumerator en = catches.GetEnumerator(); while (en.MoveNext()) { Output.Write("}"); if (Options.ElseOnClosing) { Output.Write(" "); } else { Output.WriteLine(""); } CodeCatchClause current = (CodeCatchClause)en.Current; Output.Write("catch ("); OutputType(current.CatchExceptionType); Output.Write(" "); OutputIdentifier(current.LocalName); Output.Write(")"); OutputStartingBrace(); Indent++; GenerateStatements(current.Statements); Indent--; } } CodeStatementCollection finallyStatements = e.FinallyStatements; if (finallyStatements.Count > 0) { Output.Write("}"); if (Options.ElseOnClosing) { Output.Write(" "); } else { Output.WriteLine(""); } Output.Write("finally"); OutputStartingBrace(); Indent++; GenerateStatements(finallyStatements); Indent--; } Output.WriteLine("}"); }
void VisitCodeTryCatchFinallyStatement(CodeTryCatchFinallyStatement tryStatement) { WriteLine("VisitCodeTryCatchFinallyStatement"); using (IDisposable currentLevel = Indentation.IncrementLevel()) { WriteLine("Try statements follow: Count: " + tryStatement.TryStatements.Count); foreach (CodeStatement statement in tryStatement.TryStatements) { VisitCodeStatement(statement); } WriteLine("Catch clauses follow: Count: " + tryStatement.CatchClauses.Count); foreach (CodeCatchClause catchClause in tryStatement.CatchClauses) { VisitCodeCatchClause(catchClause); } WriteLine("Finally statements follow: Count: " + tryStatement.FinallyStatements); foreach (CodeStatement statement in tryStatement.FinallyStatements) { VisitCodeStatement(statement); } } }
private void WriteHookupMethods(CodeTypeDeclaration cls) { if (this.axctlEventsType != null) { CodeMemberMethod method = new CodeMemberMethod { Name = "CreateSink", Attributes = MemberAttributes.Family | MemberAttributes.Override }; CodeObjectCreateExpression expression = new CodeObjectCreateExpression(this.axctl + "EventMulticaster", new CodeExpression[0]); expression.Parameters.Add(new CodeThisReferenceExpression()); CodeAssignStatement statement = new CodeAssignStatement(this.multicasterRef, expression); CodeObjectCreateExpression expression2 = new CodeObjectCreateExpression(typeof(AxHost.ConnectionPointCookie).FullName, new CodeExpression[0]); expression2.Parameters.Add(this.memIfaceRef); expression2.Parameters.Add(this.multicasterRef); expression2.Parameters.Add(new CodeTypeOfExpression(this.axctlEvents)); CodeAssignStatement statement2 = new CodeAssignStatement(this.cookieRef, expression2); CodeTryCatchFinallyStatement statement3 = new CodeTryCatchFinallyStatement(); statement3.TryStatements.Add(statement); statement3.TryStatements.Add(statement2); statement3.CatchClauses.Add(new CodeCatchClause("", new CodeTypeReference(typeof(Exception)))); method.Statements.Add(statement3); cls.Members.Add(method); CodeMemberMethod method2 = new CodeMemberMethod { Name = "DetachSink", Attributes = MemberAttributes.Family | MemberAttributes.Override }; CodeFieldReferenceExpression targetObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), this.cookie); CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(targetObject, "Disconnect", new CodeExpression[0]); statement3 = new CodeTryCatchFinallyStatement(); statement3.TryStatements.Add(expression4); statement3.CatchClauses.Add(new CodeCatchClause("", new CodeTypeReference(typeof(Exception)))); method2.Statements.Add(statement3); cls.Members.Add(method2); } CodeMemberMethod method3 = new CodeMemberMethod { Name = "AttachInterfaces", Attributes = MemberAttributes.Family | MemberAttributes.Override }; CodeCastExpression right = new CodeCastExpression(this.axctlType.FullName, new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "GetOcx", new CodeExpression[0])); CodeAssignStatement statement4 = new CodeAssignStatement(this.memIfaceRef, right); CodeTryCatchFinallyStatement statement5 = new CodeTryCatchFinallyStatement(); statement5.TryStatements.Add(statement4); statement5.CatchClauses.Add(new CodeCatchClause("", new CodeTypeReference(typeof(Exception)))); method3.Statements.Add(statement5); cls.Members.Add(method3); }
protected override void GenerateTryCatchFinallyStatement(System.CodeDom.CodeTryCatchFinallyStatement e) { throw new Exception("The method or operation is not implemented."); }
/// <summary> /// Generated code for function to do conversion of date from DMTF format to DateTime format /// </summary> void AddToDateTimeFunction() { String dmtfParam = "dmtfDate"; String year = "year"; String month = "month"; String day = "day"; String hour = "hour"; String minute = "minute"; String second = "second"; String ticks = "ticks"; String dmtf = "dmtf"; String tempStr = "tempString"; String datetimeVariable = "datetime"; CodeCastExpression cast = null; CodeMemberMethod cmmdt = new CodeMemberMethod(); cmmdt.Name = PrivateNamesUsed["ToDateTimeMethod"].ToString(); cmmdt.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmdt.ReturnType = new CodeTypeReference("System.DateTime"); cmmdt.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.String"),dmtfParam)); cmmdt.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TODATETIME"))); // create a local variable to initialize from - fixed warnings in MCPP which doesn't // like you copying sub items (like year) out of MinValue cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.DateTime"),"initializer",new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"))); CodeVariableReferenceExpression cvreInitializer = new CodeVariableReferenceExpression("initializer"); //Int32 year = initializer.Year; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),year,new CodePropertyReferenceExpression(cvreInitializer,"Year"))); //Int32 month = initializer.Month; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),month, new CodePropertyReferenceExpression(cvreInitializer,"Month"))); //Int32 day = initializer.Day; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),day,new CodePropertyReferenceExpression(cvreInitializer,"Day"))); //Int32 hour = initializer.Hour; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),hour,new CodePropertyReferenceExpression(cvreInitializer,"Hour"))); //Int32 minute = Sinitializer.Minute; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),minute,new CodePropertyReferenceExpression(cvreInitializer,"Minute"))); //Int32 second = initializer.Second; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),second,new CodePropertyReferenceExpression(cvreInitializer,"Second"))); //Int32 millisec = 0; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int64"),ticks,new CodePrimitiveExpression(0))); //String dmtf = dmtfDate ; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),dmtf,new CodeVariableReferenceExpression(dmtfParam))); //System.DateTime datetime = System.DateTime.MinValue ; CodeFieldReferenceExpression cpreMinVal = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.DateTime"),"MinValue"); cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.DateTime"),datetimeVariable,cpreMinVal)); //String tempString = String.Empty ; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),tempStr,new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("System.String"),"Empty"))); /* if (dmtf == null) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(dmtf); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; CodeObjectCreateExpression codeThrowException = new CodeObjectCreateExpression(); codeThrowException.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); /* if (dmtf.Length == 0) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Length"); cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); /* if (str.Length != DMTF_DATETIME_STR_LENGTH ) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Length"); cboe.Right = new CodePrimitiveExpression(DMTF_DATETIME_STR_LENGTH); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmdt.Statements.Add(cis); CodeTryCatchFinallyStatement tryblock = new CodeTryCatchFinallyStatement(); DateTimeConversionFunctionHelper(tryblock.TryStatements,"****",tempStr,dmtf,year,0,4); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,month,4,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,day,6,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,hour,8,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,minute,10,2); DateTimeConversionFunctionHelper(tryblock.TryStatements,"**",tempStr,dmtf,second,12,2); /* tempString = dmtf.Substring(15, 6); if (("******" != tempString)) { ticks = (System.Int64.Parse(tempString)) * (System.TimeSpan.TicksPerMillisecond/1000); } */ CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(15)); cmie.Parameters.Add(new CodePrimitiveExpression(6)); tryblock.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePrimitiveExpression("******"); cboe.Right = new CodeVariableReferenceExpression(tempStr); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; CodeMethodReferenceExpression cmre1 = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int64"),"Parse"); CodeMethodInvokeExpression cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre1; cmie1.Parameters.Add(new CodeVariableReferenceExpression(tempStr)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMillisecond"); cboe.Right = new CodePrimitiveExpression(1000); cboe.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe); CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(); cboe2.Left = cmie1; cboe2.Right = cast; cboe2.Operator = CodeBinaryOperatorType.Multiply; cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(ticks),cboe2)); tryblock.TryStatements.Add(cis); /* if( year < 0 || month < 0 || day < 0 || hour < 0 || minute < 0 || second < 0 || ticks < 0) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboeYear = new CodeBinaryOperatorExpression(); cboeYear.Left = new CodeVariableReferenceExpression(year); cboeYear.Right = new CodePrimitiveExpression(0); cboeYear.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMonth = new CodeBinaryOperatorExpression(); cboeMonth.Left = new CodeVariableReferenceExpression(month); cboeMonth.Right = new CodePrimitiveExpression(0); cboeMonth.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeDay = new CodeBinaryOperatorExpression(); cboeDay.Left = new CodeVariableReferenceExpression(day); cboeDay.Right = new CodePrimitiveExpression(0); cboeDay.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeHour = new CodeBinaryOperatorExpression(); cboeHour.Left = new CodeVariableReferenceExpression(hour); cboeHour.Right = new CodePrimitiveExpression(0); cboeHour.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMinute = new CodeBinaryOperatorExpression(); cboeMinute.Left = new CodeVariableReferenceExpression(minute); cboeMinute.Right = new CodePrimitiveExpression(0); cboeMinute.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeSecond = new CodeBinaryOperatorExpression(); cboeSecond.Left = new CodeVariableReferenceExpression(second); cboeSecond.Right = new CodePrimitiveExpression(0); cboeSecond.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeTicks = new CodeBinaryOperatorExpression(); cboeTicks.Left = new CodeVariableReferenceExpression(ticks); cboeTicks.Right = new CodePrimitiveExpression(0); cboeTicks.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboetemp1 = new CodeBinaryOperatorExpression(); cboetemp1.Left = cboeYear; cboetemp1.Right = cboeMonth; cboetemp1.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp2 = new CodeBinaryOperatorExpression(); cboetemp2.Left = cboetemp1; cboetemp2.Right = cboeDay; cboetemp2.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp3 = new CodeBinaryOperatorExpression(); cboetemp3.Left = cboetemp2; cboetemp3.Right = cboeHour; cboetemp3.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp4 = new CodeBinaryOperatorExpression(); cboetemp4.Left = cboetemp3; cboetemp4.Right = cboeMinute; cboetemp4.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp5 = new CodeBinaryOperatorExpression(); cboetemp5.Left = cboetemp4; cboetemp5.Right = cboeMinute; cboetemp5.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp6 = new CodeBinaryOperatorExpression(); cboetemp6.Left = cboetemp5; cboetemp6.Right = cboeSecond; cboetemp6.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp7 = new CodeBinaryOperatorExpression(); cboetemp7.Left = cboetemp6; cboetemp7.Right = cboeTicks; cboetemp7.Operator = CodeBinaryOperatorType.BooleanOr; cis = new CodeConditionStatement(); cis.Condition = cboetemp7; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); tryblock.TryStatements.Add(cis); /* catch { throw new System.ArgumentOutOfRangeException(null, e.Message); } */ string exceptVar = "e"; CodeCatchClause catchblock = new CodeCatchClause(exceptVar); CodeObjectCreateExpression codeThrowExceptionWithArgs = new CodeObjectCreateExpression(); codeThrowExceptionWithArgs.CreateType = new CodeTypeReference (PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); codeThrowExceptionWithArgs.Parameters.Add(new CodePrimitiveExpression(null)); codeThrowExceptionWithArgs.Parameters.Add ( new CodePropertyReferenceExpression ( new CodeVariableReferenceExpression(exceptVar), "Message" ) ); catchblock.Statements.Add(new CodeThrowExceptionStatement(codeThrowExceptionWithArgs)); // // add the catch block to the try block // tryblock.CatchClauses.Add(catchblock); // // add the try block to cmmdt // cmmdt.Statements.Add(tryblock); /* datetime = new System.DateTime(year, month, day, hour, minute, second, millisec); */ coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.DateTime"); coce.Parameters.Add(new CodeVariableReferenceExpression(year)); coce.Parameters.Add(new CodeVariableReferenceExpression(month)); coce.Parameters.Add(new CodeVariableReferenceExpression(day)); coce.Parameters.Add(new CodeVariableReferenceExpression(hour)); coce.Parameters.Add(new CodeVariableReferenceExpression(minute)); coce.Parameters.Add(new CodeVariableReferenceExpression(second)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),coce)); /* datetime = datetime.AddTicks(ticks); */ CodeMethodReferenceExpression cmre2 = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(datetimeVariable),"AddTicks"); CodeMethodInvokeExpression cmie2 = new CodeMethodInvokeExpression(); cmie2.Method = cmre2; cmie2.Parameters.Add(new CodeVariableReferenceExpression(ticks)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),cmie2)); /* System.TimeSpan tickOffset = System.TimeZone.CurrentTimeZone.GetUtcOffset(datetime); */ cmre1 = new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.TimeZone"),"CurrentTimeZone"), "GetUtcOffset"); cmie1 = new CodeMethodInvokeExpression(); cmie1.Method = cmre1; cmie1.Parameters.Add(new CodeVariableReferenceExpression(datetimeVariable)); String tickoffset = "tickOffset"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),tickoffset,cmie1)); /* System.Int32 UTCOffset = 0; System.Int32 OffsetToBeAdjusted = 0; long OffsetMins = tickOffset.Ticks / System.TimeSpan.TicksPerMinute; tempString = dmtf.Substring(22, 3); */ String utcOffset = "UTCOffset"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),utcOffset,new CodePrimitiveExpression(0))); String offsetAdjust = "OffsetToBeAdjusted"; cmmdt.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),offsetAdjust,new CodePrimitiveExpression(0))); String OffsetMins = "OffsetMins"; cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tickoffset),"Ticks"); cboe.Right = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"TicksPerMinute"); cboe.Operator = CodeBinaryOperatorType.Divide; cast = new CodeCastExpression("System.Int64", cboe); cmmdt.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference("System.Int64"), OffsetMins, cast ) ); cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(22)); cmie.Parameters.Add(new CodePrimitiveExpression(3)); cmmdt.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); /* if (("***" != tempString1)) { tempString1 = dmtf.Substring(21, 4); try { UTCOffset = System.Int32.Parse(tempString1); } catch { throw new System.ArgumentOutOfRangeException(); } OffsetToBeAdjusted = UTCOffset-OffsetMins; // We have to substract the minutes from the time datetime = datetime.AddMinutes((System.Double)(OffsetToBeAdjusted)); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(tempStr); cboe.Right = new CodePrimitiveExpression("******"); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(dmtf),"Substring"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodePrimitiveExpression(21)); cmie.Parameters.Add(new CodePrimitiveExpression(4)); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(tempStr), cmie)); CodeTryCatchFinallyStatement tryblock2 = new CodeTryCatchFinallyStatement(); cmre = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int32"),"Parse"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodeVariableReferenceExpression(tempStr)); tryblock2.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(utcOffset), cmie)); // // add the catch block // tryblock2.CatchClauses.Add(catchblock); // // add tryblock2 to cis // cis.TrueStatements.Add(tryblock2); cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(OffsetMins); cboe.Right = new CodeVariableReferenceExpression(utcOffset); cboe.Operator = CodeBinaryOperatorType.Subtract; cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(offsetAdjust),new CodeCastExpression(new CodeTypeReference("System.Int32"),cboe))); cmre = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(datetimeVariable),"AddMinutes"); cmie = new CodeMethodInvokeExpression(); cmie.Method = cmre; cmie.Parameters.Add(new CodeCastExpression("System.Double",new CodeVariableReferenceExpression(offsetAdjust))); cis.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(datetimeVariable),cmie)); cmmdt.Statements.Add(cis); /* return datetime; */ cmmdt.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(datetimeVariable))); cc.Members.Add(cmmdt); }
/// <summary> /// Gets the load from file CodeDOM method. /// </summary> /// <param name="type">The type CodeTypeDeclaration.</param> /// <returns>return the codeDom LoadFromFile method</returns> protected override CodeMemberMethod GetLoadFromFileMethod(CodeTypeDeclaration type) { var typeName = GeneratorContext.GeneratorParams.GenericBaseClass.Enabled ? "T" : type.Name; // --------------------------------------------- // public static T LoadFromFile(string fileName) // --------------------------------------------- var loadFromFileMethod = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Static, Name = GeneratorContext.GeneratorParams.Serialization.LoadFromFileMethodName }; loadFromFileMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "fileName")); if (GeneratorContext.GeneratorParams.Serialization.EnableEncoding) { loadFromFileMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Encoding), "encoding")); } loadFromFileMethod.ReturnType = new CodeTypeReference(typeName); loadFromFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(IsolatedStorageFile)), "isoFile", new CodePrimitiveExpression(null))); loadFromFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(IsolatedStorageFileStream)), "isoStream", new CodePrimitiveExpression(null))); loadFromFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(StreamReader)), "sr", new CodePrimitiveExpression(null))); var tryStatmanentsCol = new CodeStatementCollection(); var finallyStatmanentsCol = new CodeStatementCollection(); tryStatmanentsCol.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("isoFile"), CodeDomHelper.GetInvokeMethod("IsolatedStorageFile", "GetUserStoreForApplication"))); tryStatmanentsCol.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("isoStream"), new CodeObjectCreateExpression( typeof(IsolatedStorageFileStream), new CodeExpression[] { new CodeArgumentReferenceExpression("fileName"), CodeDomHelper.GetEnum("FileMode","Open"), new CodeVariableReferenceExpression("isoFile") }))); CodeExpression[] codeParamExpression; if (GeneratorContext.GeneratorParams.Serialization.EnableEncoding) { codeParamExpression = new CodeExpression[] { new CodeVariableReferenceExpression("isoStream"), new CodeVariableReferenceExpression("encoding") }; } else { codeParamExpression = new CodeExpression[] { new CodeVariableReferenceExpression("isoStream") }; } tryStatmanentsCol.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("sr"), new CodeObjectCreateExpression( typeof(StreamReader), codeParamExpression ))); // ---------------------------------- // string xmlString = sr.ReadToEnd(); // ---------------------------------- var readToEndInvoke = CodeDomHelper.GetInvokeMethod("sr", "ReadToEnd"); var xmlString = new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(string)), "xmlString", readToEndInvoke); tryStatmanentsCol.Add(xmlString); tryStatmanentsCol.Add(CodeDomHelper.GetInvokeMethod("isoStream", "Close")); tryStatmanentsCol.Add(CodeDomHelper.GetInvokeMethod("sr", "Close")); // ------------------------------------------------------ // return Deserialize(xmlString, out obj, out exception); // ------------------------------------------------------ var fileName = new CodeVariableReferenceExpression("xmlString"); var deserializeInvoke = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(null, GeneratorContext.GeneratorParams.Serialization.DeserializeMethodName), new CodeExpression[] { fileName }); var rstmts = new CodeMethodReturnStatement(deserializeInvoke); tryStatmanentsCol.Add(rstmts); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("isoFile")); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("isoStream")); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("sr")); var tryfinally = new CodeTryCatchFinallyStatement( CodeDomHelper.CodeStmtColToArray(tryStatmanentsCol), new CodeCatchClause[0], CodeDomHelper.CodeStmtColToArray(finallyStatmanentsCol)); loadFromFileMethod.Statements.Add(tryfinally); return loadFromFileMethod; }
void AddToTimeSpanFunction() { String tsParam = "dmtfTimespan"; String days = "days"; String hours = "hours"; String minutes = "minutes"; String seconds = "seconds"; String ticks = "ticks"; CodeMemberMethod cmmts = new CodeMemberMethod(); cmmts.Name = PrivateNamesUsed["ToTimeSpanMethod"].ToString(); cmmts.Attributes = MemberAttributes.Final | MemberAttributes.Static; cmmts.ReturnType = new CodeTypeReference("System.TimeSpan"); cmmts.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.String"),tsParam)); cmmts.Comments.Add(new CodeCommentStatement(GetString("COMMENT_TOTIMESPAN"))); //Int32 days = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),days,new CodePrimitiveExpression(0))); //Int32 hours = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),hours,new CodePrimitiveExpression(0))); //Int32 minutes = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),minutes,new CodePrimitiveExpression(0))); //Int32 seconds = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32"),seconds,new CodePrimitiveExpression(0))); //Int32 ticks = 0; cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int64"),ticks,new CodePrimitiveExpression(0))); /* if (dmtfTimespan == null) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodeVariableReferenceExpression(tsParam); cboe.Right = new CodePrimitiveExpression(null); cboe.Operator = CodeBinaryOperatorType.IdentityEquality; CodeConditionStatement cis = new CodeConditionStatement(); cis.Condition = cboe; CodeObjectCreateExpression codeThrowException = new CodeObjectCreateExpression(); codeThrowException.CreateType = new CodeTypeReference(PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if (dmtfTimespan.Length == 0) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Length"); cboe.Right = new CodePrimitiveExpression(0); cboe.Operator = CodeBinaryOperatorType.ValueEquality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if (dmtfTimespan.Length != DMTF_DATETIME_STR_LENGTH ) { throw new System.ArgumentOutOfRangeException(); } */ cboe = new CodeBinaryOperatorExpression(); cboe.Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Length"); cboe.Right = new CodePrimitiveExpression(DMTF_DATETIME_STR_LENGTH); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); /* if(dmtfTimespan.Substring(21,4) != ":000") { throw new System.ArgumentOutOfRangeException(); } */ CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(21)); cmie.Parameters.Add(new CodePrimitiveExpression(4)); cboe = new CodeBinaryOperatorExpression(); cboe.Left = cmie; cboe.Right = new CodePrimitiveExpression(":000"); cboe.Operator = CodeBinaryOperatorType.IdentityInequality; cis = new CodeConditionStatement(); cis.Condition = cboe; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); cmmts.Statements.Add(cis); CodeTryCatchFinallyStatement tryblock = new CodeTryCatchFinallyStatement(); /* string tempString = System.String.Empty; */ string strTemp = "tempString"; tryblock.TryStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.String"),strTemp, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.String"),"Empty"))); /* tempString = dmtfTimespan.Substring(0, 8); days = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(8, 2); hours = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(10, 2); minutes = System.Int32.Parse(tempString); tempString = dmtfTimespan.Substring(12, 2); seconds = System.Int32.Parse(tempString); */ ToTimeSpanHelper(0,8,days,tryblock.TryStatements); ToTimeSpanHelper(8,2,hours,tryblock.TryStatements); ToTimeSpanHelper(10,2,minutes,tryblock.TryStatements); ToTimeSpanHelper(12,2,seconds,tryblock.TryStatements); /* tempString = dmtfTimespan.Substring(15, 6); */ cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(tsParam),"Substring"); cmie.Parameters.Add(new CodePrimitiveExpression(15)); cmie.Parameters.Add(new CodePrimitiveExpression(6)); tryblock.TryStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(strTemp),cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.Int64"),"Parse"); cmie.Parameters.Add(new CodeVariableReferenceExpression(strTemp)); /* ticks = (System.Int64.Parse(tempString)) * (System.TimeSpan.TicksPerMillisecond/1000); */ tryblock.TryStatements.Add ( new CodeAssignStatement( new CodeVariableReferenceExpression(ticks), new CodeBinaryOperatorExpression( cmie, CodeBinaryOperatorType.Multiply, new CodeCastExpression( "System.Int64", new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression("System.TimeSpan"), "TicksPerMillisecond" ), CodeBinaryOperatorType.Divide, new CodePrimitiveExpression(1000) ) ) ) ) ); /* if( days < 0 || hours < 0 || minutes < 0 || seconds < 0 || ticks < 0) { throw new System.ArgumentOutOfRangeException(); } */ CodeBinaryOperatorExpression cboeDays = new CodeBinaryOperatorExpression(); cboeDays.Left = new CodeVariableReferenceExpression(days); cboeDays.Right = new CodePrimitiveExpression(0); cboeDays.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeHours = new CodeBinaryOperatorExpression(); cboeHours.Left = new CodeVariableReferenceExpression(hours); cboeHours.Right = new CodePrimitiveExpression(0); cboeHours.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeMinutes = new CodeBinaryOperatorExpression(); cboeMinutes.Left = new CodeVariableReferenceExpression(minutes); cboeMinutes.Right = new CodePrimitiveExpression(0); cboeMinutes.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeSeconds = new CodeBinaryOperatorExpression(); cboeSeconds.Left = new CodeVariableReferenceExpression(seconds); cboeSeconds.Right = new CodePrimitiveExpression(0); cboeSeconds.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboeTicks = new CodeBinaryOperatorExpression(); cboeTicks.Left = new CodeVariableReferenceExpression(ticks); cboeTicks.Right = new CodePrimitiveExpression(0); cboeTicks.Operator = CodeBinaryOperatorType.LessThan; CodeBinaryOperatorExpression cboetemp1 = new CodeBinaryOperatorExpression(); cboetemp1.Left = cboeDays; cboetemp1.Right = cboeHours; cboetemp1.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp2 = new CodeBinaryOperatorExpression(); cboetemp2.Left = cboetemp1; cboetemp2.Right = cboeMinutes; cboetemp2.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp3 = new CodeBinaryOperatorExpression(); cboetemp3.Left = cboetemp2; cboetemp3.Right = cboeSeconds; cboetemp3.Operator = CodeBinaryOperatorType.BooleanOr; CodeBinaryOperatorExpression cboetemp4 = new CodeBinaryOperatorExpression(); cboetemp4.Left = cboetemp3; cboetemp4.Right = cboeTicks; cboetemp4.Operator = CodeBinaryOperatorType.BooleanOr; cis = new CodeConditionStatement(); cis.Condition = cboetemp4; cis.TrueStatements.Add(new CodeThrowExceptionStatement(codeThrowException)); /* catch { throw new System.ArgumentOutOfRangeException(null, e.Message); } */ string exceptVar = "e"; CodeCatchClause catchblock = new CodeCatchClause(exceptVar); CodeObjectCreateExpression codeThrowExceptionWithArgs = new CodeObjectCreateExpression(); codeThrowExceptionWithArgs.CreateType = new CodeTypeReference (PublicNamesUsed["ArgumentOutOfRangeException"].ToString()); codeThrowExceptionWithArgs.Parameters.Add(new CodePrimitiveExpression(null)); codeThrowExceptionWithArgs.Parameters.Add ( new CodePropertyReferenceExpression ( new CodeVariableReferenceExpression(exceptVar), "Message" ) ); catchblock.Statements.Add(new CodeThrowExceptionStatement(codeThrowExceptionWithArgs)); // // add the catch block to the try block // tryblock.CatchClauses.Add(catchblock); // // add the try block to cmmts // cmmts.Statements.Add(tryblock); /* timespan = new System.TimeSpan(days, hours, minutes, seconds, 0); */ string timespan = "timespan"; coce = new CodeObjectCreateExpression(); coce.CreateType = new CodeTypeReference("System.TimeSpan"); coce.Parameters.Add(new CodeVariableReferenceExpression(days)); coce.Parameters.Add(new CodeVariableReferenceExpression(hours)); coce.Parameters.Add(new CodeVariableReferenceExpression(minutes)); coce.Parameters.Add(new CodeVariableReferenceExpression(seconds)); coce.Parameters.Add(new CodePrimitiveExpression(0)); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),timespan,coce)); /* TimeSpan tsTemp = System.TimeSpan.FromTicks(ticks); timespan = timespan.Add(tsTemp); */ string tsTemp = "tsTemp"; cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("System.TimeSpan"),"FromTicks"); cmie.Parameters.Add(new CodeVariableReferenceExpression(ticks)); cmmts.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.TimeSpan"),tsTemp,cmie)); cmie = new CodeMethodInvokeExpression(); cmie.Method = new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(timespan),"Add"); cmie.Parameters.Add(new CodeVariableReferenceExpression(tsTemp)); cmmts.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(timespan),cmie)); /* return timespan; */ cmmts.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(timespan))); cc.Members.Add(cmmts); }
public CodeExpression GenerateLoadPixbuf (string name, Gtk.IconSize size) { bool found = false; foreach (CodeTypeDeclaration t in cns.Types) { if (t.Name == "IconLoader") { found = true; break; } } if (!found) { CodeTypeDeclaration cls = new CodeTypeDeclaration ("IconLoader"); cls.Attributes = MemberAttributes.Private; cls.TypeAttributes = System.Reflection.TypeAttributes.NestedAssembly; cns.Types.Add (cls); CodeMemberMethod met = new CodeMemberMethod (); cls.Members.Add (met); met.Attributes = MemberAttributes.Public | MemberAttributes.Static; met.Name = "LoadIcon"; met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(Gtk.Widget), "widget")); met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(string), "name")); met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(Gtk.IconSize), "size")); met.ReturnType = new CodeTypeReference (typeof(Gdk.Pixbuf)); CodeExpression widgetExp = new CodeVariableReferenceExpression ("widget"); CodeExpression nameExp = new CodeVariableReferenceExpression ("name"); CodeExpression sizeExp = new CodeVariableReferenceExpression ("size"); CodeExpression szExp = new CodeVariableReferenceExpression ("sz"); CodeExpression mgExp = new CodeBinaryOperatorExpression (szExp, CodeBinaryOperatorType.Divide, new CodePrimitiveExpression (4)); CodeExpression pmapExp = new CodeVariableReferenceExpression ("pmap"); CodeExpression gcExp = new CodeVariableReferenceExpression ("gc"); CodeExpression szM1Exp = new CodeBinaryOperatorExpression (szExp, CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression (1)); CodeExpression zeroExp = new CodePrimitiveExpression (0); CodeExpression resExp = new CodeVariableReferenceExpression ("res"); met.Statements.Add ( new CodeVariableDeclarationStatement (typeof(Gdk.Pixbuf), "res", new CodeMethodInvokeExpression ( widgetExp, "RenderIcon", nameExp, sizeExp, new CodePrimitiveExpression (null) ) ) ); CodeConditionStatement nullcheck = new CodeConditionStatement (); met.Statements.Add (nullcheck); nullcheck.Condition = new CodeBinaryOperatorExpression ( resExp, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression (null) ); nullcheck.TrueStatements.Add (new CodeMethodReturnStatement (resExp)); // int sz, h; // Gtk.Icon.SizeLookup (size, out sz, out h); nullcheck.FalseStatements.Add (new CodeVariableDeclarationStatement (typeof(int), "sz")); nullcheck.FalseStatements.Add (new CodeVariableDeclarationStatement (typeof(int), "sy")); nullcheck.FalseStatements.Add (new CodeMethodInvokeExpression ( new CodeTypeReferenceExpression (typeof(Gtk.Icon).ToGlobalTypeRef ()), "SizeLookup", sizeExp, new CodeDirectionExpression (FieldDirection.Out, szExp), new CodeDirectionExpression (FieldDirection.Out, new CodeVariableReferenceExpression ("sy")) )); CodeTryCatchFinallyStatement trycatch = new CodeTryCatchFinallyStatement (); nullcheck.FalseStatements.Add (trycatch); trycatch.TryStatements.Add ( new CodeMethodReturnStatement ( new CodeMethodInvokeExpression ( new CodePropertyReferenceExpression ( new CodeTypeReferenceExpression (new CodeTypeReference (typeof(Gtk.IconTheme))), "Default" ), "LoadIcon", nameExp, szExp, zeroExp ) ) ); CodeCatchClause ccatch = new CodeCatchClause (); trycatch.CatchClauses.Add (ccatch); CodeConditionStatement cond = new CodeConditionStatement (); ccatch.Statements.Add (cond); cond.Condition = new CodeBinaryOperatorExpression ( nameExp, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression ("gtk-missing-image") ); cond.TrueStatements.Add ( new CodeMethodReturnStatement ( new CodeMethodInvokeExpression ( new CodeTypeReferenceExpression (cns.Name + "." + cls.Name), "LoadIcon", widgetExp, new CodePrimitiveExpression ("gtk-missing-image"), sizeExp ) ) ); CodeStatementCollection stms = cond.FalseStatements; stms.Add ( new CodeVariableDeclarationStatement (typeof(Gdk.Pixmap), "pmap", new CodeObjectCreateExpression ( typeof(Gdk.Pixmap), new CodePropertyReferenceExpression ( new CodePropertyReferenceExpression ( new CodeTypeReferenceExpression (typeof(Gdk.Screen)), "Default" ), "RootWindow" ), szExp, szExp ) ) ); stms.Add ( new CodeVariableDeclarationStatement (typeof(Gdk.GC), "gc", new CodeObjectCreateExpression (typeof(Gdk.GC), pmapExp) ) ); stms.Add ( new CodeAssignStatement ( new CodePropertyReferenceExpression ( gcExp, "RgbFgColor" ), new CodeObjectCreateExpression ( typeof(Gdk.Color), new CodePrimitiveExpression (255), new CodePrimitiveExpression (255), new CodePrimitiveExpression (255) ) ) ); stms.Add ( new CodeMethodInvokeExpression ( pmapExp, "DrawRectangle", gcExp, new CodePrimitiveExpression (true), zeroExp, zeroExp, szExp, szExp ) ); stms.Add ( new CodeAssignStatement ( new CodePropertyReferenceExpression ( gcExp, "RgbFgColor" ), new CodeObjectCreateExpression ( typeof(Gdk.Color), zeroExp, zeroExp, zeroExp ) ) ); stms.Add ( new CodeMethodInvokeExpression ( pmapExp, "DrawRectangle", gcExp, new CodePrimitiveExpression (false), zeroExp, zeroExp, szM1Exp, szM1Exp ) ); stms.Add ( new CodeMethodInvokeExpression ( gcExp, "SetLineAttributes", new CodePrimitiveExpression (3), new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.LineStyle)), "Solid"), new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.CapStyle)), "Round"), new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typeof(Gdk.JoinStyle)), "Round") ) ); stms.Add ( new CodeAssignStatement ( new CodePropertyReferenceExpression ( gcExp, "RgbFgColor" ), new CodeObjectCreateExpression ( typeof(Gdk.Color), new CodePrimitiveExpression (255), zeroExp, zeroExp ) ) ); stms.Add ( new CodeMethodInvokeExpression ( pmapExp, "DrawLine", gcExp, mgExp, mgExp, new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp), new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp) ) ); stms.Add ( new CodeMethodInvokeExpression ( pmapExp, "DrawLine", gcExp, new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp), mgExp, mgExp, new CodeBinaryOperatorExpression (szM1Exp, CodeBinaryOperatorType.Subtract, mgExp) ) ); stms.Add ( new CodeMethodReturnStatement ( new CodeMethodInvokeExpression ( new CodeTypeReferenceExpression (typeof(Gdk.Pixbuf)), "FromDrawable", pmapExp, new CodePropertyReferenceExpression (pmapExp, "Colormap"), zeroExp, zeroExp, zeroExp, zeroExp, szExp, szExp ) ) ); } int sz, h; Gtk.Icon.SizeLookup (size, out sz, out h); return new CodeMethodInvokeExpression ( new CodeTypeReferenceExpression (new CodeTypeReference (cns.Name + ".IconLoader", CodeTypeReferenceOptions.GlobalReference)), "LoadIcon", rootObject, new CodePrimitiveExpression (name), new CodeFieldReferenceExpression ( new CodeTypeReferenceExpression (new CodeTypeReference (typeof(Gtk.IconSize), CodeTypeReferenceOptions.GlobalReference)), size.ToString () ) ); }
CodeMemberMethod GenerateLoadMethod() { ////Generate the following code: //private static System.Reflection.Assembly Load(string assemblyNameVal) { // System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName(assemblyNameVal); // byte[] publicKeyToken = assemblyName.GetPublicKeyToken(); // System.Reflection.Assembly asm = null; // try { // asm = System.Reflection.Assembly.Load(assemblyName.FullName); // } // catch (System.Exception ) { // System.Reflection.AssemblyName shortName = new System.Reflection.AssemblyName(assemblyName.Name); // if ((publicKeyToken != null)) { // shortName.SetPublicKeyToken(publicKeyToken); // } // asm = System.Reflection.Assembly.Load(shortName); // } // return asm; //} CodeMemberMethod loadMethod = new CodeMemberMethod() { Name = "Load", Attributes = MemberAttributes.Private | MemberAttributes.Static, ReturnType = new CodeTypeReference(typeof(Assembly)) }; loadMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "assemblyNameVal")); CodeVariableReferenceExpression assemblyNameVal = new CodeVariableReferenceExpression("assemblyNameVal"); CodeExpression initAssemblyName = typeof(AssemblyName).New(assemblyNameVal); CodeVariableReferenceExpression assemblyName = loadMethod.Statements.DeclareVar(typeof(AssemblyName), "assemblyName", initAssemblyName); CodeVariableReferenceExpression publicKeyToken = loadMethod.Statements.DeclareVar(typeof(byte[]), "publicKeyToken", new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression() { MethodName = "GetPublicKeyToken", TargetObject = assemblyName, }, } ); CodeVariableReferenceExpression asm = loadMethod.Statements.DeclareVar(typeof(Assembly), "asm", new CodePrimitiveExpression(null)); CodeExpression publicKeyTokenNotNullExp = new CodeBinaryOperatorExpression(publicKeyToken, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeTryCatchFinallyStatement tryCatchExp = new CodeTryCatchFinallyStatement(); tryCatchExp.TryStatements.Add(new CodeAssignStatement(asm, new CodeMethodInvokeExpression( new CodeMethodReferenceExpression() { MethodName = "System.Reflection.Assembly.Load" }, new CodePropertyReferenceExpression(assemblyName, "FullName") ) )); CodeCatchClause catchClause = new CodeCatchClause(); CodeVariableReferenceExpression shortName = catchClause.Statements.DeclareVar(typeof(AssemblyName), "shortName", typeof(AssemblyName).New(new CodePropertyReferenceExpression(assemblyName, "Name"))); CodeConditionStatement setPublicKeyTokenExp = new CodeConditionStatement(); setPublicKeyTokenExp.Condition = publicKeyTokenNotNullExp; setPublicKeyTokenExp.TrueStatements.Add( new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(shortName, "SetPublicKeyToken"), publicKeyToken) ); catchClause.Statements.Add(setPublicKeyTokenExp); catchClause.Statements.Add(new CodeAssignStatement(asm, new CodeMethodInvokeExpression( new CodeMethodReferenceExpression() { MethodName = "System.Reflection.Assembly.Load" }, shortName ) )); tryCatchExp.CatchClauses.Add(catchClause); loadMethod.Statements.Add(tryCatchExp); loadMethod.Statements.Add(new CodeMethodReturnStatement(asm)); return loadMethod; }
// Add a new vertex method to the DryadLinq vertex class internal CodeMemberMethod AddVertexMethod(DLinqQueryNode node) { CodeMemberMethod vertexMethod = new CodeMemberMethod(); vertexMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; vertexMethod.ReturnType = new CodeTypeReference(typeof(int)); vertexMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "args")); vertexMethod.Name = MakeUniqueName(node.NodeType.ToString()); CodeTryCatchFinallyStatement tryBlock = new CodeTryCatchFinallyStatement(); string startedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name + " started at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))"; vertexMethod.Statements.Add(new CodeSnippetExpression(startedMsg)); // We need to add a call to CopyResources() vertexMethod.Statements.Add(new CodeSnippetExpression("CopyResources()")); if (StaticConfig.LaunchDebugger) { // If static config requests it, we do an unconditional Debugger.Launch() at vertex entry. // Currently this isn't used because StaticConfig.LaunchDebugger is hardcoded to false System.Console.WriteLine("Launch debugger: may block application"); CodeExpression launchExpr = new CodeSnippetExpression("System.Diagnostics.Debugger.Launch()"); vertexMethod.Statements.Add(new CodeExpressionStatement(launchExpr)); } else { // Otherwise (the default behavior), we check an environment variable to decide whether // to launch the debugger, wait for a manual attach or simply skip straigt into vertex code. CodeMethodInvokeExpression debuggerCheckExpr = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(HelperClassName), DebugHelperMethodName)); vertexMethod.Statements.Add(new CodeExpressionStatement(debuggerCheckExpr)); } vertexMethod.Statements.Add(MakeVertexParamsDecl(node)); vertexMethod.Statements.Add(SetVertexParamField("VertexStageName", vertexMethod.Name)); vertexMethod.Statements.Add(SetVertexParamField("UseLargeBuffer", node.UseLargeWriteBuffer)); Int32[] portCountArray = node.InputPortCounts(); bool[] keepPortOrderArray = node.KeepInputPortOrders(); for (int i = 0; i < node.InputArity; i++) { CodeExpression setParamsExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(VertexParamName), "SetInputParams", new CodePrimitiveExpression(i), new CodePrimitiveExpression(portCountArray[i]), new CodePrimitiveExpression(keepPortOrderArray[i])); vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr)); } // YY: We could probably do better here. for (int i = 0; i < node.GetReferencedQueries().Count; i++) { CodeExpression setParamsExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(VertexParamName), "SetInputParams", new CodePrimitiveExpression(i + node.InputArity), new CodePrimitiveExpression(1), new CodePrimitiveExpression(false)); vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr)); } // Push the parallel-code settings into DryadLinqVertex bool multiThreading = this.m_context.EnableMultiThreadingInVertex; vertexMethod.Statements.Add(SetVertexParamField("MultiThreading", multiThreading)); vertexMethod.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression(DLVTypeExpr, "s_multiThreading"), new CodePrimitiveExpression(multiThreading))); vertexMethod.Statements.Add(MakeVertexEnvDecl(node)); Type[] outputTypes = node.OutputTypes; string[] writerNames = new string[outputTypes.Length]; for (int i = 0; i < outputTypes.Length; i++) { CodeVariableDeclarationStatement writerDecl = MakeVertexWriterDecl(outputTypes[i], this.GetStaticFactoryName(outputTypes[i])); vertexMethod.Statements.Add(writerDecl); writerNames[i] = writerDecl.Name; } // Add side readers: node.AddSideReaders(vertexMethod); // Generate code based on the node type: switch (node.NodeType) { case QueryNodeType.Where: case QueryNodeType.OrderBy: case QueryNodeType.Distinct: case QueryNodeType.Skip: case QueryNodeType.SkipWhile: case QueryNodeType.Take: case QueryNodeType.TakeWhile: case QueryNodeType.Merge: case QueryNodeType.Select: case QueryNodeType.SelectMany: case QueryNodeType.Zip: case QueryNodeType.GroupBy: case QueryNodeType.BasicAggregate: case QueryNodeType.Aggregate: case QueryNodeType.Contains: case QueryNodeType.Join: case QueryNodeType.GroupJoin: case QueryNodeType.Union: case QueryNodeType.Intersect: case QueryNodeType.Except: case QueryNodeType.RangePartition: case QueryNodeType.HashPartition: case QueryNodeType.Apply: case QueryNodeType.Fork: case QueryNodeType.Dynamic: { Type[] inputTypes = node.InputTypes; string[] sourceNames = new string[inputTypes.Length]; for (int i = 0; i < inputTypes.Length; i++) { CodeVariableDeclarationStatement readerDecl = MakeVertexReaderDecl(inputTypes[i], this.GetStaticFactoryName(inputTypes[i])); vertexMethod.Statements.Add(readerDecl); sourceNames[i] = readerDecl.Name; } string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, sourceNames, writerNames); if (sourceToSink != null) { CodeExpression sinkExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(writerNames[0]), "WriteItemSequence", new CodeVariableReferenceExpression(sourceToSink)); vertexMethod.Statements.Add(sinkExpr); } break; } case QueryNodeType.Super: { string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, null, writerNames); if (sourceToSink != null) { CodeExpression sinkExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(writerNames[0]), "WriteItemSequence", new CodeVariableReferenceExpression(sourceToSink)); vertexMethod.Statements.Add(sinkExpr); } break; } default: { //@@TODO: this should not be reachable. could change to Assert/InvalidOpEx throw new DryadLinqException(DryadLinqErrorCode.Internal, String.Format(SR.AddVertexNotHandled, node.NodeType)); } } string completedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name + " completed at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))"; vertexMethod.Statements.Add(new CodeSnippetExpression(completedMsg)); // add a catch block CodeCatchClause catchBlock = new CodeCatchClause("e"); CodeTypeReferenceExpression errorReportClass = new CodeTypeReferenceExpression("VertexEnv"); CodeMethodReferenceExpression errorReportMethod = new CodeMethodReferenceExpression(errorReportClass, "ReportVertexError"); CodeVariableReferenceExpression exRef = new CodeVariableReferenceExpression(catchBlock.LocalName); catchBlock.Statements.Add(new CodeMethodInvokeExpression(errorReportMethod, exRef)); tryBlock.CatchClauses.Add(catchBlock); // wrap the entire vertex method in a try/catch block tryBlock.TryStatements.AddRange(vertexMethod.Statements); vertexMethod.Statements.Clear(); vertexMethod.Statements.Add(tryBlock); // Always add "return 0", to make CLR hosting happy... vertexMethod.Statements.Add(new CodeMethodReturnStatement(ZeroExpr)); this.m_dryadVertexClass.Members.Add(vertexMethod); return vertexMethod; }
CodeMemberMethod GenerateInitializeMethod(ClassData classData, List<CodeMemberField> memberFields) { // /// <summary> InitializeComponent </summary> // [DebuggerNonUserCodeAttribute] // [System.CodeDom.Compiler.GeneratedCodeAttribute("<%= AssemblyName %>", "<%= AssemblyVersion %>")] // public void InitializeComponent() { // CodeMemberMethod initializeMethod = new CodeMemberMethod() { Name = "InitializeComponent", Attributes = MemberAttributes.Public | MemberAttributes.Final, CustomAttributes = { new CodeAttributeDeclaration(new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute))), GeneratedCodeAttribute } }; initializeMethod.Comments.AddRange(GenerateXmlComments(initializeMethod.Name)); // if (__contentLoaded) { return; } initializeMethod.Statements.Add( new CodeConditionStatement() { Condition = new CodeBinaryOperatorExpression() { Left = new CodeFieldReferenceExpression() { FieldName = "_contentLoaded", TargetObject = new CodeThisReferenceExpression() }, Operator = CodeBinaryOperatorType.ValueEquality, Right = new CodePrimitiveExpression(true) }, TrueStatements = { new CodeMethodReturnStatement() } } ); // __contentLoaded = true; initializeMethod.Statements.Add( new CodeAssignStatement() { Left = new CodeFieldReferenceExpression() { FieldName = "_contentLoaded", TargetObject = new CodeThisReferenceExpression() }, Right = new CodePrimitiveExpression(true) } ); if (ArePartialMethodsSupported()) { // bool isInitialized = false; // BeforeInitializeComponent(ref isInitialized); // if (isInitialized) { // AfterInitializeComponent(); // return; // } initializeMethod.Statements.Add(new CodeVariableDeclarationStatement( typeof(bool), "isInitialized", new CodePrimitiveExpression(false))); initializeMethod.Statements.Add(new CodeMethodInvokeExpression( new CodeThisReferenceExpression(), "BeforeInitializeComponent", new CodeDirectionExpression(FieldDirection.Ref, new CodeVariableReferenceExpression("isInitialized")) )); initializeMethod.Statements.Add( new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("isInitialized"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(true) ), TrueStatements = { new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "AfterInitializeComponent"), new CodeMethodReturnStatement() } } ); } // string resourceName = FindResource(); CodeVariableReferenceExpression resourceNameVar = initializeMethod.Statements.DeclareVar( typeof(string), "resourceName", new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression() { MethodName = "FindResource", TargetObject = new CodeThisReferenceExpression(), }, } ); // Stream initializeXaml = typeof(<%= className %>).Assembly.GetManifestResourceStream(resourceName); // CodeVariableReferenceExpression initializeXamlVar = initializeMethod.Statements.DeclareVar( typeof(Stream), "initializeXaml", new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression() { MethodName = "GetManifestResourceStream", TargetObject = new CodePropertyReferenceExpression() { PropertyName = "Assembly", TargetObject = new CodeTypeOfExpression() { Type = new CodeTypeReference(classData.Name) } } }, Parameters = { new CodeVariableReferenceExpression(resourceNameVar.VariableName), } } ); // var reader = new System.Xaml.XamlXmlReader(new System.IO.StreamReader(initializeXaml)); // CodeVariableReferenceExpression xmlReaderVar = initializeMethod.Statements.DeclareVar( typeof(XmlReader), "xmlReader", new CodePrimitiveExpression(null)); CodeVariableReferenceExpression xamlReaderVar = initializeMethod.Statements.DeclareVar( typeof(XamlReader), "reader", new CodePrimitiveExpression(null)); CodeVariableReferenceExpression objWriterVar = initializeMethod.Statements.DeclareVar( typeof(XamlObjectWriter), "objectWriter", new CodePrimitiveExpression(null)); // Enclose in try finally block // This is to call Dispose on the xmlReader in the finally block, which is the CodeDom way of the C# "using" block CodeTryCatchFinallyStatement tryCatchFinally = new CodeTryCatchFinallyStatement(); tryCatchFinally.TryStatements.AddRange(GetInitializeMethodTryStatements(xmlReaderVar, xamlReaderVar, objWriterVar, initializeXamlVar, classData, memberFields)); tryCatchFinally.FinallyStatements.AddRange(GetInitializeMethodFinallyStatements(xmlReaderVar, xamlReaderVar, objWriterVar)); initializeMethod.Statements.Add(tryCatchFinally); if (ArePartialMethodsSupported()) { // AfterInitializeComponent(); initializeMethod.Statements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "AfterInitializeComponent")); } return initializeMethod; }
protected abstract void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement s);
public bool ValidateCodeTryCatchFinallyStatement (CodeTryCatchFinallyStatement exp) { PushError ("CodeTryCatchFinallyStatement is not in the subset."); return false; }
protected override void AddPageTypeCtorStatements (CodeStatementCollection statements) { base.AddPageTypeCtorStatements (statements); CodeTypeReference uriType = new CodeTypeReference (typeof(Uri)); CodeVariableDeclarationStatement procVar = new CodeVariableDeclarationStatement { Name = "proc", Type = new CodeTypeReference(typeof(IXQueryProcessor)), InitExpression = new CodeIndexerExpression { TargetObject = new CodePropertyReferenceExpression { PropertyName = "XQuery", 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 virtualPathVar = new CodeVariableDeclarationStatement { Name = "virtualPath", Type = new CodeTypeReference(typeof(String)), InitExpression = new CodePrimitiveExpression(this.parser.AppRelativeVirtualPath) }; CodeVariableDeclarationStatement sourceUriVar = new CodeVariableDeclarationStatement { Name = "sourceUri", Type = uriType, InitExpression = new CodeObjectCreateExpression { CreateType = uriType, Parameters = { new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "MapPath", TargetObject = new CodeTypeReferenceExpression(typeof(HostingEnvironment)) }, Parameters = { new CodeVariableReferenceExpression(virtualPathVar.Name) } }, new CodePropertyReferenceExpression { PropertyName = "Absolute", TargetObject = new CodeTypeReferenceExpression(typeof(UriKind)) } } } }; CodeTryCatchFinallyStatement trySt = new CodeTryCatchFinallyStatement (); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodeVariableReferenceExpression(sourceVar.Name), Right = new CodeCastExpression { TargetType = new CodeTypeReference(typeof(Stream)), Expression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "OpenRead", TargetObject = new CodeTypeReferenceExpression(typeof(File)) }, Parameters = { new CodePropertyReferenceExpression { PropertyName = "LocalPath", TargetObject = new CodeVariableReferenceExpression(sourceUriVar.Name) } } } } }); CodeVariableDeclarationStatement optionsVar = new CodeVariableDeclarationStatement { Name = "options", Type = new CodeTypeReference(typeof(XQueryCompileOptions)), }; 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 = PageTypeReferenceExpression }, Right = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "Compile", TargetObject = new CodeVariableReferenceExpression(procVar.Name) }, Parameters = { 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) } }; disposeIf.TrueStatements.Add (new CodeMethodInvokeExpression ( new CodeMethodReferenceExpression { MethodName = "Dispose", TargetObject = new CodeVariableReferenceExpression(sourceVar.Name) } )); trySt.FinallyStatements.Add (disposeIf); statements.AddRange (new CodeStatement[] { procVar, sourceVar, virtualPathVar, sourceUriVar, trySt }); }
protected override void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement statement) { TextWriter output = Output; CodeGeneratorOptions options = Options; output.Write ("try"); OutputStartBrace (); ++Indent; GenerateStatements (statement.TryStatements); --Indent; foreach (CodeCatchClause clause in statement.CatchClauses) { output.Write ('}'); if (options.ElseOnClosing) output.Write (' '); else output.WriteLine (); output.Write ("catch ("); OutputTypeNamePair (clause.CatchExceptionType, GetSafeName(clause.LocalName)); output.Write (")"); OutputStartBrace (); ++Indent; GenerateStatements (clause.Statements); --Indent; } CodeStatementCollection finallies = statement.FinallyStatements; if (finallies.Count > 0) { output.Write ('}'); if (options.ElseOnClosing) output.Write (' '); else output.WriteLine (); output.Write ("finally"); OutputStartBrace (); ++Indent; GenerateStatements (finallies); --Indent; } output.WriteLine('}'); }
protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e) { base.Output.WriteLine("Try "); base.Indent++; this.GenerateVBStatements(e.TryStatements); base.Indent--; CodeCatchClauseCollection catchClauses = e.CatchClauses; if (catchClauses.Count > 0) { IEnumerator enumerator = catchClauses.GetEnumerator(); while (enumerator.MoveNext()) { CodeCatchClause current = (CodeCatchClause)enumerator.Current; base.Output.Write("Catch "); this.OutputTypeNamePair(current.CatchExceptionType, current.LocalName); base.Output.WriteLine(""); base.Indent++; this.GenerateVBStatements(current.Statements); base.Indent--; } } CodeStatementCollection finallyStatements = e.FinallyStatements; if (finallyStatements.Count > 0) { base.Output.WriteLine("Finally"); base.Indent++; this.GenerateVBStatements(finallyStatements); base.Indent--; } base.Output.WriteLine("End Try"); }
private void ValidateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e) { ValidateStatements(e.TryStatements); CodeCatchClauseCollection catches = e.CatchClauses; if (catches.Count > 0) { IEnumerator en = catches.GetEnumerator(); while (en.MoveNext()) { CodeCatchClause current = (CodeCatchClause)en.Current; ValidateTypeReference(current.CatchExceptionType); ValidateIdentifier(current,"LocalName",current.LocalName); ValidateStatements(current.Statements); } } CodeStatementCollection finallyStatements = e.FinallyStatements; if (finallyStatements.Count > 0) { ValidateStatements(finallyStatements); } }
protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e) { Output.WriteLine("[CodeTryCatchFinallyStatement: {0}]", e.ToString()); }
/// <summary> /// Gets the Silverlight save to isolate storage file. /// </summary> /// <param name="type">CodeTypeDeclaration type.</param> /// <returns>return the save to file code DOM method statment </returns> protected override CodeMemberMethod GetSaveToFileMethod() { // ----------------------------------------------- // public virtual void SaveToFile(string fileName) // ----------------------------------------------- var saveToFileMethod = new CodeMemberMethod { Attributes = MemberAttributes.Public, Name = GeneratorContext.GeneratorParams.Serialization.SaveToFileMethodName }; saveToFileMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "fileName")); if (GeneratorContext.GeneratorParams.Serialization.EnableEncoding) { saveToFileMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Encoding), "encoding")); } saveToFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(StreamWriter)), "streamWriter", new CodePrimitiveExpression(null))); saveToFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(IsolatedStorageFile)), "isoFile", new CodePrimitiveExpression(null))); saveToFileMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(IsolatedStorageFileStream)), "isoStream", new CodePrimitiveExpression(null))); // ------------------------ // try {...} finally {...} // ----------------------- var tryExpression = new CodeStatementCollection(); tryExpression.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("isoFile"), CodeDomHelper.GetInvokeMethod("IsolatedStorageFile", "GetUserStoreForApplication"))); tryExpression.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("isoStream"), new CodeObjectCreateExpression( typeof(IsolatedStorageFileStream), new CodeExpression[] { new CodeArgumentReferenceExpression("fileName"), CodeDomHelper.GetEnum("FileMode","Create"), new CodeVariableReferenceExpression("isoFile") }))); tryExpression.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("streamWriter"), new CodeObjectCreateExpression( typeof(StreamWriter), new CodeExpression[] { new CodeVariableReferenceExpression("isoStream"), }))); // --------------------------------------- // string xmlString = Serialize(encoding); // --------------------------------------- CodeMethodInvokeExpression serializeMethodInvoke; if (GeneratorContext.GeneratorParams.Serialization.EnableEncoding) { serializeMethodInvoke = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(null, GeneratorContext.GeneratorParams.Serialization.SerializeMethodName), new CodeExpression[] { new CodeArgumentReferenceExpression("encoding") }); } else { serializeMethodInvoke = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(null, GeneratorContext.GeneratorParams.Serialization.SerializeMethodName)); } var xmlString = new CodeVariableDeclarationStatement( new CodeTypeReference(typeof(string)), "xmlString", serializeMethodInvoke); tryExpression.Add(xmlString); if (GeneratorContext.GeneratorParams.Serialization.EnableEncoding) { // ---------------------------------------------------------------- // streamWriter = new StreamWriter(fileName, false, Encoding.UTF8); // ---------------------------------------------------------------- tryExpression.Add(new CodeAssignStatement( new CodeVariableReferenceExpression("streamWriter"), new CodeObjectCreateExpression( typeof(StreamWriter), new CodeExpression[] { new CodeSnippetExpression("fileName"), new CodeSnippetExpression("false"), new CodeSnippetExpression(GeneratorContext.GeneratorParams.Serialization.GetEncoderString()) }))); } else { // -------------------------------------------------------------- // System.IO.FileInfo xmlFile = new System.IO.FileInfo(fileName); // -------------------------------------------------------------- tryExpression.Add(CodeDomHelper.CreateObject(typeof(FileInfo), "xmlFile", new[] { "fileName" })); // ---------------------------------------- // StreamWriter Tex = xmlFile.CreateText(); // ---------------------------------------- var createTextMethodInvoke = CodeDomHelper.GetInvokeMethod("xmlFile", "CreateText"); tryExpression.Add( new CodeAssignStatement( new CodeVariableReferenceExpression("streamWriter"), createTextMethodInvoke)); } // ---------------------------------- // streamWriter.WriteLine(xmlString); // ---------------------------------- var writeLineMethodInvoke = CodeDomHelper.GetInvokeMethod( "streamWriter", "WriteLine", new CodeExpression[] { new CodeVariableReferenceExpression("xmlString") }); tryExpression.Add(writeLineMethodInvoke); tryExpression.Add(CodeDomHelper.GetInvokeMethod("streamWriter", "Close")); tryExpression.Add(CodeDomHelper.GetInvokeMethod("isoStream", "Close")); var finallyStatmanentsCol = new CodeStatementCollection(); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("streamWriter")); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("isoFile")); finallyStatmanentsCol.Add(CodeDomHelper.GetDispose("isoStream")); var trycatch = new CodeTryCatchFinallyStatement(tryExpression.ToArray(), new CodeCatchClause[0], finallyStatmanentsCol.ToArray()); saveToFileMethod.Statements.Add(trycatch); return saveToFileMethod; }
public override object Visit(TryCatchStatement tryCatchStatement, object data) { ProcessSpecials(tryCatchStatement.Specials); // add a try-catch-finally CodeTryCatchFinallyStatement tryStmt = new CodeTryCatchFinallyStatement(); codeStack.Push(tryStmt.TryStatements); ProcessSpecials(tryCatchStatement.StatementBlock.Specials); tryCatchStatement.StatementBlock.AcceptChildren(this, data); codeStack.Pop(); if (tryCatchStatement.FinallyBlock != null) { codeStack.Push(tryStmt.FinallyStatements); ProcessSpecials(tryCatchStatement.FinallyBlock.Specials); tryCatchStatement.FinallyBlock.AcceptChildren(this,data); codeStack.Pop(); } if (tryCatchStatement.CatchClauses != null) { foreach (CatchClause clause in tryCatchStatement.CatchClauses) { CodeCatchClause catchClause = new CodeCatchClause(clause.VariableName); catchClause.CatchExceptionType = new CodeTypeReference(clause.Type); tryStmt.CatchClauses.Add(catchClause); codeStack.Push(catchClause.Statements); ProcessSpecials(clause.StatementBlock.Specials); clause.StatementBlock.AcceptChildren(this, data); codeStack.Pop(); } } // Add Statement to Current Statement Collection AddStmt(tryStmt); return tryStmt; }
public async System.Threading.Tasks.Task GCode_CodeDom_GenerateMethodCode(CodeTypeDeclaration codeClass, LinkPinControl element, GenerateCodeContext_Class context, MethodGenerateData data) { var csParam = CSParam as MethodOverrideConstructParam; Type[] paramTypes = new Type[csParam.MethodInfo.Params.Count]; for (int i = 0; i < paramTypes.Length; i++) { switch (csParam.MethodInfo.Params[i].FieldDirection) { case FieldDirection.In: if (csParam.MethodInfo.Params[i].IsParamsArray) { throw new InvalidOperationException("未实现"); } else { paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType; } break; case FieldDirection.Out: case FieldDirection.Ref: if (csParam.MethodInfo.Params[i].IsParamsArray) { throw new InvalidOperationException("未实现"); } else { paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType.MakeByRefType(); } break; } } EngineNS.Editor.MacrossMemberAttribute.enMacrossType macrossType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable; if (csParam.MethodInfo.IsFromMacross) { macrossType |= EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable; } else { var methodInfo = csParam.MethodInfo.ParentClassType.GetMethod(csParam.MethodInfo.MethodName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static, null, paramTypes, null); var atts = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.MacrossMemberAttribute), false); if (atts.Length > 0) { var macrossMemberAtt = atts[0] as EngineNS.Editor.MacrossMemberAttribute; macrossType = macrossMemberAtt.MacrossType; } } if (element == null || element == mCtrlMethodPin_Next) { var methodCode = new CodeGenerateSystem.CodeDom.CodeMemberMethod(); methodCode.Attributes = MemberAttributes.Override; //if (mMethodInfo != null) //{ if (csParam.MethodInfo.IsFamily) { methodCode.Attributes |= MemberAttributes.Family; } if (csParam.MethodInfo.IsFamilyAndAssembly) { methodCode.Attributes |= MemberAttributes.FamilyAndAssembly; } if (csParam.MethodInfo.IsFamilyOrAssembly) { methodCode.Attributes |= MemberAttributes.FamilyOrAssembly; } if (csParam.MethodInfo.IsPublic) { methodCode.Attributes |= MemberAttributes.Public; } //} //else // methodCode.Attributes |= MemberAttributes.Public; methodCode.Name = NodeName; var mcType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow; if (csParam.MethodInfo.MC_Callable) { mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable; } if (csParam.MethodInfo.MC_Overrideable) { mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable; } if (mcType != EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow) { methodCode.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(EngineNS.Editor.MacrossMemberAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(mcType)))); } if (data != null) { foreach (var localParam in data.LocalParams) { var defVal = CodeGenerateSystem.Program.GetDefaultValueFromType(localParam.ParamType); var initExp = Program.GetValueCode(methodCode.Statements, localParam.ParamType, defVal); methodCode.Statements.Add(new CodeVariableDeclarationStatement(localParam.ParamType, localParam.ParamName, initExp)); } } string paramPreStr = "temp___"; //bool needUnsafeFlag = false; string catchParamName = "("; foreach (var paramNode in mChildNodes) { var paramExp = new System.CodeDom.CodeParameterDeclarationExpression(); if (paramNode is MethodInvokeParameterControl) { var pm = paramNode as MethodInvokeParameterControl; var pmParam = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams; paramExp.Direction = pm.ParamFlag; if (pmParam.ParamInfo.ParameterDisplayType != null) { paramExp.Name = paramPreStr + pmParam.ParamInfo.ParamName; paramExp.Type = new CodeTypeReference(pmParam.ParamInfo.ParameterType); } else { paramExp.Name = pmParam.ParamInfo.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); } //if (pm.ParamType.IsPointer) // needUnsafeFlag = true; } else if (paramNode is ParamParameterControl) { var pm = paramNode as ParamParameterControl; paramExp.Name = pm.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); //if (pm.ParamType.IsPointer) // needUnsafeFlag = true; } else if (paramNode is MethodInvoke_DelegateControl) { var pm = paramNode as MethodInvoke_DelegateControl; paramExp.Name = pm.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); } methodCode.Parameters.Add(paramExp); catchParamName += paramExp.Type + " " + paramExp.Name + ","; } // 所有函数全部unsafe //if (needUnsafeFlag) { //var typeName = MethodReturnType.FullName; methodCode.ReturnType = new CodeTypeReference(MethodReturnType); if (MethodReturnType == typeof(System.Threading.Tasks.Task) || MethodReturnType.BaseType == typeof(System.Threading.Tasks.Task)) { methodCode.IsAsync = true; } else { if (EngineNS.Editor.MacrossMemberAttribute.HasType(macrossType, EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unsafe)) { methodCode.IsUnsafe = true; } } } //else // methodCode.ReturnType = new CodeTypeReference(MethodReturnType); catchParamName = catchParamName.TrimEnd(','); catchParamName += ")"; var tryCatchExp = new System.CodeDom.CodeTryCatchFinallyStatement(); tryCatchExp.TryStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "Begin", new CodeExpression[0])); var exName = "ex_" + EngineNS.Editor.Assist.GetValuedGUIDString(Id); var cah = new System.CodeDom.CodeCatchClause(exName); cah.Statements.Add(new System.CodeDom.CodeExpressionStatement( new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression( new System.CodeDom.CodeSnippetExpression("EngineNS.Profiler.Log"), "WriteException", new System.CodeDom.CodeVariableReferenceExpression(exName), new CodePrimitiveExpression("Macross异常")))); tryCatchExp.CatchClauses.Add(cah); tryCatchExp.FinallyStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "End", new CodeExpression[0])); string paramComment = ""; // 设置out参数默认值 foreach (var param in csParam.MethodInfo.Params) { if (param.ParameterDisplayType != null) { if (param.FieldDirection == FieldDirection.Out) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType)))); } methodCode.Statements.Add(new CodeVariableDeclarationStatement(param.ParameterDisplayType, param.ParamName, new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterDisplayType, new CodeVariableReferenceExpression(paramPreStr + param.ParamName)))); } else { if (param.FieldDirection == FieldDirection.Out) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.ParamName), new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType)))); } } paramComment += param.FieldDirection + "," + param.ParameterType.FullName + "|"; } paramComment = paramComment.TrimEnd('|'); methodCode.Statements.Add(tryCatchExp); foreach (var param in csParam.MethodInfo.Params) { // ref或out,需要将displayType造成的临时变量再赋给原函数参数 if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName)))); } } if (csParam.MethodInfo.ReturnType != typeof(void) && csParam.MethodInfo.ReturnType != typeof(System.Threading.Tasks.Task)) { var retVal = CodeGenerateSystem.Program.GetDefaultValueFromType(csParam.MethodInfo.ReturnType); methodCode.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(retVal))); } if (csParam.MethodInfo.IsFromMacross) { codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {csParam.MethodInfo.FuncId.ToString()} {NodeName} {paramComment}")); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998")); codeClass.Members.Add(methodCode); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998")); codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {csParam.MethodInfo.FuncId.ToString()} {NodeName}")); } else { codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {NodeName} {paramComment}")); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998")); codeClass.Members.Add(methodCode); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998")); codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {NodeName}")); } var methodContext = new CodeGenerateSystem.Base.GenerateCodeContext_Method(context, methodCode); // 收集用于调试的数据的代码 var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(tryCatchExp.TryStatements); foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var paramCtrl = paramNode as MethodInvokeParameterControl; CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetTypeString(paramCtrl.ParamPin, methodContext), methodContext); } else if (paramNode is ParamParameterControl) { throw new InvalidOperationException(); } } // 断点 var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id); // 设置数据 foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var paramCtrl = paramNode as MethodInvokeParameterControl; CodeDomNode.BreakPoint.GetSetDataValueCodeStatement(breakCondStatement.TrueStatements, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetType(paramCtrl.ParamPin, methodContext)); } else if (paramNode is ParamParameterControl) { throw new InvalidOperationException(); } } CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(tryCatchExp.TryStatements, debugCodes); if (mCtrlMethodPin_Next.HasLink) { methodContext.ReturnValueType = MethodReturnType; await mCtrlMethodPin_Next.GetLinkedObject(0, false).GCode_CodeDom_GenerateCode(codeClass, tryCatchExp.TryStatements, mCtrlMethodPin_Next.GetLinkedPinControl(0, false), methodContext); } } }