/** * Method to parse a Slot * * @param slot Element The XOM element that represents the slot to be parsed. * @return Returns the data structure that represents the slot in a way that can be used by the * reasoning engine. * @throws ParseException Thrown if there is an error parsing the slot. */ private Term parseSlot(Element slot) throws ParseException { Elements children = slot.getChildElements(); Element firstChildName = children.get(0); boolean dataSlot = false; if (firstChildName.getLocalName().equals(tagNames.DATA)) { dataSlot = true; } if (!firstChildName.getLocalName().equals(tagNames.IND) && !firstChildName.getLocalName().equals(tagNames.DATA)) { throw new ParseException("In a <slot> only <Ind> and <Data> are allowed."); } // Getting the Role from the symbol Table, it will assign one if it // doesnt already exist int role = SymbolTable.internRole(firstChildName.getValue().trim()); Element element = children.get(1); Term term = parseDefaultElement(element); term.setRole(role); if (dataSlot) { term.setDataSlot(true); } return term; }
/** * Method to parse a naf (Negation as Failure) * * @param naf Element The XOM element that represents the naf atom to be parsed. * @return Returns the data structure that represents the naf in a way that can be used by the * reasoning engine. * @throws ParseException Thrown if there is an error parsing the naf. */ private Term parseNaf(Element naf) throws ParseException { Elements children = naf.getChildElements(); Element el = skipRoleTag(children.get(0)); Vector<Term> subterms = new Vector<Term>(); if (el.getLocalName().equals(tagNames.ATOM)) { subterms.add(parseAtom(el, false, false)); } else if (el.getLocalName().equals(tagNames.AND)) { children = el.getChildElements(); for (int i = 0; i < children.size(); i++) { Element el2 = children.get(i); if (!el2.getLocalName().equals(tagNames.ATOM)) { throw new ParseException("And child of Naf element should only contain Atom elements."); } subterms.add(parseAtom(el2, false, false)); } } else { throw new ParseException("Naf element should only contain Atom or And child element."); } Term t = new Term(SymbolTable.INAF, SymbolTable.INOROLE, Types.IOBJECT, subterms); t.setAtom(true); return t; }
/** * This method is used to parse and <oid> element. * * @param oid Element The XOM element that represents the oid to be parsed. * @return Returns the data structure that represents the oid in a way that can be used by the * reasoning engine. * @throws ParseException Thrown if there is an error parsing the oid. */ private Term parseOid(Element oid) throws ParseException { Element element = oid.getChildElements().get(0); Term term = parseDefaultElement(element); term.role = SymbolTable.IOID; return term; }
/** * This method is used to parse an Assertion in the RuleML Document. * * @param ass Element The XOM Element object that represents the assertion. * @return A term object that represents the assertion in a way that can be used by the reasoning * engine. * @throws ParseException Thrown if there is a serious error parsing the assertion. */ private Term parseAssert(Element ass) throws ParseException { Elements children = ass.getChildElements(); Element firstChild = skipRoleTag(children.get(0)); if (firstChild.getLocalName().equals(tagNames.ATOM)) { DefiniteClause dc = parseFact(firstChild); Vector<Term> v = new Vector<Term>(); for (int i = 0; i < dc.atoms.length; i++) { v.add(dc.atoms[i]); } Term t = new Term(SymbolTable.IASSERT, SymbolTable.INOROLE, Types.IOBJECT, v); t.setAtom(true); return t; } else if (firstChild.getLocalName().equals(tagNames.IMPLIES)) { Vector<DefiniteClause> v2 = parseImplies(firstChild); DefiniteClause dc = (DefiniteClause) v2.get(0); Vector<Term> v = new Vector<Term>(); for (int i = 0; i < dc.atoms.length; i++) { v.add(dc.atoms[i]); } Term t = new Term(SymbolTable.IASSERT, SymbolTable.INOROLE, Types.IOBJECT, v); t.setAtom(true); return t; } else { throw new ParseException("Assert element can only contain Atom (fact) or Implies elements."); } }
/** * Method to parse a resl (Rested Slot) * * @param resl Element The XOM element that represents the resl to be parsed. * @return Returns the data structure that represents the resl in a way that can be used by the * reasoning engine. * @throws ParseException Thrown if there is an error parsing the resl. */ private Term parseResl(Element resl) throws ParseException { Elements children = resl.getChildElements(); Element firstChild = skipRoleTag(children.get(0)); Term t = parseDefaultElement(firstChild); // HACK: only change symbol, if term is no <Plex> if (t.getSymbol() != SymbolTable.IPLEX) { t.setRole(SymbolTable.IREST); } return t; }
public DefiniteClause buildResult(Term t) { if (t.getSymbol() != symbol) { return null; } if (t.subTerms.length != 3) { return null; } Term p2 = t.subTerms[2].deepCopy(); if (p2.getSymbol() < 0) { return null; } if (p2.getType() != Types.IFLOAT && p2.getType() != Types.IINTEGER) { return null; } String p2s = p2.getSymbolString(); double p2d; try { p2d = Double.parseDouble(p2s); } catch (Exception e) { return null; } double result = Math.tan(p2d); String results = "" + result; Term r1 = new Term(SymbolTable.internSymbol(results), SymbolTable.INOROLE, Types.IFLOAT); Term roid = new Term(SymbolTable.internSymbol("$jdrew-tan-" + p2s), SymbolTable.IOID, Types.ITHING); Vector v = new Vector(); v.add(roid); v.add(r1); v.add(p2); Term atm = new Term(symbol, SymbolTable.INOROLE, Types.IOBJECT, v); atm.setAtom(true); Vector v2 = new Vector(); v2.add(atm); return new DefiniteClause(v2, new Vector()); }
/** * Method to parse a repo (Rested Positional Slot) * * @param repo Element The XOM element that represents the repo to be parsed. * @return Term Returns the data structure that represents the repo in a way that can be used by * the reasoning engine. * @throws ParseException Thrown if there is an error parsing the repo. */ private Term parseRepo(Element repo) throws ParseException { Term t = parseResl(repo); t.setRole(SymbolTable.IPREST); return t; }
/** * Method to parse an Atom * * @param Atom Element The XOM element that represents the Atom to be parsed. * @param head boolean This tells the engine if the atom is a head of a rule. * @param neg boolean This tells the engine if the atom is a negative atom (Neg) * @return Returns the data structure that represents the Atom in a way that can be used by the * reasoning engine. * @throws ParseException Thrown if there is an error parsing the Atom. */ private Term parseAtom(Element atom, boolean head, boolean neg) throws ParseException { boolean foundoid = false; Elements children = atom.getChildElements(); // checking for op tag before the rel Element op = getFirstChildElement(atom, tagNames.OP); Element rel = null; if (op != null) { Elements relTag = op.getChildElements(); rel = relTag.get(0); } else { rel = getFirstChildElement(atom, tagNames.REL); } if (rel == null) { throw new ParseException("In an <Atom>, first child of <op> must be a <Rel>."); } String relname = rel.getValue().trim(); if (neg) { relname = "$neg-" + relname; } int symbol = SymbolTable.internSymbol(relname); Vector<Term> subterms = new Vector<Term>(); int startIndex = getFirstChildElementIndex(children, 0) + 1; for (int i = startIndex; i < children.size(); i++) { Element element = children.get(i); Term term = null; if (element.getLocalName().equals(tagNames.OID)) { if (foundoid) { throw new ParseException("<Atom> must contain a most one <oid>."); } term = parseOid(element); foundoid = true; } else { term = parseDefaultElement(element); } subterms.add(term); } // Generate a fake OID if the atom does not have one. // This is a requirement put in place by the reasoner. if (!foundoid) { if (head) { String symname = "$gensym" + SymbolTable.genid++; int symid = SymbolTable.internSymbol(symname); Term t2 = new Term(symid, SymbolTable.IOID, Types.IOBJECT); subterms.add(t2); } else { String varname = generateAnonymousIdentifier(); int symid = this.internVariable(varname); Vector<Integer> types = new Vector<Integer>(); types.add(Types.IOBJECT); this.varClasses.put(symid, types); Term t2 = new Term(symid, SymbolTable.IOID, Types.IOBJECT); subterms.add(t2); } } Term t = new Term(symbol, SymbolTable.INOROLE, Types.IOBJECT, subterms); t.setAtom(true); return t; }
private Term parseData(Element data) throws ParseException { Term term = parseSimpleElement(data); term.setData(true); return term; }
/** * This method is used to parse a implication element, creating a new variable name list if * indicated. Typically a new variable list is wanted; but in certain cases (such as parsing an * inner clause in an assert) the same variable list must be used. * * @param implies Element The XOM Element object that represents the implication to be parsed. * @return A vector of DefiniteClause data structures that represents the implication in a way * that can be used by the reasoning engine. * @throws ParseException Thrown if there is a serious error parsing the implication. */ private Vector<DefiniteClause> parseImplies(Element implies) throws ParseException { Vector<DefiniteClause> newclauses = new Vector<DefiniteClause>(); // Implies must have two children (excluding OID elements) Elements children = implies.getChildElements(); // Set first and second child and skip OID element if exists. Element firstChild = skipRoleTag(children.get(0)); Element secondChild = skipRoleTag(children.get(1)); if (firstChild.getLocalName().equals(tagNames.OID)) { firstChild = skipRoleTag(children.get(1)); secondChild = skipRoleTag(children.get(2)); } String firstChildName = firstChild.getLocalName(); Element premise, conclusion; // Check if implies starts with premise element if (firstChildName.equals(tagNames.PREMISE)) { premise = firstChild.getChildElements().get(0); conclusion = secondChild.getChildElements().get(0); } // If implies starts with conclusion element else if (firstChildName.equals(tagNames.CONCLUSION)) { premise = secondChild.getChildElements().get(0); conclusion = firstChild.getChildElements().get(0); } // No premise or conclusion tag available else { // Use canonical order for stripe-skipped syntax premise = firstChild; conclusion = secondChild; } premise = skipRoleTag(premise); conclusion = skipRoleTag(conclusion); Vector<Term> subterms = new Vector<Term>(); if (conclusion.getLocalName().equals(tagNames.ATOM)) { subterms.add(parseAtom(conclusion, true, false)); } else if (conclusion.getLocalName().equals(tagNames.NEG)) { Elements headatms = conclusion.getChildElements(tagNames.ATOM); if (headatms.size() != 1) throw new ParseException("Neg should have one ATOM element"); Term atom = parseAtom(headatms.get(0), true, true); subterms.add(atom); String atomstr = atom.toPOSLString(true); String clause = "$Sinconsistent() :-"; clause += atomstr + ", \"" + atomstr.substring(6) + "."; System.err.println(clause); POSLParser pp = new POSLParser(); try { DefiniteClause dc2 = pp.parseDefiniteClause(clause); if (dc2 != null) newclauses.add(dc2); } catch (Exception e) { throw new ParseException("Error creating inconsistency check rule."); } } else { throw new ParseException( "Second element of Implies should always be an Atom or Neg element."); } String premiseName = premise.getLocalName(); if (premiseName.equals(tagNames.ATOM)) { subterms.add(parseAtom(premise, false, false)); } else if (premiseName.equals(tagNames.NAF)) { subterms.add(parseNaf(premise)); } else if (premiseName.equals(tagNames.ASSERT)) { subterms.add(parseAssert(premise)); } else if (premiseName.equals(tagNames.NEG)) { subterms.add(parseAtom(premise, false, true)); } else if (premiseName.equals(tagNames.AND)) { children = premise.getChildElements(); for (int i = 0; i < children.size(); i++) { Element el = skipRoleTag(children.get(i)); if (el.getLocalName().equals(tagNames.ATOM)) { subterms.add(parseAtom(el, false, false)); } else if (el.getLocalName().equals(tagNames.NAF)) { subterms.add(parseNaf(el)); } else if (el.getLocalName().equals(tagNames.ASSERT)) { subterms.add(parseAssert(el)); } else if (el.getLocalName().equals(tagNames.NEG)) { subterms.add(parseAtom(el, false, true)); } else { throw new ParseException( "Implies And element should only contain Atom and Naf elements."); } } } else { throw new ParseException("First element of Implies should be an Atom, Naf or And element."); } logger.debug("Building Types"); Hashtable<Integer, Integer> types = this.buildTypeTable(); logger.debug("Built Types"); Iterator<Term> it = subterms.iterator(); int i = 0; while (it.hasNext()) { Term t = (Term) it.next(); this.fixVarTypes(t, types); logger.debug("Fixed atom : " + i++); } DefiniteClause dc = new DefiniteClause(subterms, variableNames); newclauses.add(0, dc); return newclauses; }
public DefiniteClause buildResult(Term t) { if (t.getSymbol() != sym) { return null; } if (t.subTerms.length != 3) { return null; } Term p1 = t.subTerms[1].deepCopy(); Term p2 = t.subTerms[2].deepCopy(); if (p1.getSymbol() < 0 || p2.getSymbol() < 0) { return null; } String p1s = p1.getSymbolString(); String p2s = p2.getSymbolString(); if ((p1.getType() == Types.IFLOAT || p1.getType() == Types.IINTEGER) && (p2.getType() == Types.IFLOAT || p2.getType() == Types.IINTEGER)) { double d1; double d2; try { d1 = Double.parseDouble(p1s); d2 = Double.parseDouble(p2s); } catch (Exception e) { return null; } if (d1 > d2) { return null; } } else if (p1.getType() == Types.ISTRING && p2.getType() == Types.ISTRING) { if (p1s.compareTo(p2s) > 0) { return null; } } else { return null; } Term roid = new Term( SymbolTable.internSymbol("$jdrew-lte-" + p1s + "<=" + p2s), SymbolTable.IOID, Types.ITHING); Vector v = new Vector(); v.add(roid); v.add(p1); v.add(p2); Term atm = new Term(sym, SymbolTable.INOROLE, Types.IOBJECT, v); atm.setAtom(true); Vector v2 = new Vector(); v2.add(atm); return new DefiniteClause(v2, new Vector()); }