public void ValidateTestResults()
{
Console.WriteLine("Validate: {0}", TestCaseName);
XElement xDocument = XElement.Load(Path.Combine(Properties.Settings.Default.TestsFolder, TestCaseName));
int testCaseNumber = 0;
foreach (XElement xTestCase in xDocument.Elements(TestCaseElementName))
{
Console.WriteLine("Test case {0}.", ++testCaseNumber);
string testCaseSource = xTestCase.Element(SourceElementName).Value;
CodeSentence testCaseCodeSentence = CodeSentence.Create(xTestCase.Element(CodeSentence.ElementName));
CodeSentence[] codeSentences = Parser.Parse(testCaseSource);
if (codeSentences == null ||
codeSentences.Length == 0)
{
Console.WriteLine("*** Could not parse source.");
}
else if (codeSentences.Length > 1)
{
Console.WriteLine("*** More than one CodeSentence returned by parser.");
}
else if (testCaseCodeSentence != codeSentences[0])
{
Console.WriteLine("*** CodeSentence mismatch.");
}
}
Console.WriteLine("Validate complete: {0}", TestCaseName);
}
internal Clause Add(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
if (codeSentence.Head == null)
{
throw new ArgumentException("Query cannot be added to program.", "codeSentence");
}
if (Functor.Create(codeSentence.Head.Functor) != Procedure.Functor)
{
throw new ArgumentException("Clause not member of procedure.", "codeSentence");
}
if (Contains(codeSentence))
{
throw new ArgumentException("Item already exists.", "codeSentence");
}
Clause clause = new Clause(this, codeSentence);
Items.Add(clause);
Procedure.InvalidateInstructionStream();
Procedure.InvalidatePosition();
Procedure.Container.Program.Touch();
return(clause);
}
public void CreateTestResults()
{
var filename = Path.Combine(_configuration["Paths:SampleFolder"], ProgramName);
if (!File.Exists(filename))
{
Console.WriteLine("File {0} not found, aborting", filename);
return;
}
var program = Prolog.Program.Load(filename);
var xDocument = new XElement(RootElementName, new XAttribute(ProgramNameAttributeName, ProgramName));
foreach (var procedure in program.Procedures)
{
foreach (var clause in procedure.Clauses)
{
var xCodeSentence = clause.CodeSentence.ToXElement();
var codeSentence = CodeSentence.Create(xCodeSentence);
Debug.Assert(codeSentence == clause.CodeSentence);
var xTest = new XElement(TestCaseElementName, new XElement(SourceElementName, clause.ToString()), xCodeSentence);
xDocument.Add(xTest);
}
}
xDocument.Save(Path.Combine(_configuration["Paths:TestFolder"], TestCaseName));
}
public void CreateTestResults()
{
Program program = Program.Load(Path.Combine(Properties.Settings.Default.SamplesFolder, ProgramName));
XElement xDocument =
new XElement(RootElementName,
new XAttribute(ProgramNameAttributeName, ProgramName));
foreach (Procedure procedure in program.Procedures)
{
foreach (Clause clause in procedure.Clauses)
{
XElement xCodeSentence = clause.CodeSentence.ToXElement();
CodeSentence codeSentence = CodeSentence.Create(xCodeSentence);
Debug.Assert(codeSentence == clause.CodeSentence);
XElement xTest =
new XElement(TestCaseElementName,
new XElement(SourceElementName, clause.ToString()),
xCodeSentence);
xDocument.Add(xTest);
}
}
xDocument.Save(Path.Combine(Properties.Settings.Default.TestsFolder, TestCaseName));
}
public void ValidateTestResults()
{
Console.WriteLine("Validate: {0}", TestCaseName);
var xDocument = XElement.Load(Path.Combine(_configuration["Paths:TestFolder"], TestCaseName));
var testCaseNumber = 0;
foreach (var xTestCase in xDocument.Elements(TestCaseElementName))
{
Console.WriteLine("Test case {0}.", ++testCaseNumber);
var testCaseSource = xTestCase.Element(SourceElementName).Value;
var testCaseCodeSentence = CodeSentence.Create(xTestCase.Element(CodeSentence.ElementName));
var codeSentences = Parser.Parse(testCaseSource);
if (codeSentences == null || codeSentences.Length == 0)
{
Console.WriteLine("*** Could not parse source.");
}
else if (codeSentences.Length > 1)
{
Console.WriteLine("*** More than one CodeSentence returned by parser.");
}
else if (testCaseCodeSentence != codeSentences[0])
{
Console.WriteLine("*** CodeSentence mismatch.");
}
}
Console.WriteLine("Validate complete: {0}", TestCaseName);
}
public Clause Add(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
if (codeSentence.Head == null)
{
throw new ArgumentException("Query cannot be added to program.", "codeSentence");
}
var functor = Functor.Create(codeSentence.Head.Functor);
if (functor == Functor.PragmaFunctor)
{
ProcessPragma(codeSentence);
return(null);
}
// Find procedure associated with codeSentence. Create a new procedure if necessary.
//
Procedure procedure;
if (!Procedures.TryGetProcedure(functor, out procedure))
{
procedure = Procedures.Add(functor);
}
// Create clause for codeSentence.
//
var clause = procedure.Clauses.Add(codeSentence);
return(clause);
}
public static void Write(CodeSentence codeSentence, int indentation, TextWriter wtr)
{
wtr.WriteLine("{0}CodeSentence", Indentation(indentation));
Write(codeSentence.Head, indentation + 1, wtr);
foreach (var item in codeSentence.Body)
{
Write(item, indentation + 1, wtr);
}
}
internal bool Contains(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
return(this.Any(clause => clause.CodeSentence == codeSentence));
}
public static void Write(CodeSentence codeSentence, int indentation, TextWriter wtr)
{
wtr.WriteLine("{0}CodeSentence", Indentation(indentation));
Write(codeSentence.Head, indentation+1, wtr);
foreach (CodeCompoundTerm item in codeSentence.Body)
{
Write(item, indentation + 1, wtr);
}
}
public CodeSentenceDataObject(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
m_object = codeSentence;
m_format = CodeSentenceDataFormat;
m_autoConvert = true;
}
public Query(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
m_codeSentence = codeSentence;
m_libraries = LibraryList.Create();
m_libraries.Add(Library.Standard);
}
public Query(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
CodeSentence = codeSentence;
Libraries = LibraryList.Create();
Libraries.Add(Library.Standard);
}
internal Clause(ProcedureClauseList container, CodeSentence codeSentence)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
Container = container;
_codeSentence = codeSentence;
}
internal Clause(ProcedureClauseList container, CodeSentence codeSentence)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
m_container = container;
m_codeSentence = codeSentence;
}
private void CommandPaste_Executed(object sender, ExecutedRoutedEventArgs e)
{
if (AppState.Program != null)
{
IDataObject dataObject = Clipboard.GetDataObject();
object codeSentenceObject = dataObject.GetData(CodeSentenceDataObject.CodeSentenceDataFormat);
if (codeSentenceObject != null)
{
CodeSentence codeSentence = codeSentenceObject as CodeSentence;
if (codeSentence != null ||
codeSentence.Head != null)
{
AppState.Program.Add(codeSentence);
}
}
}
}
internal bool Contains(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
foreach (Clause clause in this)
{
if (clause.CodeSentence == codeSentence)
{
return(true);
}
}
return(false);
}
void ProcessPragma(CodeSentence codeSentence)
{
if (codeSentence.Body.Count != 0)
{
return;
}
var pragma = codeSentence.Head;
var pragmaName = pragma.Children[0].AsCodeCompoundTerm;
var pragmaArgument = pragma.Children[1];
if (pragmaName == null || pragmaArgument == null)
{
return;
}
if (pragmaName.Functor == PragmaOptimizeFunctor)
{
ProcessOptimizePragma(pragmaArgument);
}
}
private void ProcessPragma(CodeSentence codeSentence)
{
if (codeSentence.Body.Count != 0)
{
return;
}
CodeCompoundTerm pragma = codeSentence.Head;
CodeCompoundTerm pragmaName = pragma.Children[0].AsCodeCompoundTerm;
CodeTerm pragmaArgument = pragma.Children[1];
if (pragmaName != null &&
pragmaArgument != null)
{
if (pragmaName.Functor == PragmaOptimizeFunctor)
{
ProcessOptimizePragma(pragmaArgument);
}
}
}
public bool Contains(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
if (codeSentence.Head == null)
{
throw new ArgumentException("Program cannot contain query.", "codeSentence");
}
var functor = Functor.Create(codeSentence.Head.Functor);
Procedure procedure;
if (Procedures.TryGetProcedure(functor, out procedure))
{
if (procedure.Clauses.Contains(codeSentence))
{
return(true);
}
}
return(false);
}
public WamInstructionStream Compile(CodeSentence codeSentence, LibraryList libraries, bool optimize)
{
return(Compile(codeSentence, null, -1, false, libraries, optimize));
}
private void ProcessPragma(CodeSentence codeSentence)
{
if (codeSentence.Body.Count != 0)
{
return;
}
CodeCompoundTerm pragma = codeSentence.Head;
CodeCompoundTerm pragmaName = pragma.Children[0].AsCodeCompoundTerm;
CodeTerm pragmaArgument = pragma.Children[1];
if (pragmaName != null
&& pragmaArgument != null)
{
if (pragmaName.Functor == PragmaOptimizeFunctor)
{
ProcessOptimizePragma(pragmaArgument);
}
}
}
void ProcessPragma(CodeSentence codeSentence)
{
if (codeSentence.Body.Count != 0)
{
return;
}
var pragma = codeSentence.Head;
var pragmaName = pragma.Children[0].AsCodeCompoundTerm;
var pragmaArgument = pragma.Children[1];
if (pragmaName == null || pragmaArgument == null) return;
if (pragmaName.Functor == PragmaOptimizeFunctor)
{
ProcessOptimizePragma(pragmaArgument);
}
}
public Clause Add(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
if (codeSentence.Head == null)
{
throw new ArgumentException("Query cannot be added to program.", "codeSentence");
}
var functor = Functor.Create(codeSentence.Head.Functor);
if (functor == Functor.PragmaFunctor)
{
ProcessPragma(codeSentence);
return null;
}
// Find procedure associated with codeSentence. Create a new procedure if necessary.
//
Procedure procedure;
if (!Procedures.TryGetProcedure(functor, out procedure))
{
procedure = Procedures.Add(functor);
}
// Create clause for codeSentence.
//
var clause = procedure.Clauses.Add(codeSentence);
return clause;
}
public bool Contains(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
if (codeSentence.Head == null)
{
throw new ArgumentException("Program cannot contain query.", "codeSentence");
}
var functor = Functor.Create(codeSentence.Head.Functor);
Procedure procedure;
if (Procedures.TryGetProcedure(functor, out procedure))
{
if (procedure.Clauses.Contains(codeSentence))
{
return true;
}
}
return false;
}
public WamInstructionStream Compile(CodeSentence codeSentence, Functor functor, int index, bool isLast, LibraryList libraries, bool optimize)
{
Initialize();
// When true, indicates we are compiling code for a procedure clause. When false, indicates we
// are compiling for an ad hoc query.
//
bool isClause = (functor != null);
if (isClause)
{
WamInstructionStreamClauseAttribute clauseAttribute = new WamInstructionStreamClauseAttribute(
m_instructionStreamBuilder.NextIndex,
functor,
index);
m_instructionStreamBuilder.AddAttribute(clauseAttribute);
}
if (isClause)
{
if (isLast)
{
if (index == 0)
{
// Procedure only has one clause in it. No retry logic required.
}
else
{
TrustMe();
}
}
else
{
if (index == 0)
{
TryMeElse(functor, index + 1);
}
else
{
RetryMeElse(functor, index + 1);
}
}
}
Allocate();
if (codeSentence.Head != null)
{
for (int idx = 0; idx < codeSentence.Head.Children.Count; ++idx)
{
Get(codeSentence.Head.Children[idx], GetArgumentRegister(idx));
}
}
if (codeSentence.Body.Count > 0)
{
for (int idxProcedure = 0; idxProcedure < codeSentence.Body.Count; ++idxProcedure)
{
CodeCompoundTerm codeCompoundTerm = codeSentence.Body[idxProcedure];
for (int idxArgument = 0; idxArgument < codeCompoundTerm.Children.Count; ++idxArgument)
{
Put(codeCompoundTerm.Children[idxArgument], GetArgumentRegister(idxArgument), libraries);
}
bool isLastCall = (idxProcedure == codeSentence.Body.Count - 1);
if (isClause)
{
if (isLastCall)
{
if (optimize
&& !libraries.Contains(Functor.Create(codeCompoundTerm.Functor))
&& codeCompoundTerm.Functor != CodeFunctor.CutFunctor)
{
Deallocate();
Execute(codeCompoundTerm.Functor);
}
else
{
Call(codeCompoundTerm.Functor, libraries);
Deallocate();
Proceed();
}
}
else
{
Call(codeCompoundTerm.Functor, libraries);
}
}
else // isQuery
{
Call(codeCompoundTerm.Functor, libraries);
if (isLastCall)
{
Success();
}
}
}
}
else // fact
{
if (isClause)
{
Deallocate();
Proceed();
}
else // isQuery
{
// No action required.
}
}
return InstructionStreamBuilder.ToInstructionStream();
}
public WamInstructionStream Compile(CodeSentence codeSentence, LibraryList libraries, bool optimize)
{
return Compile(codeSentence, null, -1, false, libraries, optimize);
}
public WamInstructionStream Compile(CodeSentence codeSentence, Functor functor, int index, bool isLast, LibraryList libraries, bool optimize)
{
Initialize();
// When true, indicates we are compiling code for a procedure clause. When false, indicates we
// are compiling for an ad hoc query.
//
bool isClause = (functor != null);
if (isClause)
{
WamInstructionStreamClauseAttribute clauseAttribute = new WamInstructionStreamClauseAttribute(
m_instructionStreamBuilder.NextIndex,
functor,
index);
m_instructionStreamBuilder.AddAttribute(clauseAttribute);
}
if (isClause)
{
if (isLast)
{
if (index == 0)
{
// Procedure only has one clause in it. No retry logic required.
}
else
{
TrustMe();
}
}
else
{
if (index == 0)
{
TryMeElse(functor, index + 1);
}
else
{
RetryMeElse(functor, index + 1);
}
}
}
Allocate();
if (codeSentence.Head != null)
{
for (int idx = 0; idx < codeSentence.Head.Children.Count; ++idx)
{
Get(codeSentence.Head.Children[idx], GetArgumentRegister(idx));
}
}
if (codeSentence.Body.Count > 0)
{
for (int idxProcedure = 0; idxProcedure < codeSentence.Body.Count; ++idxProcedure)
{
CodeCompoundTerm codeCompoundTerm = codeSentence.Body[idxProcedure];
for (int idxArgument = 0; idxArgument < codeCompoundTerm.Children.Count; ++idxArgument)
{
Put(codeCompoundTerm.Children[idxArgument], GetArgumentRegister(idxArgument), libraries);
}
bool isLastCall = (idxProcedure == codeSentence.Body.Count - 1);
if (isClause)
{
if (isLastCall)
{
if (optimize &&
!libraries.Contains(Functor.Create(codeCompoundTerm.Functor)) &&
codeCompoundTerm.Functor != CodeFunctor.CutFunctor)
{
Deallocate();
Execute(codeCompoundTerm.Functor);
}
else
{
Call(codeCompoundTerm.Functor, libraries);
Deallocate();
Proceed();
}
}
else
{
Call(codeCompoundTerm.Functor, libraries);
}
}
else // isQuery
{
Call(codeCompoundTerm.Functor, libraries);
if (isLastCall)
{
Success();
}
}
}
}
else // fact
{
if (isClause)
{
Deallocate();
Proceed();
}
else // isQuery
{
// No action required.
}
}
return(InstructionStreamBuilder.ToInstructionStream());
}
