public Operation exec(Prolog engine) {
    engine.requireFeature(Prolog.Feature.JAVA_REFLECTION, this, arg1);
    engine.setB0();

    Term a1, a2, a3;
    a1 = arg1;
    a2 = arg2;
    a3 = arg3;

    Class clazz = null;
    Object instance = null;
    Field field = null;
    Object value = null;

    try {
      // 1st. argument (atom or java term)
      a1 = a1.dereference();
      if (a1.isVariable()) {
        throw new PInstantiationException(this, 1);
      } else if (a1.isSymbol()) { // class
        clazz = Class.forName(((SymbolTerm) a1).name());
      } else if (a1.isJavaObject()) { // instance
        instance = ((JavaObjectTerm) a1).object();
        clazz = ((JavaObjectTerm) a1).getClazz();
      } else {
        throw new IllegalTypeException(this, 1, "atom_or_java", a1);
      }
      // 2nd. argument (atom)
      a2 = a2.dereference();
      if (a2.isVariable()) {
        throw new PInstantiationException(this, 2);
      } else if (!a2.isSymbol()) {
        throw new IllegalTypeException(this, 2, "atom", a2);
      }
      field = clazz.getDeclaredField(((SymbolTerm) a2).name());
      // 3rd. argument (term)
      a3 = a3.dereference();
      if (a3.isJavaObject()) value = a3.toJava();
      else value = a3;
      field.setAccessible(true);
      field.set(instance, value);
      return cont;
    } catch (ClassNotFoundException e) { // Class.forName
      throw new JavaException(this, 1, e);
    } catch (NoSuchFieldException e) { // Class.getField(..)
      throw new JavaException(this, 2, e);
    } catch (SecurityException e) { // Class.getField(..)
      throw new JavaException(this, 2, e);
    } catch (NullPointerException e) { // Class.getField(..)
      throw new JavaException(this, 2, e);
    } catch (IllegalAccessException e) { // Field.get(..)
      throw new JavaException(this, 2, e);
    } catch (IllegalArgumentException e) { // Field.get(..)
      throw new JavaException(this, 2, e);
    }
  }
Example #2
0
  // TODO: update it for rules with non-DL prediciates in the body
  public Set<Variable> getNonDistinguishedVars() {
    Set<Variable> nonDistinguishedVars = new HashSet<Variable>();
    Set<Term> distinguishedVars = this.getDistinguishedVariables();
    for (Atom atom : body) {
      for (Term term : atom.getTerms())
        if (distinguishedVars == null) { // Xiao: can not happen!
          if (term.isVariable()) nonDistinguishedVars.add((Variable) term);
        } else if ((term.isVariable()) && !distinguishedVars.contains(term))
          nonDistinguishedVars.add((Variable) term);
    }

    return nonDistinguishedVars;
  }
Example #3
0
 public Set<Term> getDistinguishedVariables() {
   Set<Term> vars = new HashSet<Term>();
   for (Term term : this.head.getTerms()) {
     if (term.isVariable()) vars.add(term);
   }
   return vars;
 }
Example #4
0
 /* Term */
 public boolean unify(Term t, Trail trail) {
   t = t.dereference();
   if (t.isVariable()) {
     ((VariableTerm) t).bind(this, trail);
     return true;
   }
   return eq(this, t);
 }
Example #5
0
 /**
  * Compares two terms in <em>Prolog standard order of terms</em>.<br>
  * It is noted that <code>t1.compareTo(t2) == 0</code> has the same <code>boolean</code> value as
  * <code>t1.equals(t2)</code>.
  *
  * @param anotherTerm the term to compared with. It must be dereferenced.
  * @return the value <code>0</code> if two terms are identical; a value less than <code>0</code>
  *     if this term is <em>before</em> the <code>anotherTerm</code>; and a value greater than
  *     <code>0</code> if this term is <em>after</em> the <code>anotherTerm</code>.
  */
 public int compareTo(Term anotherTerm) { // anotherTerm must be dereferenced.
   if (anotherTerm.isVariable() || anotherTerm.isNumber()) return AFTER;
   if (!anotherTerm.isSymbol()) return BEFORE;
   if (this == anotherTerm) return EQUAL;
   int x = name.compareTo(((SymbolTerm) anotherTerm).name());
   if (x != 0) return x;
   int y = this.arity - ((SymbolTerm) anotherTerm).arity();
   if (y != 0) return y;
   throw new InternalException("SymbolTerm is not unique");
 }
Example #6
0
 public CQ computeQprime(TIntHashSet type, Variable x) {
   CQ qPrime = new CQ();
   qPrime.setHead(head);
   int numberOfIndividual = 0;
   Constant individual = new Constant();
   for (Term term : this.computeRenamingVars(x)) {
     if (!term.isVariable()) {
       numberOfIndividual++;
       individual = (Constant) term;
     }
   }
   if (numberOfIndividual > 1) // cannot merge two individuals
   return null;
   // if there is no individual in the variables which should be renamed
   if (numberOfIndividual == 0) {
     for (Atom atom : body) { // compute body
       if (!(atom.getTerms().contains(x))) {
         // atom that contains x will disappear in the rewrite query
         List<Term> newTerms = new ArrayList<Term>();
         for (Term term : atom.getTerms()) {
           if (this.computeRenamingVars(x).contains(term)) newTerms.add(x);
           else newTerms.add(term);
         }
         Atom renamedVarAtom = new Atom(atom.getPredicate(), newTerms);
         if (!qPrime.body.contains(renamedVarAtom)) {
           qPrime.body.add(renamedVarAtom);
         }
       }
     }
     // add type(x) to the body
     Set<Atom> currentBody = qPrime.getBody();
     qPrime.body.addAll(addTypeOfXToBody(x, type, currentBody));
     // compute head
     Atom newHead = computeNewHead(x, this.head);
     qPrime.setHead(newHead);
   }
   // if there is an individual in the variables which should be renamed
   // then all these variables should be renamed as the individual
   if (numberOfIndividual == 1) {
     // compute body
     for (Atom atom : body) {
       if (!(atom.getTerms().contains(x))) {
         // atom that contains x will disappear in the rewrite query
         List<Term> newTerms = new ArrayList<Term>();
         for (Term term : atom.getTerms()) {
           if (this.computeRenamingVars(x).contains(term))
             // this term should be renamed
             newTerms.add(individual);
           else newTerms.add(term);
         }
         Atom renamedVarAtom = new Atom(atom.getPredicate(), newTerms);
         if (!qPrime.body.contains(renamedVarAtom)) {
           qPrime.body.add(renamedVarAtom);
         }
       }
     }
     // at type(x) to the body
     Set<Atom> currentBody = qPrime.getBody();
     qPrime.body.addAll(addTypeOfXToBody(individual, type, currentBody));
     // compute head
     Atom newHead = computeNewHead(x, individual, this.head);
     qPrime.setHead(newHead);
   }
   return qPrime;
 }