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