public CodeExpression GetReferenceCode(object method, CodeStatementCollection statements, string propertyName, CodeExpression target, bool forValue)
{
if (_ps != null)
{
return(_ps.GetReferenceCode(method, statements, propertyName, target, forValue));
}
if (_pp != null)
{
for (int i = 0; i < _pp.Length; i++)
{
if (string.Compare(_pp[i].Name, propertyName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (forValue)
{
return(VPLUtil.ConvertByType(EPField.ToSystemType(_pp[i].Type), new CodePropertyReferenceExpression(new CodeArrayIndexerExpression(target, new CodePrimitiveExpression(propertyName)), "Value")));
}
else
{
return(new CodePropertyReferenceExpression(new CodeArrayIndexerExpression(target, new CodePrimitiveExpression(propertyName)), "Value"));
}
}
}
}
return(target);
}
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 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)));
}
private CodeExpression convert(CodeExpression e)
{
return(VPLUtil.ConvertByType(this.DataType.Type, e));
}
