public void IntegerPrimitiveRejectsAtom()
{
StructureObject so = new StructureObject("integer", "a");
PrologMachine pm = new PrologMachine();
Assert.IsFalse(pm.Resolve(so));
}
public void EqualPrimitiveUnifyVariables()
{
StructureObject so = new StructureObject("=", "Y", "X");
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
}
public void AtomicPrimitiveAcceptsAtom()
{
StructureObject so = new StructureObject("atomic", "a");
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
}
public void EqualPrimitiveDontUnifyDifferentAtoms()
{
StructureObject so = new StructureObject("=", "a", "b");
PrologMachine pm = new PrologMachine();
Assert.IsFalse(pm.Resolve(so));
}
public void NonVarPrimitiveRejectsVariable()
{
StructureObject so = new StructureObject("nonvar", "X");
PrologMachine pm = new PrologMachine();
Assert.IsFalse(pm.Resolve(so));
}
public void VarPrimitiveRejectsStructure()
{
StructureObject so = new StructureObject("var", new StructureObject("foo", "bar"));
PrologMachine pm = new PrologMachine();
Assert.IsFalse(pm.Resolve(so));
}
public void NonVarPrimitiveAcceptsStructure()
{
StructureObject so = new StructureObject("nonvar", new StructureObject("foo", "bar"));
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
}
public void VarPrimitiveAcceptsVariable()
{
StructureObject so = new StructureObject("var", "X");
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
}
public void VarPrimitiveRejectsInteger()
{
StructureObject so = new StructureObject("var", 1);
PrologMachine pm = new PrologMachine();
Assert.IsFalse(pm.Resolve(so));
}
public void IntegerPrimitiveAcceptsInteger()
{
StructureObject so = new StructureObject("integer", 1);
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
}
public void EqualPrimitiveUnifyInternalAtomVariable()
{
StructureObject so = new StructureObject("=", new StructureObject("f", "a"), new StructureObject("f", "X"));
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
Assert.AreEqual("a", pm.GetVariable(0).Dereference().ToString());
}
public void EqualPrimitiveUnifyAtomWithVariable()
{
StructureObject so = new StructureObject("=", "a", "X");
PrologMachine pm = new PrologMachine();
Assert.IsTrue(pm.Resolve(so));
Assert.AreEqual(so.Parameters[0], pm.GetVariable(0).Dereference());
}
public void ShouldCreateVariable()
{
PrologMachine pm = new PrologMachine();
Variable v1 = pm.GetVariable(0);
Assert.IsNotNull(v1);
}
public void ShouldCreateVariables()
{
PrologMachine pm = new PrologMachine();
Variable v1 = pm.GetVariable(0);
Variable v2 = pm.GetVariable(0);
Assert.IsTrue(v1.Equals(v2));
Assert.AreEqual("_0", v1.ToString());
}
void OnMachineChanged(object sender, MachineChangedEventArgs e)
{
if (_currentMachine != null)
{
_currentMachine.ExecutionComplete -= OnExecutionComplete;
_currentMachine.ExecutionSuspended -= OnExecutionSuspended;
}
_currentMachine = e.Machine;
if (_currentMachine != null)
{
_currentMachine.ExecutionComplete += OnExecutionComplete;
_currentMachine.ExecutionSuspended += OnExecutionSuspended;
}
AdjustVariables();
}
public static void HelloWorld()
{
CodeSentence codeSentence;
codeSentence = Prolog.Parser.Parse("hello(world)")[0];
Program program = new Program();
program.Add(codeSentence);
codeSentence = Prolog.Parser.Parse(":-hello(X)")[0];
Query query = new Query(codeSentence);
PrologMachine machine = PrologMachine.Create(program, query);
ExecutionResults results = machine.RunToSuccess();
}
void OnMachineChanged(object sender, MachineChangedEventArgs e)
{
if (_currentMachine != null)
{
_currentMachine.ExecutionComplete -= OnExecutionComplete;
_currentMachine.ExecutionSuspended -= OnExecutionSuspended;
}
_currentMachine = e.Machine;
if (_currentMachine != null)
{
_currentMachine.ExecutionComplete += OnExecutionComplete;
_currentMachine.ExecutionSuspended += OnExecutionSuspended;
}
SetCurrentStackFrame();
}
PrologMachine Execute(Prolog.Program program, Query query)
{
try
{
var machine = PrologMachine.Create(program, query);
machine.ExecutionComplete += CodeExecuted;
var result = machine.RunToSuccess();
Console.WriteLine(Enum.GetName(typeof(ExecutionResults), result));
return(machine);
}
catch (Exception ex)
{
Console.WriteLine("Error, got exception: {0}", ex.Message);
return(null);
}
}
PrologMachine Execute(PrologMachine machine, Query query)
{
try
{
machine.ExecutionComplete += CodeExecuted;
machine.RunToBacktrack();
machine.Restart();
var result = machine.RunToSuccess();
Console.WriteLine(Enum.GetName(typeof(ExecutionResults), result));
return(machine);
}
catch (Exception ex)
{
Console.WriteLine("Error, got exception: {0}", ex.Message);
return(null);
}
}
public void Run()
{
var program = new Prolog.Program();
var content = File.ReadAllText(_fileName);
var codeSentences = GetCodeSentences(content);
if (codeSentences == null)
{
return;
}
foreach (var sentence in codeSentences)
{
program.Add(sentence);
}
PrologMachine lastMachine = null;
while (true)
{
Console.WriteLine("Hint.: " + _queryHint);
Console.Write("Query: ");
var input = Console.ReadLine();
if (string.IsNullOrEmpty(input))
{
return;
}
var query = GetQuery(input);
if (query == null)
{
continue;
}
if (input.ToLower() == ";" && lastMachine != null)
{
lastMachine = Execute(lastMachine, query);
continue;
}
lastMachine = Execute(program, query);
}
}
public Schedule Execute()
{
PrologMachine machine = Machine;
if (!machine.CanRunToSuccess)
{
return(null);
}
ExecutionResults executionResults = machine.RunToSuccess();
if (executionResults != ExecutionResults.Success)
{
return(null);
}
CodeTerm codeTerm = machine.QueryResults.Variables[0].CodeTerm;
Schedule schedule = Schedule.Create(codeTerm);
return(schedule);
}
private void ExecutePrologProgram(string programStr)
{
var lines = programStr.Split(Environment.NewLine.ToCharArray());
var codeSentences = new List <CodeSentence>();
foreach (var line in lines)
{
codeSentences.AddRange(Prolog.Parser.Parse(line));
}
Prolog.Program program = new Prolog.Program();
foreach (var codeSentence in codeSentences)
{
program.Add(codeSentence);
}
var qw = Parser.Parse($":-{QueryTextBox.Text}");
Query query = new Query(qw[0]);
PrologMachine machine = PrologMachine.Create(program, query);
StringBuilder sb = new StringBuilder();
sb.AppendLine(machine.RunToSuccess().ToString());
if (machine.QueryResults != null)
{
foreach (var v in machine.QueryResults.Variables)
{
sb.AppendLine($"{v.Name} = {v.Text}");
}
}
//if (machine.StackFrames != null)
//{
// foreach (var v in machine.StackFrames)
// {
// sb.AppendLine(v.ToString());
// }
//}
ResultTextBox.Text = sb.ToString();
}
public MachineChangedEventArgs(PrologMachine machine)
{
Machine = machine;
}
public void Reset()
{
Machine = null;
}
public void Restart()
{
PrologMachine machine = Machine;
machine.Restart();
}
protected static PrologMachine CreateMachine()
{
var codeSentence = Parser.Parse("pragma(optimize,true).").FirstOrDefault();
return(PrologMachine.Create(An <Program>(), new Query(codeSentence))); //AppState.Program, query);
}
void ProcessInput(bool executeQuery)
{
var input = CurrentInput;
if (input == null)
{
return;
}
input = input.Trim();
if (string.IsNullOrEmpty(input))
{
return;
}
TranscriptProvider.Transcript.AddTranscriptEntry(TranscriptEntryTypes.Request, input);
var selectedClause = CurrentClauseProvider.SelectedClause;
var codeSentences = Parser.Parse(input);
if (codeSentences == null || codeSentences.Length == 0)
{
TranscriptProvider.Transcript.AddTranscriptEntry(TranscriptEntryTypes.Response, Resources.Strings.MessageUnrecognizedInput);
return;
}
foreach (var codeSentence in codeSentences)
{
if (codeSentence.Head == null) // query
{
var query = new Query(codeSentence);
MachineProvider.Machine = PrologMachine.Create(ProgramProvider.Program, query);
MachineProvider.Machine.ExecutionComplete += OnMachineExecutionComplete;
if (executeQuery)
{
MachineProvider.Machine.RunToSuccess();
}
}
else // fact or rule
{
if (selectedClause != null && selectedClause.Container.Procedure.Functor == Functor.Create(codeSentence.Head.Functor))
{
selectedClause.CodeSentence = codeSentence;
TranscriptProvider.Transcript.AddTranscriptEntry(TranscriptEntryTypes.Response, Resources.Strings.ResponseSuccess);
}
else
{
if (ProgramProvider.Program.Contains(codeSentence))
{
TranscriptProvider.Transcript.AddTranscriptEntry(TranscriptEntryTypes.Response, Resources.Strings.MessageDuplicateClause);
}
else
{
ProgramProvider.Program.Add(codeSentence);
TranscriptProvider.Transcript.AddTranscriptEntry(TranscriptEntryTypes.Response, Resources.Strings.ResponseSuccess);
}
}
}
}
}
private void ProcessInput(string input, bool executeQuery)
{
// Ignore empty input.
//
if (input == null)
{
return;
}
input = input.Trim();
if (string.IsNullOrEmpty(input))
{
return;
}
AppState.Transcript.Entries.AddTranscriptEntry(TranscriptEntryTypes.Request, input);
Clause selectedClause = ctrlProgram.SelectedClause;
CodeSentence[] codeSentences = Parser.Parse(input);
if (codeSentences == null ||
codeSentences.Length == 0)
{
AppState.Transcript.Entries.AddTranscriptEntry(TranscriptEntryTypes.Response, Properties.Resources.MessageUnrecognizedInput);
}
else
{
foreach (CodeSentence codeSentence in codeSentences)
{
if (codeSentence.Head == null) // query
{
Query query = new Query(codeSentence);
AppState.Machine = PrologMachine.Create(AppState.Program, query);
if (executeQuery)
{
AppState.Machine.RunToSuccess();
}
}
else // fact or rule
{
if (selectedClause != null &&
selectedClause.Container.Procedure.Functor == Functor.Create(codeSentence.Head.Functor))
{
selectedClause.CodeSentence = codeSentence;
AppState.Transcript.Entries.AddTranscriptEntry(TranscriptEntryTypes.Response, Properties.Resources.ResponseSuccess);
}
else
{
if (AppState.Program.Contains(codeSentence))
{
AppState.Transcript.Entries.AddTranscriptEntry(TranscriptEntryTypes.Response, Properties.Resources.MessageDuplicateClause);
}
else
{
AppState.Program.Add(codeSentence);
AppState.Transcript.Entries.AddTranscriptEntry(TranscriptEntryTypes.Response, Properties.Resources.ResponseSuccess);
}
}
}
}
}
}
