/// <summary>
/// Creates a blank DB entry for the specified functor
/// </summary>
public PredicateInfo(Symbol functorName, int arity, KnowledgeBase kb)
{
Name = functorName;
Arity = arity;
Entries = new List<KnowledgeBaseEntry>();
KnowledgeBase = kb;
}
public static void DeclareOperator(int pri, Symbol type, Symbol op)
{
DeclareOperator(pri, Specifier(type.Name), op.Name);
}
/// <summary>
/// Thrown to signal that a predicate used as a goal does not appear in the database.
/// </summary>
public UndefinedPredicateException(Symbol functor, int arity)
: this(new PredicateIndicator(functor, arity))
{ }
public static IList<object> Arglist(Symbol functor)
{
return Implementations[functor].Arglist();
}
/// <summary>
/// Creates a new logic variable
/// </summary>
public LogicVariable(Symbol name)
{
Name = name;
UID = ++UIDCounter;
mValue = this;
}
PredicateInfo CheckForPredicateInfoInThisKB(Symbol functor, int arity)
{
return CheckForPredicateInfoInThisKB(new PredicateIndicator(functor, arity));
}
/// <summary>
/// Attempts to prove the specified goal.
/// </summary>
internal IEnumerable<CutState> Prove(Symbol functor, object[] args, PrologContext context, ushort parentFrame)
{
context.PushGoalStack(functor, args, parentFrame);
context.NewStep();
PrologPrimitives.PrimitiveImplementation prim;
if (PrologPrimitives.Implementations.TryGetValue(functor, out prim))
{
return CallPrimitive(functor, prim, args, context);
}
return ProveFromDB(functor, args, context);
}
internal static Structure PredicateIndicatorExpression(Symbol functor, int arity)
{
return new Structure(Symbol.Slash, functor, arity);
}
public static void PushIndexicalBinding(Symbol name, object value, PrologContext context)
{
context.IndexicalBindingStack.Add(new KeyValuePair<Symbol, object>(name, value));
}
private static Func<PrologContext, object> MakeLookup(Symbol name, object defaultValue)
{
return context =>
{
var bindingStack = context.IndexicalBindingStack;
for (int i=bindingStack.Count-1; i>=0; i--)
if (bindingStack[i].Key == name)
return bindingStack[i].Value;
return defaultValue;
};
}
private static void MakeUserBindableIndexical(Symbol name, object defaultValue)
{
if (!Term.IsGround(defaultValue))
throw new ArgumentException("Initial value of an indexical must be a ground term.");
// We do CopyInstantiation out of paranoia that there might be some variables buried in defaultValue
// that might get unbound in the future.
DeclareIndexical(name, MakeLookup(name, CopyInstantiation(defaultValue)));
}
public BadProcedureException(Symbol functor, int arity)
{
Procedure = new Structure(Symbol.Intern("/"), functor, arity);
}
public GoalStackFrame(Symbol functor, object[] args, ushort parentFrame)
{
this.Functor = functor;
this.Arguments = args;
this.Parent = parentFrame;
}
public void PushGoalStack(Symbol functor, object[] args, ushort parentFrame)
{
if (GoalStackDepth >= goalStack.Count)
{
goalStack.Add(new GoalStackFrame(functor, args, parentFrame));
goalStackCurrentRules.Add(null);
}
else
{
goalStack[GoalStackDepth] = new GoalStackFrame(functor, args, parentFrame);
goalStackCurrentRules[GoalStackDepth] = null;
}
GoalStackDepth++;
}
/// <summary>
/// Add a term (fact or rule) to the KB.
/// </summary>
public void Assert(Structure structure, bool atEnd, bool checkSingletons)
{
if (structure == null) throw new ArgumentNullException("structure", "Term to add to KB may not be null.");
//structure = structure.Expand();
if (structure == null) throw new ArgumentNullException("structure");
Structure head = structure.IsFunctor(Symbol.Implication, 2)
? Term.Structurify(structure.Argument(0),
"Head of :- must be a valid proposition or predicate.")
: structure;
if (head.IsFunctor(Symbol.ColonColon, 2))
{
var argument = head.Argument(0);
var kb = argument as KnowledgeBase;
if (kb == null)
{
var o = argument as GameObject;
if (o != null)
kb = o.KnowledgeBase();
else
{
var c = argument as Component;
if (c != null)
kb = c.KnowledgeBase();
else
throw new ArgumentTypeException(
"assert",
"knowledgebase",
argument,
typeof(KnowledgeBase));
}
}
if (structure.IsFunctor(Symbol.Implication, 2))
kb.Assert(
new Structure(Symbol.Implication, head.Argument(1), structure.Argument(1)),
atEnd,
checkSingletons);
else
{
kb.Assert(structure.Argument(1), atEnd, checkSingletons);
}
}
else
{
if (PrologPrimitives.Implementations.ContainsKey(head.Functor))
throw new PrologException(
new Structure(
"error",
new Structure(
"permission_error",
Symbol.Intern("modify"),
Symbol.Intern("static_procedure"),
Term.PredicateIndicatorExpression(head))));
KnowledgeBaseRule assertion = KnowledgeBaseRule.FromTerm(
structure,
checkSingletons,
Prolog.CurrentSourceFile,
Prolog.CurrentSourceLineNumber);
PredicateInfo info = EntryForStoring(head.PredicateIndicator);
PredicateInfo parentInfo;
if (!info.Shadow && this.Parent != null
&& (parentInfo = this.Parent.CheckForPredicateInfoInThisKB(head.PredicateIndicator)) != null
&& !parentInfo.External)
throw new PrologException(
new Structure(
"error",
new Structure(
"permission_error",
Symbol.Intern("shadow"),
Term.PredicateIndicatorExpression(head))));
info.Assert(assertion, atEnd);
}
}
static bool IsQuoteNeeded(Symbol s)
{
string name = s.Name;
if (Char.IsUpper(name[0]))
return true;
foreach (char ch in name)
if (Char.IsWhiteSpace(ch))
return true;
return false;
}
public static Indexical Find(Symbol name)
{
Indexical result;
return IndexicalTable.TryGetValue(name, out result) ? result : null;
}
// ReSharper disable once InconsistentNaming
IEnumerable<CutState> ProveFromDB(Symbol functor, object[] args, PrologContext context)
{
PredicateInfo info = GetPredicateInfo(this, new PredicateIndicator(functor, args.Length));
if (info == null)
{
if (ErrorOnUndefined)
throw new UndefinedPredicateException(functor, args.Length);
return PrologPrimitives.FailImplementation;
}
return info.Prove(args, context);
}
public static void DeclareIndexical(Symbol name, Func<PrologContext, object> valueFunc)
{
IndexicalTable[name] = new Indexical(name, valueFunc);
}
IEnumerable<CutState> CallPrimitive(Symbol functor, PrologPrimitives.PrimitiveImplementation handler, object[] args, PrologContext context)
{
if (Trace)
context.TraceOutput("Goal: {0}", new Structure(functor, args));
foreach (var state in handler(args, context))
{
if (Trace)
context.TraceOutput((state == CutState.Continue) ? "Succeed: {0}" : "Cut: {0}", new Structure(functor, args));
yield return state;
if (Trace)
context.TraceOutput("Retry: {0}", new Structure(functor, args));
}
if (Trace)
context.TraceOutput("Fail: {0}", new Structure(functor, args));
context.PopGoalStack();
}
private Indexical(Symbol name, Func<PrologContext, object> valueFunc)
{
this.Name = name;
this.valueFunc = valueFunc;
}
public Parser(params object[] arg)
{
parser_arg = arg;
symbol = new Symbol(this);
strStartChar = '\u0027';
strStartCharAlt = '\u0022';
streamInPrefix = "";
streamInPreLen = 0;
}
private void WarnUndefined(KnowledgeBaseRule rule,Symbol functor,int arity)
{
rule.PrintWarning("{0}/{1} undefined", functor, arity);
}
private static void DefinePrimitive(Symbol name, PrimitiveImplementation implementationDelegate,
string manualSections, string docstring, params object[] arglist)
{
Implementations[name] = implementationDelegate;
if (arglist.Length > 0 && (arglist[arglist.Length - 1] as string) == "...")
{
MinimumArity[name] = arglist.Length - 2;
MaximumArity[name] = int.MaxValue;
}
else
{
MinimumArity[name] = MaximumArity[name] = arglist.Length;
for (var i = arglist.Length - 1; i >= 0; i--)
{
if (!((string)(arglist[i])).StartsWith("["))
{
// This is a non-optional parameter
MinimumArity[name] = i + 1;
break;
}
}
}
DelegateUtils.NameProcedure(implementationDelegate, name.Name);
Manual.AddToSections(manualSections, implementationDelegate);
for (int i = 0; i < arglist.Length; i++)
if (arglist[i] is string)
arglist[i] = Symbol.Intern((string) arglist[i]);
DelegateUtils.Arglists[implementationDelegate] = arglist;
DelegateUtils.Docstrings[implementationDelegate] = docstring;
}
/// <summary>
/// Adds assertion to GAMEOBJECT's knowledgebase.
/// </summary>
/// <param name="gameObject">Object whose knowledge base it should be added to</param>
/// <param name="functor">Functor (i.e. predicate) of the assertion</param>
/// <param name="args">Arguments to the functor</param>
public static void Assert(this GameObject gameObject, Symbol functor, params object[] args)
{
gameObject.KnowledgeBase().AssertZ(new Structure(functor, args));
}
// ReSharper restore InconsistentNaming
private static IEnumerable<CutState> MapListInternal(Symbol functor, object[] args, object list1, object list2,
PrologContext context)
{
// maplist(_, [], []).
// ReSharper disable UnusedVariable
#pragma warning disable 414, 168, 219
foreach (var ignore in Term.Unify(null, list1))
foreach (var ignore2 in Term.Unify(null, list2))
#pragma warning restore 414, 168, 219
// ReSharper restore UnusedVariable
yield return CutState.Continue;
// maplist(P, [X | XT], [Y | YT]) :- call(P, X, Y), maplist(P, XT, YT).
var x = new LogicVariable(SX);
var xT = new LogicVariable(SXt);
var y = new LogicVariable(SY);
var yT = new LogicVariable(SYt);
// ReSharper disable UnusedVariable
#pragma warning disable 414, 168, 219
foreach (var ignore in Term.Unify(list1, new Structure(Symbol.PrologListConstructor, x, xT)))
foreach (var ignore2 in Term.Unify(list2, new Structure(Symbol.PrologListConstructor, y, yT)))
#pragma warning restore 414, 168, 219
{
// call(P, X, Y)
var realArgs = new object[args.Length + 2];
args.CopyTo(realArgs, 0);
realArgs[realArgs.Length - 2] = x;
realArgs[realArgs.Length - 1] = y;
#pragma warning disable 414, 168, 219
foreach (
var ignore3 in context.KnowledgeBase.Prove(functor, realArgs, context, context.CurrentFrame))
// maplist(P, XT, YT)
foreach (var ignore4 in MapListInternal(functor, args, xT, yT, context))
#pragma warning restore 414, 168, 219
// ReSharper restore UnusedVariable
yield return CutState.Continue;
}
}
/// <summary>
/// Adds assertion to component's knowledgebase.
/// </summary>
/// <param name="component">Object whose knowledge base it should be added to</param>
/// <param name="functor">Functor (i.e. predicate) of the assertion</param>
/// <param name="args">Arguments to the functor</param>
public static void Assert(this Component component, Symbol functor, params object[] args)
{
component.KnowledgeBase().AssertZ(new Structure(functor, args));
}
public CSVParser(Symbol functor, char delimiter, PositionTrackingTextReader reader)
{
this.functor = functor;
this.delimiter = delimiter;
this.reader = reader;
}
public PredicateIndicator(Symbol functor, int arity)
{
this.Functor = functor;
this.Arity = arity;
}
static object ResolveNamedValue(Symbol nameSymbol)
{
if (nameSymbol == Symbol.Global)
return KnowledgeBase.Global;
return Indexical.Find(nameSymbol) ?? ResolveNamedString(nameSymbol.Name);
}
PredicateInfo CheckForPredicateInfoInThisKB(Symbol functor, int arity)
{
return CheckForPredicateInfoInThisKB(new PredicateIndicator(functor, arity));
}
