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);
}
}
}
}
}
}
