public static CodeStatementCollection BuildDetectChangedMembers(TableViewTableTypeBase table) { CodeStatementCollection ValidationSetStatement = new CodeStatementCollection(); String PocoTypeName = "this"; ValidationSetStatement.Add(new CodeSnippetExpression("Boolean bResult = new Boolean()")); ValidationSetStatement.Add(new CodeSnippetExpression("bResult = false")); foreach (Column c in table.Columns) { MemberGraph mGraph = new MemberGraph(c); CodeConditionStatement csTest1 = new CodeConditionStatement(); if (mGraph.IsNullable) { csTest1.Condition = new CodeSnippetExpression(PocoTypeName + "." + mGraph.PropertyName() + ".HasValue == true"); csTest1.TrueStatements.Add(new CodeSnippetExpression("bResult = true")); } else { csTest1.Condition = new CodeSnippetExpression(PocoTypeName + "." + mGraph.PropertyName() + " == null"); csTest1.TrueStatements.Add(new CodeSnippetExpression("")); csTest1.FalseStatements.Add(new CodeSnippetExpression("bResult = true")); } } return ValidationSetStatement; }
protected CodeStatementCollection GenerateSetMappedPropertyCode(CodeExpression targetObj, CodeExpression value) { CodeStatementCollection statements = new CodeStatementCollection(); CodePropertyReferenceExpression property = new CodePropertyReferenceExpression(targetObj, MappedProperty.Name); if (_mappedProperty.PropertyType.IsArray) { statements.Add(new CodeAssignStatement( new CodeIndexerExpression(property, new CodePrimitiveExpression(_index)), value)); return statements; } if (IsCollection(_mappedProperty.PropertyType)) { CodeBinaryOperatorExpression isNull = new CodeBinaryOperatorExpression(property, CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("null")); CodeAssignStatement create = new CodeAssignStatement(property, new CodeObjectCreateExpression(_mappedProperty.PropertyType)); statements.Add(new CodeConditionStatement(isNull, create)); statements.Add(new CodeMethodInvokeExpression(property, "Add", value)); return statements; } statements.Add(new CodeAssignStatement(property, value)); return statements; }
internal static void BuildExpressionSetup(ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isTwoWayBound, bool designerMode) { // {{controlType}} target; CodeVariableDeclarationStatement targetDecl = new CodeVariableDeclarationStatement(controlBuilder.ControlType, "dataBindingExpressionBuilderTarget"); methodStatements.Add(targetDecl); CodeVariableReferenceExpression targetExp = new CodeVariableReferenceExpression(targetDecl.Name); // target = ({{controlType}}) sender; CodeAssignStatement setTarget = new CodeAssignStatement(targetExp, new CodeCastExpression(controlBuilder.ControlType, new CodeArgumentReferenceExpression("sender"))); setTarget.LinePragma = linePragma; statements.Add(setTarget); Type bindingContainerType = controlBuilder.BindingContainerType; CodeVariableDeclarationStatement containerDecl = new CodeVariableDeclarationStatement(bindingContainerType, "Container"); methodStatements.Add(containerDecl); // {{containerType}} Container = ({{containerType}}) target.BindingContainer; CodeAssignStatement setContainer = new CodeAssignStatement(new CodeVariableReferenceExpression(containerDecl.Name), new CodeCastExpression(bindingContainerType, new CodePropertyReferenceExpression(targetExp, "BindingContainer"))); setContainer.LinePragma = linePragma; statements.Add(setContainer); string variableName = isTwoWayBound ? "BindItem" : "Item"; GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, variableName); //Generate code for other variable as well at design time in addition to runtime variable for intellisense to work. if (designerMode) { GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, isTwoWayBound ? "Item" : "BindItem"); } }
public override CodeStatementCollection BuildOperation(CodeGenerationContext ctx, ICodeGeneratorNode element, CodeVariableReferenceExpression value) { CodeStatementCollection statemets = new CodeStatementCollection(); statemets.Add(new CodeSnippetExpression( string.Format("{0} = ({2})((int){0} >> {1})", value.VariableName, Value, GetValueType(element.MappedProperty).FullName))); return statemets; }
private CodeStatementCollection GenerateCoreGroupMethod(GroupActivity groupActivity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(this.coreProcessBuilder.GenerateStartCodeStatement(groupActivity.Transitions, "start", null, this.activityNameToServiceNameDictionnary)); return invocationCodeCollection; }
public virtual object Serialize (IDesignerSerializationManager manager, object value) { if (value == null) throw new ArgumentNullException ("value"); if (manager == null) throw new ArgumentNullException ("manager"); object serialized = null; bool isComplete = false; CodeExpression createExpr = base.SerializeCreationExpression (manager, value, out isComplete); if (isComplete) { serialized = createExpr; base.SetExpression (manager, value, createExpr); } else { ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext; if (context != null && context.PresetValue == value) { CodeStatementCollection statements = new CodeStatementCollection (); statements.Add (new CodeAssignStatement (context.Expression, createExpr)); base.SerializeProperties (manager, statements, value, new Attribute[0]); base.SerializeEvents (manager, statements, value, new Attribute[0]); } else { CodeExpression expression = base.GetExpression (manager, value); if (expression == null) { serialized = expression = createExpr; base.SetExpression (manager, value, expression); } } } return serialized; }
public override object Serialize(IDesignerSerializationManager manager, object value) { CodeExpression expression; CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration; RootContext context = manager.Context[typeof(RootContext)] as RootContext; CodeStatementCollection statements = new CodeStatementCollection(); if ((declaration != null) && (context != null)) { CodeMemberField field = new CodeMemberField(typeof(IContainer), "components") { Attributes = MemberAttributes.Private }; declaration.Members.Add(field); expression = new CodeFieldReferenceExpression(context.Expression, "components"); } else { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(IContainer), "components"); statements.Add(statement); expression = new CodeVariableReferenceExpression("components"); } base.SetExpression(manager, value, expression); CodeObjectCreateExpression right = new CodeObjectCreateExpression(typeof(Container), new CodeExpression[0]); CodeAssignStatement statement2 = new CodeAssignStatement(expression, right); statement2.UserData["IContainer"] = "IContainer"; statements.Add(statement2); return statements; }
public CodeStatementCollection DefaultInvocationMethod(Activity activity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity)); return invocationCodeCollection; }
internal static void BuildEvalExpression(string field, string formatString, string propertyName, Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isEncoded, ref bool hasTempObject) { // Altogether, this function will create a statement that looks like this: // if (this.Page.GetDataItem() != null) { // target.{{propName}} = ({{propType}}) this.Eval(fieldName, formatString); // } // this.Eval(fieldName, formatString) CodeMethodInvokeExpression evalExpr = new CodeMethodInvokeExpression(); evalExpr.Method.TargetObject = new CodeThisReferenceExpression(); evalExpr.Method.MethodName = EvalMethodName; evalExpr.Parameters.Add(new CodePrimitiveExpression(field)); if (!String.IsNullOrEmpty(formatString)) { evalExpr.Parameters.Add(new CodePrimitiveExpression(formatString)); } CodeStatementCollection evalStatements = new CodeStatementCollection(); BuildPropertySetExpression(evalExpr, propertyName, propertyType, controlBuilder, methodStatements, evalStatements, linePragma, isEncoded, ref hasTempObject); // if (this.Page.GetDataItem() != null) CodeMethodInvokeExpression getDataItemExpr = new CodeMethodInvokeExpression(); getDataItemExpr.Method.TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Page"); getDataItemExpr.Method.MethodName = GetDataItemMethodName; CodeConditionStatement ifStmt = new CodeConditionStatement(); ifStmt.Condition = new CodeBinaryOperatorExpression(getDataItemExpr, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); ifStmt.TrueStatements.AddRange(evalStatements); statements.Add(ifStmt); }
public override void ToCodeDom(CodeStatementCollection statements) { CodeStatement init = null; CodeStatement increment = null; if (this.initStatement!=null) { CodeStatementCollection col = new CodeStatementCollection(); this.initStatement.ToCodeDom(col); init = col[0]; } if (this.incrementStatement!=null) { CodeStatementCollection col = new CodeStatementCollection(); this.incrementStatement.ToCodeDom(col); increment = col[0]; } statements.Add( new CodeIterationStatement( init, this.testExpression.ToCodeDom(), increment, this.statements.ToCodeDomArray() ) ); }
public override object Serialize (IDesignerSerializationManager manager, object value) { if (value == null) throw new ArgumentNullException ("value"); if (manager == null) throw new ArgumentNullException ("manager"); object serialized = null; string name = manager.GetName (value); ExpressionContext exprContext = manager.Context[typeof (ExpressionContext)] as ExpressionContext; if (exprContext != null && exprContext.PresetValue == value) { CodeStatementCollection statements = new CodeStatementCollection (); bool isComplete = true; statements.Add (new CodeCommentStatement (String.Empty)); statements.Add (new CodeCommentStatement (name)); statements.Add (new CodeCommentStatement (String.Empty)); statements.Add (new CodeAssignStatement (GetFieldReference (manager, name), base.SerializeCreationExpression (manager, value, out isComplete))); base.SerializeProperties (manager, statements, value, new Attribute[0]); base.SerializeEvents (manager, statements, value); serialized = statements; } else { serialized = base.Serialize (manager, value); } return serialized; }
private void BuildControlSkins(CodeStatementCollection statements) { foreach (ControlSkinBuilderEntry entry in _controlSkinBuilderEntryList) { string skinID = entry.SkinID; ControlBuilder builder = entry.Builder; statements.Add(BuildControlSkinAssignmentStatement(builder, skinID)); } }
public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { if (statements == null) throw new ArgumentNullException ("statements"); if (manager == null) throw new ArgumentNullException ("manager"); if (value == null) throw new ArgumentNullException ("value"); if (descriptor == null) throw new ArgumentNullException ("descriptor"); IEventBindingService service = manager.GetService (typeof (IEventBindingService)) as IEventBindingService; if (service != null) { // In the propertygrid the events are represented by PropertyDescriptors and the value is a string // which contains the method name to bind to. The propertydescriptors are managed and created by the // IEventBindingService // EventDescriptor ev = (EventDescriptor) descriptor; string methodName = (string) service.GetEventProperty (ev).GetValue (value); CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression (new CodeTypeReference (ev.EventType), _thisReference, methodName); CodeExpression targetObject = base.SerializeToExpression (manager, value); CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression (targetObject, ev.Name); statements.Add (new CodeAttachEventStatement (eventRef, listener)); } }
public void AddRange(CodeStatementCollection value) { foreach(CodeStatement e in value) { List.Add(e); } }
private void FillJSONArrayMembers(CodeStatementCollection statements) { if (IsComplexType()) { statements.Add( new CodeVariableDeclarationStatement(new CodeTypeReference("Org.Json.JSONObject"), "jsonObject", new CodeObjectCreateExpression("Org.Json.JSONObject"))); statements.Add( new CodeMethodInvokeExpression(null, "AddToJsonArray", new CodeVariableReferenceExpression("jsonArray"), new CodeVariableReferenceExpression("jsonObject"))); statements.Add( new CodeMethodInvokeExpression(null, methodName, new CodeVariableReferenceExpression("objs[i]"), new CodeVariableReferenceExpression("jsonObject"))); } else { if (IsEnum()) { statements.Add( new CodeMethodInvokeExpression(null, "AddToJsonArray", new CodeVariableReferenceExpression("jsonArray"), new CodeCastExpression(type.Fields[0].FieldType.FullName, new CodeVariableReferenceExpression("objs[i]")))); } else { statements.Add( new CodeMethodInvokeExpression(null, "AddToJsonArray", new CodeVariableReferenceExpression("jsonArray"), new CodeVariableReferenceExpression("objs[i]"))); } } }
public override void ToCodeDom(CodeStatementCollection statements) { if (this.expression!=null) statements.Add(new CodeExpressionStatement(this.expression.ToCodeDom())); else statements.Add(new CodeStatement()); }
public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements) { if (statements == null) throw new ArgumentNullException ("statements"); if (manager == null) throw new ArgumentNullException ("manager"); if (value == null) throw new ArgumentNullException ("value"); if (descriptor == null) throw new ArgumentNullException ("descriptor"); IEventBindingService service = manager.GetService (typeof (IEventBindingService)) as IEventBindingService; if (service != null) { EventDescriptor eventDescriptor = (EventDescriptor) descriptor; string methodName = (string) service.GetEventProperty (eventDescriptor).GetValue (value); if (methodName != null) { CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression (new CodeTypeReference (eventDescriptor.EventType), _thisReference, methodName); CodeExpression targetObject = base.SerializeToExpression (manager, value); CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression (targetObject, eventDescriptor.Name); statements.Add (new CodeAttachEventStatement (eventRef, listener)); } } }
public virtual object Serialize (IDesignerSerializationManager manager, object value) { if (value == null) throw new ArgumentNullException ("value"); if (manager == null) throw new ArgumentNullException ("manager"); bool isComplete = true; CodeStatementCollection statements = new CodeStatementCollection (); ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext; object serialized = null; if (context != null && context.PresetValue == value) { string varName = base.GetUniqueName (manager, value); CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement (value.GetType (), varName); // declare statement.InitExpression = base.SerializeCreationExpression (manager, value, out isComplete); // initialize base.SetExpression (manager, value, statement.InitExpression); statements.Add (statement); serialized = statement; } else { string name = manager.GetName (value); if (name == null) name = base.GetUniqueName (manager, value); serialized = GetFieldReference (manager, name); } base.SerializeProperties (manager, statements, value, new Attribute[0]); base.SerializeEvents (manager, statements, value, new Attribute[0]); return serialized; }
public PreshaderSrc(AsmListing listing, CodeStatementCollection statementCollection) { statements = new List<CodeStatement>(); object[] paramsArray = new object[1]; StringBuilder sb = new StringBuilder(); foreach (AsmCommand cmd in listing.Commands) { MethodInfo method; if (!methodList.TryGetValue(cmd.Target, out method)) { if (cmd.Target == "preshader") continue; throw new CompileException(string.Format("Error decoding PreShader: Unexpected command '{0}'", cmd.Target)); } string[] args = new string[cmd.OpCount]; for (int i = 0; i < cmd.OpCount; i++) { cmd.GetOp(i).ToString(sb); args[i] = sb.ToString(); sb.Length = 0; } paramsArray[0] = args; method.Invoke(this, paramsArray); } statementCollection.AddRange(this.statements.ToArray()); }
public override void ToCodeDom(CodeStatementCollection statements) { statements.Add(new CodeAssignStatement( left.ToCodeDom(), right.ToCodeDom() )); }
protected override void CreateConstructor (CodeStatementCollection localVars, CodeStatementCollection trueStmt) { if (pageParser.ClientTarget != null) { CodeExpression prop; prop = new CodePropertyReferenceExpression (thisRef, "ClientTarget"); CodeExpression ct = new CodePrimitiveExpression (pageParser.ClientTarget); if (localVars == null) localVars = new CodeStatementCollection (); localVars.Add (new CodeAssignStatement (prop, ct)); } #if NET_2_0 if (pageParser.MasterPageFile != null) { CodeExpression prop; prop = new CodePropertyReferenceExpression (thisRef, "MasterPageFile"); CodeExpression ct = new CodePrimitiveExpression (pageParser.MasterPageFile); if (localVars == null) localVars = new CodeStatementCollection (); localVars.Add (new CodeAssignStatement (prop, ct)); } #endif base.CreateConstructor (localVars, trueStmt); }
private void AddOwner(object statementOwner, CodeStatementCollection statements) { if (this._table == null) { this._table = new List<TableEntry>(); } else { for (int i = 0; i < this._table.Count; i++) { if (object.ReferenceEquals(this._table[i].Owner, statementOwner)) { if (this._table[i].Statements != null) { throw new InvalidOperationException(); } if (statements != null) { this._table[i] = new TableEntry(statementOwner, statements); } return; } } } this._table.Add(new TableEntry(statementOwner, statements)); this._version++; }
public static CodeStatementCollection Clone(this CodeStatementCollection collection) { if (collection == null) return null; CodeStatementCollection c = new CodeStatementCollection(); foreach (CodeStatement statement in collection) c.Add(statement.Clone()); return c; }
void EmitStatements(CodeStatementCollection statements) { foreach (CodeStatement statement in statements) { WriteSpace(); EmitStatement(statement); } }
public void Constructor1_NullItem () { CodeStatement[] statements = new CodeStatement[] { new CodeStatement (), null }; CodeStatementCollection coll = new CodeStatementCollection ( statements); }
public override void ToCodeDom(CodeStatementCollection statements) { statements.Add( new CodeThrowExceptionStatement( this.toThrow.ToCodeDom() ) ); }
public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses) { this.tryStatments = new CodeStatementCollection(); this.finallyStatments = new CodeStatementCollection(); this.catchClauses = new CodeCatchClauseCollection(); this.TryStatements.AddRange(tryStatements); this.CatchClauses.AddRange(catchClauses); }
public override void ToCodeDom(CodeStatementCollection statements) { statements.Add(new CodeConditionStatement( this.condition.ToCodeDom(), this.trueStatements.ToCodeDomArray(), this.falseStatements.ToCodeDomArray() )); }
public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements) { this.statements = new CodeStatementCollection(); this.InitStatement = initStatement; this.TestExpression = testExpression; this.IncrementStatement = incrementStatement; this.Statements.AddRange(statements); }
public GeneratorContext (CodeNamespace cns, string idPrefix, CodeStatementCollection statements, GenerationOptions options) { this.cns = cns; this.idPrefix = idPrefix; this.statements = statements; this.options = options; map = new WidgetMap (vars); }
/// <summary> /// Serializes a PaletteGroupView object to the code DOM. /// </summary> /// <param name="manager"></param> /// <param name="value"></param> /// <returns></returns> public override object Serialize(IDesignerSerializationManager manager, object value) { object retVal = value; CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(GroupView), typeof(CodeDomSerializer)); if (baseSerializer != null) { retVal = baseSerializer.Serialize(manager, value); if (retVal != null) { System.CodeDom.CodeStatementCollection stmts = retVal as System.CodeDom.CodeStatementCollection; if (stmts != null) { PaletteGroupView palGrpVw = value as PaletteGroupView; if (palGrpVw != null) { SymbolPalette pal = palGrpVw.Palette; if (pal != null) { // Serialize the palette into the resource file BinaryFormatter formatter = new BinaryFormatter(); System.IO.MemoryStream oStream = new System.IO.MemoryStream(); formatter.Serialize(oStream, pal); string resName = palGrpVw.Name + "." + "Palette"; this.SerializeResource(manager, resName, oStream.GetBuffer()); oStream.Close(); // Add statements to CodeDom to load the palette from // the resource file at run-time string formClassName = ""; IDesignerHost designerHost = manager.GetService(typeof(IDesignerHost)) as IDesignerHost; if (designerHost != null) { formClassName = designerHost.RootComponentClassName; CodePropertyReferenceExpression exprRefGroupView = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), palGrpVw.Name); CodeExpression[] loadPalParams = new CodeExpression[] { new CodePropertyReferenceExpression(new CodeTypeOfExpression(formClassName), "Assembly"), new CodePrimitiveExpression(formClassName), new CodePrimitiveExpression(resName) }; CodeMethodInvokeExpression stmtLoadPalette = new CodeMethodInvokeExpression(exprRefGroupView, "LoadPalette", loadPalParams); stmts.Add(stmtLoadPalette); } } } } } } return(retVal); }
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(System.CodeDom.CodeTypeDeclaration codeClass, System.CodeDom.CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context) { MethodInvokeParameterControl retCtrl = null; Dictionary <BaseNodeControl, System.CodeDom.CodeExpression> paramCodeExps = new Dictionary <BaseNodeControl, System.CodeDom.CodeExpression>(); foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var pm = paramNode as MethodInvokeParameterControl; var param = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams; if (param.ParamInfo.ParamName == "Return") { retCtrl = pm; continue; } if (pm.HasLink()) { await pm.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, pm.ParamPin, context); var exp = new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParamInfo.ParameterType, pm.GCode_CodeDom_GetValue(pm.ParamPin, context)); paramCodeExps[paramNode] = exp; codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement( new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName), exp)); } else if (mTemplateClassInstance != null) { var proInfo = mTemplateClassInstance.GetType().GetProperty(param.ParamInfo.ParamName); object proValue; if (proInfo == null) { proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType); } else { proValue = proInfo.GetValue(mTemplateClassInstance); } var valueExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue); paramCodeExps[paramNode] = valueExp; codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName), valueExp)); } } else { throw new InvalidOperationException(); } } if (retCtrl != null) { if (retCtrl.HasLink()) { await retCtrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, retCtrl.ParamPin, context); } System.CodeDom.CodeExpression retExp = null; if (retCtrl.HasLink()) { var retStatement = new System.CodeDom.CodeMethodReturnStatement(); retExp = retCtrl.GCode_CodeDom_GetValue(retCtrl.ParamPin, context); paramCodeExps[retCtrl] = retExp; } else if (mTemplateClassInstance != null) { var param = retCtrl.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams; var proInfo = mTemplateClassInstance.GetType().GetProperty("Return"); object proValue; if (proInfo == null) { proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType); } else { proValue = proInfo.GetValue(mTemplateClassInstance); } retExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue); paramCodeExps[retCtrl] = retExp; } #region Debug var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection); foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var pm = paramNode as MethodInvokeParameterControl; System.CodeDom.CodeExpression exp; if (paramCodeExps.TryGetValue(paramNode, out exp)) { CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, pm.ParamPin.GetLinkPinKeyName(), exp, pm.GCode_GetTypeString(pm.ParamPin, context), context); } } else { throw new InvalidOperationException("未实现"); } } var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id); CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes); #endregion var returnParam = CSParam as ReturnConstructParam; foreach (var param in returnParam.MethodInfo.Params) { // ref或out,需要将displayType造成的临时变量再赋给原函数参数 if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null) { codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName)))); } } if (returnParam.MethodInfo.ReturnType.BaseType == typeof(System.Threading.Tasks.Task)) { var genericType = returnParam.MethodInfo.ReturnType.GetGenericArguments()[0]; codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(genericType, retExp))); } else { codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(returnParam.MethodInfo.ReturnType, retExp))); } } else { #region Debug var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection); var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id); CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes); #endregion var returnParam = CSParam as ReturnConstructParam; foreach (var param in returnParam.MethodInfo.Params) { // ref或out,需要将displayType造成的临时变量再赋给原函数参数 if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null) { codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName)))); } } codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement()); } }
public override void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug) { IMathExpression mathExp = MathExp; if (mathExp != null) { CodeExpression ceCondition = null; if (Condition != null) { ceCondition = Condition.ExportCode(methodToCompile); if (ceCondition != null) { ceCondition = CompilerUtil.ConvertToBool(Condition.DataType, ceCondition); } } CodeExpression ce = mathExp.ReturnCodeExpression(methodToCompile); if (ce != null) { if (ceCondition == null) { statements.Add(new CodeMethodReturnStatement(ce)); } else { CodeConditionStatement cd = new CodeConditionStatement(); cd.Condition = ceCondition; cd.TrueStatements.Add(new CodeMethodReturnStatement(ce)); statements.Add(cd); } } } }
public CodeConditionStatement() { this.trueStatments = new CodeStatementCollection(); this.falseStatments = new CodeStatementCollection(); }
public CodeStatementCollection(CodeStatementCollection value) { AddRange(value); }
public override void GCode_CodeDom_GenerateCode(System.CodeDom.CodeTypeDeclaration codeClass, System.CodeDom.CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context) { var linkOI = GetLinkObjInfo(mParamsMethod); if (linkOI.HasLink) { int i = 0; for (; i < linkOI.LinkInfos.Count; i++) { var linkInfo = linkOI.LinkInfos[i]; if (linkInfo.m_linkFromObjectInfo == linkOI) { break; } } if (!linkOI.GetLinkObject(i, false).IsOnlyReturnValue) { linkOI.GetLinkObject(i, false).GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, linkOI.GetLinkElement(i, false), context); } } }
public void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, MathExp.IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug) { }