public PartListImpl ParseBody(Tokeniser tk, string mt)
{
// Body -> Term {, Term...}
PartListImpl p = new PartListImpl();
var i = 0;
Term t;
while ((t = (Term)ParseTerm(tk, mt)) != null)
{
p.AddPart(t);
i++;
if (tk.current != ",")
{
break;
}
tk.consume();
}
if (i == 0)
{
return(null);
}
return(p);
}
public Term(string head, bool isVar, PartListImpl a0N)
{
_name = head;
headIsVar = isVar;
partlist0 = a0N;
var isVarName = IsVarName(head);
if (a0N == null)
{
throw ErrorBadOp("Term Arglist NULL: {0}", head);
}
if (isVar)
{
if (!isVarName)
{
throw ErrorBadOp("Pred was supposed to be variable: {0}", this);
}
}
else
{
if (isVarName)
{
throw ErrorBadOp("Pred was NOT supposed to be variable: {0}", this);
}
}
if (a0N.Arity > 0)
{
Part a0 = a0N.ArgList[0];
if (a0 is PartListImpl)
{
Warn("Poorly constructed term: {0}", this);
}
}
a0N.TParent = this;
}
public ProveResult TripleQuery(Term thisTerm, PartListImpl goalList, PEnv environment, PDB db, int level, reportDelegate reportFunction)
{
// bagof(Term, ConditionTerm, ReturnList)
// PartList goalList = (PartList)goalIn;
Part collect0 = value((Part)thisTerm.ArgList[0], environment);
Part subgoal = value((Part)thisTerm.ArgList[1], environment);
Part into = value((Part)thisTerm.ArgList[2], environment);
Part collect = renameVariables(collect0, level, thisTerm);
//var newGoal = new Term(subgoal.name, renameVariables(subgoal.ArgList, level, thisTerm));
Term newGoal = new Term(subgoal.fname, false,
(PartListImpl)renameVariables(((PartListImpl)subgoal), level, thisTerm));
newGoal.parent = thisTerm;
//var newGoals = [];
//newGoals[0] = newGoal;
PartListImpl newGoals = new PartListImpl();
newGoals.AddPart(newGoal);
// Prove this subgoal, collecting up the environments...
PartListImpl anslist = new PartListImpl();
anslist.renumber = -1;
var ret = prove(newGoals, environment, db, level + 1, BagOfCollectFunction(collect, anslist));
// Turn anslist into a proper list and unify with 'into'
// optional here: nil anslist -> fail?
Part answers = Atom.FromSource(FUNCTOR_NIL);
/*
* print("Debug: anslist = [");
* for (var j = 0; j < anslist.length; j++) {
* anslist[j].print();
* print(", ");
* }
* print("]\n");
*/
for (int i = anslist.Arity; i > 0; i--)
{
answers = MakeList(anslist.ArgList[i - 1], answers);
}
//print("Debug: unifying "); into.print(); print(" with "); answers.print(); print("\n");
var env2 = unify(into, answers, environment);
if (env2 == null)
{
//print("Debug: bagof cannot unify anslist with "); into.print(); print(", failing\n");
return(null);
}
// Just prove the rest of the goallist, recursively.
return(prove(goalList, env2, db, level + 1, reportFunction));
}
public PartListImpl(PartListImpl head, PEnv env)
{
this.tlist = new List <Part>();
for (var i = 0; i < head.Count; i++)
{
tlist.Add(value(head[i], env));
}
}
public static Term RuleToTerm(Part head, PartListImpl rulebody)
{
if (IsBodyAlwaysTrue(rulebody))
{
return(head.AsTerm());
}
return(MakeTerm(":-", head, RuleBodyToTerm(rulebody)));
}
public ProveResult ExecuteSharp(Term thisTerm, PartListImpl goalList, PEnv environment, PDB db, int level,
reportDelegate reportFunction)
{
Term collect0 = value((Part)thisTerm.ArgList[1], environment).AsTerm();
string methodName = collect0.fname;
var partObj = value((Part)thisTerm.ArgList[0], environment);
object result;
TextWriter warns = new StringWriter();
try
{
if (partObj.IsObject)
{
if (!CanInvokeObject(partObj.Functor0, methodName, collect0.ArgList, out result, warns))
{
Warn(warns);
return(new ProveResult()
{
Failed = true
});
}
}
else
{
if (!CanInvokeObjectByName(partObj.Text, methodName, collect0.ArgList, true, out result, warns))
{
Warn(warns);
return(new ProveResult()
{
Failed = true
});
}
}
}
catch (Exception e2)
{
Warn(warns);
throw e2;
return(new ProveResult()
{
Failed = true
});
}
//print("Debug: unifying "); into.print(); print(" with "); answers.print(); print("\n");
var env2 = unify(thisTerm.ArgList[2], ObjectToPart(result), environment);
if (env2 == null)
{
//print("Debug: bagof cannot unify anslist with "); into.print(); print(", failing\n");
return(null);
}
// Just prove the rest of the goallist, recursively.
return(prove(goalList, env2, db, level + 1, reportFunction));
}
public static Term RuleBodyToTerm(PartListImpl rulebody)
{
if (IsBodyAlwaysTrue(rulebody))
{
return(TERM_TRUE);
}
if (rulebody.Count == 1)
{
return(rulebody[0].AsTerm());
}
return(new Term(",", false, rulebody));
}
public Rule(Term head, PartListImpl bodylist)
: this(head)
{
if (bodylist != null)
{
this.body = new Body(bodylist);
body.parent = this;
}
else
{
this.body = null;
}
}
public Rule TripleToRule(Triple triple, IGraph listResolves, bool keepOriginalGraphUri)
{
var s = triple.Subject;
var p = triple.Predicate;
var o = triple.Object;
string sp = triple.Predicate.ToString();
if (!GlobalSharedSettings.TODO1Completed)
{
//RdfRules rules = new RdfRules(rdfGraph);
Term t = MakeTerm(TripleName, Atom.MakeNodeAtom(s), Atom.MakeNodeAtom(p), Atom.MakeNodeAtom(o));
var rule = new Rule(t);
//rule.rdfRuleCache = rules;
return(rule);
}
var pp = Atom.MakeNodeAtom(p);
if (sp == RdfSpecsHelper.RdfListFirst || sp == RdfSpecsHelper.RdfListRest)
{
var rule =
new Rule(new Term(pp.fname, false, new PartListImpl(Atom.MakeNodeAtom(s), Atom.MakeNodeAtom(o))));
return(rule);
}
int argNum = GraphWithDef.GetInstanceOnArg(sp);
if (argNum == -1)
{
// assume it's one to one?
argNum = 0;
}
if (argNum != 0)
{
//1: [a f (b c)]
//2: [b f (a c)]
//3: [c f (a b)]
PartListImpl parts = new PartListImpl();
AddRdfList(parts, o, argNum, s, triple, listResolves);
var rule = new Rule(new Term(pp.fname, false, parts));
return(rule);
}
// pred + args are in the list [db1 f (a b c)]
if (argNum == 0)
{
PartListImpl parts = new PartListImpl();
AddRdfList(parts, o, -1, null, triple, listResolves);
var rule = new Rule(new Term(pp.fname, false, parts));
return(rule);
}
return(null);
}
public Rule ParseRule(Tokeniser tk, string mt)
{
// A rule is a Head followed by . or by :- Body
var p = ParseHead(tk, mt);
if (p == null)
{
prolog_reader_debug("cant parse Rule head: " + tk);
return(null);
}
Term h = p as Term;
if (h == null)
{
if (!(p is Atom))
{
prolog_reader_debug("didn't parse Rule head as atom or term: " + tk);
// return null;
}
h = p.AsTerm();
}
if (tk.current == ".")
{
// A simple rule.
tk.consume();
return(new Rule(h));
}
if (tk.current != ":-")
{
prolog_reader_debug("Rule neck missing: " + tk);
return(null);
}
tk.consume();
PartListImpl b = ParseBody(tk, mt);
if (b == null)
{
prolog_reader_debug("Rule body not present: " + tk);
return(null);
}
if (tk.current == "." || tk.current == "eof")
{
tk.consume();
return(new Rule(h, b));
}
prolog_reader_debug("Rule body not terminated: " + tk);
return(null);
}
public override string ToSource(SourceLanguage language)
{
language = language.Inner();
string result = "";
if (IsListName(this.fname) && Arity == 2)
{
Part x = this;
{
result += "[";
var com = false;
while (IsList(x))
{
if (com)
{
result += ", ";
}
result += x.ArgList[0].ToSource(language); // May need to case var/atom/term
com = true;
x = x.ArgList[1];
}
if (x.ToSource(SourceLanguage.Prolog) != "[]")
{
result += " | ";
result += x.ToSource(language);
}
result += "]";
return(result);
}
}
if (Arity == 0)
{
if (fname == "cut")
{
return("!");
}
return(ReadableName);
}
PartListImpl argList = this.ArgList;
if (argList == null)
{
return(result + "()");
}
result += "" + ReadableName + "(";
result += argList.ToSource(language);
result += ")";
return(result);
}
static public PartListImpl ParseConjuncts(Tokeniser tk, string mt, string requiredEnd, string sep, bool eofReturnsPart)
{
// Body -> Term {, Term...}
PartListImpl p = new PartListImpl();
var i = 0;
while (true)
{
if (tk.current == requiredEnd)
{
tk.consume();
break;
}
if (tk.current == "eof")
{
if (!eofReturnsPart)
{
prolog_reader_debug("read EOF " + tk);
return(null);
}
break;
}
if (tk.current == sep)
{
tk.consume();
continue;
}
Part t = ParsePart(tk, mt);
if (t == null)
{
prolog_reader_debug("cant read Conjuct item " + tk);
return(null);
}
p.AddPart(t);
i++;
}
if (i == 0)
{
prolog_reader_debug("no items read " + tk);
return(null);
}
return(p);
}
// Aux function: return the reportFunction to use with a bagof subgoal
public reportDelegate IstQueryCollectFunction(Part collect, PartListImpl anslist)
{
return(delegate(PEnv env)
{
/*
* print("DEBUG: solution in bagof/3 found...\n");
* print("Value of collection term ");
* collect.print();
* print(" in this environment = ");
* (value(collect, env)).print();
* print("\n");
* printEnv(env);
*/
// Rename this appropriately and throw it into anslist
anslist.AddPart(renameVariables(value(collect, env), anslist.renumber--, null));
return true;
});
}
public static bool AddRdfList(PartListImpl parts, INode node, int argNum, INode obj, Triple triple,
IGraph listResolves)
{
if (parts.Count + 1 == argNum)
{
bool a = AddRdfList(parts, obj, -1, null, triple, listResolves);
bool b = AddRdfList(parts, node, -1, null, triple, listResolves);
return(a && b);
}
switch (node.NodeType)
{
case NodeType.Uri:
case NodeType.Literal:
parts.AddPart(Atom.MakeNodeAtom(node));
return(true);
case NodeType.Variable:
parts.AddPart(new Variable(node.ToString().Substring(1)));
return(true);
case NodeType.Blank:
{
INode f, r;
if (GetRdfList(node, listResolves, out f, out r, triple))
{
bool a = AddRdfList(parts, f, argNum, obj, triple, listResolves);
bool b = AddRdfList(parts, r, argNum, obj, triple, listResolves);
return(a && b);
}
}
parts.AddPart(Atom.MakeNodeAtom(node));
return(foundNodeMoreThanTriple(listResolves, node, triple));
// case NodeType.GraphLiteral:
// break;
default:
Warn("cant intern " + node);
return(false);
throw new ArgumentOutOfRangeException();
}
}
static public Part MakeTermPostReader(String f, bool isHeadVar, PartListImpl partlist)
{
if (partlist.Arity == 0)
{
if (isHeadVar)
{
return(new Variable(f));
}
return(Atom.FromName(f));
}
if (f == "$obj")
{
Part partlist1 = partlist[0];
if (partlist1.fname == "$literal")
{
return(Atom.MakeLiteral(partlist[1].AsString(), partlist[2].AsString(), partlist[3].AsString()));
}
Warn("Not sure how to create a " + partlist);
}
return(new Term(f, isHeadVar, partlist));
}
public Body(PartListImpl l)
{
plist = l;
plist.parent = this;
}
public static bool IsBodyAlwaysTrue(PartListImpl rulebody)
{
return(rulebody == null || rulebody.Count == 0 ||
(rulebody.Count == 1 && TERM_TRUE.Equals(rulebody[0])));
}
// This was a beautiful piece of code. It got kludged to add [a,b,c|Z] sugar.
static public Part ParsePart(Tokeniser tk, string mt)
{
// string mt = threadLocal.curKB;
// Part -> var | id | id(optParamList)
// Part -> [ listBit ] ::-> cons(...)
if (tk.type == "punc" && tk.current == "[")
{
// Parse a list (syntactic sugar goes here)
tk.consume();
// Special case: [] = Atom.Make(nil).
if (tk.type == "punc" && tk.current == "]")
{
tk.consume();
return(Atom.FromSource(FUNCTOR_NIL));
}
// Get a list of parts into l
ArrayList l = new ArrayList();
int i = 0;
while (true)
{
var t = ParsePart(tk, mt);
if (t == null)
{
prolog_reader_debug("cant parse List Part " + tk);
return(null);
}
l.Insert(i++, t);
if (tk.current != ",")
{
break;
}
tk.consume();
}
// Find the end of the list ... "| Var ]" or "]".
Part append;
if (tk.current == "|")
{
tk.consume();
append = ParsePart(tk, mt);
}
else
{
append = Atom.FromSource(FUNCTOR_NIL);
}
if (tk.current != "]")
{
prolog_reader_debug("Unclosed List " + tk);
return(null);
}
tk.consume();
// Return the new cons.... of all this rubbish.
for (--i; i >= 0; i--)
{
append = MakeList((Part)l[i], append);
}
return(append);
}
var notthis = false;
if (tk.current == "NOTTHIS")
{
notthis = true;
tk.consume();
}
var type = tk.type;
var name = tk.current;
var quotingType = tk.typeSyntax;
tk.consume();
if (quotingType == SYNTAX_DoubleQuotes)
{
return(Atom.FromSourceReader(name, quotingType));
}
// fail shorthand for fail(), ie, fail/0
if (type == "id" && name == "fail")
{
return(MakeTerm("fail"));
}
// Parse ! as cut/0
if (type == "punc" && name == "!")
{
return(MakeTerm("cut"));
}
// Parse [id|var](ParamList)
if (tk.current == "(")
{
tk.consume();
PartListImpl p = ParseConjuncts(tk, mt, ")", ",", false);
if (p == null)
{
prolog_reader_debug("cant read termargs " + tk);
return(null);
}
Part term = MakeTermPostReader(name, type == "var", p);
if (term is Term)
{
if (notthis)
{
((Term)term).excludeThis = true;
}
}
return(term);
}
if (type == "var")
{
return(new Variable(name));
}
return(Atom.FromSourceReader(name, quotingType));
}
