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