private void RunTest(Expression e, DataType dt)
{
var eq = new EquivalenceClassBuilder(factory, store);
e.Accept(eq);
e.Accept(exa);
exd.MeetDataType(e, dt);
e.Accept(exd, e.TypeVariable);
var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name);
Verify(outputFileName);
}
private void RunTest(Expression e)
{
var globals = new Identifier("globals", PrimitiveType.Pointer32, RegisterStorage.None);
store.EnsureExpressionTypeVariable(factory, globals, "globals_t");
var eq = new EquivalenceClassBuilder(factory, store);
e.Accept(eq);
e.Accept(exa);
var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name);
Verify(outputFileName);
}
public Instruction MakeAssignment(Expression dst, Expression src)
{
var tvDst = dst.TypeVariable;
var tvSrc = src.TypeVariable;
src = src.Accept(this);
DataType dtSrc = DataTypeOf(src);
dst = dst.Accept(this);
DataType dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs<UnionType>();
UnionType uSrc = dtSrc.ResolveAs<UnionType>();
if (uDst != null)
{
var ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex();
}
else if (uSrc != null)
{
var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
src = ceb.BuildComplex();
}
else
throw new NotImplementedException(string.Format("{0} [{1}] = {2} [{3}] (in assignment {4} = {5}) not supported.", tvDst, dtDst, tvSrc, dtSrc, dst, src));
}
Identifier idDst = dst as Identifier;
if (idDst != null)
return new Assignment(idDst, src);
else
return new Store(dst, src);
}
public void Collect(Expression tvBasePointer, int basePointerSize, Expression eField, Expression effectiveAddress)
{
this.basePointer = tvBasePointer;
this.basePointerSize = basePointerSize;
this.eField = eField;
effectiveAddress.Accept(this);
}
public void CollectArray(Expression tvBasePointer, Expression tvField, Expression arrayBase, int elementSize, int length)
{
this.basePointer = tvBasePointer;
this.eField = tvField;
bool c = arrayContext;
arrayContext = true;
arrayElementSize = elementSize;
arrayLength = length;
arrayBase.Accept(this);
arrayContext = c;
}
public string StringifyExpression(Expression expression)
{
if (expression == null)
{
// I don't think I need this anymore - if there's no expression don't print anything.
// A touch of reflection so I can print out what methods are causing exceptions.
//var thisMethod = MethodBase.GetCurrentMethod();
//Console.Error.WriteLine($"{thisMethod.DeclaringType.FullName}.{thisMethod.Name} :: {nameof(expression)} is null");
//Console.Error.WriteLine();
}
return(expression?.Accept(this) ?? null);
}
private Expression MakeIntegerResult(Expression ex)
{
var arg = ex.Accept(this);
if (arg.ResultType.CILType.Equals(typeof(int)))
{
return arg;
}
else
{
var iarg = IntrinsicFunctions.Cast(ex, arg.ResultType.CILType, typeof(int));
return iarg;
}
}
private Expression MakeIntegerResult(Expression ex)
{
var arg = ex.Accept(this);
if (arg.ResultType.CILType.Equals(typeof(int)))
{
return(arg);
}
else
{
var iarg = IntrinsicFunctions.Cast(ex, arg.ResultType.CILType, typeof(int));
return(iarg);
}
}
public void DtbSegmentedDirectAddress()
{
ProcedureBuilder m = new ProcedureBuilder();
var arch = new Reko.Arch.X86.X86ArchitectureReal("x86-real-16");
var program = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(null, arch)
};
store.EnsureExpressionTypeVariable(factory, program.Globals);
Identifier ds = m.Local16("ds");
Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Word16(0x0200));
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(coll);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedDirectAddress.txt");
}
public override void Pop(Expression expression)
{
expression.Accept(this);
switch (expression.Type().simpleName())
{
case "long":
case "double":
_methodVisitor.visitInsn(POP2);
break;
default:
_methodVisitor.visitInsn(POP);
break;
}
}
protected override void InstrospectiveFieldAssignation(Expression node, string memberName, Object obj)
{
InheritedAttributes ia = (InheritedAttributes)obj;
SetMemberCallSite callSite = GetCallSiteContainer(ia.CurrentMethod).AddSetMemberCallSite(memberName);
string id = GetAuxFielVar() + memberName;
this.codeGenerator.WriteAuxiliarLocalVariable(this.indent, id, "object");
this.codeGenerator.stloc(this.indent, id);
this.codeGenerator.pop(this.indent);
this.codeGenerator.WriteLine(indent, "ldsfld class " + callSite.CallSiteType + " class " + callSite.FullName);
this.codeGenerator.WriteLine(indent, "ldfld !0 class " + callSite.CallSiteType + "::Target");
this.codeGenerator.WriteLine(indent, "ldsfld class " + callSite.CallSiteType + " class " + callSite.FullName);
node.Accept(this, obj);
this.codeGenerator.ldloc(this.indent, id);
this.codeGenerator.WriteLine(indent, "callvirt instance void class " + callSite.CallSiteSubType + "::Invoke(!0, !1, !2)");
}
public static NQExpression FromMethodDefinition(MethodDefinition method)
{
ValidatePredicateMethodDefinition(method);
Expression expression = GetQueryExpression(method);
if (null == expression)
{
UnsupportedPredicate("No expression found.");
}
Visitor visitor = new Visitor(method, new AssemblyResolver(_assemblyCachingStrategy));
expression.Accept(visitor);
return(visitor.Expression);
}
private void CompareIntOrReferenceType(Expression lhs, Expression rhs, int opcode)
{
lhs.Accept(this);
rhs.Accept(this);
Label l0 = new Label();
_methodVisitor.visitJumpInsn(opcode, l0);
_methodVisitor.visitInsn(ICONST_1);
Label l1 = new Label();
_methodVisitor.visitJumpInsn(GOTO, l1);
_methodVisitor.visitLabel(l0);
_methodVisitor.visitInsn(ICONST_0);
_methodVisitor.visitLabel(l1);
}
public DataType VisitMemoryAccessCommon(Expression access, Expression ea)
{
var dtEa = ea.Accept(this);
var ptEa = dtEa as Pointer;
DataType dt;
if (ptEa != null)
{
dt = ptEa.Pointee;
}
else
{
dt = access.DataType;
}
return(RecordDataType(dt, access));
}
public static Expression Rewrite(Expression expression)
{
if (expression == null)
{
return(null);
}
expression = expression.Accept(new Visitor(), null);
if (expression is PropertyExpression propertyExpression)
{
// A single property expression left?
// Convert that one into a relational expression.
expression = new RelationalExpression(propertyExpression, new ConstantExpression(true), RelationalOperator.EqualTo);
}
return(expression);
}
private Instruction MakeAssignment(Expression dst, Expression src)
{
src = src.Accept(this);
var tvDst = dst.TypeVariable;
dst = dst.Accept(this);
var dtSrc = DataTypeOf(src);
var dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs <UnionType>();
UnionType uSrc = dtSrc.ResolveAs <UnionType>();
if (uDst != null)
{
// ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
tvDst.DataType = dtDst;
tvDst.OriginalDataType = dtSrc;
dst.TypeVariable = tvDst;
var ceb = new ComplexExpressionBuilder(dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex(false);
}
else if (uSrc != null)
{
//throw new NotImplementedException();
//var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
//src = ceb.BuildComplex(false);
src = new Cast(dtDst, src);
}
else
{
Debug.Print("{2} [{0}] = {3} [{1}] not supported.", dtDst, dtSrc, dst, src);
src = new Cast(dtDst, src);
}
}
var idDst = dst as Identifier;
if (idDst != null)
{
return(new Assignment(idDst, src));
}
else
{
return(new Store(dst, src));
}
}
public static Answer FromExpression(Expression expr)
{
return(expr.Accept(new Expression.Visitor <Answer>()
{
fVisitApplication = (fname, args) => {
if (fname == nameof(Yes) && args.Length == 0)
{
return new Yes();
}
if (fname == nameof(No) && args.Length == 0)
{
return new No();
}
throw new ArgumentOutOfRangeException();
}
}));
}
private void CompareLongOrFloatType(Expression lhs, Expression rhs, int opcode, int compare)
{
lhs.Accept(this);
rhs.Accept(this);
_methodVisitor.visitInsn(opcode);
Label l0 = new Label();
_methodVisitor.visitJumpInsn(compare, l0);
_methodVisitor.visitInsn(ICONST_1);
Label l1 = new Label();
_methodVisitor.visitJumpInsn(GOTO, l1);
_methodVisitor.visitLabel(l0);
_methodVisitor.visitInsn(ICONST_0);
_methodVisitor.visitLabel(l1);
}
public override void Field(FieldReference field, Expression value)
{
string modifiers = Modifier.ToString(field.Modifiers());
Append(" ").Append(modifiers);
if (modifiers.Length > 0)
{
Append(" ");
}
Append(field.Type().fullName()).Append(' ').Append(field.Name());
if (value != null)
{
Append(" = ");
value.Accept(new MethodSourceWriter(_target, this));
}
Append(";\n");
}
public override void Box(Expression expression)
{
expression.Accept(this);
if (expression.Type().Primitive)
{
switch (expression.Type().name())
{
case "byte":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false);
break;
case "short":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false);
break;
case "int":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
break;
case "long":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false);
break;
case "char":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false);
break;
case "boolean":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
break;
case "float":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false);
break;
case "double":
_methodVisitor.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false);
break;
default:
//do nothing, expression is already boxed
break;
}
}
}
/// <summary>
/// Start the analysis with the expression in the indirect jump.
/// Detect any live expressions, and place them in the `Live`
/// collection.
/// </summary>
/// <param name="indirectJump"></param>
/// <returns></returns>
public bool Start(Expression indirectJump)
{
var sr = indirectJump.Accept(this, BackwardSlicerContext.Jump(RangeOf(indirectJump)));
if (JumpTableFormat == null)
{
JumpTableFormat = indirectJump;
}
this.Live = sr.LiveExprs;
if (!sr.LiveExprs.Keys.OfType <Identifier>().Any())
{
// Couldn't find any indirect registers, so there is no work to do.
DebugEx.Warn(BackwardSlicer.trace, "Bwslc: No indirect registers?");
return(false);
}
DebugEx.Verbose(BackwardSlicer.trace, " live: {0}", DumpLive(this.Live));
return(true);
}
/// <summary>
/// Start the analysis with the expression in the indirect jump.
/// Detect any live expressions, and place them in the `Live`
/// collection.
/// </summary>
/// <param name="indirectJump"></param>
/// <returns></returns>
public bool Start(Expression indirectJump)
{
var sr = indirectJump.Accept(this, BackwardSlicerContext.Jump(RangeOf(indirectJump)));
if (JumpTableFormat == null)
{
JumpTableFormat = indirectJump;
}
this.Live = sr.LiveExprs;
if (sr.LiveExprs.Count == 0)
{
// Couldn't find any indirect registers, so there is no work to do.
DebugEx.PrintIf(BackwardSlicer.trace.TraceWarning, " No indirect registers?");
return(false);
}
DebugEx.PrintIf(BackwardSlicer.trace.TraceVerbose, " live: {0}", DumpLive(this.Live));
return(true);
}
public override void AcceptChildren(WSqlFragmentVisitor visitor)
{
if (Expression != null)
{
Expression.Accept(visitor);
}
if (Subquery != null)
{
Subquery.Accept(visitor);
}
if (Values != null)
{
var index = 0;
for (var count = Values.Count; index < count; ++index)
{
Values[index].Accept(visitor);
}
}
base.AcceptChildren(visitor);
}
public override void Invoke(Expression target, MethodReference method, Expression[] arguments)
{
target.Accept(this);
foreach (Expression argument in arguments)
{
argument.Accept(this);
}
if (Modifier.isInterface(method.Owner().modifiers()))
{
_methodVisitor.visitMethodInsn(INVOKEINTERFACE, byteCodeName(method.Owner()), method.Name(), desc(method), true);
}
else if (method.Constructor)
{
_methodVisitor.visitMethodInsn(INVOKESPECIAL, byteCodeName(method.Owner()), method.Name(), desc(method), false);
}
else
{
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, byteCodeName(method.Owner()), method.Name(), desc(method), false);
}
}
public override void Done()
{
if (_staticFields.Count > 0)
{
MethodVisitor methodVisitor = _classVisitor.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
ByteCodeExpressionVisitor expressionVisitor = new ByteCodeExpressionVisitor(methodVisitor);
methodVisitor.visitCode();
foreach (KeyValuePair <FieldReference, Expression> entry in _staticFields.SetOfKeyValuePairs())
{
FieldReference field = entry.Key;
Expression value = entry.Value;
value.Accept(expressionVisitor);
methodVisitor.visitFieldInsn(PUTSTATIC, byteCodeName(field.Owner()), field.Name(), typeName(field.Type()));
}
methodVisitor.visitInsn(RETURN);
methodVisitor.visitMaxs(0, 0);
methodVisitor.visitEnd();
}
_classVisitor.visitEnd();
}
public Instruction MakeAssignment(Expression dst, Expression src)
{
var tvDst = dst.TypeVariable;
var tvSrc = src.TypeVariable;
src = src.Accept(this);
DataType dtSrc = DataTypeOf(src);
dst = dst.Accept(this);
DataType dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs <UnionType>();
UnionType uSrc = dtSrc.ResolveAs <UnionType>();
if (uDst != null)
{
var ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex();
}
else if (uSrc != null)
{
var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
src = ceb.BuildComplex();
}
else
{
throw new NotImplementedException(string.Format("{0} [{1}] = {2} [{3}] (in assignment {4} = {5}) not supported.", tvDst, dtDst, tvSrc, dtSrc, dst, src));
}
}
Identifier idDst = dst as Identifier;
if (idDst != null)
{
return(new Assignment(idDst, src));
}
else
{
return(new Store(dst, src));
}
}
private void WriteSwitchStatement(Block node, BinaryExpression conditionVarInitialization, CastExpression castFromConditionToCases)
{
_writer.Write("switch (");
Expression conditionExpression = conditionVarInitialization.Right;
if (castFromConditionToCases != null)
{
_writer.Write("(");
castFromConditionToCases.Type.Accept(_us2CsVisitor);
_writer.Write(") ");
}
conditionExpression.Accept(_us2CsVisitor);
_writer.WriteLine(")");
_writer.WriteLine("{");
var nonConstExpressionCaseEntries = new List <IfStatement>();
using (new BlockIdentation(_writer))
{
var cases = node.Statements.OfType <IfStatement>().Where(stmt => IsCaseEntry(stmt, conditionVarInitialization.Left));
foreach (var caseStatement in cases)
{
var equalityCheck = caseStatement.Condition as BinaryExpression;
if (equalityCheck == null)
{
// Log: Expecting binary expression in "case", found: actual
continue;
}
if (!WriteSwitchCase(equalityCheck, caseStatement.TrueBlock))
{
nonConstExpressionCaseEntries.Add(caseStatement);
}
}
WriteDefaultCase(node, nonConstExpressionCaseEntries, conditionVarInitialization);
}
_writer.WriteLine("}");
}
public override void Unbox(Expression expression)
{
expression.Accept(this);
switch (expression.Type().fullName())
{
case "java.lang.Byte":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
break;
case "java.lang.Short":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false);
break;
case "java.lang.Integer":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false);
break;
case "java.lang.Long":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
break;
case "java.lang.Character":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false);
break;
case "java.lang.Boolean":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
break;
case "java.lang.Float":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false);
break;
case "java.lang.Double":
_methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false);
break;
default:
throw new System.InvalidOperationException("Cannot unbox " + expression.Type().fullName());
}
}
public override void OnMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.Target.Entity == null || (node.Target.Entity.EntityType != EntityType.Method && node.Target.Entity.EntityType != EntityType.Constructor))
{
return;
}
for (int i = 0; i < node.Arguments.Count; i++)
{
_currentArgument = node.Arguments[i];
if (_currentArgument.ExpressionType.ElementType != TypeSystemServices.TypeType)
{
continue;
}
_currentArgument.Accept(this);
}
_currentArgument = null;
base.OnMethodInvocationExpression(node);
}
protected bool VisitCondition(Expression node)
{
var condition = node.Accept(this);
if (condition is Boolean)
{
return((Boolean)condition);
}
if (condition is bool)
{
return((bool)condition);
}
if (condition is null)
{
return(false);
}
IConvertible c = condition as IConvertible;
// null mean other type
return(c == null || (c.GetTypeCode() != TypeCode.Boolean) || c.ToBoolean(null));
}
public static Question FromExpression(Expression expr)
{
return(expr.Accept(new Expression.Visitor <Question>()
{
fVisitApplication = (fname, args) => {
if (fname == nameof(Even) && args.Length == 1)
{
return new Even(Object.FromExpression(args[0]));
}
if (fname == nameof(Odd) && args.Length == 1)
{
return new Odd(Object.FromExpression(args[0]));
}
if (fname == nameof(Prime) && args.Length == 1)
{
return new Prime(Object.FromExpression(args[0]));
}
throw new ArgumentOutOfRangeException();
}
}));
}
private static string GenerateSqlStatement(EntityConfiguration configuration, Expression expression)
{
// Generate SQL for the query.
var statement = new List <string>
{
"SELECT",
$"{configuration.TableName}.*",
"FROM",
configuration.TableName
};
// Got an expression?
if (expression != null)
{
statement.Add("WHERE");
var visitor = new QueryTranslatorVisitor();
statement.Add(expression.Accept(visitor, configuration));
}
return(string.Join(" ", statement));
}
public List <ConstantData> BuildGraph()
{
// First build the constants dependency graph.
foreach (ConstantData constant in constants.Values)
{
// Store the current constant.
currentConstant = constant;
// Visit the initializer expression.
Expression init = constant.GetInitializer();
init.Accept(this);
}
// Now, perform topological sort.
List <ConstantData> sorted = new List <ConstantData> ();
foreach (ConstantData constant in constants.Values)
{
TopoVisit(constant, sorted);
}
return(sorted);
}
public override object Accept(StructuralVisitor visitor)
{
var ret = visitor.Visit(this);
if (visitor.AutoVisit)
{
if (visitor.Skip)
{
visitor.Skip = false;
return(ret);
}
if (visitor.Continue && left != null)
{
left.Accept(visitor);
}
if (visitor.Continue && right != null)
{
right.Accept(visitor);
}
}
return(ret);
}
public override void Assign(LocalVariable variable, Expression value)
{
value.Accept(_expressionVisitor);
if (variable.Type().Primitive)
{
switch (variable.Type().name())
{
case "int":
case "byte":
case "short":
case "char":
case "boolean":
_methodVisitor.visitVarInsn(ISTORE, variable.Index());
break;
case "long":
_methodVisitor.visitVarInsn(LSTORE, variable.Index());
break;
case "float":
_methodVisitor.visitVarInsn(FSTORE, variable.Index());
break;
case "double":
_methodVisitor.visitVarInsn(DSTORE, variable.Index());
break;
default:
_methodVisitor.visitVarInsn(ASTORE, variable.Index());
break;
}
}
else
{
_methodVisitor.visitVarInsn(ASTORE, variable.Index());
}
}
private Result SimplifyExpression(Expression e)
{
var simp = e.Accept(eval);
if (simp == Constant.Invalid)
{
return new Result {
Value = simp, PropagatedExpression = e
}
}
;
if (ctx.IsFramePointer(simp))
{
return new Result {
Value = simp, PropagatedExpression = simp
}
}
;
if (simp is Constant)
{
return new Result {
Value = simp, PropagatedExpression = simp
}
}
;
if (IsConstantOffsetFromFramePointer(simp) &&
!(e is MemoryAccess || e is SegmentedAccess))
{
return(new Result {
Value = simp, PropagatedExpression = simp
});
}
return(new Result {
Value = simp, PropagatedExpression = e
});
}
public Expression Rewrite(Expression expression, bool dereferenced)
{
var oldDereferenced = this.dereferenced;
this.dereferenced = dereferenced;
var exp = expression.Accept(this);
this.dereferenced = oldDereferenced;
return exp;
}
public bool IsCritical(Expression expr)
{
expr.Accept(this);
return isCritical;
}
private Expression GetValue(Expression op)
{
return op.Accept<Expression>(eval);
}
private void Use(Statement stm, Expression e)
{
e.Accept(new ExpressionUseAdder(stm, ssa.Identifiers));
}
private Expression TransformArgument(Expression arg)
{
return arg.Accept(argumentTransformer);
}
protected void Write(string ns, string key, LanguageInfo language, Expression expr, TextWriter output, string clientClassName)
{
var context = new EvaluationContext
{
Namespace = ns,
Language = language,
StringEncoder = x => x
};
var writer = new JavaScriptExpressionWriter(Writers, output, context);
writer.ClientClassName = clientClassName;
expr.Accept(writer);
}
public static List<Identifier> Find(SsaIdentifierCollection ssaIds, Expression exp)
{
var inst = new UsedIdentifierFinder(ssaIds);
exp.Accept(inst);
return inst.identifiers;
}
public void UseExpression(Expression exp)
{
if (Statement == null)
return;
var xu = new ExpressionUseAdder(Statement, ssaIds);
exp.Accept(xu);
}
private void Use(Expression expr, Statement stm)
{
ExpressionUseAdder eua = new ExpressionUseAdder(stm, ssaIds);
expr.Accept(eua);
}
/// <summary>
/// Writes an expression in a context where it needs no parentheses.
/// </summary>
/// <param name="expr"></param>
public void WriteExpression(Expression expr)
{
int prec = precedenceCur;
precedenceCur = PrecedenceLeast;
expr.Accept(this);
precedenceCur = prec;
}
public void VisitExpression(Expression expression)
{
expression.Accept(this);
}
public SideEffectFlags FindSideEffect(Expression e)
{
flags = SideEffectFlags.None;
e.Accept(this);
return flags;
}
private Instruction MakeAssignment(Expression dst, Expression src)
{
src = src.Accept(this);
var tvDst = dst.TypeVariable;
dst = dst.Accept(this);
var dtSrc = DataTypeOf(src);
var dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs<UnionType>();
UnionType uSrc = dtSrc.ResolveAs<UnionType>();
if (uDst != null)
{
// ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
tvDst.DataType = dtDst;
tvDst.OriginalDataType = dtSrc;
dst.TypeVariable = tvDst;
var ceb = new ComplexExpressionBuilder(dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex(false);
}
else if (uSrc != null)
{
//throw new NotImplementedException();
//var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
//src = ceb.BuildComplex(false);
src = new Cast(dtDst, src);
}
else
{
Debug.Print("{2} [{0}] = {3} [{1}] not supported.", dtDst, dtSrc, dst, src);
src = new Cast(dtDst, src);
}
}
var idDst = dst as Identifier;
if (idDst != null)
return new Assignment(idDst, src);
else
return new Store(dst, src);
}
public override void Visit(Expression expression)
{
expression.Accept(this);
}
