public virtual void WriteCallUnOp(CallUnOp s, ExpressionUsage u)
{
Begin(u.IsObject());
Write(s.Operator.Symbol);
WriteExpression(s.Operand, ExpressionUsage.Object);
End(u.IsObject());
}
public void WriteCastOp(CastOp s, ExpressionUsage u)
{
switch (s.CastType)
{
default:
WriteCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Up:
WriteUpCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Down:
WriteDownCast(s.Source, s.ReturnType, s.Operand, u);
break;
case CastType.Box:
WriteBox(s.Source, s.ReturnType, s.Operand, false, u);
break;
case CastType.Unbox:
WriteUnbox(s.Source, s.ReturnType, s.Operand, u);
break;
}
}
public virtual void WriteStoreLocal(StoreLocal s, ExpressionUsage u)
{
Begin(u);
Write(s.Variable.Name + Assign);
WriteExpression(s.Value);
End(u);
}
public virtual void WriteStoreArgument(StoreArgument s, ExpressionUsage u)
{
Begin(u);
Write(s.Parameter.Name + Assign);
WriteExpression(s.Value);
End(u);
}
void WriteSequenceOp(SequenceOp s, ExpressionUsage u, bool parentIsSequenceOp)
{
Begin(!parentIsSequenceOp);
if (s.Left is SequenceOp)
{
WriteSequenceOp(s.Left as SequenceOp, ExpressionUsage.Statement, true);
}
else
{
WriteExpression(s.Left, ExpressionUsage.Statement);
}
Write(Comma);
if (s.Right is SequenceOp)
{
WriteSequenceOp(s.Right as SequenceOp, u, true);
}
else
{
WriteExpression(s.Right, u);
}
End(!parentIsSequenceOp);
}
public void EndWhen(bool cond, ExpressionUsage u)
{
if (cond && u >= ExpressionUsage.Operand)
{
Write(")");
}
}
public void End(ExpressionUsage u)
{
if (u >= ExpressionUsage.Operand)
{
Write(")");
}
}
public static bool Run(Pass parent, string operatorName, Expression e, ExpressionUsage u)
{
var p = new NoLocalAccessOrLValueValidator(parent, operatorName);
p.VisitNullable(ref e, u);
return(!p.HasError);
}
public override void WriteConstant(Constant c, ExpressionUsage u)
{
if (c.ReturnType is EnumType)
{
foreach (var v in (c.ReturnType as EnumType).Literals)
{
if (v.Value.Equals(c.Value))
{
WriteType(c.Source, c.ReturnType);
Write("." + v.UnoName);
return;
}
}
if (c.Value.Equals(0))
{
Write("0");
return;
}
Write("(");
WriteType(c.Source, c.ReturnType);
Write(")");
}
base.WriteConstant(c, u);
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
if (Object != null)
{
Object.Disassemble(sb, ExpressionUsage.Object);
}
else
{
sb.Append(Property.DeclaringType);
}
if (Property.Parameters.Length == 0)
{
sb.Append("." + Property.Name);
}
else
{
sb.Append("[");
for (int i = 0; i < Arguments.Length; i++)
{
sb.CommaWhen(i > 0);
Arguments[i].Disassemble(sb);
}
sb.Append("]");
}
sb.AppendWhen(Storage != null, "~" + Storage);
}
public void Begin(ExpressionUsage u)
{
if (u >= ExpressionUsage.Operand)
{
Write("(");
}
}
public override void End(ref Expression e, ExpressionUsage u)
{
switch (e.ExpressionType)
{
case ExpressionType.SequenceOp:
{
var s = e as SequenceOp;
// This fixes bug https://github.com/Outracks/Uno/issues/219
if (s.Right is Constant && s.Right.ConstantValue == null)
{
s.Right = new CastOp(s.Right.Source, s.Right.ReturnType, s.Right);
}
break;
}
case ExpressionType.ConditionalOp:
{
var s = e as ConditionalOp;
// This fixes bug https://github.com/Outracks/Uno/issues/219
if (s.True is Constant && s.True.ConstantValue == null)
{
s.True = new CastOp(s.True.Source, s.True.ReturnType, s.True);
}
break;
}
}
}
public override void WriteCallCast(CallCast s, ExpressionUsage u)
{
WriteStaticType(s.Source, s.ReturnType);
Write("(");
WriteExpression(s.Operand);
Write(")");
}
public override void WriteDownCast(Source src, DataType dt, Expression s, ExpressionUsage u)
{
WriteType(src, dt);
Write("(");
WriteExpression(s);
Write(")");
}
public override void WriteLoadField(Source src, Field field, Expression obj, ExpressionUsage u)
{
switch (field.DeclaringType.BuiltinType)
{
case BuiltinType.Float4x4:
{
WriteExpression(obj, ExpressionUsage.Object);
int fid = field.Index;
Write("[" + (fid / 4) + "]." + VectorFields[fid % 4]);
return;
}
case BuiltinType.Float3x3:
{
WriteExpression(obj, ExpressionUsage.Object);
int fid = field.Index;
Write("[" + (fid / 3) + "]." + VectorFields[fid % 3]);
return;
}
case BuiltinType.Float2x2:
{
WriteExpression(obj, ExpressionUsage.Object);
int fid = field.Index;
Write("[" + (fid / 2) + "]." + VectorFields[fid % 2]);
return;
}
}
base.WriteLoadField(src, field, obj, u);
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
switch (e.ExpressionType)
{
case ExpressionType.LoadElement:
case ExpressionType.StoreElement:
case ExpressionType.CallDelegate:
case ExpressionType.LoadPtr:
Function.Stats |= EntityStats.ThrowsException;
break;
case ExpressionType.CallMethod:
{
var s = (CallMethod)e;
if (s.Function.IsVirtual && !(s.Object is Base))
{
Function.Stats |= EntityStats.ThrowsException;
}
break;
}
case ExpressionType.CastOp:
{
var s = (CastOp)e;
switch (s.CastType)
{
case CastType.Down:
case CastType.Unbox:
Function.Stats |= EntityStats.ThrowsException;
break;
}
break;
}
}
}
public override void WriteDefault(Source src, DataType dt, ExpressionUsage u = ExpressionUsage.Argument)
{
string defVal = Environment.GetString(dt, "DefaultValue");
if (defVal != null)
{
Write(defVal);
}
else
{
switch (dt.TypeType)
{
case TypeType.Enum:
Write("0");
break;
case TypeType.Struct:
WriteNewObject(src, dt, u);
break;
default:
Write("null");
break;
}
}
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
if (e is AddressOf && e.ReturnType is FixedArrayType)
{
e = e.ActualValue;
}
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
Array.Disassemble(sb, ExpressionUsage.Object);
sb.Append("[");
Index.Disassemble(sb);
sb.Append("]");
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
sb.AppendWhen(u.IsObject(), "(");
sb.Append("(" + TargetType + ")");
Operand.Disassemble(sb, ExpressionUsage.Operand);
sb.AppendWhen(u.IsObject(), ")");
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
if (e is This)
{
e = _replace;
}
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
sb.AppendWhen(u >= ExpressionUsage.Operand, "(");
sb.Append("this = ");
Value.Disassemble(sb);
sb.AppendWhen(u >= ExpressionUsage.Operand, ")");
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
sb.AppendWhen(u.IsObject(), "(");
sb.Append(Operator.Symbol);
Operand.Disassemble(sb, ExpressionUsage.Operand);
sb.AppendWhen(u.IsObject(), ")");
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
switch (e.ExpressionType)
{
case ExpressionType.Lambda:
{
if (_lambda != null)
{
break;
}
_lambda = (Lambda)e;
var closureType = _closureStack.Peek().Type;
_lambdaMethod = new Method(
e.Source,
_closureStack.Peek().Type,
"Lambda method",
Modifiers.Public | Modifiers.Generated,
closureType.GetUniqueIdentifier("generated_lambda"),
_lambda.DelegateType.ReturnType,
_lambda.Parameters,
_lambda.Body as Scope ?? new Scope(_lambda.Source, _lambda.Body));
closureType.Methods.Add(_lambdaMethod);
break;
}
}
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
sb.Append("vertex_attrib<" + ReturnType + ">(");
VertexAttributeType.Disassemble(sb);
sb.Append(", ");
VertexBuffer.Disassemble(sb);
sb.Append(", ");
VertexBufferStride.Disassemble(sb);
sb.Append(", ");
VertexBufferOffset.Disassemble(sb);
if (OptionalIndexType != null)
{
sb.Append(", ");
OptionalIndexType.Disassemble(sb);
}
if (OptionalIndexBuffer != null)
{
sb.Append(", ");
OptionalIndexBuffer.Disassemble(sb);
}
sb.Append(")");
}
public override void Visit(Pass p, ExpressionUsage u)
{
for (var var = Variable; var != null; var = var.Next)
{
p.VisitNullable(ref var.OptionalValue);
}
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
if (e is GetMetaObject)
{
e = _obj;
}
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
switch (e.ExpressionType)
{
case ExpressionType.Base:
case ExpressionType.This:
case ExpressionType.GetMetaObject:
case ExpressionType.GetMetaProperty:
case ExpressionType.CapturedArgument:
case ExpressionType.CapturedLocal:
{
var s = Generator.ProcessValue(e);
if (Expressions.IsVariableOrGlobal(s.Value))
{
e = s.Value;
SetMinStage(e.Source, s.MinStage);
SetMaxStage(e.Source, s.MaxStage);
}
else
{
e = AddArgument(e.Source, s);
}
}
break;
case ExpressionType.NewVertexAttrib:
case ExpressionType.NewPixelSampler:
{
if (!NoLocalAccessOrLValueValidator.Run(this, e.ExpressionType == ExpressionType.NewVertexAttrib ? "vertex_attrib" : "pixel_sampler", e, u))
{
e = Expression.Invalid;
break;
}
var s = Generator.ProcessValue(e);
SetMinStage(e.Source, s.MinStage);
SetMaxStage(e.Source, s.MaxStage);
e = s.Value;
}
break;
case ExpressionType.Swizzle:
OnObject(ref e, ref (e as Swizzle).Object);
break;
case ExpressionType.LoadField:
OnObject(ref e, ref (e as LoadField).Object);
break;
case ExpressionType.GetProperty:
OnObject(ref e, ref (e as GetProperty).Object);
break;
case ExpressionType.CallMethod:
OnObject(ref e, ref (e as CallMethod).Object);
break;
}
}
public override void Disassemble(StringBuilder sb, ExpressionUsage u)
{
sb.AppendWhen(u >= ExpressionUsage.Operand, "(");
Left.Disassemble(sb, ExpressionUsage.Operand);
sb.Append(EqualityType == EqualityType.Equal ? " == " : " != ");
Right.Disassemble(sb, ExpressionUsage.Operand);
sb.AppendWhen(u >= ExpressionUsage.Operand, ")");
}
public override void Begin(ref Expression e, ExpressionUsage u)
{
if (e is CallMethod)
{
var methodExpr = (CallMethod)e;
OnTwinMethod(ref methodExpr.Method);
}
}
