public ExprBinaryOp (MethodInfo methodInfo, Expr left, Expr right, Sn signage) : base (methodInfo) { this.Left = left; this.Right = right; this.Signage = signage; }
public virtual Expr Visit (Expr e) { switch (e.ExprType) { case ExprType.Block: return this.VisitBlock ((ExprBlock) e); case ExprType.Nop: return this.VisitNop ((ExprNop) e); case ExprType.Call: return this.VisitCall ((ExprCall) e); case ExprType.CompareEqual: return this.VisitCompareEqual ((ExprCompareEqual) e); case ExprType.CompareLessThan: return this.VisitCompareLessThan ((ExprCompareLessThan) e); case ExprType.CompareGreaterThan: return this.VisitCompareGreaterThan ((ExprCompareGreaterThan) e); case ExprType.Add: return this.VisitAdd ((ExprAdd) e); case ExprType.Sub: return this.VisitSub ((ExprSub) e); case ExprType.LoadArg: return this.VisitLoadArg ((ExprLoadArg) e); case ExprType.LoadConstant: return this.VisitLoadConstant ((ExprLoadConstant) e); case ExprType.Return: return this.VisitReturn ((ExprReturn) e); case ExprType.Box: return this.VisitBox ((ExprBox) e); case ExprType.Conv: return this.VisitConv ((ExprConv) e); default: throw new NotSupportedException ("Cannot handle: " + e.ExprType); } }
public override Expr Visit (Expr e) { Instruction inst; if (this.instructionLookup.TryGetValue (e, out inst)) { this.instructions.Add (inst); } return base.Visit (e); }
private void Emit (Expr originalExpr, Instruction inst) { Instruction originalInst; if (this.instructionLookup != null) { // TODO: Doesn't handle inherited contracts - need to check what to do in this case. //if (this.instructionLookup.TryGetValue (originalExpr, out originalInst)) { // inst.SequencePoint = originalInst.SequencePoint; //} } this.fnEmit (inst); }
protected virtual Expr VisitCollection (IEnumerable<Expr> collection, Expr e, Func<IEnumerable<Expr>, Expr> fnCreateNew) { int index = 0; List<Expr> exprs = null; foreach (var expr in collection) { Expr exprVisited = this.Visit (expr); if (exprs != null || exprVisited != expr) { if (exprs == null) { exprs = new List<Expr> (collection.Take (index)); } exprs.Add (exprVisited); } index++; } if (exprs == null) { return e; } else { return fnCreateNew(exprs); } }
public ContractRequiresInfo (Expr originalExpr, Expr rewrittenExpr) { this.OriginalExpr = originalExpr; this.RewrittenExpr = rewrittenExpr; }
public ExprCompareGreaterThan CompareGreaterThan (Expr left, Expr right, Sn signage) { return new ExprCompareGreaterThan (this.methodInfo, left, right, signage); }
public ExprCompareEqual (MethodInfo methodInfo, Expr left, Expr right) : base (methodInfo, left, right, Sn.None) { }
public ExprBox Box (Expr exprToBox) { return new ExprBox (this.methodInfo, exprToBox); }
public ExprCompareEqual CompareEqual (Expr left, Expr right) { return new ExprCompareEqual (this.methodInfo, left, right); }
public ExprConv Conv (Expr exprToConvert, TypeCode convToType) { return new ExprConv (this.methodInfo, exprToConvert, convToType); }
public ExprSub Sub (Expr left, Expr right, Sn signage, bool overflow) { return new ExprSub (this.methodInfo, left, right, signage, overflow); }
public ExprBinaryOpArithmetic (MethodInfo methodInfo, Expr left, Expr right, Sn signage, bool overflow) : base (methodInfo, left, right, signage) { this.Overflow = overflow; }
private void RewriteIL (MethodBody body, Dictionary<Expr,Instruction> instructionLookup, Expr remove, Expr insert) { var il = body.CilWorker; Instruction instInsertBefore; if (remove != null) { var vInstExtent = new InstructionExtentVisitor (instructionLookup); vInstExtent.Visit (remove); instInsertBefore = vInstExtent.Instructions.Last ().Next; foreach (var instRemove in vInstExtent.Instructions) { il.Remove (instRemove); } } else { instInsertBefore = body.Instructions [0]; } if (insert != null) { var compiler = new CompileVisitor (il, instructionLookup, inst => il.InsertBefore (instInsertBefore, inst)); compiler.Visit (insert); } }
public ExprBinaryOpComparison (MethodInfo methodInfo, Expr left, Expr right, Sn signage) : base (methodInfo, left, right, signage) { }
private void Emit (Expr originalExpr, Func<IEnumerable<Instruction>> fnCreateInstruction) { throw new NotImplementedException (); }
public ExprBox (MethodInfo methodInfo, Expr exprToBox) : base (methodInfo) { this.ExprToBox = exprToBox; }
public ExprSub (MethodInfo methodInfo, Expr left, Expr right, Sn signage, bool overflow) : base (methodInfo, left, right, signage, overflow) { }
private string GetConditionString (Expr e) { var vSource = new SourcePositionVisitor (this.instructionLookup); vSource.Visit (e); var extractor = new ConditionTextExtractor (vSource.SourceCodeFileName, vSource.StartPosition, vSource.EndPosition); return extractor.GetConditionText (); }
public override Expr Visit (Expr e) { Instruction inst; if (this.instructionLookup.TryGetValue (e, out inst)) { var seq = inst.SequencePoint; if (seq != null) { this.SourceCodeFileName = seq.Document.Url; var instStart = new CodePosition(seq.StartLine, seq.StartColumn); if (this.StartPosition.IsEmpty || instStart < this.StartPosition) { this.StartPosition = instStart; } var instEnd = new CodePosition (seq.EndLine, seq.EndColumn); if (this.EndPosition.IsEmpty || instEnd > this.EndPosition) { this.EndPosition = instEnd; } } } return base.Visit (e); }
private Expr ProcessCall (MethodReference method) { int paramCount = method.Parameters.Count; Expr [] parameterExprs = new Expr [paramCount]; for (int i = 0; i < paramCount; i++) { Expr parameter = this.exprs.Pop (); parameterExprs [paramCount - i - 1] = parameter; } return this.gen.Call(method, parameterExprs); }
private void Emit (Expr originalExpr, Func<Instruction> fnCreateInstruction) { Instruction inst = fnCreateInstruction(); this.Emit (originalExpr, inst); }
protected Expr VisitCollection (Expr e, Func<IEnumerable<Expr>, Expr> fnCreateNew, params Expr [] collection) { return this.VisitCollection (collection, e, fnCreateNew); }
public ExprCompareGreaterThan (MethodInfo methodInfo, Expr left, Expr right, Sn signage) : base (methodInfo, left, right, signage) { }
public ExprConv (MethodInfo methodInfo, Expr exprToConvert, TypeCode convToType) : base (methodInfo) { this.ExprToConvert = exprToConvert; this.ConvToType = convToType; }