public override void Execute(AbstractMachineState state)
{
AMProgram prog = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
AbstractTerm X1 = ((AbstractTerm)state["X1"]).Dereference();
if (!X0.IsConstant)
{
Console.WriteLine("Invalid class type of object/2");
state.Backtrack();
}
if (X1.IsConstant)
{
Console.WriteLine("object/2: object instantiation error.");
state.Backtrack();
}
if (CreateObject(X0.Data() as string, X1, state))
{
prog.Next();
}
else
{
state.Backtrack();
}
}
public void Call()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
ArrayList prog = new ArrayList();
prog.Add(new PutConstantInstruction());
prog.Add(new HaltInstruction());
state.Initialize(prog);
AMProgram program = (AMProgram)state.Program;
ProgramClause clause = new ProgramClause("male", 2);
program.AddLabel("male/2", clause);
CallInstruction i = new CallInstruction();
object[] args = { "male", "2" };
i.Process(args);
i.Execute(state);
Assert.AreEqual("call", i.Name());
Assert.AreEqual(2, i.NumberOfArguments());
Assert.AreSame(clause, program.P);
Assert.AreEqual("halt", program.CP.Instruction.Name());
}
public void Call()
{
ArrayList prog = new ArrayList();
prog.Add(new NopInstruction());
prog.Add(new HaltInstruction());
AbstractMachineState state = new AbstractMachineState(new AMFactory());
state.Initialize(prog);
AMProgram program = (AMProgram)state.Program;
ArrayList predicateCode = new ArrayList();
AMInstructionSet iset = new AMInstructionSet();
// say_hello(X) :- write(X).
predicateCode.Add(iset.CreateInstruction("bcall", "write/1"));
predicateCode.Add(iset.CreateInstruction("proceed"));
AbstractTerm X0 = (AbstractTerm)state["X0"];
X0.Assign(new ConstantTerm("Hello, World!"));
program.AssertFirst("say_hello", 1, predicateCode);
Assert.IsTrue(state.Call("say_hello", 1, new object[] { "Hello man" }));
}
public void UnsaveRegisters(AbstractMachineState state, int count)
{
for (int i = 0; i < count; i++)
{
AbstractTerm Xi = (AbstractTerm)state["X" + i.ToString()];
Xi.Assign((AbstractTerm)_savedVariables[i]);
}
}
public void SaveRegisters(AbstractMachineState state, int count)
{
for (int i = 0; i < count; i++)
{
AbstractTerm toSave = new AbstractTerm();
toSave.Copy((AbstractTerm)state["X" + i.ToString()]);
_savedVariables.Add(toSave);
}
}
public AbstractMachineState SetupMachine()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
ArrayList prog = new ArrayList();
prog.Add(new HaltInstruction());
state.Initialize(prog);
return state;
}
public void Initialize()
{
AMHeap heap = new AMHeap();
AbstractMachineState state = new AbstractMachineState(new AMFactory());
heap.Initialize(state);
Assert.IsNull(heap.H);
Assert.IsNull(heap.Top());
}
public void Stop()
{
ArrayList prog = new ArrayList();
prog.Add(new NopInstruction());
prog.Add(new HaltInstruction());
AbstractMachineState state = new AbstractMachineState(new AMFactory());
state.Initialize(prog);
Assert.IsFalse(state.Stop());
}
public void Initialize()
{
ArrayList prog = new ArrayList();
prog.Add(new NopInstruction());
prog.Add(new HaltInstruction());
AbstractMachineState state = new AbstractMachineState(new AMFactory());
state.Initialize(prog);
Assert.IsNotNull(state.Program);
Assert.IsNotNull(state.DataArea);
}
private bool CreateObject(string classType, AbstractTerm netObject, AbstractMachineState state)
{
Assembly asm = GetRequiredAssembly(classType, state);
Type[] types = asm.GetTypes();
Type type = null;
type = asm.GetType(fullTypeName);
if (type == null)
{
return false;
}
netObject.Assign(new ObjectTerm(Activator.CreateInstance(type)));
return true;
}
public InteractiveCompiler(string filename)
{
PrologCodeProvider provider = new PrologCodeProvider();
IPrologCompiler compiler = provider.CreateCompiler();
PrologCompilerParameters parameters = new PrologCompilerParameters();
PrologCompilerResults results = compiler.CompileAbstractCodeFromFile(parameters, "boot.pro");
/* Run */
AbstractMachineState runtime = new AbstractMachineState(new AMFactory());
//runtime.Init(results.AbstractInstructions, results.ForeignMethods, results.Namespaces, results.AssemblyFiles);
runtime.Initialize(results.AbstractInstructions);
runtime.Transition();
}
public void Backtrack()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
AMProgram program = (AMProgram)state.Program;
state.Backtrack();
Assert.IsNotNull(program.P);
ProgramClause nextClause = new ProgramClause();
state.B = new Choicepoint(2, null, null, null, nextClause, 3, null);
state.Backtrack();
Assert.AreSame(program.P, nextClause);
}
public override void Execute(AbstractMachineState state)
{
AMProgram prog = (AMProgram)state.Program;
runtime = state;
// invoke(+ClassObj,+meth(+x..),-Return).
AbstractTerm X0 = (state["X0"] as AbstractTerm).Dereference();
AbstractTerm X1 = (state["X1"] as AbstractTerm).Dereference();
AbstractTerm X2 = (state["X2"] as AbstractTerm).Dereference();
if (Getproperty(X0, X1, X2))
{
prog.Next();
}
else
{
state.Backtrack();
}
}
private Assembly GetRequiredAssembly(string classType, AbstractMachineState state)
{
AMAssemblyCache cache = (AMAssemblyCache)state.AssemblyCache;
string assemblyFile = "";
// if it exists in the global assembly cache, then get it from there...
foreach (string ns in cache.Namespaces)
{
string fullName = ns + "." + classType;
if (cache.LocalAssemblyCache.Contains(fullName))
{
assemblyFile = (string)cache.LocalAssemblyCache[fullName];
fullTypeName = fullName;
return Assembly.LoadWithPartialName(assemblyFile);
}
}
foreach (string loadedAssembly in cache.AssemblyFiles)
{
Assembly a = Assembly.LoadFrom(loadedAssembly);
Type[] types = a.GetTypes();
Type type = null;
foreach (Type t in types)
{
if (t.Name == classType)
{
type = t;
break;
}
}
fullTypeName = type.FullName;
return a;
}
return null;
}
public override void Initialize(AbstractMachineState state)
{
_state = state;
}
public override void Execute(AbstractMachineState state)
{
state.B = null;
}
public override void Initialize(AbstractMachineState state)
{
_state = state;
}
abstract public void Execute(AbstractMachineState state);
public abstract void Initialize(AbstractMachineState state);
public abstract void Execute(AbstractMachineState state);
public void UnsaveRegisters(AbstractMachineState state, int count)
{
for (int i = 0; i < count; i++)
{
AbstractTerm Xi = (AbstractTerm)state["X" + i.ToString()];
Xi.Assign((AbstractTerm)_savedVariables[i]);
}
}
public void SaveRegisters(AbstractMachineState state, int count)
{
for (int i = 0; i < count; i++)
{
AbstractTerm toSave = new AbstractTerm();
toSave.Copy((AbstractTerm)state["X" + i.ToString()]);
_savedVariables.Add(toSave);
}
}
private bool InvokeMethod(AbstractTerm obj, AbstractTerm method, AbstractTerm returnObject, AbstractMachineState state)
{
if (obj.IsConstant)
{
// invoke a static method
Assembly asm = GetRequiredAssembly(obj.Data() as string, state);
Type type = asm.GetType(obj.Data() as string);
if (type == null)
{
return false;
}
ArrayList paramArray = new ArrayList();
GetTypes(type.GetMethod(method.Data() as string), method, ref paramArray, obj);
object[] arguments = paramArray.ToArray();
object res = type.InvokeMember(method.Data() as string, BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, arguments);
switch (res.GetType().ToString())
{
case "System.Char":
case "System.String":
case "System.Int32":
case "System.Boolean":
returnObject.Assign(new ConstantTerm(res.ToString()));
break;
default:
returnObject.Assign(new ObjectTerm(res));
break;
}
SetTypes(method, arguments);
}
else
{
// invoke an instance method
ArrayList paramArray = new ArrayList();
GetTypes(obj.Data().GetType().GetMethod(method.Data() as string), method, ref paramArray, obj);
object classObject = obj.Data();
MethodInfo omi = classObject.GetType().GetMethod(method.Data() as string);
object[] arguments = paramArray.ToArray();
object res = obj.Data().GetType().InvokeMember(method.Data() as string, BindingFlags.Default | BindingFlags.ExactBinding | BindingFlags.InvokeMethod, null, obj.Data(), arguments);
if (res != null)
{
switch (res.GetType().ToString())
{
case "System.String":
ConstantTerm rC = new ConstantTerm(res.ToString());
if (!returnObject.Unify(rC))
{
return false;
}
break;
case "System.Char":
case "System.Int32":
case "System.Boolean":
ConstantTerm returnConstant = new ConstantTerm(res.ToString());
if (!returnObject.Unify(returnConstant))
{
return false;
}
break;
default:
returnObject.Assign(new ObjectTerm(res));
break;
}
}
SetTypes(method, arguments);
}
return true;
}
public void SaveRegisters()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
ArrayList prog = new ArrayList();
prog.Add(new HaltInstruction());
state.Initialize(prog);
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
AbstractTerm X2 = (AbstractTerm)state["X2"];
X0.Assign(new ConstantTerm("ali"));
X1.Assign(new ConstantTerm("samir"));
X2.Assign(new ConstantTerm("moe"));
Choicepoint c = new Choicepoint();
c.SaveRegisters(state, 3);
Assert.AreEqual("ali", c["X0"].Data());
Assert.AreEqual("samir", c["X1"].Data());
Assert.AreEqual("moe", c["X2"].Data());
}
abstract public void Initialize(AbstractMachineState state);
public void X_Registers()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
}