commit 9e2950ab33a7af0ddb4c633534453d8bf2d27325 Author: josch Date: Mon Jan 17 23:10:11 2011 +0200 initial commit diff --git a/META-INF/MANIFEST.MF b/META-INF/MANIFEST.MF new file mode 100644 index 0000000..cbf316c --- /dev/null +++ b/META-INF/MANIFEST.MF @@ -0,0 +1,19 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: Hets +Bundle-SymbolicName: de.unibremen.informatik.hets;singleton:=true +Bundle-Version: 1.0.0.qualifier +Bundle-Activator: de.unibremen.informatik.hets.protege.Activator +Bundle-ActivationPolicy: lazy +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 +Import-Package: org.osgi.framework;version="1.3.0", + org.protege.owlapi.apibinding, + org.protege.owlapi.model, + org.semanticweb.owlapi.model, + javax.swing +Require-Bundle: org.eclipse.equinox.registry, + org.eclipse.equinox.common, + org.protege.common;bundle-version="4.1.0", + org.protege.editor.core.application;bundle-version="4.1.0", + org.protege.editor.owl;bundle-version="4.1.0", + org.semanticweb.owl.owlapi;bundle-version="3.0.0" diff --git a/build.xml b/build.xml new file mode 100644 index 0000000..3f5e094 --- /dev/null +++ b/build.xml @@ -0,0 +1,267 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugin.xml b/plugin.xml new file mode 100644 index 0000000..9964a33 --- /dev/null +++ b/plugin.xml @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/de/unibremen/informatik/hets/grammar/HetCASLGrammar.jjt b/src/de/unibremen/informatik/hets/grammar/HetCASLGrammar.jjt new file mode 100644 index 0000000..09da904 --- /dev/null +++ b/src/de/unibremen/informatik/hets/grammar/HetCASLGrammar.jjt @@ -0,0 +1,270 @@ +options { +// MULTI=true; +// NODE_EXTENDS="MyNode"; + TRACK_TOKENS=true; + UNICODE_INPUT=true; + STATIC=false; +} + +PARSER_BEGIN(HetCASLParser) +package de.unibremen.informatik.hets.grammar; + +import java.util.Hashtable; + +public class HetCASLParser {} +PARSER_END(HetCASLParser) + +SKIP : { " " | "\t" | "\n" | "\r" } + +/* COMMENTS */ + +SPECIAL_TOKEN : +{ + +} + +TOKEN : { +/* reserved */ + < _AND: "and" > +| < _ARCH: "arch" > +| < _AS: "as" > +| < _AXIOM: "axiom" > +| < _AXIOMS: "axioms" > +| < _CLOSED: "closed" > +| < _DEF: "def" > +| < _ELSE: "else" > +| < _END: "end" > +| < _EXISTS: "exists" > +| < _FALSE: "false" > +| < _FIT: "fit" > +| < _FORALL: "forall" > +| < _FREE: "free" > +| < _FROM: "from" > +| < _GENERATED: "generated" > +| < _GET: "get" > +| < _GIVEN: "given" > +| < _HIDE: "hide" > +| < _IF: "if" > +| < _IN: "in" > +| < _LAMBDA: "lambda" > +| < _LIBRARY: "library" > +| < _LOCAL: "local" > +| < _NOT: "not" > +| < _OP: "op" > +| < _OPS: "ops" > +| < _PRED: "pred" > +| < _PREDS: "preds" > +| < _RESULT: "result" > +| < _REVEAL: "reveal" > +| < _SORT: "sort" > +| < _SORTS: "sorts" > +| < _SPEC: "spec" > +| < _THEN: "then" > +| < _TO: "to" > +| < _TRUE: "true" > +| < _TYPE: "type" > +| < _TYPEs: "types" > +| < _UNIT: "unit" > +| < _UNITS: "units" > +| < _VAR: "var" > +| < _VARS: "vars" > +| < _VERSION: "version" > +| < _VIEW: "view" > +| < _WHEN: "when" > +| < _WITH: "with" > +| < _WITHIN: "within" > +/* not reserved */ +| < _ASSOC: "assoc" > +| < _COMM: "comm" > +| < _IDEM: "idem" > +/* hetcasl */ +| < _LOGIC: "logic" > +| < _DATA: "data" > +/* helper */ +//| < _EQUALS: "=" > +} + +/* specification libraries */ +TOKEN : { + < LIB_NAME : | ( ) > +} + +TOKEN : { + < LIB_ID : | > +} + +TOKEN : { + < VERSION_NUMBER : ( )+ > +} + +/* words */ + +TOKEN : { + < WORDS : ( "_" )* > +} + +TOKEN : { + < DOT_WORDS : "." > +} + +TOKEN : { + < WORD : ( )+ > +} + +TOKEN : { + < WORD_CHAR : | "’" | > +} + +TOKEN : { + < LETTER : [ "A"-"Z", "a"-"z", "À", "Á", "Â", "Ã", "Ä", "Å", "Æ", "Ç", "È", "É", + "Ê", "Ë", "Ì", "Í", "Î", "Ï", "Ð", "Ñ", "Ò", "Ó", "Ô", "Õ", "Ö", + "Ø", "Ù", "Ú", "Û", "Ü", "Ý", "Þ", "ß", "à", "á", "â", "ã", "ä", + "å", "æ", "ç", "è", "é", "ê", "ë", "ì", "í", "î", "ï", "ð", "ñ", + "ò", "ó", "ô", "õ", "ö", "ø", "ù", "ú", "û", "ü", "ý", "þ", "ÿ" ] > +} + +TOKEN : { + < DIGIT : [ "0"-"9" ] > +} + +/* signs */ + +TOKEN : { + < SIGNS : ( )+ > +} + +TOKEN : { + < SIGN : [ "+", "-", "*", "/", "\\", "&", /* "=",*/ "<", ">", + "!", "?", ":", ".", "$", "@", "#", "ˆ", "˜", + "¡", "¿", "×", "÷", "£", "c", "±", "¶", "§", + "1", "2", "3", "·", "c", "◦", "¬", "µ", "|" ] > +} + +/* literal strings and numbers */ + +TOKEN : { + < NUMBER : ( )+ > +} + +/* urls and paths */ + +TOKEN : { + < PATH_CHAR : [ "A"-"Z", "a"-"z", "0"-"9", + "$", "-", "_", "@", ".", "&", "+", "!", "*", + "\"", "’", "(", ")", ",", ":", "~" ] + | ("%" ) > +} + +TOKEN : { + < HEX_CHAR : [ "A"-"F", "a"-"f", "0"-"9" ] > +} + +TOKEN : { + < PATH_WORD : ( )+ > +} + +TOKEN : { + < PATH : ( "/" )+ > +} + +TOKEN : { + < URL : "http://" + | "ftp://" + | "file:///" > +} + +TOKEN : { + < _EQUALS : "=" > : IN_SPEC +} + + MORE : { + < ~[] > +} + + SPECIAL_TOKEN : { + < EXT_ANNO_CONS : "%cons" > +} + SPECIAL_TOKEN : { + < EXT_ANNO_MONO : "%mono" > +} + SPECIAL_TOKEN : { + < EXT_ANNO_DEF : "%def" > +} + SPECIAL_TOKEN : { + < EXT_ANNO_IMPLIES : "%implies" > +} + + TOKEN : { +// < SPEC_AND : <_AND> > : IN_SPEC + < SPEC_THEN : <_THEN> > : IN_SPEC +| < SPEC_END : <_END> > : DEFAULT +} + +/* basic spec */ + +SimpleNode LIB_DEFN() : +{ + String value; + Token t; +} +{ + <_LIBRARY> t= ( LOGIC() )+ + { + value = t.image; + jjtThis.jjtSetValue(value); + return jjtThis; + } +} + +void LOGIC() : +{ + String value; + Token t; +} +{ + <_LOGIC> t= ( SPEC_DEFN() )+ + { + value = t.image; + jjtThis.jjtSetValue(value); + } +} + +void SPEC_DEFN() : +{ + String value; + Token t; +} +{ + <_SPEC> t= <_EQUALS> ( SPEC_END() | ( SPEC_THEN() )+ SPEC_END() ) + { + value = t.image; + jjtThis.jjtSetValue(value); + } +} + +void SPEC_END() : +{ + String value; + Token t; +} +{ + t = + { + t.image = t.image.substring(0, t.image.length()-3); + value = t.image; + jjtThis.jjtSetValue(value); + } +} +void SPEC_THEN() : +{ + String value; + Token t; +} +{ + t = + { + t.image = t.image.substring(0, t.image.length()-4); + value = t.image; + jjtThis.jjtSetValue(value); + } +} \ No newline at end of file diff --git a/src/de/unibremen/informatik/hets/protege/Activator.java b/src/de/unibremen/informatik/hets/protege/Activator.java new file mode 100644 index 0000000..5267dd3 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/Activator.java @@ -0,0 +1,27 @@ +package de.unibremen.informatik.hets.protege; + +import org.osgi.framework.BundleActivator; +import org.osgi.framework.BundleContext; + + + +public class Activator implements BundleActivator { + + //private OWLDataFactory dataFactory; + /* + * (non-Javadoc) + * @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext) + */ + public void start(BundleContext context) throws Exception { + System.out.println("Hello Woaaaarld!!"); + } + + /* + * (non-Javadoc) + * @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext) + */ + public void stop(BundleContext context) throws Exception { + System.out.println("Goodbye World!!"); + } + +} diff --git a/src/de/unibremen/informatik/hets/protege/Aterm.java b/src/de/unibremen/informatik/hets/protege/Aterm.java new file mode 100644 index 0000000..e69de29 diff --git a/src/de/unibremen/informatik/hets/protege/ExportHetsAction.java b/src/de/unibremen/informatik/hets/protege/ExportHetsAction.java new file mode 100644 index 0000000..4c07be5 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/ExportHetsAction.java @@ -0,0 +1,107 @@ +package de.unibremen.informatik.hets.protege; + +import java.awt.event.ActionEvent; +import java.io.ByteArrayOutputStream; +import java.util.HashSet; +import java.util.Set; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +import org.protege.editor.core.ui.util.UIUtil; +import org.protege.editor.owl.ui.action.ProtegeOWLAction; +import org.semanticweb.owlapi.model.OWLOntologyManager; +import org.semanticweb.owlapi.model.OWLOntologyStorageException; +import org.semanticweb.owlapi.io.StreamDocumentTarget; + +import org.semanticweb.owlapi.model.OWLOntology; + +import de.unibremen.informatik.hets.protege.ImportHetsAction; +import org.semanticweb.owlapi.model.IRI; + +public class ExportHetsAction extends ProtegeOWLAction { + + /** + * + */ + private static final long serialVersionUID = 8507263538705345008L; + + public ExportHetsAction() { + // TODO Auto-generated constructor stub + } + + @Override + public void initialise() throws Exception { + // TODO Auto-generated method stub + + } + + @Override + public void dispose() throws Exception { + // TODO Auto-generated method stub + } + + String dumpOntologyToString(String name) { + String result; + + OWLOntologyManager ontologymanager = this.getOWLModelManager().getOWLOntologyManager(); + ByteArrayOutputStream outputstream = new ByteArrayOutputStream(); + + try { + ontologymanager.saveOntology(ontologymanager.getOntology(IRI.create("http://informatik.uni-bremen.de/hets/"+name+".het")), outputstream); + } catch (OWLOntologyStorageException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + result = outputstream.toString(); + result = result.replaceAll("(?m)^Prefix: .*$", ""); + result = result.replaceAll("(?m)^Ontology: .*$", ""); + result = result.replaceAll("(?m)^Import: .*$", ""); + result = result.replaceAll("(?m)^\\s*$[\n\r]{1,}", ""); + result = result.replaceAll("(?m)(^.*$)", " $1"); + return result; + } + + @Override + public void actionPerformed(ActionEvent e) { + /* + Set exts = new HashSet(); + exts.add("het"); + exts.add("owl"); + UIUtil.saveFile(this.getOWLWorkspace(), "title", "description", exts, "foobar.het"); + System.out.println(this.getOWLModelManager().getActiveOntology()); + this.getOWLModelManager().getOWLOntologyManager().addOntologyStorer(new HetCASLOntologyStorer()); + this.getOWLWorkspace(); + try { + this.getOWLModelManager().getOWLOntologyManager().saveOntology(this.getOWLModelManager().getActiveOntology(), new HetCASLOntologyFormat(), new StreamDocumentTarget(System.out)); + } catch (OWLOntologyStorageException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + }*/ + + + Set exts = new HashSet(); + exts.add("het"); + exts.add("owl"); + File f = UIUtil.saveFile(this.getOWLWorkspace(), "title", "description", exts, "foobar.het"); + if (f.exists()) { + // TODO: ask if overwrite + f.delete(); + } + FileOutputStream outputFile = null; + try { + outputFile = new FileOutputStream(f, true); + int i; + for (i = 0; i < ImportHetsAction.parts.size()-1; i++) { + outputFile.write(ImportHetsAction.parts.get(i).getBytes()); + outputFile.write(dumpOntologyToString(ImportHetsAction.owl_parts.get(i)).getBytes()); + } + outputFile.write(ImportHetsAction.parts.get(i).getBytes()); + outputFile.close(); + } catch (IOException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/src/de/unibremen/informatik/hets/protege/HetCASLOntologyFormat.java b/src/de/unibremen/informatik/hets/protege/HetCASLOntologyFormat.java new file mode 100644 index 0000000..6dd63b8 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/HetCASLOntologyFormat.java @@ -0,0 +1,18 @@ +package de.unibremen.informatik.hets.protege; + +import org.coode.owlapi.manchesterowlsyntax.ManchesterOWLSyntaxOntologyFormat; + +public class HetCASLOntologyFormat extends ManchesterOWLSyntaxOntologyFormat { + + public HetCASLOntologyFormat() { + setDefaultPrefix("http://informatik.uni-bremen.de/hets#"); + } + + public HetCASLOntologyFormat(String prefix) { + setDefaultPrefix(prefix); + } + + public String toString() { + return "HetCASL"; + } +} \ No newline at end of file diff --git a/src/de/unibremen/informatik/hets/protege/HetCASLOntologyStorer.java b/src/de/unibremen/informatik/hets/protege/HetCASLOntologyStorer.java new file mode 100644 index 0000000..a84a555 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/HetCASLOntologyStorer.java @@ -0,0 +1,12 @@ +package de.unibremen.informatik.hets.protege; + +import org.semanticweb.owlapi.model.OWLOntologyFormat; + +import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOntologyStorer; + +public class HetCASLOntologyStorer extends ManchesterOWLSyntaxOntologyStorer { + + public boolean canStoreOntology(OWLOntologyFormat arg0) { + return arg0.equals(new HetCASLOntologyFormat()); + } +} \ No newline at end of file diff --git a/src/de/unibremen/informatik/hets/protege/HetCASLRenderingViewComponent.java b/src/de/unibremen/informatik/hets/protege/HetCASLRenderingViewComponent.java new file mode 100644 index 0000000..d59a248 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/HetCASLRenderingViewComponent.java @@ -0,0 +1,24 @@ +package de.unibremen.informatik.hets.protege; + +import java.io.Writer; + +import org.protege.editor.owl.ui.view.ontology.AbstractOntologyRenderingViewComponent; +import org.semanticweb.owlapi.model.OWLOntology; + +import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxRenderer; + +public class HetCASLRenderingViewComponent extends AbstractOntologyRenderingViewComponent { + + /** + * + */ + private static final long serialVersionUID = 3845613418666267771L; + + @Override + protected void renderOntology(OWLOntology ontology, Writer writer) throws Exception { + // TODO Auto-generated method stub + ManchesterOWLSyntaxRenderer ren = new ManchesterOWLSyntaxRenderer(getOWLModelManager().getOWLOntologyManager()); + ren.render(ontology, writer); + writer.flush(); + } +} \ No newline at end of file diff --git a/src/de/unibremen/informatik/hets/protege/ImportHetsAction.java b/src/de/unibremen/informatik/hets/protege/ImportHetsAction.java new file mode 100644 index 0000000..6859e54 --- /dev/null +++ b/src/de/unibremen/informatik/hets/protege/ImportHetsAction.java @@ -0,0 +1,246 @@ +package de.unibremen.informatik.hets.protege; + +import java.awt.HeadlessException; +import java.awt.event.ActionEvent; +import org.protege.editor.core.ui.util.UIUtil; + +import javax.swing.*; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.OutputStream; +import java.io.FileInputStream; +import java.util.HashSet; +import java.util.Hashtable; +import java.util.ArrayList; +import java.util.Set; + +import org.protege.editor.owl.ui.action.ProtegeOWLAction; +import org.semanticweb.owlapi.apibinding.OWLManager; +import org.semanticweb.owlapi.model.AddImport; +import org.semanticweb.owlapi.model.IRI; +import org.semanticweb.owlapi.model.OWLClass; +import org.semanticweb.owlapi.model.OWLOntology; +import org.semanticweb.owlapi.model.OWLOntologyCreationException; +import org.semanticweb.owlapi.model.OWLOntologyManager; +import org.semanticweb.owlapi.model.OWLOntologyStorageException; +import org.semanticweb.owlapi.util.SimpleIRIMapper; + +import de.unibremen.informatik.hets.grammar.HetCASLParser; +import de.unibremen.informatik.hets.grammar.ParseException; +import de.unibremen.informatik.hets.grammar.SimpleNode; + +public class ImportHetsAction extends ProtegeOWLAction { + + public static ArrayList parts; + public static Hashtable ontologies; + public static ArrayList owl_parts; + + /** + * + */ + private static final long serialVersionUID = -4056096587762591108L; + + @Override + public void initialise() throws Exception { + // TODO Auto-generated method stub + } + + @Override + public void dispose() throws Exception { + // TODO Auto-generated method stub + + } + + OWLOntology loadOntologyFromString(OWLOntologyManager manager, String str, String iri) { + OWLOntology ont; + try { + str = "Ontology: \n" + + "Prefix: : \n" + + str; + ont = manager.loadOntologyFromOntologyDocument(new ByteArrayInputStream(str.getBytes())); + } catch (OWLOntologyCreationException e1) { + System.out.println(" -- begin"); + System.out.println(str); + System.out.println("-- end"); + e1.printStackTrace(); + ont = null; + } + return ont; + } + + void saveOntologyToStream(OWLOntologyManager manager, OWLOntology ont, OutputStream out, String defaultprefix) { + try { + manager.saveOntology(ont, new HetCASLOntologyFormat(defaultprefix), out); + } catch (OWLOntologyStorageException e) { + e.printStackTrace(); + } + } + + OWLOntology createOntologyFromURL(OWLOntologyManager manager, String url) { + OWLOntology ont; + try { + ont = manager.createOntology(IRI.create(url)); + } catch (OWLOntologyCreationException e) { + e.printStackTrace(); + ont = null; + } + return ont; + } + + OWLOntology displayOntology(String ont_string, OWLOntology parent_ont, String iri, String parent_iri) { + OWLOntologyManager manager = this.getOWLModelManager().getOWLOntologyManager(); + + manager.addOntologyStorer(new HetCASLOntologyStorer()); + + System.out.println(parent_ont + ", " + parent_iri + ", " + iri); + if (parent_ont != null && parent_iri != "" && parent_iri != iri) { + OWLOntologyManager tempmanager = OWLManager.createOWLOntologyManager(); + tempmanager.addOntologyStorer(new HetCASLOntologyStorer()); + + manager.addIRIMapper(new SimpleIRIMapper(IRI.create("http://informatik.uni-bremen.de/hets/"+iri+".het"), IRI.create("http://foobar"))); + OWLOntology temp_ont; + ByteArrayOutputStream outputstream = new ByteArrayOutputStream(); + temp_ont = createOntologyFromURL(tempmanager, "http://informatik.uni-bremen.de/hets/"+iri+".het"); + + System.out.println(parent_iri + ", " + parent_ont); + tempmanager.addIRIMapper(new SimpleIRIMapper(IRI.create("http://informatik.uni-bremen.de/hets/"+parent_iri+".het"), manager.getOntologyDocumentIRI(parent_ont))); + + tempmanager.applyChange(new AddImport(temp_ont, manager.getOWLDataFactory().getOWLImportsDeclaration(IRI.create("http://informatik.uni-bremen.de/hets/"+parent_iri+".het")))); + + for (OWLClass cls : parent_ont.getClassesInSignature()) { + tempmanager.addAxiom(temp_ont, manager.getOWLDataFactory().getOWLDeclarationAxiom(cls)); + } + + saveOntologyToStream(tempmanager, temp_ont, outputstream, "http://informatik.uni-bremen.de/hets/"+parent_iri+".het#"); + + tempmanager.removeOntology(temp_ont); + + try { + outputstream.write(ont_string.getBytes()); + } catch (IOException e) { + e.printStackTrace(); + } + + ont_string = outputstream.toString(); + } + + if (parent_iri == "") { + parent_iri = iri; + } + + OWLOntology ontology1 = loadOntologyFromString(manager, ont_string, iri); + manager.setOntologyFormat(ontology1, new HetCASLOntologyFormat("http://informatik.uni-bremen.de/hets/"+parent_iri+".het#")); + + this.getOWLModelManager().setActiveOntology(ontology1); + + return ontology1; + } + + @Override + public void actionPerformed(ActionEvent event) { + + parts = new ArrayList(); + ontologies = new Hashtable(); + owl_parts = new ArrayList(); + + Set exts = new HashSet(); + exts.add("het"); + exts.add("owl"); + FileInputStream file = null; + try { + file = new FileInputStream(UIUtil.openFile(new JFrame(), "HetCASL", "Please select a *.het file", exts)); + } catch (HeadlessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + HetCASLParser parser = new HetCASLParser(file); + SimpleNode parseTree = null; + try { + parseTree = parser.LIB_DEFN(); + } catch (ParseException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + int num_logics, num_spec_defs, num_specs; + boolean is_owl = false; + OWLOntology parent = null; + String parent_name = ""; + String spec_name = ""; + String value; + SimpleNode logicnode, specdefnode, specnode; + + value = (String)((SimpleNode)parseTree).jjtGetValue(); // lib name + num_logics = parseTree.jjtGetNumChildren(); + + parts.add(""); + parts.set(parts.size()-1, parts.get(parts.size()-1) + "library " + value + "\n\n"); + + for (int i = 0; i < num_logics; i++) { + logicnode = (SimpleNode)parseTree.jjtGetChild(i); + value = (String)logicnode.jjtGetValue(); // logic name + num_spec_defs = logicnode.jjtGetNumChildren(); + + parts.set(parts.size()-1, parts.get(parts.size()-1) + "logic " + value + "\n\n"); + + System.out.println(value); + if (value.contains("OWL")) { + is_owl = true; + System.out.println("is OWL"); + } else { + is_owl = false; + } + + for (int j = 0; j < num_spec_defs; j++) { + specdefnode = (SimpleNode)logicnode.jjtGetChild(j); + value = (String)specdefnode.jjtGetValue(); // spec name + num_specs = specdefnode.jjtGetNumChildren(); + + spec_name = value.trim(); + parts.set(parts.size()-1, parts.get(parts.size()-1) + "spec " + spec_name + " ="); + + for (int k = 0; k < num_specs; k++) { + specnode = (SimpleNode)specdefnode.jjtGetChild(k); + value = (String)specnode.jjtGetValue(); // spec + + // TODO: enable printspecial + //System.out.println(printspecial(specnode.jjtGetFirstToken())); + + if (is_owl) { + // check if only name + if (value.trim().contains(" ")) { + //System.out.println("display ontology: "+spec_name+", "+parent_name); + parent = displayOntology(value, parent, spec_name, parent_name); + ontologies.put(spec_name+parent_name, parent); + owl_parts.add(spec_name); + parts.add(""); + } else { + parent_name = value.trim(); + parts.set(parts.size()-1, parts.get(parts.size()-1) + " " + parent_name + "\n"); + parent = ontologies.get(parent_name); + + //System.out.println(" +++ " + parent + " " + ((String)values.get("spec")).trim()); + } + } else { + parts.set(parts.size()-1, parts.get(parts.size()-1) + value); + } + + if (specnode.toString() == "SPEC_THEN") { + parts.set(parts.size()-1, parts.get(parts.size()-1) + "then"); + } else if (specnode.toString() == "SPEC_END") { + parts.set(parts.size()-1, parts.get(parts.size()-1) + "end\n\n"); + } + } + + parent = null; + parent_name = ""; + } + } + } +}