Term firstGoalArg = goal.getFunctor().getArgument(index); Term firstClauseArg = clause.getHead().getArgument(index); else if (((Functor) firstGoalArg.getValue()).getName() == ((Functor) firstClauseArg).getName())
/** * Creates an atom (functor with no arguments). * * @param name The name of the atom. * * @return An atom. */ public Functor atom(String name) { int internedName = interner.internFunctorName(name, 0); return new Functor(internedName, null); }
/** * Creates a built-in for the specified functor. * * @param functor The functor to create a built-in for. */ public BuiltInFunctor(Functor functor) { super(functor.getName(), functor.getArguments()); this.functor = functor; }
/** * Creates a cut built-in to implement the specified functor. * * @param functor The functor to implement as a built-in. * @param defaultBuiltIn The default built in, for standard compilation and interners and symbol tables. */ public Cut(Functor functor, DefaultBuiltIn defaultBuiltIn) { // Here the cut functor is transformed from ! to !(Y), where Y is a level variable that may be needed // to hold the current choice point. super(new Functor(functor.getName(), new Term[] { CutLevelVariable.CUT_LEVEL_VARIABLE }), defaultBuiltIn); }
/** * Creates a traversable state for the specified label term. * * @param labelTerm The label term to create a traversable state for. */ public LabelState(Functor labelTerm) { this.labelTerm = labelTerm; labelPath = new String[] { ((StringLiteral) labelTerm.getArgument(0)).stringValue() }; isLeaf = labelTerm.getArity() <= 1; }
/** {@inheritDoc} */ public String getFunctorName(Functor functor) { return getFunctorName(functor.getName()); }
int numOutermostArgs = expression.getArity(); Term nextOutermostArg = expression.getArgument(j); int allocation = (Integer) symbolTable.get(nextOutermostArg.getSymbolKey(), SymbolTableKeys.SYMKEY_ALLOCATION); (Integer) symbolTable.get(nextFunctor.getSymbolKey(), SymbolTableKeys.SYMKEY_ALLOCATION); addrMode = (byte) ((allocation & 0xff00) >> 8); address = (byte) (allocation & 0xff); interner.getDeinternedFunctorName(nextFunctor.getName()), nextFunctor); instructions.add(instruction); int numArgs = nextFunctor.getArity(); Term nextArg = nextFunctor.getArgument(i); allocation = (Integer) symbolTable.get(nextArg.getSymbolKey(), SymbolTableKeys.SYMKEY_ALLOCATION);
/** {@inheritDoc} */ public boolean proofStep(ResolutionState state) { Functor isOp = state.getGoalStack().poll().getFunctor(); // Evaluate both sides of the comparison, checking that they are fully instantiated numbers. NumericType n1 = BuiltInUtils.evaluateAsNumeric(isOp.getArgument(0)); NumericType n2 = BuiltInUtils.evaluateAsNumeric(isOp.getArgument(1)); // Evaluate the comparison operator. return evaluate(n1, n2); }
if (functor.getArity() == 0) List<SymbolKey> constantSymKeys = constants.get(functor.getName()); constants.put(functor.getName(), constantSymKeys); constantSymKeys.add(functor.getSymbolKey()); argumentConstants.add(functor.getName());
predicateName = head.getName(); head.setReversable(new ContextOperator(clauseScopedSymbolTable, 0, createHeadOperator(head, clause))); head.setTermTraverser(this); queue.offer(head); bodyFunctor.setReversable(new ContextOperator(clauseScopedSymbolTable, i + 1, createBodyOperator(bodyFunctor, i, body, clause))); bodyFunctor.setTermTraverser(this); queue.offer(bodyFunctor);
/** {@inheritDoc} */ public void visit(Functor functor) { // functor is ground if all of its arguments are ground. boolean ground = true; if (functor.getArguments() != null) { for (Term argument : functor.getArguments()) { SymbolKey symbolKey = argument.getSymbolKey(); TermDomain annotation = (TermDomain) symbolTable.get(symbolKey, TERM_DOMAIN); if ((annotation == null) || !annotation.ground) { ground = false; break; } } } /*log.fine((ground ? "ground " : "non-ground ") + functor.toString(interner, true, false));*/ symbolTable.put(functor.getSymbolKey(), TERM_DOMAIN, new TermDomain(ground)); }
int numOutermostArgs = expression.getArity(); (Integer) symbolTable.get(nextFunctor.getSymbolKey(), SymbolTableKeys.SYMKEY_ALLOCATION); int numArgs = nextFunctor.getArity(); Term nextArg = nextFunctor.getArgument(i); allocation = (Integer) symbolTable.get(nextArg.getSymbolKey(), SymbolTableKeys.SYMKEY_ALLOCATION); addrMode = (byte) ((allocation & 0xff00) >> 8);
/** {@inheritDoc} */ public Iterator<Operator<Term>> traverse(Functor functor, boolean reverse) { /*log.fine("Traversing functor " + functor.toString());*/ Queue<Operator<Term>> queue = (!reverse) ? new StackQueue<Operator<Term>>() : new LinkedList<Operator<Term>>(); Term[] arguments = functor.getArguments(); // For a top-level functor clear top-level flag, so that child functors are not taken as top-level. if (arguments != null) { for (int i = leftToRightFunctorArgs ? 0 : (arguments.length - 1); leftToRightFunctorArgs ? (i < arguments.length) : (i >= 0); i = i + (leftToRightFunctorArgs ? 1 : -1)) { Term argument = arguments[i]; argument.setReversable(createTermOperator(argument, i, functor)); argument.setTermTraverser(this); queue.offer(argument); } } return queue.iterator(); }
/** * Parses a single functor in first order logic with its arguments. * * @return A single functor in first order logic with its arguments. * * @throws SourceCodeException If the token sequence does not parse as a valid functor. */ public Term functor() throws SourceCodeException { Token name = consumeToken(FUNCTOR); Term[] args = arglist(); consumeToken(RPAREN); int nameId = interner.internFunctorName((args == null) ? name.image : name.image.substring(0, name.image.length() - 1), (args == null) ? 0 : args.length); Functor result = new Functor(nameId, args); SourceCodePosition position = new SourceCodePositionImpl(name.beginLine, name.beginColumn, name.endLine, name.endColumn); result.setSourceCodePosition(position); return result; }
/** {@inheritDoc} */ public SymbolKey getSymbolKey() { return functor.getSymbolKey(); } }
/** {@inheritDoc} */ public void visit(Functor functor) { if (isEnteringContext()) { SymbolKey key = currentSymbolTable.getSymbolKey(currentPosition); functor.setSymbolKey(key); /*log.fine(functor.toString(interner, true, false) + " assigned " + key);*/ } else if (isLeavingContext()) { functor.setTermTraverser(null); } if (delegate != null) { delegate.visit(functor); } }
/** {@inheritDoc} */ public void setSymbolKey(SymbolKey key) { functor.setSymbolKey(key); }
/** * Examines all top-level functors within a clause, including any head and body, and determines which functor has * the highest number of arguments. * * @param clause The clause to determine the highest number of arguments within. * * @return The highest number of arguments within any top-level functor in the clause. */ private int findMaxArgumentsInClause(Clause clause) { int result = 0; Functor head = clause.getHead(); if (head != null) { result = head.getArity(); } Functor[] body = clause.getBody(); if (body != null) { for (int i = 0; i < body.length; i++) { int arity = body[i].getArity(); result = (arity > result) ? arity : result; } } return result; }
/** * Creates a shallow clone of this operator symbol. * * @return A shallow clone of this object. * * @throws CloneNotSupportedException If cloning fails. */ protected Object clone() throws CloneNotSupportedException { // Create a new state and copy the existing board position into it OpSymbol newSymbol = (OpSymbol) super.clone(); return newSymbol; } }
/** {@inheritDoc} */ public Clause acceptTransformer(TermTransformer transformer) { Clause result; if (transformer instanceof ClauseTransformer) { result = ((ClauseTransformer) transformer).transform(this); } else { result = (Clause) super.acceptTransformer(transformer); } if (head != null) { result.head = (Functor) head.acceptTransformer(transformer); } if (body != null) { for (int i = 0; i < body.length; i++) { result.body[i] = (Functor) body[i].acceptTransformer(transformer); } } return result; }