public override CodeExpression ExportCode(IMethodCompile method) { if (_methodRef.MethodOwner == null) { throw new Exception("methodOwner is not assigned to MethodNode."); } MathNode.Trace("{0}:ExportCode for {1}", this.GetType().Name, this.TraceInfo); if (_methodRef.Parameters != null) { int n = ChildNodeCount; if (_methodRef.ParameterCount != n) { throw new MathException("method parameters are not initialized for {0}.", this.GetType().Name); } MathNode.Trace("{0} parameter(s)", n); MathNode.IndentIncrement(); parameterCode = new CodeExpression[n]; for (int i = 0; i < n; i++) { MathNode.Trace("parameter {0}: {1}", i, this[i].TraceInfo); CodeExpression ce = this[i].ExportCode(method); if (!_methodRef.Parameters[i].DataType.IsSameType(this[i].DataType)) { ce = RaisDataType.GetConversionCode(this[i].DataType, ce, _methodRef.Parameters[i].DataType, method.MethodCode.Statements); } parameterCode[i] = ce; if (_methodRef.Parameters[i].Direction != FieldDirection.In) { parameterCode[i] = new CodeDirectionExpression(_methodRef.Parameters[i].Direction, parameterCode[i]); } } MathNode.IndentDecrement(); } else { parameterCode = new CodeExpression[] { }; } if (_methodRef.MethodOwner.Type == ObjectRefType.Type) //a static function { MathNode.Trace("Invoke static function {0}.{1}", _methodRef.MethodOwner.Value.LibType, _methodRef.MethodName); CodeMethodInvokeExpression e = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(_methodRef.MethodOwner.Value.LibType), _methodRef.MethodName, parameterCode); return(e); } else { if (_methodRef.MethodName == XmlSerialization.CONSTRUCTOR_METHOD) { MathNode.Trace("Invoke constructor for {0}", _methodRef.MethodOwner.TypeString); CodeObjectCreateExpression oc = new CodeObjectCreateExpression(_methodRef.MethodOwner.TypeString, parameterCode); return(oc); } MathNode.Trace("Invoke member function {0} from {1}", FunctionName, _methodRef.MethodOwner.Name); if (TargetObject == null) { if (_methodRef.IsStatic) { TargetObject = new CodeTypeReferenceExpression(_methodRef.MethodOwner.TypeString); } else { TargetObject = this.MethodOwner.ExportCode(_methodRef.MethodOwner.XPath); } } // CodeMethodInvokeExpression e = new CodeMethodInvokeExpression( TargetObject, _methodRef.MethodName, parameterCode); return(e); } }
public bool LoadData(ITestData test) { try { _testData = (TestData)test; //provide drawing attributes for parameters mroot = new MathNodeRoot(); if (_testData.Parameters.Count > 2) { mroot.ChildNodeCount = _testData.Parameters.Count; } parameters.Properties.Clear(); for (int i = 0; i < _testData.Parameters.Count; i++) { mroot[i] = (MathNode)_testData.Parameters[i].CloneExp(mroot); parameters.Properties.Add(new PropertySpec(_testData.Parameters[i].VariableName + ":" + _testData.Parameters[i].CodeVariableName, _testData.Parameters[i].VariableType.Type)); } foreach (IPropertyPointer pp in _testData.Pointers) { parameters.Properties.Add(new PropertySpec(pp.ToString() + ":" + pp.CodeName, pp.ObjectType)); //.PointerDataType)); } // CodeGeneratorOptions o = new CodeGeneratorOptions(); o.BlankLinesBetweenMembers = false; o.BracingStyle = "C"; o.ElseOnClosing = false; o.IndentString = " "; // CSharpCodeProvider cs = new CSharpCodeProvider(); StringWriter sw; sw = new StringWriter(); cs.GenerateCodeFromCompileUnit(_testData.CU, sw, o); // string sCode = sw.ToString(); sw.Close(); // int pos = sCode.IndexOf("a tool."); if (pos > 0) { sCode = sCode.Substring(0, pos) + "Limnor Visual Object Builder." + sCode.Substring(pos + 7); } // textBox1.Text = sCode; // CompilerParameters cp = new CompilerParameters(); foreach (AssemblyRef ar in _testData.Assemblies) { MathNode.AddImportLocation(ar.Location); } foreach (string s in MathNode.ImportLocations) { cp.ReferencedAssemblies.Add(s); } cp.GenerateExecutable = false; CompilerResults crs = cs.CompileAssemblyFromDom(cp, new CodeCompileUnit[] { _testData.CU }); if (crs.Errors.HasErrors) { MathNode.Trace("Error compiling."); MathNode.IndentIncrement(); FormCompilerError dlg = new FormCompilerError(); for (int i = 0; i < crs.Errors.Count; i++) { MathNode.Trace(crs.Errors[i].ToString()); dlg.AddItem(crs.Errors[i]); } MathNode.IndentDecrement(); dlg.TopLevel = false; dlg.Parent = this; dlg.Show(); dlg.TopMost = true; dlg.BringToFront(); } else { Type[] types = crs.CompiledAssembly.GetExportedTypes(); if (types != null) { for (int i = 0; i < types.Length; i++) { if (types[i].Name == _testData.ClassName) { _mi = types[i].GetMethod(_testData.MethodName); if (_mi != null) { break; } } } } } textBox2.Text = MathNode.GetLogContents(); return(true); } catch (Exception err) { MathNode.Log(this, err); textBox2.Text = MathNode.GetLogContents(); } return(false); }
public override string CreatePhpScript(StringCollection method) { if (_methodRef.MethodOwner == null) { throw new Exception("methodOwner is not assigned to MethodNode."); } MathNode.Trace("{0}:CreatePhpScript for {1}", this.GetType().Name, this.TraceInfo); if (_methodRef.Parameters != null) { int n = ChildNodeCount; if (_methodRef.ParameterCount != n) { throw new MathException("method parameters are not initialized for {0}.", this.GetType().Name); } MathNode.Trace("{0} parameter(s)", n); MathNode.IndentIncrement(); parameterCodePhp = new string[n]; for (int i = 0; i < n; i++) { MathNode.Trace("parameter {0}: {1}", i, this[i].TraceInfo); string ce = this[i].CreatePhpScript(method); parameterCodePhp[i] = ce; } MathNode.IndentDecrement(); } else { parameterCodePhp = new string[] { }; } if (_methodRef.MethodOwner.Type == ObjectRefType.Type) //a static function { MathNode.Trace("Invoke static function {0}.{1}", _methodRef.MethodOwner.Value.LibType, _methodRef.MethodName); StringBuilder mCode = new StringBuilder(); mCode.Append(_methodRef.MethodOwner.Value.LibType.FullName); mCode.Append("->"); mCode.Append(_methodRef.MethodName); mCode.Append("("); if (parameterCodePhp.Length > 0) { mCode.Append(parameterCodePhp[0]); for (int i = 1; i < parameterCodePhp.Length; i++) { mCode.Append(","); mCode.Append(parameterCodePhp[i]); } } mCode.Append(")"); return(mCode.ToString()); } else { if (_methodRef.MethodName == XmlSerialization.CONSTRUCTOR_METHOD) { MathNode.Trace("Invoke constructor for {0}", _methodRef.MethodOwner.TypeString); if (parameterCodePhp.Length == 0) { return(MathNode.FormString("new _methodRef.MethodOwner.TypeString()")); } else { string cn = MathNode.FormString("_const{0}", _methodRef.MethodOwner.TypeString.Replace(".", "_")); StringBuilder constructor = new StringBuilder("function "); constructor.Append(cn); constructor.Append("("); constructor.Append(_methodRef.Parameters[0].Name); for (int i = 1; i < _methodRef.Parameters.Length; i++) { constructor.Append(","); constructor.Append(_methodRef.Parameters[i].Name); } constructor.Append(")"); string cst = constructor.ToString(); string scode = method.ToString(); bool bExist = (scode.IndexOf(cst) >= 0); if (!bExist) { method.Add(cst); method.Add("\r\n{\r\n"); method.Add("$this->"); method.Add(_methodRef.Parameters[0].Name); method.Add(";\r\n"); for (int i = 1; i < _methodRef.Parameters.Length; i++) { constructor.Append("this->"); constructor.Append(_methodRef.Parameters[i].Name); method.Add(";\r\n"); } method.Add("\r\n}\r\n"); } StringBuilder callC = new StringBuilder("new "); callC.Append(cn); callC.Append("("); callC.Append(parameterCodePhp[0]); for (int i = 1; i < parameterCodePhp.Length; i++) { callC.Append(","); callC.Append(parameterCodePhp[i]); } callC.Append(")"); return(callC.ToString()); } } MathNode.Trace("Invoke member function {0} from {1}", FunctionName, _methodRef.MethodOwner.Name); if (string.IsNullOrEmpty(TargetObjectPhp)) { if (_methodRef.IsStatic) { TargetObjectPhp = _methodRef.MethodOwner.TypeString; } else { TargetObjectPhp = this.MethodOwner.CreatePhpScript(method, _methodRef.MethodOwner.XPath); } } // StringBuilder e = new StringBuilder(TargetObjectPhp); if (!string.IsNullOrEmpty(TargetObjectPhp)) { e.Append("->"); } e.Append(_methodRef.MethodName); e.Append("("); if (parameterCodePhp.Length > 0) { e.Append(parameterCodePhp[0]); for (int i = 1; i < parameterCodePhp.Length; i++) { e.Append(","); e.Append(parameterCodePhp[i]); } } e.Append(")"); return(e.ToString()); } }
public static void CreateTestMethod(IMathExpression result, CodeTypeDeclaration t, CodeNamespace ns, CodeMemberMethod m, AssemblyRefList imports, VariableList parameters, List <IPropertyPointer> pointerList) { result.GetAllImports(imports); // m.ReturnType = new CodeTypeReference(result.DataType.Type); // m.Comments.Add(new CodeCommentStatement("Variable mapping:")); m.Comments.Add(new CodeCommentStatement("In formula: method parameter")); // MethodType mt = new MethodType(); mt.MethodCode = m; result.GenerateInputVariables(); VariableList variables = result.InputVariables; Dictionary <string, IPropertyPointer> pointers = new Dictionary <string, IPropertyPointer>(); result.GetPointers(pointers); int n = variables.Count; MathNode.Trace("Generate arguments from {0} input variables", n); MathNode.IndentIncrement(); for (int k = 0; k < n; k++) { IVariable var = variables[k]; MathNode.Trace(k, var); if (!(var is MathNodeVariableDummy) && !var.IsParam && !var.IsConst) { string paramName = ""; parameters.Add(var); paramName = var.CodeVariableName; CodeParameterDeclarationExpression p = new CodeParameterDeclarationExpression(new CodeTypeReference(var.VariableType.Type), paramName); m.Parameters.Add(p); //add comment string sub = var.SubscriptName; if (string.IsNullOrEmpty(sub)) { sub = " "; } m.Comments.Add(new CodeCommentStatement(string.Format("{0}{1}:\t {2}", var.VariableName, sub, var.CodeVariableName))); MathNode.IndentIncrement(); MathNode.Trace("Argument {0} {1} for {2}, {3}", var.VariableType.Type, paramName, var.TraceInfo, var.GetType()); MathNode.IndentDecrement(); // result.AssignCodeExp(new CodeArgumentReferenceExpression(paramName), var.CodeVariableName); } } MathNode.Trace("Generate arguments from {0} pointers", pointers.Count); foreach (KeyValuePair <string, IPropertyPointer> kv in pointers) { string paramName = ""; pointerList.Add(kv.Value); paramName = kv.Value.CodeName; CodeParameterDeclarationExpression p = new CodeParameterDeclarationExpression(new CodeTypeReference(kv.Value.ObjectType), paramName); m.Parameters.Add(p); //add comment m.Comments.Add(new CodeCommentStatement(string.Format("{0}:\t {1}", kv.Value.ToString(), paramName))); MathNode.IndentIncrement(); MathNode.Trace("Argument {0} {1} for {2}", kv.Value.ObjectType, paramName, kv.Value.ToString()); MathNode.IndentDecrement(); } MathNode.IndentDecrement(); //do the compiling CodeExpression ce = result.ReturnCodeExpression(mt); // MathNode.Trace("Test method returns {0}, compiled type: {1}", result.DataType.Type, result.ActualCompileDataType.Type); if (result.ActualCompileDataType.Type.Equals(result.DataType.Type)) { CodeMethodReturnStatement mr = new CodeMethodReturnStatement(ce); m.Statements.Add(mr); } else { if (result.ActualCompileDataType.IsVoid) { m.Statements.Add(new CodeExpressionStatement(ce)); CodeMethodReturnStatement mr = new CodeMethodReturnStatement(ValueTypeUtil.GetDefaultValueByType(result.DataType.Type)); m.Statements.Add(mr); } else { if (result.DataType.IsVoid) { m.Statements.Add(new CodeExpressionStatement(ce)); } else { if (result.DataType.Type.Equals(typeof(string))) { CodeMethodReturnStatement mr = new CodeMethodReturnStatement(new CodeMethodInvokeExpression(ce, "ToString", new CodeExpression[] { })); m.Statements.Add(mr); } else { CodeExpression mie = RaisDataType.GetConversionCode(result.ActualCompileDataType, ce, result.DataType, m.Statements); if (mie != null) { CodeMethodReturnStatement mr = new CodeMethodReturnStatement(mie); m.Statements.Add(mr); } } } } } }