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