/// <summary>
/// create conversion code
/// </summary>
/// <param name="sourceType"></param>
/// <param name="sourceCode"></param>
/// <param name="targetType"></param>
/// <returns>conversion code converting sourceCode to the targetType</returns>
public static CodeExpression GetConversionCode(RaisDataType sourceType, CodeExpression sourceCode, RaisDataType targetType, CodeStatementCollection supprtStatements)
{
CodeExpression codeRet;
if (sourceType.IsSameType(targetType))
{
return(sourceCode);
}
if (targetType.IsLibType || sourceType.IsLibType)
{
if (MathNode.GetTypeConversion != null)
{
return(MathNode.GetTypeConversion(targetType.Type, sourceCode, sourceType.Type, supprtStatements));
}
return(CastOrConvert(sourceCode, sourceType.Type, targetType.Type, supprtStatements));
}
string srcType = sourceType.DevType.TypeString;
string tgtType = targetType.DevType.TypeString;
if (srcType.StartsWith(tgtType))
{
return(sourceCode);
}
if (tgtType.StartsWith(srcType))
{
return(new CodeCastExpression(tgtType, VPLUtil.GetCoreExpressionFromCast(sourceCode)));
}
TypeConverter converter = TypeDescriptor.GetConverter(targetType.Type);
if (converter.CanConvertFrom(sourceType.Type))
{
MathNode.AddImportLocation(typeof(TypeConverter).Assembly.Location);
string converterName = "conv" + targetType.Type.Name;
if (!MathNodeVariable.VariableDeclared(supprtStatements, converterName))
{
CodeVariableDeclarationStatement cs1 = new CodeVariableDeclarationStatement(
typeof(TypeConverter), converterName,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter",
new CodeExpression[] { new CodeSnippetExpression("typeof(" + tgtType + ")") }));
supprtStatements.Add(cs1);
}
//=================================================
//
codeRet = new CodeCastExpression(tgtType,
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(converterName), "ConvertFrom",
new CodeExpression[] { sourceCode }));
MathNode.Trace("\tcode 102: source type:{0}, target type:{1} result=converter.ConvertFrom(code);", sourceType, targetType);
}
else
{
codeRet = CastOrConvert(sourceCode, sourceType.Type, targetType.Type, supprtStatements);
}
return(codeRet);
}
public override System.CodeDom.CodeExpression ExportCode(IMethodCompile method)
{
MathNode.Trace("{0}.ExportCode: [{1}]", this.GetType().Name, this[0].TraceInfo);
CodeMethodReferenceExpression mr = new CodeMethodReferenceExpression();
mr.MethodName = "Sqrt";
mr.TargetObject = new CodeTypeReferenceExpression(typeof(Math));
CodeExpression[] ps = new CodeExpression[1];
ps[0] = this[0].ExportCode(method);
if (!this[0].DataType.Type.Equals(typeof(double)))
{
ps[0] = new CodeCastExpression(typeof(double), VPLUtil.GetCoreExpressionFromCast(ps[0]));
}
return(new CodeMethodInvokeExpression(
mr,
ps));
}
/// <summary>
/// implement IProgramEntity.ReturnCodeExpression
/// if _castTo is null then this function returns the same as IMathExpression.ReturnCodeExpression
/// </summary>
/// <param name="portSelection"></param>
/// <param name="method"></param>
/// <returns></returns>
public CodeExpression ReturnCodeExpression(object portSelection, IMethodCompile method)
{
CodeExpression ce = ReturnCodeExpression(method);
if (_castTo != null)
{
IProgramPort p = portSelection as IProgramPort;
if (p != null)
{
ObjectRef prop = p.PortProperty;
if (prop != null)
{
StringCollection props = new StringCollection();
ce = new CodeCastExpression(_castTo.EntityType.TypeString, VPLUtil.GetCoreExpressionFromCast(ce));
while (true)
{
props.Add(prop.localName);
prop = prop.Owner;
if (prop == null)
{
break;
}
if (prop.IsSameType(_castTo.EntityType))
{
break;
}
}
for (int i = props.Count - 1; i >= 0; i--)
{
ce = new CodePropertyReferenceExpression(ce, props[i]);
}
}
}
}
return(ce);
}
static CodeExpression CastOrConvert(CodeExpression code, Type sourceType, Type targetType, CodeStatementCollection csc)
{
if (sourceType.Equals(targetType))
{
MathNode.Trace("CastOrConvert 1: same type: {0}", targetType);
return(code);
}
if (targetType.IsByRef)
{
MathNode.Trace("CastOrConvert 2: by ref type: {0}", targetType);
return(code);
}
if (targetType.Equals(typeof(string)))
{
MathNode.Trace("CastOrConvert 3: to string from: {0}", sourceType);
return(new CodeMethodInvokeExpression(code, "ToString", new CodeExpression[] { }));
}
TypeCode tcTarget = Type.GetTypeCode(targetType);
TypeCode tcSource = Type.GetTypeCode(sourceType);
if (IsNumeric(tcTarget))
{
if (IsNumeric(tcSource))
{
return(new CodeCastExpression(targetType, VPLUtil.GetCoreExpressionFromCast(code)));
}
else
{
if (tcSource == TypeCode.String)
{
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), GetConverToName(tcTarget), code));
}
}
}
switch (tcTarget)
{
case TypeCode.Boolean:
if (IsNumeric(tcSource) || tcSource == TypeCode.Char)
{
return(new CodeBinaryOperatorExpression(code, CodeBinaryOperatorType.IdentityInequality, new CodeCastExpression(sourceType, new CodePrimitiveExpression(0))));
}
switch (tcSource)
{
case TypeCode.Boolean:
return(code);
case TypeCode.DateTime:
return(new CodeBinaryOperatorExpression(code, CodeBinaryOperatorType.GreaterThan, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(DateTime)), "MinValue")));
case TypeCode.Object:
return(new CodeBinaryOperatorExpression(code, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)));
}
break;
case TypeCode.String:
return(new CodeMethodInvokeExpression(code, "ToString"));
case TypeCode.Char:
if (code is CodePrimitiveExpression)
{
CodePrimitiveExpression cp = (CodePrimitiveExpression)code;
if (cp.Value == null)
{
return(new CodePrimitiveExpression('\0'));
}
if (ValueTypeUtil.IsNumber(cp.Value.GetType()))
{
short v = Convert.ToInt16(cp.Value);
return(new CodePrimitiveExpression((char)v));
}
string s = cp.Value.ToString();
if (string.IsNullOrEmpty(s))
{
return(new CodePrimitiveExpression('\0'));
}
else
{
return(new CodePrimitiveExpression(s[0]));
}
}
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToChar", code));
case TypeCode.DateTime:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToDateTime", code));
}
if (sourceType.IsSubclassOf(targetType))
{
return(code);
}
if (targetType.IsSubclassOf(sourceType))
{
return(new CodeCastExpression(targetType, code));
}
return(CodeExpConvertTo(code, sourceType, targetType, csc));
}
public static void CreateAssignment(CodeExpression left, Type leftType, CodeExpression right, Type rightType, CodeStatementCollection statements, bool bThreadSafe)
{
if (leftType.IsAssignableFrom(rightType))
{
CodeAssignStatement cas = new CodeAssignStatement(left, right);
if (!bThreadSafe)
{
statements.Add(new CodeSnippetStatement(CompilerUtil.InvokeStart));
}
statements.Add(cas);
if (!bThreadSafe)
{
statements.Add(new CodeSnippetStatement(CompilerUtil.InvokeEnd));
}
}
else
{
if (typeof(string).Equals(leftType) || typeof(PhpString).Equals(leftType))
{
if (rightType.IsValueType)
{
CodeAssignStatement cas = new CodeAssignStatement(left,
new CodeMethodInvokeExpression(right, "ToString"));
statements.Add(cas);
}
else
{
//if it is null then return null else return var.ToString()
string vn = "l" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(rightType, vn, right);
statements.Add(vds);
CodeConditionStatement ccs = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(vn), CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeAssignStatement(left, new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(vn), "ToString")) },
new CodeStatement[] { new CodeAssignStatement(left, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty")) });
statements.Add(ccs);
}
}
else if (typeof(bool).Equals(leftType))
{
CodeAssignStatement cas = new CodeAssignStatement(left,
ConvertToBool(rightType, right));
statements.Add(cas);
}
else
{
bool converted = false;
if ((leftType.IsPrimitive || leftType.GetInterface("IConvertible") != null) &&
(rightType.IsPrimitive || rightType.GetInterface("IConvertible") != null))
{
CodeExpression ex = VPLUtil.ConvertByType(leftType, right);
if (ex != null)
{
CodeAssignStatement cas = new CodeAssignStatement(left, ex);
statements.Add(cas);
converted = true;
}
}
if (!converted)
{
TypeConverter converter = TypeDescriptor.GetConverter(leftType);
if (converter != null)
{
if (converter.CanConvertFrom(rightType))
{
string vn = "c" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(TypeConverter), vn,
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeTypeOfExpression(leftType)));
statements.Add(vds);
CodeAssignStatement cas = new CodeAssignStatement(left,
new CodeCastExpression(leftType,
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(vn), "ConvertFrom", right)));
statements.Add(cas);
converted = true;
}
}
}
if (!converted)
{
TypeConverter converter = TypeDescriptor.GetConverter(rightType);
if (converter != null)
{
if (converter.CanConvertTo(leftType))
{
string vn = "c" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(TypeConverter), vn,
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeTypeOfExpression(rightType)));
statements.Add(vds);
CodeAssignStatement cas = new CodeAssignStatement(left,
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(vn), "CanConvertTo", right, new CodeTypeOfExpression(leftType)));
statements.Add(cas);
converted = true;
}
}
}
if (!converted)
{
CodeAssignStatement cas = new CodeAssignStatement(left,
new CodeCastExpression(leftType, VPLUtil.GetCoreExpressionFromCast(right)));
statements.Add(cas);
}
}
}
}
public static CodeCastExpression GetTypeConversion(string targetType, CodeExpression data)
{
return(new CodeCastExpression(targetType, VPLUtil.GetCoreExpressionFromCast(data)));
}
public static CodeExpression GetTypeConversion(DataTypePointer targetType, CodeExpression data, DataTypePointer dataType, CodeStatementCollection statements)
{
if (targetType.IsLibType && typeof(Type).Equals(targetType.BaseClassType))
{
if (data is CodeTypeOfExpression)
{
return(data);
}
}
if (targetType.IsAssignableFrom(dataType))
{
return(data);
}
if (typeof(string).Equals(targetType.BaseClassType))
{
if (typeof(JsString).Equals(dataType.BaseClassType))
{
return(data);
}
if (typeof(PhpString).Equals(dataType.BaseClassType))
{
return(data);
}
if (dataType.IsValueType)
{
return(new CodeMethodInvokeExpression(data, "ToString"));
}
else
{
string vn = "l" + Guid.NewGuid().GetHashCode().ToString("x");
string vs = "l" + Guid.NewGuid().GetHashCode().ToString("x");
CodeExpression val;
if (data is CodePropertyReferenceExpression || data is CodeFieldReferenceExpression || data is CodeVariableReferenceExpression)
{
val = data;
}
else
{
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(dataType.GetCodeTypeReference(), vn, data);
statements.Add(vds);
val = new CodeVariableReferenceExpression(vn);
}
CodeVariableDeclarationStatement vds2 = new CodeVariableDeclarationStatement(typeof(string), vs);
statements.Add(vds2);
CodeVariableReferenceExpression re = new CodeVariableReferenceExpression(vs);
CodeConditionStatement ccs = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
val, CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeAssignStatement(re, new CodeMethodInvokeExpression(val, "ToString")) },
new CodeStatement[] { new CodeAssignStatement(re, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty")) });
statements.Add(ccs);
return(re);
}
}
if (typeof(bool).Equals(targetType.BaseClassType))
{
return(ConvertToBool(dataType.BaseClassType, data));
}
if ((targetType.BaseClassType.IsPrimitive || targetType.BaseClassType.GetInterface("IConvertible") != null) &&
(dataType.BaseClassType.IsPrimitive || dataType.BaseClassType.GetInterface("IConvertible") != null))
{
CodeExpression ex = VPLUtil.ConvertByType(targetType.BaseClassType, data);
if (ex != null)
{
return(ex);
}
}
if (targetType.BaseClassType.IsArray)
{
if (!dataType.BaseClassType.IsArray && !typeof(Array).Equals(dataType.BaseClassType))
{
Type elementType;
if (targetType.BaseClassType.HasElementType)
{
elementType = targetType.BaseClassType.GetElementType();
}
else
{
elementType = typeof(object);
}
CodeArrayCreateExpression ae = new CodeArrayCreateExpression(elementType, new CodeExpression[] { GetTypeConversion(new DataTypePointer(elementType), data, dataType, statements) });
return(ae);
}
}
TypeConverter converter = TypeDescriptor.GetConverter(targetType);
if (converter != null)
{
if (converter.CanConvertFrom(dataType.BaseClassType))
{
string vn = "c" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(TypeConverter), vn,
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeTypeOfExpression(targetType.GetCodeTypeReference())));
statements.Add(vds);
string vn2 = "c" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds2 = new CodeVariableDeclarationStatement(typeof(TypeConverterNullable), vn2,
new CodeObjectCreateExpression(typeof(TypeConverterNullable), new CodeVariableReferenceExpression(vn)));
statements.Add(vds2);
return(new CodeCastExpression(targetType.GetCodeTypeReference(),
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(vn2), "ConvertFrom", data)));
}
}
converter = TypeDescriptor.GetConverter(dataType);
if (converter != null)
{
if (converter.CanConvertTo(targetType.BaseClassType))
{
string vn = "c" + Guid.NewGuid().GetHashCode().ToString("x");
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement(typeof(TypeConverter), vn,
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeTypeOfExpression(dataType.GetCodeTypeReference())));
statements.Add(vds);
return(new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(vn), "CanConvertTo", data, new CodeTypeOfExpression(targetType.GetCodeTypeReference())));
}
}
TypeCode tc = Type.GetTypeCode(targetType.BaseClassType);
switch (tc)
{
case TypeCode.Boolean:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToBoolean", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Byte:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToByte", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Char:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToChar", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.DateTime:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToDateTime", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Decimal:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToDecimal", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Double:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToDouble", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Int16:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToInt16", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Int32:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToInt32", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Int64:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToInt64", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.SByte:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToSByte", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.Single:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToSingle", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.String:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToString", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.UInt16:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToUInt16", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.UInt32:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToUInt32", VPLUtil.GetCoreExpressionFromCast(data)));
case TypeCode.UInt64:
return(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Convert)), "ToUInt64", VPLUtil.GetCoreExpressionFromCast(data)));
}
ConstructorInfo cif = targetType.BaseClassType.GetConstructor(new Type[] { dataType.BaseClassType });
if (cif != null)
{
return(new CodeObjectCreateExpression(targetType.BaseClassType, data));
}
return(new CodeCastExpression(targetType.GetCodeTypeReference(), VPLUtil.GetCoreExpressionFromCast(data)));
}