@skaterqiang/protege-js 0.1.0

package/src/io/FunctionalSyntaxParser.js

@@ -0,0 +1,399 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// FunctionalSyntaxParser — parses the OWL 2 Functional-Style syntax.
+// Handles the full axiom set: Declaration, SubClassOf, EquivalentClasses,
+// DisjointClasses, DisjointUnion, SubObjectPropertyOf, SubObjectPropertyChain,
+// EquivalentObjectProperties, DisjointObjectProperties, ObjectPropertyDomain,
+// ObjectPropertyRange, InverseObjectProperties, Functional/InverseFunctional/
+// Reflexive/Irreflexive/Symmetric/Asymmetric/Transitive ObjectProperty,
+// SubDataPropertyOf, EquivalentDataProperties, DisjointDataProperties,
+// DataPropertyDomain, DataPropertyRange, FunctionalDataProperty,
+// DatatypeDefinition, HasKey, SameIndividual, DifferentIndividuals,
+// ClassAssertion, ObjectPropertyAssertion, NegativeObjectPropertyAssertion,
+// DataPropertyAssertion, NegativeDataPropertyAssertion,
+// AnnotationAssertion, SubAnnotationPropertyOf, AnnotationPropertyDomain/Range,
+// plus all class expressions (Object*/Data*) and data ranges.
+// ---------------------------------------------------------------------------
+
+const { OWLOntology, OWLOntologyID } = require('../model/OWLOntology');
+const { OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual, OWLDatatype, OWLAnnotationProperty } = require('../model/OWLEntity');
+const { IRI } = require('../model/IRI');
+const { OWLLiteral } = require('../model/OWLLiteral');
+const CE = require('../model/OWLClassExpression');
+const AX = require('../model/OWLAxiom');
+
+const KNOWN_PREFIXES = {
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  owl: 'http://www.w3.org/2002/07/owl#',
+  xsd: 'http://www.w3.org/2001/XMLSchema#'
+};
+
+class FunctionalSyntaxParser {
+  constructor() {
+    this.prefixes = { ...KNOWN_PREFIXES };
+  }
+
+  /** Parse functional-syntax text, return OWLOntology. */
+  parse(text, ontologyIRI = 'http://example.org/ontology') {
+    const tokens = this._tokenize(text);
+    this._pos = 0;
+    this._tokens = tokens;
+    const onto = new OWLOntology(new OWLOntologyID(IRI.create(ontologyIRI)));
+    // Optionally: handle Prefix(...) declarations and Ontology(...) wrapper.
+    while (this._pos < tokens.length) {
+      this._statement(onto);
+    }
+    return onto;
+  }
+
+  _tokenize(text) {
+    const out = [];
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+      const ch = text[i];
+      if (/\s/.test(ch)) { i++; continue; }
+      if (ch === '#') { while (i < n && text[i] !== '\n') i++; continue; }
+      if (ch === '(') { out.push({ t: '(' }); i++; continue; }
+      if (ch === ')') { out.push({ t: ')' }); i++; continue; }
+      if (ch === '"') {
+        let j = i + 1;
+        let v = '';
+        while (j < n && text[j] !== '"') {
+          if (text[j] === '\\' && j + 1 < n) { v += text[j + 1]; j += 2; }
+          else { v += text[j]; j++; }
+        }
+        out.push({ t: 'STRING', v });
+        i = j + 1;
+        continue;
+      }
+      if (ch === '<') {
+        const j = text.indexOf('>', i);
+        out.push({ t: 'IRI', v: text.slice(i + 1, j) });
+        i = j + 1;
+        continue;
+      }
+      if (ch === '@') {
+        let j = i + 1;
+        while (j < n && /[A-Za-z-]/.test(text[j])) j++;
+        out.push({ t: 'LANG', v: text.slice(i + 1, j) });
+        i = j;
+        continue;
+      }
+      if (ch === '^' && text[i + 1] === '^') { out.push({ t: '^^' }); i += 2; continue; }
+      if (ch === '=') { out.push({ t: '=' }); i++; continue; }
+      // number
+      if (/[0-9+-]/.test(ch)) {
+        let j = i + 1;
+        while (j < n && /[0-9.eE+-]/.test(text[j])) j++;
+        out.push({ t: 'NUMBER', v: text.slice(i, j) });
+        i = j;
+        continue;
+      }
+      // name (identifier or prefixed)
+      let j = i;
+      while (j < n && /[A-Za-z0-9_:\-.]/.test(text[j])) j++;
+      if (j > i) { out.push({ t: 'NAME', v: text.slice(i, j) }); i = j; continue; }
+      throw new Error('Unexpected char: ' + ch + ' at ' + i);
+    }
+    return out;
+  }
+
+  _peek() { return this._tokens[this._pos]; }
+  _next() { return this._tokens[this._pos++]; }
+  _expect(t) {
+    const tok = this._next();
+    if (!tok || tok.t !== t) throw new Error(`Expected ${t}, got ${tok && tok.t}`);
+    return tok;
+  }
+
+  _iriFrom(tok) {
+    if (tok.t === 'IRI') return IRI.create(tok.v);
+    if (tok.t === 'NAME') {
+      const s = tok.v;
+      const idx = s.indexOf(':');
+      if (idx > 0) {
+        const prefix = s.slice(0, idx);
+        const local = s.slice(idx + 1);
+        if (this.prefixes[prefix]) return IRI.create(this.prefixes[prefix] + local);
+      }
+      return IRI.create(s);
+    }
+    throw new Error('Expected IRI, got ' + JSON.stringify(tok));
+  }
+
+  _statement(onto) {
+    const tok = this._peek();
+    if (tok.t === 'NAME' && tok.v === 'Prefix') {
+      this._next(); this._expect('(');
+      const pn = this._expect('NAME');
+      this._expect('='); // may not tokenize — handle below
+      const iriTok = this._expect('IRI');
+      const pfx = pn.v.replace(/:$/, '');
+      this.prefixes[pfx] = iriTok.v;
+      if (onto && onto.addPrefix) onto.addPrefix(pfx, iriTok.v); // prefix fidelity (L5)
+      this._expect(')');
+      return;
+    }
+    if (tok.t === 'NAME' && tok.v === 'Ontology') {
+      // Ontology( [iri] [versionIRI] Import(...)* Annotation(...)* axiom* )
+      this._next(); this._expect('(');
+      // Optional ontology IRI
+      if (this._peek().t === 'IRI' || (this._peek().t === 'NAME' && this._tokens[this._pos + 1] && this._tokens[this._pos + 1].t !== '(')) {
+        onto.id.ontologyIRI = this._iriFrom(this._next());
+        // Optional version IRI
+        if (this._peek() && this._peek().t === 'IRI') {
+          onto.id.versionIRI = this._iriFrom(this._next());
+        }
+      }
+      while (this._peek() && this._peek().t !== ')') {
+        const t = this._peek();
+        if (t.t === 'NAME' && t.v === 'Import') {
+          this._next(); this._expect('(');
+          onto.imports.push(this._iriFrom(this._next()));
+          this._expect(')');
+          continue;
+        }
+        if (t.t === 'NAME' && t.v === 'Annotation') {
+          // Ontology-level annotation
+          this._next(); this._expect('(');
+          const propTok = this._next();
+          const prop = this._iriFrom(propTok);
+          const valTok = this._next();
+          let value;
+          if (valTok.t === 'STRING') {
+            const { OWLLiteral } = require('../model/OWLLiteral');
+            value = new OWLLiteral(valTok.v);
+            if (this._peek() && this._peek().t === '^^') {
+              this._next();
+              const { OWLDatatype } = require('../model/OWLEntity');
+              value.datatype = new OWLDatatype(this._iriFrom(this._next()));
+            }
+          } else {
+            value = this._iriFrom(valTok);
+          }
+          const { OWLAnnotationAssertionAxiom } = require('../model/OWLAxiom');
+          const { OWLAnnotationProperty } = require('../model/OWLEntity');
+          onto.addOntologyAnnotation(new OWLAnnotationAssertionAxiom(
+            onto.id.ontologyIRI, new OWLAnnotationProperty(prop), value));
+          this._expect(')');
+          continue;
+        }
+        this._axiom(onto);
+      }
+      this._expect(')');
+      return;
+    }
+    this._axiom(onto);
+  }
+
+  _axiom(onto) {
+    const name = this._expect('NAME').v;
+    this._expect('(');
+    const args = [];
+    while (this._peek() && this._peek().t !== ')') {
+      args.push(this._term());
+    }
+    this._expect(')');
+    this._dispatch(onto, name, args);
+  }
+
+  _term() {
+    const tok = this._peek();
+    if (tok.t === '(') {
+      this._next();
+      const head = this._expect('NAME').v;
+      const items = [];
+      while (this._peek() && this._peek().t !== ')') items.push(this._term());
+      this._expect(')');
+      return { kind: 'expr', name: head, items };
+    }
+    // NAME followed by '(' — e.g. Class(ex:Person) inside Declaration
+    if (tok.t === 'NAME' && this._tokens[this._pos + 1] && this._tokens[this._pos + 1].t === '(') {
+      const head = this._next().v;
+      this._expect('(');
+      const items = [];
+      while (this._peek() && this._peek().t !== ')') items.push(this._term());
+      this._expect(')');
+      return { kind: 'expr', name: head, items };
+    }
+    if (tok.t === 'STRING') {
+      this._next();
+      let lit = { lex: tok.v, dt: null, lang: null };
+      const next = this._peek();
+      if (next && next.t === '^^') {
+        this._next();
+        const dtTok = this._next();
+        lit.dt = this._iriFrom(dtTok).toString();
+      } else if (next && next.t === 'LANG') {
+        this._next();
+        lit.lang = next.v;
+      }
+      return { kind: 'literal', value: lit };
+    }
+    if (tok.t === 'NUMBER') {
+      this._next();
+      return { kind: 'number', value: tok.v };
+    }
+    // IRI or name
+    return { kind: 'iri', value: this._iriFrom(this._next()) };
+  }
+
+  _dispatch(onto, name, args) {
+    const P = (tok) => {
+      if (tok.kind === 'iri') {
+        const iri = tok.value;
+        // heuristic: ObjectProperty if name in prop position; we let caller wrap.
+        return iri;
+      }
+      return tok;
+    };
+
+    const entity = (tok, kind) => {
+      const iri = tok.kind === 'iri' ? tok.value : (() => { throw new Error('expected iri'); })();
+      switch (kind) {
+        case 'class': return new OWLClass(iri);
+        case 'op': return new OWLObjectProperty(iri);
+        case 'dp': return new OWLDataProperty(iri);
+        case 'ni': return new OWLNamedIndividual(iri);
+        case 'dt': return new OWLDatatype(iri);
+        case 'ap': return new OWLAnnotationProperty(iri);
+        default: throw new Error('unknown entity kind ' + kind);
+      }
+    };
+
+    const literal = (tok) => {
+      if (tok.kind !== 'literal' && tok.kind !== 'number') throw new Error('expected literal');
+      if (tok.kind === 'number') {
+        const v = tok.value;
+        const dt = /^-?\d+$/.test(v) ? 'http://www.w3.org/2001/XMLSchema#integer'
+          : /^-?\d+\.\d+$/.test(v) ? 'http://www.w3.org/2001/XMLSchema#decimal'
+          : 'http://www.w3.org/2001/XMLSchema#double';
+        return new OWLLiteral(v, new OWLDatatype(IRI.create(dt)));
+      }
+      return new OWLLiteral(tok.value.lex, tok.value.dt ? new OWLDatatype(IRI.create(tok.value.dt)) : null, tok.value.lang);
+    };
+
+    const classExpr = (tok) => {
+      if (tok.kind === 'iri') return new OWLClass(tok.value);
+      const n = tok.name;
+      const it = tok.items;
+      switch (n) {
+        case 'ObjectIntersectionOf': return new CE.OWLObjectIntersectionOf(it.map(classExpr));
+        case 'ObjectUnionOf': return new CE.OWLObjectUnionOf(it.map(classExpr));
+        case 'ObjectComplementOf': return new CE.OWLObjectComplementOf(classExpr(it[0]));
+        case 'ObjectSomeValuesFrom': return new CE.OWLObjectSomeValuesFrom(entity(it[0], 'op'), classExpr(it[1]));
+        case 'ObjectAllValuesFrom': return new CE.OWLObjectAllValuesFrom(entity(it[0], 'op'), classExpr(it[1]));
+        case 'ObjectHasValue': return new CE.OWLObjectHasValue(entity(it[0], 'op'), entity(it[1], 'ni'));
+        case 'ObjectOneOf': return new CE.OWLObjectOneOf(it.map(i => entity(i, 'ni')));
+        case 'ObjectHasSelf': return new CE.OWLObjectHasSelf(entity(it[0], 'op'));
+        case 'ObjectMinCardinality': return new CE.OWLObjectCardinalityRestriction(CE.ClassExpressionType.OBJECT_MIN_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'op'), it[2] ? classExpr(it[2]) : null);
+        case 'ObjectMaxCardinality': return new CE.OWLObjectCardinalityRestriction(CE.ClassExpressionType.OBJECT_MAX_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'op'), it[2] ? classExpr(it[2]) : null);
+        case 'ObjectExactCardinality': return new CE.OWLObjectCardinalityRestriction(CE.ClassExpressionType.OBJECT_EXACT_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'op'), it[2] ? classExpr(it[2]) : null);
+        case 'DataSomeValuesFrom': return new CE.OWLDataSomeValuesFrom(entity(it[0], 'dp'), dataRange(it[1]));
+        case 'DataAllValuesFrom': return new CE.OWLDataAllValuesFrom(entity(it[0], 'dp'), dataRange(it[1]));
+        case 'DataHasValue': return new CE.OWLDataHasValue(entity(it[0], 'dp'), literal(it[1]));
+        case 'DataMinCardinality': return new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_MIN_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'dp'), it[2] ? dataRange(it[2]) : null);
+        case 'DataMaxCardinality': return new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_MAX_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'dp'), it[2] ? dataRange(it[2]) : null);
+        case 'DataExactCardinality': return new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_EXACT_CARDINALITY, parseInt(it[0].value, 10), entity(it[1], 'dp'), it[2] ? dataRange(it[2]) : null);
+        default: throw new Error('Unknown class expression: ' + n);
+      }
+    };
+
+    const dataRange = (tok) => {
+      if (tok.kind === 'iri') return new OWLDatatype(tok.value);
+      const n = tok.name;
+      const it = tok.items;
+      switch (n) {
+        case 'DataIntersectionOf': return new CE.OWLDataIntersectionOf(it.map(dataRange));
+        case 'DataUnionOf': return new CE.OWLDataUnionOf(it.map(dataRange));
+        case 'DataComplementOf': return new CE.OWLDataComplementOf(dataRange(it[0]));
+        case 'DataOneOf': return new CE.OWLDataOneOf(it.map(literal));
+        case 'DatatypeRestriction': {
+          const dt = new OWLDatatype(tok.items[0].value);
+          const facets = it.slice(1).map(f => ({ facet: f.items ? f.items[0].value : f.value, value: literal(f.items ? f.items[1] : f) }));
+          return new CE.OWLDatatypeRestriction(dt, facets);
+        }
+        default: throw new Error('Unknown data range: ' + n);
+      }
+    };
+
+    const add = (ax) => onto.addAxiom(ax);
+
+    switch (name) {
+      case 'Declaration': {
+        const entTok = args[0];
+        if (entTok.kind === 'expr') {
+          const kind = entTok.name;
+          const iriTok = entTok.items[0];
+          const map = { Class: 'class', ObjectProperty: 'op', DataProperty: 'dp', NamedIndividual: 'ni', Datatype: 'dt', AnnotationProperty: 'ap' };
+          if (map[kind]) add(new AX.OWLDeclarationAxiom(entity(iriTok, map[kind])));
+        }
+        return;
+      }
+      case 'SubClassOf': add(new AX.OWLSubClassOfAxiom(classExpr(args[0]), classExpr(args[1]))); return;
+      case 'EquivalentClasses': add(new AX.OWLEquivalentClassesAxiom(args.map(classExpr))); return;
+      case 'DisjointClasses': add(new AX.OWLDisjointClassesAxiom(args.map(classExpr))); return;
+      case 'DisjointUnion': add(new AX.OWLDisjointUnionAxiom(entity(args[0], 'class'), args.slice(1).map(classExpr))); return;
+      case 'SubObjectPropertyOf': {
+        if (args[0] && args[0].kind === 'expr' && args[0].name === 'ObjectPropertyChain') {
+          const chain = args[0].items.map(t => entity(t, 'op'));
+          add(new AX.OWLSubPropertyChainOfAxiom(chain, entity(args[args.length - 1], 'op')));
+        } else {
+          add(new AX.OWLSubObjectPropertyOfAxiom(entity(args[0], 'op'), entity(args[1], 'op')));
+        }
+        return;
+      }
+      case 'SubObjectPropertyChain': {
+        const chain = args[0].kind === 'expr' && args[0].name === 'ObjectPropertyChain'
+          ? args[0].items.map(t => entity(t, 'op'))
+          : args.slice(0, -1).map(t => entity(t, 'op'));
+        add(new AX.OWLSubPropertyChainOfAxiom(chain, entity(args[args.length - 1], 'op')));
+        return;
+      }
+      case 'EquivalentObjectProperties': add(new AX.OWLEquivalentObjectPropertiesAxiom(args.map(t => entity(t, 'op')))); return;
+      case 'DisjointObjectProperties': add(new AX.OWLDisjointObjectPropertiesAxiom(args.map(t => entity(t, 'op')))); return;
+      case 'ObjectPropertyDomain': add(new AX.OWLObjectPropertyDomainAxiom(entity(args[0], 'op'), classExpr(args[1]))); return;
+      case 'ObjectPropertyRange': add(new AX.OWLObjectPropertyRangeAxiom(entity(args[0], 'op'), classExpr(args[1]))); return;
+      case 'InverseObjectProperties': add(new AX.OWLInverseObjectPropertiesAxiom(entity(args[0], 'op'), entity(args[1], 'op'))); return;
+      case 'FunctionalObjectProperty': add(new AX.OWLFunctionalObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'InverseFunctionalObjectProperty': add(new AX.OWLInverseFunctionalObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'ReflexiveObjectProperty': add(new AX.OWLReflexiveObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'IrreflexiveObjectProperty': add(new AX.OWLIrreflexiveObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'SymmetricObjectProperty': add(new AX.OWLSymmetricObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'AsymmetricObjectProperty': add(new AX.OWLAsymmetricObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'TransitiveObjectProperty': add(new AX.OWLTransitiveObjectPropertyAxiom(entity(args[0], 'op'))); return;
+      case 'SubDataPropertyOf': add(new AX.OWLSubDataPropertyOfAxiom(entity(args[0], 'dp'), entity(args[1], 'dp'))); return;
+      case 'EquivalentDataProperties': add(new AX.OWLEquivalentDataPropertiesAxiom(args.map(t => entity(t, 'dp')))); return;
+      case 'DisjointDataProperties': add(new AX.OWLDisjointDataPropertiesAxiom(args.map(t => entity(t, 'dp')))); return;
+      case 'DataPropertyDomain': add(new AX.OWLDataPropertyDomainAxiom(entity(args[0], 'dp'), classExpr(args[1]))); return;
+      case 'DataPropertyRange': add(new AX.OWLDataPropertyRangeAxiom(entity(args[0], 'dp'), dataRange(args[1]))); return;
+      case 'FunctionalDataProperty': add(new AX.OWLFunctionalDataPropertyAxiom(entity(args[0], 'dp'))); return;
+      case 'DatatypeDefinition': add(new AX.OWLDatatypeDefinitionAxiom(entity(args[0], 'dt'), dataRange(args[1]))); return;
+      case 'HasKey': add(new AX.OWLHasKeyAxiom(classExpr(args[0]), args.slice(1).map(t => entity(t, 'op')))); return;
+      case 'SameIndividual': add(new AX.OWLSameIndividualAxiom(args.map(t => entity(t, 'ni')))); return;
+      case 'DifferentIndividuals': add(new AX.OWLDifferentIndividualsAxiom(args.map(t => entity(t, 'ni')))); return;
+      case 'ClassAssertion': add(new AX.OWLClassAssertionAxiom(entity(args[1], 'ni'), classExpr(args[0]))); return;
+      case 'ObjectPropertyAssertion': add(new AX.OWLObjectPropertyAssertionAxiom(entity(args[1], 'ni'), entity(args[0], 'op'), entity(args[2], 'ni'))); return;
+      case 'NegativeObjectPropertyAssertion': add(new AX.OWLNegativeObjectPropertyAssertionAxiom(entity(args[1], 'ni'), entity(args[0], 'op'), entity(args[2], 'ni'))); return;
+      case 'DataPropertyAssertion': add(new AX.OWLDataPropertyAssertionAxiom(entity(args[1], 'ni'), entity(args[0], 'dp'), literal(args[2]))); return;
+      case 'NegativeDataPropertyAssertion': add(new AX.OWLNegativeDataPropertyAssertionAxiom(entity(args[1], 'ni'), entity(args[0], 'dp'), literal(args[2]))); return;
+      case 'AnnotationAssertion': {
+        const prop = entity(args[0], 'ap');
+        const subj = args[1].kind === 'iri' ? args[1].value : null;
+        const val = args[2].kind === 'iri' ? args[2].value : literal(args[2]);
+        add(new AX.OWLAnnotationAssertionAxiom(subj, prop, val));
+        return;
+      }
+      case 'SubAnnotationPropertyOf': add(new AX.OWLSubAnnotationPropertyOfAxiom(entity(args[0], 'ap'), entity(args[1], 'ap'))); return;
+      case 'AnnotationPropertyDomain': add(new AX.OWLAnnotationPropertyDomainAxiom(entity(args[0], 'ap'), args[1].value)); return;
+      case 'AnnotationPropertyRange': add(new AX.OWLAnnotationPropertyRangeAxiom(entity(args[0], 'ap'), args[1].value)); return;
+      default:
+        throw new Error('Unsupported axiom: ' + name);
+    }
+  }
+}
+
+module.exports = { FunctionalSyntaxParser };

package/src/io/FunctionalSyntaxWriter.js

@@ -0,0 +1,180 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// io/FunctionalSyntaxWriter — serialize an OWLOntology to OWL 2 Functional
+// Syntax (W3C §9). Round-trip capable counterpart to FunctionalSyntaxParser.
+// ---------------------------------------------------------------------------
+
+const { ClassExpressionType: T } = require('../model/OWLClassExpression');
+const { AxiomType: A } = require('../model/OWLAxiom');
+
+function iriOf(x) {
+  const s = x && x.getIRI ? x.getIRI().toString() : String(x);
+  return `<${s}>`;
+}
+
+function classExpr(e) {
+  if (!e) return '';
+  if (e.getIRI) return iriOf(e); // OWLClass / entity
+  switch (e.type) {
+    case T.OBJECT_INTERSECTION_OF:
+      return `ObjectIntersectionOf(${e.operands.map(classExpr).join(' ')})`;
+    case T.OBJECT_UNION_OF:
+      return `ObjectUnionOf(${e.operands.map(classExpr).join(' ')})`;
+    case T.OBJECT_COMPLEMENT_OF:
+      return `ObjectComplementOf(${classExpr(e.operand)})`;
+    case T.OBJECT_SOME_VALUES_FROM:
+      return `ObjectSomeValuesFrom(${iriOf(e.property)} ${classExpr(e.filler)})`;
+    case T.OBJECT_ALL_VALUES_FROM:
+      return `ObjectAllValuesFrom(${iriOf(e.property)} ${classExpr(e.filler)})`;
+    case T.OBJECT_HAS_VALUE:
+      return `ObjectHasValue(${iriOf(e.property)} ${iriOf(e.value)})`;
+    case T.OBJECT_ONE_OF:
+      return `ObjectOneOf(${e.operands.map(iriOf).join(' ')})`;
+    case T.OBJECT_HAS_SELF:
+      return `ObjectHasSelf(${iriOf(e.property)})`;
+    case T.OBJECT_MIN_CARDINALITY:
+      return `ObjectMinCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    case T.OBJECT_MAX_CARDINALITY:
+      return `ObjectMaxCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    case T.OBJECT_EXACT_CARDINALITY:
+      return `ObjectExactCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    case T.OBJECT_MIN_QUALIFIED_CARDINALITY:
+      return `ObjectMinCardinality(${e.cardinality} ${iriOf(e.property)} ${classExpr(e.filler)})`;
+    case T.OBJECT_MAX_QUALIFIED_CARDINALITY:
+      return `ObjectMaxCardinality(${e.cardinality} ${iriOf(e.property)} ${classExpr(e.filler)})`;
+    case T.OBJECT_EXACT_QUALIFIED_CARDINALITY:
+      return `ObjectExactCardinality(${e.cardinality} ${iriOf(e.property)} ${classExpr(e.filler)})`;
+    case T.DATA_SOME_VALUES_FROM:
+      return `DataSomeValuesFrom(${iriOf(e.property)} ${dataRange(e.filler)})`;
+    case T.DATA_ALL_VALUES_FROM:
+      return `DataAllValuesFrom(${iriOf(e.property)} ${dataRange(e.filler)})`;
+    case T.DATA_HAS_VALUE:
+      return `DataHasValue(${iriOf(e.property)} ${literal(e.value)})`;
+    case T.DATA_MIN_CARDINALITY:
+      return `DataMinCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    case T.DATA_MAX_CARDINALITY:
+      return `DataMaxCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    case T.DATA_EXACT_CARDINALITY:
+      return `DataExactCardinality(${e.cardinality} ${iriOf(e.property)})`;
+    default:
+      return iriOf(e);
+  }
+}
+
+function dataRange(dr) {
+  if (!dr) return '';
+  if (dr.getIRI) return iriOf(dr); // OWLDatatype
+  switch (dr.type) {
+    case T.DATA_INTERSECTION_OF:
+      return `DataIntersectionOf(${dr.operands.map(dataRange).join(' ')})`;
+    case T.DATA_UNION_OF:
+      return `DataUnionOf(${dr.operands.map(dataRange).join(' ')})`;
+    case T.DATA_COMPLEMENT_OF:
+      return `DataComplementOf(${dataRange(dr.operand)})`;
+    case T.DATA_ONE_OF:
+      return `DataOneOf(${dr.operands.map(literal).join(' ')})`;
+    case T.DATATYPE_RESTRICTION: {
+      const frs = dr.facetRestrictions.map(f => `${iriOf(f.facet)} ${literal(f.value)}`).join(' ');
+      return `DatatypeRestriction(${iriOf(dr.datatype)} ${frs})`;
+    }
+    default:
+      return iriOf(dr);
+  }
+}
+
+function literal(l) {
+  let s = `"${l.lexicalValue}"`;
+  if (l.lang) s += `@${l.lang}`;
+  else if (l.datatype) s += `^^${iriOf(l.datatype)}`;
+  return s;
+}
+
+function ind(i) {
+  return i.isAnonymous && i.isAnonymous() ? i.toString() : iriOf(i);
+}
+
+function axiom(ax) {
+  const t = ax.getAxiomType();
+  switch (t) {
+    case A.DECLARATION: {
+      const e = ax.entity;
+      const kind = e.isOWLClass() ? 'Class'
+        : e.isOWLObjectProperty() ? 'ObjectProperty'
+        : e.isOWLDataProperty() ? 'DataProperty'
+        : e.isOWLAnnotationProperty() ? 'AnnotationProperty'
+        : 'NamedIndividual';
+      return `Declaration(${kind}(${iriOf(e)}))`;
+    }
+    case A.SUBCLASS_OF: return `SubClassOf(${classExpr(ax.subClass)} ${classExpr(ax.superClass)})`;
+    case A.EQUIVALENT_CLASSES: return `EquivalentClasses(${ax.classExpressions.map(classExpr).join(' ')})`;
+    case A.DISJOINT_CLASSES: return `DisjointClasses(${ax.classExpressions.map(classExpr).join(' ')})`;
+    case A.DISJOINT_UNION: return `DisjointUnion(${classExpr(ax.owlClass)} ${ax.classExpressions.map(classExpr).join(' ')})`;
+    case A.SUB_OBJECT_PROPERTY_OF: return `SubObjectPropertyOf(${iriOf(ax.subProperty)} ${iriOf(ax.superProperty)})`;
+    case A.SUB_DATA_PROPERTY_OF: return `SubDataPropertyOf(${iriOf(ax.subProperty)} ${iriOf(ax.superProperty)})`;
+    case A.EQUIVALENT_OBJECT_PROPERTIES: return `EquivalentObjectProperties(${ax.properties.map(iriOf).join(' ')})`;
+    case A.DISJOINT_OBJECT_PROPERTIES: return `DisjointObjectProperties(${ax.properties.map(iriOf).join(' ')})`;
+    case A.EQUIVALENT_DATA_PROPERTIES: return `EquivalentDataProperties(${ax.properties.map(iriOf).join(' ')})`;
+    case A.DISJOINT_DATA_PROPERTIES: return `DisjointDataProperties(${ax.properties.map(iriOf).join(' ')})`;
+    case A.INVERSE_OBJECT_PROPERTIES: return `InverseObjectProperties(${iriOf(ax.property1)} ${iriOf(ax.property2)})`;
+    case A.OBJECT_PROPERTY_DOMAIN: return `ObjectPropertyDomain(${iriOf(ax.property)} ${classExpr(ax.domain)})`;
+    case A.OBJECT_PROPERTY_RANGE: return `ObjectPropertyRange(${iriOf(ax.property)} ${classExpr(ax.range)})`;
+    case A.DATA_PROPERTY_DOMAIN: return `DataPropertyDomain(${iriOf(ax.property)} ${classExpr(ax.domain)})`;
+    case A.DATA_PROPERTY_RANGE: return `DataPropertyRange(${iriOf(ax.property)} ${dataRange(ax.range)})`;
+    case A.FUNCTIONAL_OBJECT_PROPERTY: return `FunctionalObjectProperty(${iriOf(ax.property)})`;
+    case A.INVERSE_FUNCTIONAL_OBJECT_PROPERTY: return `InverseFunctionalObjectProperty(${iriOf(ax.property)})`;
+    case A.TRANSITIVE_OBJECT_PROPERTY: return `TransitiveObjectProperty(${iriOf(ax.property)})`;
+    case A.SYMMETRIC_OBJECT_PROPERTY: return `SymmetricObjectProperty(${iriOf(ax.property)})`;
+    case A.ASYMMETRIC_OBJECT_PROPERTY: return `AsymmetricObjectProperty(${iriOf(ax.property)})`;
+    case A.REFLEXIVE_OBJECT_PROPERTY: return `ReflexiveObjectProperty(${iriOf(ax.property)})`;
+    case A.IRREFLEXIVE_OBJECT_PROPERTY: return `IrreflexiveObjectProperty(${iriOf(ax.property)})`;
+    case A.FUNCTIONAL_DATA_PROPERTY: return `FunctionalDataProperty(${iriOf(ax.property)})`;
+    case A.SUB_PROPERTY_CHAIN_OF: return `SubObjectPropertyOf(ObjectPropertyChain(${ax.propertyChain.map(iriOf).join(' ')}) ${iriOf(ax.superProperty)})`;
+    case A.CLASS_ASSERTION: return `ClassAssertion(${classExpr(ax.classExpression)} ${ind(ax.individual)})`;
+    case A.OBJECT_PROPERTY_ASSERTION: return `ObjectPropertyAssertion(${iriOf(ax.property)} ${ind(ax.subject)} ${ind(ax.object)})`;
+    case A.DATA_PROPERTY_ASSERTION: return `DataPropertyAssertion(${iriOf(ax.property)} ${ind(ax.subject)} ${literal(ax.literal)})`;
+    case A.NEGATIVE_OBJECT_PROPERTY_ASSERTION: return `NegativeObjectPropertyAssertion(${iriOf(ax.property)} ${ind(ax.subject)} ${ind(ax.object)})`;
+    case A.NEGATIVE_DATA_PROPERTY_ASSERTION: return `NegativeDataPropertyAssertion(${iriOf(ax.property)} ${ind(ax.subject)} ${literal(ax.literal)})`;
+    case A.SAME_INDIVIDUAL: return `SameIndividual(${ax.individuals.map(ind).join(' ')})`;
+    case A.DIFFERENT_INDIVIDUALS: return `DifferentIndividuals(${ax.individuals.map(ind).join(' ')})`;
+    case A.HAS_KEY: return `HasKey(${classExpr(ax.classExpression)} (${ax.propertyExpressions.map(iriOf).join(' ')}))`;
+    case A.ANNOTATION_ASSERTION: {
+      const v = ax.value && ax.value.lexicalValue !== undefined ? literal(ax.value) : iriOf(ax.value);
+      return `AnnotationAssertion(${iriOf(ax.property)} ${ax.subject ? iriOf(ax.subject) : ''} ${v})`;
+    }
+    case A.DATATYPE_DEFINITION: return `DatatypeDefinition(${iriOf(ax.datatype)} ${dataRange(ax.dataRange)})`;
+    case A.SUB_ANNOTATION_PROPERTY_OF: return `SubAnnotationPropertyOf(${iriOf(ax.subProperty)} ${iriOf(ax.superProperty)})`;
+    case A.ANNOTATION_PROPERTY_DOMAIN: return `AnnotationPropertyDomain(${iriOf(ax.property)} ${iriOf(ax.domain)})`;
+    case A.ANNOTATION_PROPERTY_RANGE: return `AnnotationPropertyRange(${iriOf(ax.property)} ${iriOf(ax.range)})`;
+    default: return null;
+  }
+}
+
+/**
+ * Serialize an OWLOntology to OWL 2 Functional Syntax.
+ * @param {OWLOntology} ont
+ * @returns {string}
+ */
+function writeFunctionalSyntax(ont) {
+  const lines = [];
+  const id = ont.getOntologyID();
+  const head = [];
+  if (id.ontologyIRI) {
+    head.push(iriOf(id.ontologyIRI));
+    if (id.versionIRI) head.push(iriOf(id.versionIRI));
+  }
+  for (const imp of ont.imports || []) {
+    head.push(`Import(${iriOf(imp)})`);
+  }
+  for (const ann of ont.getOntologyAnnotations()) {
+    const v = ann.value && ann.value.lexicalValue !== undefined ? literal(ann.value) : iriOf(ann.value);
+    head.push(`Annotation(${iriOf(ann.property)} ${v})`);
+  }
+  const axioms = ont.getAxioms().map(axiom).filter(Boolean);
+  lines.push(`Ontology(${head.join(' ')}`);
+  for (const a of axioms) lines.push('  ' + a);
+  lines.push(')');
+  return lines.join('\n');
+}
+
+module.exports = { writeFunctionalSyntax, classExpr, dataRange, literal };