public static Deref ( object value ) : object | ||
value | object | |
return | object |
public static object EvalMemberExpression(object obj, object memberExpression, PrologContext context) { obj = Eval(obj, context); memberExpression = Term.Deref(memberExpression); var methodCall = memberExpression as Structure; if (methodCall != null) { // Method call var args = new object[methodCall.Arity]; for (var i = 0; i < args.Length; i++) { args[i] = Eval(methodCall.Argument(i), context); } return(obj.InvokeMethod(methodCall.Functor.Name, args)); } var propName = memberExpression as Symbol; if (propName != null) { // Field or property reference return(obj.GetPropertyOrField(propName.Name)); } throw new ArgumentException( "Invalid member expression: " + ISOPrologWriter.WriteToString(new Structure(Symbol.Dot, obj, memberExpression))); }
/// <summary> /// Count references to variables in ARG /// </summary> private void CountVariableReferences(object arg, bool isHead, byte argRegister) { arg = Term.Deref(arg); if (arg is LogicVariable) { var l = arg as LogicVariable; if (isHead) { VariableInfo variableInfo = env[l]; if (argRegister != NoRegister && variableInfo.register == NoRegister) { variableInfo.register = argRegister; variableInfo.LockInRegister = true; } env.MarkHeadReference(l); } else { env.MarkBodyReference(l); } } else { var structure = arg as Structure; if (structure != null) { foreach (var structureArg in structure.Arguments) { this.CountVariableReferences(structureArg, isHead, NoRegister); } } } }
private void WalkGoal(KnowledgeBase kb, KnowledgeBaseRule rule, object goal) { goal = Term.Deref(goal); var atom = goal as Symbol; if (atom != null) { var p = new PredicateIndicator(atom, 0); if (PrologPrimitives.IsDefined(p)) { return; } var predicate = kb.CheckForPredicateInfo(p); if (predicate == null) { rule.PrintWarning("undefined predicate {0}", p); } else { MarkReferenced(predicate); } } else { var s = goal as Structure; if (s != null) { WalkGoal(kb, rule, s); } else if (!(goal is LogicVariable) && !(goal is bool)) { rule.PrintWarning("malformed goal: {0}", goal); } } }
public static int PrologListLength(object prologList) { object current = Term.Deref(prologList); int index = 0; while (current != null) { var t = current as Structure; if (t == null) { if (current is LogicVariable) { throw new ArgumentException("List is incomplete (i.e. it ends in a logic variable).", "prologList"); } throw new ArgumentException("Argument is not a valid Prolog list", "prologList"); } if (t.IsFunctor(Symbol.PrologListConstructor, 2)) { index++; current = t.Argument(1); } else { throw new ArgumentException("Argument is not a valid Prolog list", "prologList"); } } return(index); }
public static object PrologListElement(object prologList, int index) { object current = Term.Deref(prologList); while (current != null) { var t = current as Structure; if (t == null) { if (current is LogicVariable) { throw new ArgumentException("List is incomplete (i.e. it ends in a logic variable).", "prologList"); } throw new ArgumentException("Argument is not a valid Prolog list", "prologList"); } if (t.IsFunctor(Symbol.PrologListConstructor, 2)) { if (index-- == 0) { // Done. return(t.Argument(0)); } current = t.Argument(1); } else { throw new ArgumentException("Argument is not a valid Prolog list", "prologList"); } } // Hit the end of the list throw new IndexOutOfRangeException(); }
public PredicateArgumentIndexer(object argument) { argument = Term.Deref(argument); if (argument == null) { this.Type = IndexerType.Null; this.Functor = null; this.Arity = 0; } else { if (argument is LogicVariable || argument is Indexical) { this.Type = IndexerType.Variable; this.Functor = null; this.Arity = 0; } else { var s = argument as Structure; if (s != null) { this.Type = IndexerType.Structure; this.Functor = s.Functor; this.Arity = (byte)s.Arity; } else { this.Type = IndexerType.Atom; this.Functor = argument; this.Arity = 0; } } } }
public static bool TryQuery(object term, PrologContext context, out ELNode foundNode, out ELNodeEnumerator enumerator) { // Dereference any top-level variables. var t = Term.Deref(term); // Dereference indexicals var i = t as Indexical; if (i != null) t = i.GetValue(context); // A game object means the gameobject's EL KB. var g = t as GameObject; if (g != null) t = g.KnowledgeBase().ELRoot; // If it's already an ELNode, use that. var n = t as ELNode; if (n != null) { foundNode = n; enumerator = null; return true; } // Otherwise, it's an expression, so evaluate it. var s = t as Structure; if (s != null) return TryQueryStructure(s, context, out foundNode, out enumerator); var v = t as LogicVariable; if (v != null && !v.IsBound) throw new Exception("EL query root is an unbound variable: " + v); throw new Exception("Malformed EL query: " + ISOPrologWriter.WriteToString(term)); }
// // these write a single nodes, so they don't need to loop like queries do. // /// <summary> /// Write TERM to EL KB, creating any nodes that need to be cerated. /// </summary> /// <param name="term">Prolog-format term to store into KB</param> /// <param name="knowledgeBase">KB in which to assert the term.</param> /// <returns></returns> public static ELNode Update(object term, KnowledgeBase knowledgeBase) { term = Term.Deref(term); var s = term as Structure; if (s != null) return UpdateStructure(s, knowledgeBase); var n = term as ELNode; if (n != null) return n; throw new Exception("Malformed EL assertion: " + ISOPrologWriter.WriteToString(term)); }
public static PredicateIndicator FromExpression(object expression) { var s = Term.Deref(expression) as Structure; if (s == null || (!s.IsFunctor(Symbol.Slash, 2) && !s.IsFunctor(Symbol.SlashSlash, 2)) || !(s.Argument(0) is Symbol) || !(s.Argument(1) is int)) { throw new ArgumentException("Predicate indicator should be of the form functor/arity, but got " + ISOPrologWriter.WriteToString(expression)); } return(new PredicateIndicator((Symbol)s.Argument(0), (int)s.Argument(1))); }
private void CompileMatcher(byte register, byte argument, object obj) { obj = Term.Deref(obj); var lv = obj as LogicVariable; if (lv != null) { var info = env[lv]; if (register != NoRegister || info.register != argument) // If top level and first occurance, don't bother. { env.InsureAllocated(info); if (info.AlreadyStored) { Emit(Opcode.MatchVar, info.register); } else { Emit(Opcode.MatchVarFirst, SymbolTable.IndexOf(lv.Name), info.register); } EmitOperand(register, argument); } env.OneUseCompiled(info); } else { var structure = obj as Structure; if (structure != null) { Structure s = structure; byte destinationRegister = (register == NoRegister)?argument:this.env.GetRegister(); this.Emit(Opcode.MatchStructure, SymbolTable.IndexOf(s.Functor), (byte)s.Arity); ushort backPatchAddress = this.CurrentPC; this.EmitUShort(0); this.EmitOperand(register, argument, destinationRegister); for (byte i = 0; i < s.Arity; i++) { this.CompileMatcher(destinationRegister, i, s.Argument(i)); } this.BackPatch(backPatchAddress, this.CurrentPC); if (register != NoRegister) { this.env.FreeRegister(destinationRegister); } } else { this.Emit(Opcode.MatchLiteral, GlobalLiteralTable.IndexOf(obj)); this.EmitOperand(register, argument); } } }
public static IEnumerable PrologListItems(object prologList) { object current = Term.Deref(prologList); while (current != null) { var t = current as Structure; if (t == null) { throw new ArgumentException("List is not a proper list; it ends with: " + current); } yield return(t.Argument(0)); current = t.Argument(1); } }
public static List <object> PrologListToIList(object prologList) { object current = Term.Deref(prologList); var schemeList = new List <object>(PrologListLength(prologList)); while (current != null) { var t = current as Structure; if (t == null) { throw new ArgumentException("List is not a proper list; it ends with: " + current); } schemeList.Add(t.Argument(0)); current = t.Argument(1); } return(schemeList); }
public static object[] PrologListToArray(object prologList) { object current = Term.Deref(prologList); var array = new object[PrologListLength(prologList)]; int index = 0; while (current != null) { var t = current as Structure; if (t == null) { throw new ArgumentException("List is not a proper list; it ends with: " + current); } array[index++] = t.Argument(0); current = t.Argument(1); } return(array); }
private object DecodeOperand(PrologContext context, int framePointer, ref ushort pc) { int registerNumber = code[pc++]; object value = Term.Deref(context.GetStack(framePointer, registerNumber & 0x7f)); if (registerNumber < 0x80) { return(value); } int argNumber = code[pc++]; value = ((Structure)value).Argument(argNumber & 0x7f); if (argNumber >= 0x80) { context.SetStack(framePointer, code[pc++], value); } return(value); }
private void SetOperand(PrologContext context, int framePointer, ref ushort pc, object newValue) { int registerNumber = code[pc++]; if (registerNumber < 0x80) { context.SetStack(framePointer, registerNumber, newValue); } else { object s = Term.Deref(context.GetStack(framePointer, registerNumber & 0x7f)); int argNumber = code[pc++]; object value = ((Structure)s).Arguments[argNumber & 0x7f] = newValue; if (argNumber >= 0x80) { context.SetStack(framePointer, code[pc++], value); } } }
internal static IEnumerable <CutState> SetImplementation(object[] args, PrologContext context) { if (args.Length != 2) { throw new ArgumentCountException("set", args, new object[] { "Variable", "NewValue" }); } object value = Term.CopyInstantiation(args[1]); if (value is LogicVariable) { throw new UninstantiatedVariableException((LogicVariable)args[1], "Value argument should be a data object, not an uninstantiated (unbound) variable."); } var functor = Term.Deref(args[0]) as Symbol; if (functor == null) { throw new ArgumentTypeException("set", "functor", args[0], typeof(Symbol)); } List <KnowledgeBaseEntry> entries = context.KnowledgeBase.EntryListForStoring(new PredicateIndicator(functor, 1)); switch (entries.Count) { case 0: entries.Add(new KnowledgeBaseVariable(value)); return(CutStateSequencer.Succeed()); case 1: var v = entries[0] as KnowledgeBaseVariable; if (v == null) { throw new ArgumentException("Functor is not a variable; it has another entry defined for it."); } v.CurrentValue = value; return(CutStateSequencer.Succeed()); default: throw new ArgumentException("Functor is not a variable; it has multiple entries defined for it."); } }
private void FUNCTIONAL(Structure tp, string termname, int options) { if ((options & NUMBERVARS) != 0 && USDVAR(termname) && __ARITY(tp) == 1) { int varno; Object tp2; tp2 = __LASTARG(tp, 1); tp2 = Term.Deref(tp2); if (tp2 is int) { varno = (int)tp2; if (lastitem == IDENTIFIER_ITEM) { PUTCHAR(' '); } PUTCHAR((char)(varno % 26 + 'A')); if ((varno = varno / 26) != 0) { LowLevelWrite(varno); } lastitem = IDENTIFIER_ITEM; return; } } showname(termname, options); PUTSOLO('('); for (int i = 1; i < __ARITY(tp); i++) { recwriteterm(__ARG(tp, i), options, 1000, 1201); PUTSOLO(','); } if (__ARITY(tp) > 0) { recwriteterm(__LASTARG(tp, __ARITY(tp)), options, 1000, 1201); } PUTSOLO(')'); }
private void recwriteterm(Object tp, int options, int termpri, int atompri) /* * recursive writeterm routine */ { int prepri, inpri, postpri, spec; tp = Term.Deref(tp); if (tp == null) { LowLevelWrite(tp); return; } if (tp is int) { int intval = (int)tp; if (intval < 0) { if (lastitem == GRAPHIC_ITEM) { PUTCHAR(' '); } PUTCHAR('-'); intval = -intval; } else { if (lastitem == NUMERIC_ITEM || lastitem == IDENTIFIER_ITEM) { PUTCHAR(' '); } } LowLevelWrite(intval); lastitem = NUMERIC_ITEM; } else { var symbol = tp as Symbol; if (symbol != null) { bool brackets = false; string atomname = symbol.Name; if (atompri == 1201) { this.showname(atomname, options); } else { if (ISOPrologReader.Operator(atomname, out prepri, out inpri, out postpri, out spec)) { if (prepri >= atompri) { brackets = true; } if (inpri >= atompri) { brackets = true; } if (postpri >= atompri) { brackets = true; } if (ISOPrologReader.comma_char(atomname[0]) && atomname.Length == 1) { brackets = true; } } if (brackets) { this.PUTSOLO('('); } this.showname(atomname, options); if (brackets) { this.PUTSOLO(')'); } } } else if (tp is float) { float ff = (float)tp; if (ff < 0.0) { if (this.lastitem == GRAPHIC_ITEM) { this.PUTCHAR(' '); } } else { if (this.lastitem == NUMERIC_ITEM || this.lastitem == IDENTIFIER_ITEM) { this.PUTCHAR(' '); } } this.LowLevelWrite(ff); this.lastitem = NUMERIC_ITEM; } else if (tp is Structure) { Structure str = tp as Structure; string termname = str.Functor.Name; int termarity = str.Arguments.Length; if ((options & IGNORE_OPS) != 0 || termarity > 2) { this.FUNCTIONAL(str, termname, options); } else /* operator definitions are now in effect */ if (termarity == 2) { if (str.Functor == Symbol.PrologListConstructor) { /* list constructor */ bool first = true; this.PUTSOLO('['); do { if (first) { first = false; } else { this.PUTSOLO(','); } this.recwriteterm(__ARG(str, 1), options, 1000, 1201); tp = __LASTARG(str, 2); tp = Term.Deref(tp); str = tp as Structure; } while (str != null && str.Functor == Symbol.PrologListConstructor); if (!(tp is Symbol) && tp != null) { this.PUTSOLO('|'); this.recwriteterm(tp, options, 1000, 1201); } this.PUTSOLO(']'); } else if (ISOPrologReader.Operator(termname, out prepri, out inpri, out postpri, out spec) && ISOPrologReader.isinfix(spec) && (inpri != 0)) { if (inpri >= termpri || (options & WLTERM) != 0 && ISOPrologReader.isxfy(spec) && inpri + 1 == termpri) { this.PUTSOLO('('); } if (ISOPrologReader.isyfx(spec)) { this.recwriteterm(__ARG(str, 1), options | WLTERM, inpri + 1, 0); } else { this.recwriteterm(__ARG(str, 1), options & OPTIONMASK, inpri, 0); } if (str.Functor == Symbol.Comma) { this.PUTSOLO(','); } else { this.showname(termname, options); } this.recwriteterm(__LASTARG(str, 2), options, ISOPrologReader.isxfy(spec) ? inpri + 1 : inpri, 0); if (inpri >= termpri || (options & WLTERM) != 0 && ISOPrologReader.isxfy(spec) && inpri + 1 == termpri) { this.PUTSOLO(')'); } } else { this.FUNCTIONAL(str, termname, options); } } else if (termarity == 1) { if (ISOPrologReader.Operator(termname, out prepri, out inpri, out postpri, out spec)) { if (ISOPrologReader.isprefix(spec) && ISOPrologReader.ispostfix(spec)) { /* in case of ambiguity: * select the associative operator over the nonassociative * select prefix over postfix */ if (ISOPrologReader.isfy(spec)) { spec = ISOPrologReader.FY; } else if (ISOPrologReader.isyf(spec)) { spec = ISOPrologReader.YF; } else { spec = ISOPrologReader.FX; } } if (ISOPrologReader.isprefix(spec) && prepri != 0) { if (prepri >= termpri || (options & WLTERM) != 0 && ISOPrologReader.isfy(spec) && prepri + 1 == termpri) { this.PUTSOLO('('); } this.showname(termname, options); if (needspace(tp, ISOPrologReader.isfy(spec) ? prepri + 1 : prepri)) { this.PUTSOLO(' '); } this.recwriteterm(__LASTARG(str, 1), options, ISOPrologReader.isfy(spec) ? prepri + 1 : prepri, 0); if (prepri >= termpri || (options & WLTERM) != 0 && ISOPrologReader.isfy(spec) && prepri + 1 == termpri) { this.PUTSOLO(')'); } } else if (ISOPrologReader.ispostfix(spec) && postpri != 0) { if (postpri >= termpri) { this.PUTSOLO('('); } if (ISOPrologReader.isyf(spec)) { this.recwriteterm(__LASTARG(str, 1), options | WLTERM, postpri + 1, 0); } else { this.recwriteterm(__LASTARG(str, 1), options, postpri, 0); } this.showname(termname, options); if (postpri >= termpri) { this.PUTSOLO(')'); } } else { this.FUNCTIONAL(str, termname, options); } } else if (str.Functor == Symbol.CurlyBrackets) { /* curly brackets */ this.PUTSOLO('{'); this.recwriteterm(__LASTARG(str, 1), options, 1201, 1201); this.PUTSOLO('}'); } else { this.FUNCTIONAL(str, termname, options); } } else { this.FUNCTIONAL(str, termname, options); } } else { var variable = tp as LogicVariable; if (variable != null) { if (this.lastitem == IDENTIFIER_ITEM) { this.PUTCHAR(' '); } this.LowLevelWrite(variable); this.lastitem = IDENTIFIER_ITEM; /* same properties as variable */ } else { this.LowLevelWrite(tp); } } } }
private static bool needspace(Object tp, int termpri) /* * checks whether the term tp will be displayed between * brackets, given the priority level termpri. In that * case a space need to be inserted before the left bracket. */ { int prepri, inpri, postpri, spec; if (tp == null) { return(false); } tp = Term.Deref(tp); var symbol = tp as Symbol; if (symbol != null) { return(ISOPrologReader.Operator(symbol.Name, out prepri, out inpri, out postpri, out spec)); } else { var structure = tp as Structure; if (structure != null) { Structure str = structure; if (ISOPrologReader.Operator(str.Functor.Name, out prepri, out inpri, out postpri, out spec)) { if (__ARITY(str) == 2) { return(inpri >= termpri); } if (__ARITY(str) == 1) { if (ISOPrologReader.isprefix(spec) && ISOPrologReader.ispostfix(spec)) { /* in case of ambiguity: * select the associative operator over the nonassociative * select prefix over postfix */ if (ISOPrologReader.isfy(spec)) { spec = ISOPrologReader.FY; } else if (ISOPrologReader.isyf(spec)) { spec = ISOPrologReader.YF; } else { spec = ISOPrologReader.FX; } } if (ISOPrologReader.isprefix(spec)) { return(prepri >= termpri); } else { return(postpri >= termpri); } } else { return(false); } } else { return(false); } } else { return(false); } } }
void PrintNextQuerySolution() { try { PrologContext.ResetStepLimit(); timer.Reset(); timer.Start(); bool gotOne = prologModeAnswerStream.MoveNext(); timer.Stop(); if (gotOne) { if (freeVariablesInCurrentQuery.Count > 0) { foundOneSolution = true; foreach (LogicVariable v in freeVariablesInCurrentQuery) { Output.WriteLine("{0} = {1}", v.Name, Term.ToStringInPrologFormat(Term.Deref(v))); } } else { Output.WriteLine("yes"); prologModeAnswerStream = null; } } else { Output.WriteLine(foundOneSolution?"no more solutions found":"no"); prologModeAnswerStream = null; } if (timeCommands) { double ms = timer.Elapsed.TotalMilliseconds; Output.WriteLine("{0:###}ms, {1} inference steps, {2:0.##} KLIPS.\n", ms, prologContext.StepsUsed, prologContext.StepsUsed / ms); } } catch (Exception) { prologModeAnswerStream = null; throw; } }
private IEnumerable <CutState> BinaryPrimitiveImplementation(object[] args, PrologContext context) { if (args.Length != 2) { throw new ArgumentCountException(Name, args, expectedArguments); } var arg1 = Term.Deref(args[0]); var arg2 = Term.Deref(args[1]); var arg1AsLogicVariable = arg1 as LogicVariable; if (arg1AsLogicVariable != null) { var arg2AsLogicVariable = arg2 as LogicVariable; if (arg2AsLogicVariable != null) { // Enumerating both arguments if (doubleEnumerator == null) { throw new InstantiationException( arg1AsLogicVariable, "At least one argument to " + Name + "/2 must be instantiated."); } if (arg1AsLogicVariable == arg2AsLogicVariable) { throw new InvalidOperationException(Name + "(X,X) is not supported."); } return(EnumerateBothDriver(arg1AsLogicVariable, arg2AsLogicVariable, context)); } if (!(arg2 is T2)) { throw new ArgumentTypeException(this.Name, this.arg2Name, arg1, typeof(T1)); } if (arg1Function != null) { // It's left-unique T1 arg1Value; if (arg1Function((T2)arg2, out arg1Value)) { return(Term.UnifyAndReturnCutState(arg1, arg1Value)); } return(PrologPrimitives.FailImplementation); } // It's not left-unique if (arg1Enumerator == null) { throw new InstantiationException(arg1AsLogicVariable, Name + "/2: first argument must be instantiated."); } return(this.EnumerateArg1Driver(arg1AsLogicVariable, (T2)arg2, context)); } var variable1 = arg2 as LogicVariable; if (variable1 != null) { if (!(arg1 is T1)) { throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1)); } if (arg2Function != null) { // It's right-unique T2 arg2Value; if (arg2Function((T1)arg1, out arg2Value)) { return(Term.UnifyAndReturnCutState(arg2, arg2Value)); } return(PrologPrimitives.FailImplementation); } // It's not right-unqiue if (arg2Enumerator == null) { throw new InstantiationException(variable1, Name + "/2: second argument must be instantiated."); } return(this.EnumerateArg2Driver((T1)arg1, variable1, context)); } // Filtering if (!(arg1 is T1)) { throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1)); } if (!(arg2 is T2)) { throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1)); } if (filter == null) { throw new InstantiatedVariableException(null, Name + ": at least one argument must be uninstantiated."); } return(CutStateSequencer.FromBoolean(this.filter((T1)arg1, (T2)arg2))); }
private void Render(object renderingOperation) { renderingOperation = Term.Deref(renderingOperation); if (renderingOperation == null) { return; } var op = renderingOperation as Structure; if (op != null) { switch (op.Functor.Name) { case "cons": Render(op.Argument(0)); Render(op.Argument(1)); break; case "line": foreach (var arg in op.Arguments) { Render(arg); } textBuilder.AppendLine(); break; case "color": textBuilder.AppendFormat("<color={0}>", op.Argument(0)); for (int i = 1; i < op.Arity; i++) { Render(op.Argument(i)); } textBuilder.Append("</color>"); break; case "size": textBuilder.AppendFormat("<size={0}>", op.Argument(0)); for (int i = 1; i < op.Arity; i++) { Render(op.Argument(i)); } textBuilder.Append("</size>"); break; case "bold": textBuilder.AppendFormat("<b>"); for (int i = 0; i < op.Arity; i++) { Render(op.Argument(i)); } textBuilder.Append("</b>"); break; case "italic": textBuilder.AppendFormat("<i>"); for (int i = 0; i < op.Arity; i++) { Render(op.Argument(i)); } textBuilder.Append("</i>"); break; case "term": textBuilder.Append(ISOPrologWriter.WriteToString(op.Argument(0))); break; case "table": MakeTable(op.Argument(0)); break; default: textBuilder.Append(ISOPrologWriter.WriteToString(op)); break; } } else { var str = renderingOperation as string; textBuilder.Append(str ?? ISOPrologWriter.WriteToString(renderingOperation)); } }
public static object Eval(object term, PrologContext context) { term = Term.Deref(term); var indexical = term as Indexical; if (indexical != null) { return(indexical.GetValue(context)); } var offendingVariable = term as LogicVariable; if (offendingVariable != null) { throw new InstantiationException(offendingVariable, "arithmetic expression cannot be evaluated because it includes an uninstantiated variable."); } var t = term as Structure; if (t == null) { //var s = term as Symbol; //if (s != null) // throw new BadProcedureException(s, 0); //throw new BadProcedureException(term); return(term); // It's a literal. } switch (t.Functor.Name) { case "+": if (t.Arguments.Length != 2) { throw new ArgumentCountException("+", t.Arguments, "number1", "number2"); } return(GenericArithmetic.Add(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); case "-": if (t.Arguments.Length == 2) { return(GenericArithmetic.Subtract(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); } if (t.Arguments.Length == 1) { return(GenericArithmetic.Subtract(Eval(t.Arguments[0], context))); } throw new ArgumentException("Wrong number of arguments in - expression; should be 1 or 2."); case "*": if (t.Arguments.Length != 2) { throw new ArgumentCountException("*", t.Arguments, "number1", "number2"); } return(GenericArithmetic.Multiply(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); case "/": if (t.Arguments.Length != 2) { throw new ArgumentCountException("/", t.Arguments, "number1", "number2"); } return(GenericArithmetic.Divide(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); case "mod": if (t.Arguments.Length != 2) { throw new ArgumentCountException("mod", t.Arguments, "number1", "number2"); } return(Convert.ToInt32(Eval(t.Arguments[0], context)) % Convert.ToInt32((Eval(t.Arguments[1], context)))); case "//": if (t.Arguments.Length != 2) { throw new ArgumentCountException("//", t.Arguments, "number1", "number2"); } return(Convert.ToInt32(Eval(t.Arguments[0], context)) / Convert.ToInt32(Eval(t.Arguments[1], context))); case "sqrt": if (t.Arguments.Length != 1) { throw new ArgumentCountException("sqrt", t.Arguments, "number"); } return(Math.Sqrt(Convert.ToDouble(Eval(t.Arguments[0], context)))); case "abs": if (t.Arguments.Length != 1) { throw new ArgumentCountException("abs", t.Arguments, "number"); } return(Math.Abs(Convert.ToDouble(Eval(t.Arguments[0], context)))); case "log": if (t.Arguments.Length != 1) { throw new ArgumentCountException("log", t.Arguments, "number"); } return(Math.Log(Convert.ToDouble(Eval(t.Arguments[0], context)))); case "exp": if (t.Arguments.Length != 1) { throw new ArgumentCountException("exp", t.Arguments, "number"); } return(Math.Exp(Convert.ToDouble(Eval(t.Arguments[0], context)))); case "floor": if (t.Arguments.Length != 1) { throw new ArgumentCountException("floor", t.Arguments, "number"); } return(Math.Floor(Convert.ToDouble(Eval(t.Arguments[0], context)))); case "float": if (t.Arguments.Length != 1) { throw new ArgumentCountException("floor", t.Arguments, "number"); } return(Convert.ToSingle(Eval(t.Arguments[0], context))); case "min": if (t.Arguments.Length != 2) { throw new ArgumentCountException("min", t.Arguments, "number1", "number2"); } return(GenericArithmetic.Min(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); case "max": if (t.Arguments.Length != 2) { throw new ArgumentCountException("max", t.Arguments, "number1", "number2"); } return(GenericArithmetic.Max(Eval(t.Arguments[0], context), Eval(t.Arguments[1], context))); case "magnitude": { if (t.Arguments.Length != 1) { throw new ArgumentCountException("magnitude", t.Arguments, "Vector3"); } object v = Eval(t.Argument(0), context); if (!(v is Vector3)) { throw new ArgumentTypeException("magnitude", "vector", v, typeof(Vector3)); } return(((Vector3)v).magnitude); } case "magnitude_squared": { if (t.Arguments.Length != 1) { throw new ArgumentCountException("magnitude_squared", t.Arguments, "Vector3"); } object v = Eval(t.Argument(0), context); if (!(v is Vector3)) { throw new ArgumentTypeException("magnitude_squared", "vector", v, typeof(Vector3)); } return(((Vector3)v).sqrMagnitude); } case "distance": { if (t.Arguments.Length != 2) { throw new ArgumentCountException("distance", t.Arguments, "v1", "v2"); } object v1 = Eval(t.Argument(0), context); if (v1 is GameObject) { v1 = ((GameObject)v1).transform.position; } object v2 = Eval(t.Argument(1), context); if (v2 is GameObject) { v2 = ((GameObject)v2).transform.position; } if (!(v1 is Vector3)) { throw new ArgumentTypeException("distance", "v1", v1, typeof(Vector3)); } if (!(v2 is Vector3)) { throw new ArgumentTypeException("distance", "v2", v2, typeof(Vector3)); } return(Vector3.Distance((Vector3)v1, (Vector3)v2)); } case "distance_squared": { if (t.Arguments.Length != 2) { throw new ArgumentCountException("distance_squared", t.Arguments, "v1", "v2"); } object v1 = Eval(t.Argument(0), context); if (v1 is GameObject) { v1 = ((GameObject)v1).transform.position; } object v2 = Eval(t.Argument(1), context); if (v2 is GameObject) { v2 = ((GameObject)v2).transform.position; } if (!(v1 is Vector3)) { throw new ArgumentTypeException("distance_squared", "v1", v1, typeof(Vector3)); } if (!(v2 is Vector3)) { throw new ArgumentTypeException("distance_squared", "v2", v2, typeof(Vector3)); } return(Vector3.SqrMagnitude((Vector3)v1 - (Vector3)v2)); } case "position": { if (t.Arguments.Length != 1) { throw new ArgumentCountException("position", t.Arguments, "gameObject"); } var gameObject = Eval(t.Argument(0), context); var go = gameObject as GameObject; if (go == null) { throw new ArgumentTypeException("position", "gameObject", gameObject, typeof(GameObject)); } return(go.transform.position); } case ".": if (t.Arguments.Length != 2) { throw new ArgumentCountException(".", t.Arguments, "object"); } return(EvalMemberExpression(t.Arguments[0], t.Arguments[1], context)); case "property": { if (t.Arguments.Length != 2) { throw new ArgumentCountException("property", t.Arguments, "object", "property_name"); } object o = t.Argument(0); if (o is Structure) { o = Eval(o, context); } var name = t.Argument(1) as Symbol; if (name == null) { throw new ArgumentTypeException("property", "property_name", t.Argument(1), typeof(Symbol)); } return(o.GetPropertyOrField(name.Name)); } case "vector": { if (t.Arguments.Length != 3) { throw new ArgumentCountException("vector", t.Arguments, "x", "y", "z"); } return(new Vector3(Convert.ToSingle(Eval(t.Argument(0), context)), Convert.ToSingle(Eval(t.Argument(1), context)), Convert.ToSingle(Eval(t.Argument(2), context)))); } case "instance_id": { if (t.Arguments.Length != 1) { throw new ArgumentCountException("instance_id", t.Arguments, "game_object"); } var arg = t.Argument(0) as Object; if (arg == null) { throw new ArgumentTypeException("instance_id", "object", t.Argument(0), typeof(Object)); } return(arg.GetInstanceID()); } default: throw new BadProcedureException(t.Functor, t.Arguments.Length); } }
private object Register(PrologContext context, int framePointer, ushort pc) { return(Term.Deref(context.GetStack(framePointer, code[pc]))); }