public bool TryGetContainingMethod(out Method method) { LispList <Edge <CFGBlock, EdgeTag> > list = this.SubroutineContext; CFGBlock block = this.Block; while (block != null) { var mi = block.Subroutine as IMethodInfo; if (mi != null) { method = mi.Method; return(true); } if (list != null) { block = list.Head.From; list = list.Tail; } else { block = null; } } method = default(Method); return(false); }
internal LispObject Trace(LispObject[] args) { if (args.Length == 0) { return(LispList.FromEnumerable(TracedFunctions.Select(f => LispSymbol.CreateFromString(f)))); } else { var addedFunctions = new HashSet <string>(); var hasInvalidArguments = false; foreach (var arg in args) { if (arg is LispSymbol symbol) { var resolvedSymbol = symbol.Resolve(Host.CurrentPackage); TracedFunctions.Add(resolvedSymbol.Value); addedFunctions.Add(resolvedSymbol.Value); } else { hasInvalidArguments = true; } } if (hasInvalidArguments) { return(new LispError("Expected only symbols")); } else { return(LispList.FromEnumerable(addedFunctions.Select(f => LispSymbol.CreateFromString(f)))); } } }
private object Run_SaveToFile(LispRuntimeCommand cmd, LispList list) { object objectToSave = Run <object>(list.items[1]); switch (objectToSave) { case Map m: { CheckParameterCount(cmd, list, 2); string path = Run <string>(list.items[2]); m.Save(path); } break; case Image im: { CheckParameterCount(cmd, list, 2); string path = Run <string>(list.items[2]); im.Save(path); } break; case int[] i: { CheckParameterCount(cmd, list, 2); string path = Run <string>(list.items[2]); i.Save(path); } break; } return(null); }
public override IEnumerable <APC> Predecessors(APC pc) { if (pc.Index > 0) { yield return(new APC(pc.Block, pc.Index - 1, pc.SubroutineContext)); } else if (IsSubroutineStart(pc.Block)) { if (!pc.SubroutineContext.IsEmpty()) { foreach (APC apc in ComputeSubroutinePreContinuation(pc)) { yield return(apc); } } } else { foreach (CFGBlock block in pc.Block.Subroutine.PredecessorBlocks(pc.Block)) { LispList <Pair <EdgeTag, Subroutine> > diffs = EdgeSubroutinesOuterToInner(block, pc.Block, pc.SubroutineContext); if (diffs.IsEmpty()) { yield return(APC.ForEnd(block, pc.SubroutineContext)); } else { Subroutine sub = diffs.Head.Value; var edge = new Edge <CFGBlock, EdgeTag> (block, pc.Block, diffs.Head.Key); yield return(APC.ForEnd(sub.Exit, pc.SubroutineContext.Cons(edge))); } } } }
private object Run_FileExists(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); string path = Run <string>(list.items[1]); return(File.Exists(path)); }
private void ReplayEliminations(LispList <Update <TFunc, TADomain> > updates, LispList <Update <TFunc, TADomain> > common) { for (Update <TFunc, TADomain> update = Update <TFunc, TADomain> .Reverse(updates, common); update != null; update = update.Next) { update.ReplayElimination(this); } }
private IEnumerable <APC> APCs(LispList <Edge <CFGBlock, EdgeTag> > context) { for (int i = 0; i < Count; i++) { yield return(new APC(this, i, context)); } }
private LispList <Pair <EdgeTag, Subroutine> > InsertInvariant(CFGBlock from, LispList <Pair <EdgeTag, Subroutine> > list, Method calledMethod, ref TypeNode type, LispList <Edge <CFGBlock, EdgeTag> > context) { IMetaDataProvider metadataDecoder = this.SubroutineFacade.MetaDataProvider; Property property; if (metadataDecoder.IsPropertySetter(calledMethod, out property) && (metadataDecoder.IsAutoPropertyMember(calledMethod) || WithinConstructor(from, context))) { return(list); } if (metadataDecoder.IsConstructor(calledMethod)) { type = metadataDecoder.DeclaringType(calledMethod); } Subroutine invariant = this.SubroutineFacade.GetInvariant(type); if (invariant != null) { var methodCallBlock = from as MethodCallBlock <Label>; if (methodCallBlock != null) { EdgeTag first = methodCallBlock.IsNewObj ? EdgeTag.AfterNewObj : EdgeTag.AfterCall; return(list.Cons(new Pair <EdgeTag, Subroutine> (first, invariant))); } } return(list); }
public void Quoted() { Assert.Equal(new LispUnresolvedSymbol("A"), Read("a")); Assert.Equal(LispList.FromItems(new LispUnresolvedSymbol("QUOTE"), new LispUnresolvedSymbol("A")), Read("'a")); Assert.Equal(LispList.FromItems(new LispUnresolvedSymbol("QUOTE"), LispList.FromItems(new LispUnresolvedSymbol("QUOTE"), new LispUnresolvedSymbol("A"))), Read("''a")); Assert.Equal(LispList.FromItems(new LispUnresolvedSymbol("QUOTE"), new LispList(new LispInteger(1))), Read("'(1)")); }
private SymValue FindCandidate(SymValue[] args, TFunc function) { int length = args.Length; var multiEdge = new MultiEdge <TFunc, TADomain> (function, 0, length); for (LispList <SymValue> list = MultiEdgeMap [args [0], multiEdge]; list != null; list = list.Tail) { SymGraphTerm <TFunc> term = EqualMultiTermsMap [list.Head]; if (term.Args.Length == length) { bool found = true; for (int i = 0; i < length; ++i) { if (Find(term.Args [i]) != args [i]) { found = false; break; } } if (found) { return(list.Head); } } } return(null); }
static public dynamic vertexdata(LispList args, LispEnvironment env) { using (var stream = new MemoryStream()) { int elementCount = 0; foreach (LispElement arg in args) { dynamic vertices = arg.Eval(env); if (vertices is LispList) { foreach (var vertex in vertices) { writeVertexToStream(vertex, stream); elementCount++; } } else { writeVertexToStream(vertices, stream); elementCount++; } } var dataStream = new SlimDX.DataStream(stream.Length, false, true); stream.WriteTo(dataStream); dataStream.Position = 0; return(dataStream); } }
static public dynamic material(LispList args, LispEnvironment env) { IEnumerator <dynamic> arg = args.GetEnumerator(); arg.MoveNext(); var technique = arg.Current.Eval(env); arg.MoveNext(); var effect = arg.Current.Eval(env); arg.MoveNext(); List <KeyValuePair <string, ResourceHandle> > textures = arg.Current.Eval(env); arg.MoveNext(); var constants = arg.Current.Eval(env); var mat = new MaterialResource(effect, technique); foreach (var texture in textures) { mat.AddTexture(texture.Key, texture.Value); } foreach (var constant in constants) { mat.AddConstant(constant.Key, constant.Value); } return(mat); //var material = new MaterialResource(); throw new NotImplementedException(); }
public override LispList <Pair <EdgeTag, Subroutine> > EdgeSubroutinesOuterToInner(CFGBlock current, CFGBlock succ, out bool isExceptionHandlerEdge, LispList <Edge <CFGBlock, EdgeTag> > context) { if (current.Subroutine != this) { return(current.Subroutine.EdgeSubroutinesOuterToInner(current, succ, out isExceptionHandlerEdge, context)); } LispList <Handler> l1 = ProtectingHandlerList(current); LispList <Handler> l2 = ProtectingHandlerList(succ); isExceptionHandlerEdge = IsCatchFilterHeader(succ); LispList <Pair <EdgeTag, Subroutine> > result = GetOrdinaryEdgeSubroutines(current, succ, context); while (l1 != l2) { if (l1.Length() >= l2.Length()) { Handler head = l1.Head; if (IsFaultOrFinally(head) && (!IsFault(head) || isExceptionHandlerEdge)) { result = result.Cons(new Pair <EdgeTag, Subroutine> (EdgeTag.Finally, this.FaultFinallySubroutines [head])); } l1 = l1.Tail; } else { l2 = l2.Tail; } } return(result); }
private IEnumerable <APC> ComputeSubroutinePreContinuation(APC point) { Edge <CFGBlock, EdgeTag> edge = point.SubroutineContext.Head; LispList <Edge <CFGBlock, EdgeTag> > tail = point.SubroutineContext.Tail; bool isHandlerEdge; LispList <Pair <EdgeTag, Subroutine> > diffs = EdgeSubroutinesOuterToInner(edge.From, edge.To, out isHandlerEdge, tail); while (diffs.Head.Value != this) { diffs = diffs.Tail; } if (diffs.Tail == null) { if (isHandlerEdge) { for (int i = 0; i < edge.From.Count; i++) { yield return(new APC(edge.From, i, tail)); } } else { yield return(APC.ForEnd(edge.From, tail)); } } else { Pair <EdgeTag, Subroutine> first = diffs.Tail.Head; Subroutine nextSubroutine = first.Value; yield return(APC.ForEnd(nextSubroutine.Exit, point.SubroutineContext.Cons(new Edge <CFGBlock, EdgeTag> (edge.From, edge.To, first.Key)))); } }
private APC ComputeSubroutinePreContinuation(APC point, out bool hasSinglePredecessor) { Edge <CFGBlock, EdgeTag> head = point.SubroutineContext.Head; bool isExceptionHandlerEdge; LispList <Edge <CFGBlock, EdgeTag> > tail = point.SubroutineContext.Tail; LispList <Pair <EdgeTag, Subroutine> > flist = EdgeSubroutinesOuterToInner(head.From, head.To, out isExceptionHandlerEdge, tail); while (flist.Head.Value != this) { flist = flist.Tail; } if (flist.Tail.IsEmpty()) { if (isExceptionHandlerEdge && head.From.Count > 1) { hasSinglePredecessor = false; return(APC.Dummy); } hasSinglePredecessor = true; return(APC.ForEnd(head.From, tail)); } Pair <EdgeTag, Subroutine> first = flist.Tail.Head; Subroutine sub = first.Value; hasSinglePredecessor = true; return(APC.ForEnd(sub.Exit, point.SubroutineContext.Cons(new Edge <CFGBlock, EdgeTag> (head.From, head.To, first.Key)))); }
private object Run_GetExtension(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); string path = Run <string>(list.items[1]); return(Path.GetExtension(path)); }
public void ExecutionCannotBeHaltedWhenEvaluatingFromWithinANativeMacro() { var host = new LispHost(); host.AddMacro("NATIVE-FUNCTION", (host, executionState, args) => { var result = host.EvalAtStackFrame(executionState.StackFrame, LispList.FromEnumerable(new LispObject[] { LispSymbol.CreateFromString("*"), new LispInteger(2), new LispInteger(2) })); return(result); }); var hitBreakpoint = false; host.RootFrame.EvaluatingExpression += (s, e) => { if (!hitBreakpoint && e.Expression is LispList list && list.ToString() == "(* 2 2)") { hitBreakpoint = true; e.HaltExecution = true; // this should not be honored } }; var evalResult = host.Eval("(native-function)"); Assert.True(hitBreakpoint); Assert.True(evalResult.ExecutionState.IsExecutionComplete); Assert.Equal(4, ((LispInteger)evalResult.LastResult).Value); }
static public dynamic indexdata(LispList args, LispEnvironment env) { using (var stream = new MemoryStream()) { foreach (LispElement arg in args) { dynamic indexes = arg.Eval(env); if (indexes is LispList) { foreach (var curIndexes in indexes) { stream.Write(curIndexes, 0, curIndexes.Length); } } else { stream.Write(indexes, 0, indexes.Length); } } var dataStream = new SlimDX.DataStream(stream.Length, false, true); stream.WriteTo(dataStream); dataStream.Position = 0; return(dataStream); } }
public void InvokeBuiltInNamedFunctionReference() { var host = new LispHost(); var result = host.Eval(@"(funcall #'cons 'a 'b)").LastResult; var expected = LispList.FromItemsImproper(LispSymbol.CreateFromString("A"), LispSymbol.CreateFromString("B")); Assert.Equal(expected, result); }
private object Run_LevelDetectFilter(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); Map map = Run <Map>(list.items[1]); double[] newMap = HoleDetectFilters.LevelDetect(this.Logger, map); return(newMap); }
private object Run_MakeImage(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); Map map = Run <Map>(list.items[1]); Image img = new Image(map); return(img); }
private object Run_CorrelationFilter(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); Map map = Run <Map>(list.items[1]); Map filteredMap = HoleDetectFilters.CorrelationRun(this.Logger, map); return(filteredMap); }
public void ImproperLists() { Assert.True(LispNilList.Instance.IsProperList); Assert.True(new LispList(new LispFloat(1), new LispList(new LispFloat(2), LispNilList.Instance)).IsProperList); Assert.False(new LispList(new LispFloat(1), new LispFloat(2)).IsProperList); Assert.True(LispList.FromItems().IsProperList); Assert.True(LispList.FromItems(new LispFloat(1), new LispFloat(2)).IsProperList); }
private object Run_MorphologicalFilter(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 1); Map map = Run <Map>(list.items[1]); Map newMap = MorphologicalFilter.Filter(this.Logger, map); return(newMap); }
public void Print(TextWriter tw, ILPrinter <APC> printer, Func <CFGBlock, IEnumerable <LispList <Edge <CFGBlock, EdgeTag> > > > contextLookup, LispList <Edge <CFGBlock, EdgeTag> > context) { var set = new HashSet <Pair <Subroutine, LispList <Edge <CFGBlock, EdgeTag> > > > (); this.method_subroutine.Print(tw, printer, contextLookup, context, set); }
static public dynamic texture(LispList args, LispEnvironment env) { ResourceManager manager = ((LispObject)env.Lookup(new LispSymbol("manager"))).Value; return(new KeyValuePair <string, ResourceHandle>( args.Elems[0].Eval(env).Value, manager.GetResource(args.Elems[1].Eval(env).Value, "texture"))); }
private object Run_MapDrainage(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 2); int c = 1; Map map = Run <Map>(list.items[c++]); int lookDistance = Run <int>(list.items[c++]); return(CaveFinderAlgorithm.MapDrainage(this.Logger, map, lookDistance)); }
private object Run_ChangeExtension(LispRuntimeCommand cmd, LispList list) { CheckParameterCount(cmd, list, 2); string path = Run <string>(list.items[1]); string newExtension = Run <string>(list.items[2]); string newPath = Path.ChangeExtension(path, newExtension); return(newPath); }
public void Quoted() { var host = new LispHost(); Assert.Equal(LispSymbol.CreateFromString("A"), host.Eval("'a").LastResult); Assert.Equal(LispList.FromItems(new LispUnresolvedSymbol("QUOTE"), LispSymbol.CreateFromString("A")), host.Eval("''a").LastResult); Assert.Equal(LispList.FromItems(new LispInteger(1)), host.Eval("'(1)").LastResult); Assert.Equal("(QUOTE A)", host.Eval("(eval '''a)").LastResult.ToString()); }
static public dynamic element(LispList args, LispEnvironment env) { LispSymbol name = args[0].Eval(env); LispString format = args[1].Eval(env); env.Add(name, VertexFormats.getParserFor(format.Value)); return(new InputElement(name.Value, 0, VertexFormats.getDXFormatOf(format.Value), 0, 0)); }
public void Print (TextWriter tw, ILPrinter<APC> printer, Func<CFGBlock, IEnumerable<LispList<Edge<CFGBlock, EdgeTag>>>> contextLookup, LispList<Edge<CFGBlock, EdgeTag>> context) { DecoratorHelper.Push<IEdgeSubroutineAdaptor> (this); try { this.underlying.Print (tw, printer, contextLookup, context); } finally { DecoratorHelper.Pop (); } }
public void Print (TextWriter tw, ILPrinter<APC> printer, Func<CFGBlock, IEnumerable<LispList<Edge<CFGBlock, EdgeTag>>>> contextLookup, LispList<Edge<CFGBlock, EdgeTag>> context) { var set = new HashSet<Pair<Subroutine, LispList<Edge<CFGBlock, EdgeTag>>>> (); this.method_subroutine.Print (tw, printer, contextLookup, context, set); }
LispList<Pair<EdgeTag, Subroutine>> IEdgeSubroutineAdaptor.GetOrdinaryEdgeSubroutinesInternal (CFGBlock @from, CFGBlock to, LispList<Edge<CFGBlock, EdgeTag>> context) { return DecoratorHelper.Inner<IEdgeSubroutineAdaptor> (this) .GetOrdinaryEdgeSubroutinesInternal (from, to, context).Where ((pair) => !pair.Value.IsContract && !pair.Value.IsOldValue); }