public override CodeExpression ExportCode(IMethodCompile method) //) { CodeStatementCollection supprtStatements = method.MethodCode.Statements; if (this.UseDefaultValue) { if (_default == null) { MathNode.Trace("MathNodeParameter.ExportCode: Use default case 0:null"); return(ValueTypeUtil.GetDefaultCodeByType(this.DataType.Type)); } else { MathNode.Trace("MathNodeParameter.ExportCode: Use default case 1:{0}", _default); return(ObjectCreationCodeGen.ObjectCreationCode(_default)); } } else { if (this.InPort != null && this.InPort.LinkedPortID != 0) { MathNode.Trace("MathNodeParameter.ExportCode: call linked item"); IMathExpression rootContainer = this.root.RootContainer; if (rootContainer == null) { throw new MathException(XmlSerialization.FormatString("Parameter {0} not associated with a root container", this.TraceInfo)); } MathExpItem LinkedItem = rootContainer.GetItemByID(this.InPort.LinkedPortID); if (LinkedItem == null) { throw new MathException(string.Format("Linked Port ID {0} from ({1}) does not match an item", InPort.LinkedPortID, this.TraceInfo)); } CodeExpression ce = LinkedItem.ReturnCodeExpression(method); return(RaisDataType.GetConversionCode(LinkedItem.MathExpression.DataType, ce, this.DataType, supprtStatements)); } // MathNode.Trace("MathNodeParameter.ExportCode: call MathNodeVariable.ExportCode"); return(base.ExportCode(method)); } }
public override CodeExpression ExportCode(IMethodCompile method) { MathNode.Trace("{0}.ExportCode: reference to [{1}]", this.GetType().Name, _value); return(ObjectCreationCodeGen.ObjectCreationCode(_value)); }
public static CodeExpression GetDefaultCodeByType(Type t) { if (t.Equals(typeof(void))) { return(new CodePrimitiveExpression(null)); } TypeCode tc = Type.GetTypeCode(t); switch (tc) { case TypeCode.Boolean: return(new CodePrimitiveExpression(false)); case TypeCode.Byte: return(new CodePrimitiveExpression(default(byte))); case TypeCode.Char: return(new CodePrimitiveExpression(default(char))); case TypeCode.DateTime: return(ObjectCreationCodeGen.ObjectCreationCode(default(DateTime))); case TypeCode.Decimal: return(new CodePrimitiveExpression((decimal)0)); case TypeCode.Double: return(new CodePrimitiveExpression(default(double))); case TypeCode.Int16: return(new CodePrimitiveExpression(default(Int16))); case TypeCode.Int32: if (t.IsEnum) { Array a = Enum.GetValues(t); return(new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(t), a.GetValue(0).ToString())); } return(new CodePrimitiveExpression(default(Int32))); case TypeCode.Int64: return(new CodePrimitiveExpression(default(Int64))); case TypeCode.SByte: return(new CodePrimitiveExpression(default(sbyte))); case TypeCode.Single: return(new CodePrimitiveExpression(default(Single))); case TypeCode.String: return(new CodePrimitiveExpression("")); case TypeCode.UInt16: return(new CodePrimitiveExpression(default(UInt16))); case TypeCode.UInt32: return(new CodePrimitiveExpression(default(UInt32))); case TypeCode.UInt64: return(new CodePrimitiveExpression(default(UInt64))); case TypeCode.Object: return(ObjectCreationCodeGen.ObjectCreationCode(VPLUtil.GetDefaultValue(t))); case TypeCode.DBNull: return(new CodePrimitiveExpression(null)); case TypeCode.Empty: return(new CodePrimitiveExpression(null)); default: return(new CodeDefaultValueExpression(new CodeTypeReference(t))); } }
/// <summary>Generates a property setter or event setter statement</summary> /// <param name="cx"><see cref="CodeExpression"/> for which property has to be set</param> /// <param name="objType"><see cref="Type"/> of <see cref="object"/>, <paramref name="cx"/> is /// representing</param> /// <param name="x">Property Name</param> /// <param name="y">Property Value</param> private static CodeStatement setPropEvent(CodeExpression cx, Type objType, string x, string y) { CodeStatement as1 = null; MemberTypes result = ReflectionHelper.GetMember(x, objType); if (result == MemberTypes.Property) { // A Property Encountered. CodePropertyReferenceExpression prop = new CodePropertyReferenceExpression(cx, x); Type t = ReflectionHelper.GetPropertyType(x, objType); if (t.IsPrimitive || t.Equals(typeof(System.String))) { // A Primitive or string Property is Encountered object o = ReflectionHelper.ConvertFrom(y, t); if (t.Equals(typeof(IntPtr))) { IntPtr val = (IntPtr)o; if (IntPtr.Size == 4) { as1 = new CodeAssignStatement(prop, new CodeObjectCreateExpression(typeof(IntPtr), new CodePrimitiveExpression(val.ToInt32()))); } else { as1 = new CodeAssignStatement(prop, new CodeObjectCreateExpression(typeof(IntPtr), new CodePrimitiveExpression(val.ToInt64()))); } } else if (t.Equals(typeof(UIntPtr))) { UIntPtr val = (UIntPtr)o; if (IntPtr.Size == 4) { as1 = new CodeAssignStatement(prop, new CodeObjectCreateExpression(typeof(UIntPtr), new CodePrimitiveExpression(val.ToUInt32()))); } else { as1 = new CodeAssignStatement(prop, new CodeObjectCreateExpression(typeof(UIntPtr), new CodePrimitiveExpression(val.ToUInt64()))); } } else { as1 = new CodeAssignStatement(prop, new CodePrimitiveExpression(o)); } } else if (t.IsEnum) { // An Enum Property Encountered CodeTypeReferenceExpression xpType = new CodeTypeReferenceExpression(t); CodeFieldReferenceExpression xpField = new CodeFieldReferenceExpression(xpType, y); as1 = new CodeAssignStatement(prop, xpField); } else { InstanceDescriptor idc = ReflectionHelper.GetInstance(y, t); CodeExpression xpRite = null; if (idc.Arguments == null || idc.Arguments.Count <= 0) { xpRite = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(t), idc.MemberInfo.Name); } else { CodeExpression[] cpargs = new CodeExpression[idc.Arguments.Count]; int i = 0; foreach (object o in idc.Arguments) { cpargs[i++] = ObjectCreationCodeGen.ObjectCreationCode(o); } xpRite = new CodeObjectCreateExpression(t, cpargs); } as1 = new CodeAssignStatement(prop, xpRite); } } else if (result == MemberTypes.Event) { Type typeEvent = ReflectionHelper.GetEventType(x, objType); CodeDelegateCreateExpression xpDele = new CodeDelegateCreateExpression( new CodeTypeReference(typeEvent), new CodeThisReferenceExpression(), y); as1 = new CodeAttachEventStatement(cx, x, xpDele); } return(as1); }
/// <summary> /// multi-thread support: /// /// thread_{branch id}(object data) /// { /// object[] ps = (object[])data; /// type1 var1 = ps[0]; /// type2 var2 = ps[1]; /// ... /// {branch code} /// } /// </summary> /// <param name="compiler"></param> /// <param name="method"></param> /// <returns>true:all barnches of the main thread have method return or goto; false: at least one branch of the main thread does not have method return or goto</returns> public bool ExportCode(ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements) { bool bRet = false; MathNode.Trace("BranchList.ExportCode. Method {0}, action blocks {1}================", method.Name, this.Count); //create code threads List <ActionBranch> independentThreads; if (_independentThreads == null) { independentThreads = FindoutActionThreads(true); } else { independentThreads = _independentThreads; } IsMultiThreads = (independentThreads.Count > 1); //the case of Count == 0 (empty method) is handled by MethodClass.ExportCode if (independentThreads.Count > 0) { int k0 = 0; // main thread index this.ActionThreads.Clear(); foreach (ActionBranch a in independentThreads) { _threads.Add(a.BranchId, a); } for (int k = 0; k < independentThreads.Count; k++) { if (independentThreads[k].IsMainThread) { k0 = k; break; } } if (k0 == 0) { independentThreads[0].IsMainThread = true; } this.MainThreadId = independentThreads[k0].BranchId; List <UInt32> usedBranches = new List <uint>(); for (int k = 0; k < independentThreads.Count; k++) { independentThreads[k].IsMainThread = (k == k0); independentThreads[k].SetIsMainThreadForSubBranches(usedBranches); } //generate additional threads CodeExpression[] obs = null; CodeExpression[] ps = null; for (int k = 0; k < independentThreads.Count; k++) { if (k != k0) { ActionBranch ab = independentThreads[k]; ab.IsMainThread = false; //method for this additional thread CodeMemberMethod mt = new CodeMemberMethod(); mt.Name = "thread_" + ab.BranchId.ToString("x"); compiler.TypeDeclaration.Members.Add(mt); mt.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data")); //use an object[] to hold the method parameters which is passed to the thread method via the data parameter string pas = "******" + Guid.NewGuid().GetHashCode().ToString("x"); mt.Statements.Add(new CodeVariableDeclarationStatement(typeof(object[]), pas, new CodeCastExpression(typeof(object[]), new CodeArgumentReferenceExpression("data")))); //create variables named after the method parameters and assign values to them //so that the actions within the method can use them as if they are method parameters. for (int i = 0; i < _method.ParameterCount; i++) { mt.Statements.Add(new CodeVariableDeclarationStatement(_method.Parameters[i].TypeString, _method.Parameters[i].Name, new CodeCastExpression(_method.Parameters[i].TypeString, new CodeArrayIndexerExpression(new CodeVariableReferenceExpression(pas), new CodePrimitiveExpression(i))))); } //method contents: a single thread ab.ExportThreadCode(compiler, mt, mt.Statements); // if (compiler.Debug) { mt.Statements.Add(new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), LimnorDebugger.Debugger), "ThreadFinished" //,new CodePrimitiveExpression(ab.BranchId) ) ) ); } //code to launch this thread if (obs == null) { //create an object[] to hold all method parameters to be passed into the thread method obs = new CodeExpression[_method.ParameterCount]; for (int i = 0; i < _method.ParameterCount; i++) { obs[i] = new CodeArgumentReferenceExpression(_method.Parameters[i].Name); } } //parameters for launch the thread ps = new CodeExpression[2]; pas = "******" + Guid.NewGuid().GetHashCode().ToString("x"); statements.Add( new CodeVariableDeclarationStatement(typeof(object[]), pas, new CodeArrayCreateExpression(typeof(object), obs))); //delegate to the thread method ps[0] = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(System.Threading.WaitCallback)), new CodeThisReferenceExpression(), mt.Name); //parameter to the thread method ps[1] = new CodeVariableReferenceExpression(pas); //queue the thread statements.Add(new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(System.Threading.ThreadPool)), "QueueUserWorkItem", ps)); } } //main thread code bRet = independentThreads[k0].ExportThreadCode(compiler, method, statements); // if (_method == null) { MathNode.LogError("method is null"); } else // { if (_method.ReturnValue != null) { if (!typeof(void).Equals(_method.ReturnValue.ObjectType)) { //check whether all branches ends with a method return statement if (!independentThreads[k0].AllBranchesEndWithMethodReturnStatement()) { CodeExpression pe; if (_method.ReturnValue.ObjectType.IsArray) { pe = new CodePrimitiveExpression(null); } else { pe = ObjectCreationCodeGen.ObjectCreationCode(VPLUtil.GetDefaultValue(_method.ReturnValue.ObjectType)); } statements.Add(new CodeMethodReturnStatement(pe)); } } } } } MathNode.Trace("End of BranchList.ExportCode. Method {0}================", method.Name); return(bRet); }
/// <summary> /// generate reference code /// </summary> /// <param name="methodOwnerXPath"></param> /// <returns></returns> public CodeExpression ExportCode(string methodOwnerXPath) { MathNode.Trace("ObjectRef.ExportCode for {0}", this); switch (Type) { case ObjectRefType.Argv: case ObjectRefType.EventSender: return(new CodeArgumentReferenceExpression(_name)); case ObjectRefType.This: return(new CodeThisReferenceExpression()); case ObjectRefType.Type: return(new CodeTypeReferenceExpression(DataType)); case ObjectRefType.Field: case ObjectRefType.Property: if (Owner == null) { throw new MathException("property reference does not have an owner"); } return(new CodePropertyReferenceExpression(Owner.ExportCode(methodOwnerXPath), _name)); case ObjectRefType.Const: if (_value == null) { return(new CodePrimitiveExpression(null)); } else { return(ObjectCreationCodeGen.ObjectCreationCode(_value.DataValue)); } case ObjectRefType.XPath: if (_xpathNode == null) { throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath Node"); } if (string.IsNullOrEmpty(_name)) { throw new MathException("ObjectRef.ExportCode is called for XPath with null xpath value"); } CodeExpression codeExp = new CodeThisReferenceExpression(); if (methodOwnerXPath != _name) { //object for the reference //_name is the xpath XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name); if (thisNode == null) { throw new MathException(XmlSerialization.FormatString("ObjectRef.ExportCode is called for XPath with invalid xpath value: {0}", _name)); } // if (thisNode.Name == XmlSerialization.RAIS_R) { if (XmlSerialization.IsStaticComponent(thisNode)) { codeExp = new CodeTypeReferenceExpression(TypeString); } else { //find all names for each part R|A[@ID='?']R|A[@ID='?']... string xpath0 = _name; string name = XmlSerialization.GetName(thisNode); while (xpath0.Length > 0 && xpath0 != methodOwnerXPath) { int pos = xpath0.LastIndexOf('/'); if (pos > 0) { xpath0 = xpath0.Substring(0, pos); if (xpath0 != methodOwnerXPath) { XmlNode n0 = XmlSerialization.GetXmlNodeByPath(thisNode.OwnerDocument, xpath0); if (n0 == null) { throw new MathException(XmlSerialization.FormatString("Invalid path {0}", xpath0)); } name = XmlSerialization.GetName(n0) + "." + name; } } else { break; } } codeExp = new CodeFieldReferenceExpression(codeExp, name); } } } else { XmlNode thisNode = _xpathNode.OwnerDocument.DocumentElement.SelectSingleNode(_name); if (thisNode == null) { throw new MathException(XmlSerialization.FormatString("ObjectRef.ExportCode is called for XPath with invalid xpath value: {0}", _name)); } //use the parent node to generate code if (thisNode.Name == XmlSerialization.RAIS_R) { if (XmlSerialization.IsStaticComponent(thisNode)) { codeExp = new CodeTypeReferenceExpression(TypeString); } } } return(codeExp); } return(new CodeThisReferenceExpression()); }