compactparser.jj

Sematic Assessment System: Java GUI application that store all data in an Ontology in protege.

options {
    JAVA_UNICODE_ESCAPE = true;
    STATIC = false;
}

PARSER_BEGIN(CompactParser)

package edu.stanford.smi.protegex.owl.model.classparser.compact;

import com.hp.hpl.jena.ontology.OntClass;
import edu.stanford.smi.protege.model.*;
import edu.stanford.smi.protegex.owl.model.*;
import edu.stanford.smi.protegex.owl.model.impl.*;
import edu.stanford.smi.protegex.owl.ui.profiles.*;
import edu.stanford.smi.protegex.owl.model.classparser.*;
import java.io.StringReader;
import java.util.*;


class CompactParser {

    public static boolean nextCouldBeCls;
    public static boolean nextCouldBeInstance;
    public static boolean nextCouldBeSlot;
    public static boolean nextCouldBeDatatypeName;
    public static RDFProperty recentHasValueProperty;
    public static String errorMessage;
    public static DatatypeNameChecker datatypeNameChecker;

    private OWLModel owlModel;

    private boolean create;

	public static DatatypeNameChecker getDatatypeNameChecker() {
		return datatypeNameChecker;
	}

    public static void checkClass(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        text = CompactParserUtil.getParseableString(text);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = false;
        parser.parseFile();
    }

    private void checkFeatureSupported(OntClass ontClass) throws ParseException {
        if(!ProfilesManager.isFeatureSupported(owlModel, ontClass)) {
            String label = ontClass.getLabel(null);
            if(label == null) {
                label = ontClass.getLocalName();
            }
            errorMessage = "Feature \"" + label + "\" unavailable in current language profile";
            throw generateParseException();
        }
    }


    public static void checkHasValueFiller(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        text = CompactParserUtil.getParseableString(text);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = false;
        parser.OWLHasValueValue();
    }


    public static void checkQuantifierFiller(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        text = CompactParserUtil.getParseableString(text);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = false;
        if(parser.DataType() == null) {
            throw new ParseException("Unknown datatype \"" + text + "\".");
        }
    }


    public static RDFSClass parseClass(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        text = CompactParserUtil.getParseableString(text);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = true;
        return parser.parseFile();
    }


    public static Object parseHasValueFiller(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = true;
        return parser.OWLHasValueValue();
    }


    public static Object parseQuantifierFiller(OWLModel owlModel, String text) throws ParseException {
        reset();
        datatypeNameChecker = new DatatypeNameChecker(owlModel);
        text = CompactParserUtil.getParseableString(text);
        CompactParser parser = new CompactParser(new StringReader(text));
        parser.owlModel = owlModel;
        parser.create = false;
        return parser.DataType();
    }


    private static void reset() {
        nextCouldBeCls = false;
        nextCouldBeSlot = false;
        nextCouldBeInstance = false;
        nextCouldBeDatatypeName = false;
        errorMessage = null;
    }
}

PARSER_END(CompactParser)


/* WHITE SPACE */

SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}

TOKEN: {<OPENPAR: "(">}
TOKEN: {<CLOSEPAR: ")">}
TOKEN: {<OPENSQPAR: "[">}
TOKEN: {<CLOSESQPAR: "]">}
TOKEN: {<UNBOUNDEDVAL: "..">}

/* COMMENTS */

MORE :
{
  "//" : IN_SINGLE_LINE_COMMENT
|
  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
  "/*" : IN_MULTI_LINE_COMMENT
}

<IN_SINGLE_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT
}

<IN_FORMAL_COMMENT>
SPECIAL_TOKEN :
{
  <FORMAL_COMMENT: "*/" > : DEFAULT
}

<IN_MULTI_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
}

<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
MORE :
{
  < ~[] >
}

TOKEN :
{
  < INTEGER_LITERAL: (["-"])?["0"-"9"] (["0"-"9"])* >
|
  < FLOATING_POINT_LITERAL:
        (["-"])?(["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
      | (["-"])? "." (["0"-"9"])+ (<EXPONENT>)?
      | (["-"])?(["0"-"9"])+ <EXPONENT>
      | (["-"])?(["0"-"9"])+ (<EXPONENT>)?
  >
|
  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
|
  < STRING_LITERAL:

      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\""]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "\""
  >
}

/* IDENTIFIERS */

TOKEN :
{
  < ONE_OF: "owl:oneOf{" >
|
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* | "'" (~["'"])* "'" > {
    String idName = ParserUtils.dequoteIdentifier(matchedToken.image);
    if(CompactParser.getDatatypeNameChecker().isDatatypeName(idName)) {
		matchedToken.kind = DATATYPEID;
    }
  }
|
<DATATYPEID: (<LETTER>)+>
|
  < #LETTER:
      [
       ":",
       ".",
       "-",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uac00"-"\ud7a3",
       "\uf900"-"\ufaff"
      ]
  >
|
  < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
  >
}


RDFSClass parseFile() :
{
    RDFSClass result;
}
{
    result=OWLUnionClass() <EOF>
    {
        return result;
    }
}


RDFSClass OWLUnionClass() :
{
    List clses = new ArrayList();
    RDFSClass cls;
}
{
    cls=OWLIntersectionClass() {clses.add(cls);} ( LOOKAHEAD(2) "|"
    cls=OWLIntersectionClass() {clses.add(cls);} )*
    {
        if(clses.size() == 1) {
            return cls;
        }
        else {
            checkFeatureSupported(OWLProfiles.Union_Classes);
            if(create) {
                return owlModel.createOWLUnionClass(clses);
            }
            else {
                return null;
            }
        }
    }
}


RDFSClass OWLIntersectionClass() :
{
    List clses = new ArrayList();
    RDFSClass cls;
}
{
    cls=OWLComplementClass() {clses.add(cls);} ( LOOKAHEAD(2) "&"
    cls=OWLComplementClass() {clses.add(cls);} )*
    {
        if(clses.size() == 1) {
            return cls;
        }
        else {
            if(create) {
                return owlModel.createOWLIntersectionClass(clses);
            }
            else {
                return null;
            }
        }
    }
}


RDFSClass OWLComplementClass() :
{
    RDFSClass cls;
}
{
    (
        ("!" cls=OWLRestrictionOrNamedClass()
            {
                checkFeatureSupported(OWLProfiles.Complement_Classes);
                if(create) {
                    return owlModel.createOWLComplementClass(cls);
                }
                else {
                    return null;
                }
            }
        )
      | cls=OWLRestrictionOrNamedClass()
    )
    {
        return cls;
    }
}


RDFSClass OWLRestrictionOrNamedClass() :
{
    RDFSClass cls;
}
{
    (
        cls=OWLEnumeratedClass()
      | cls=IDClass()
      | <OPENPAR> cls=OWLUnionClass() <CLOSEPAR>
    )
    {
        return cls;
    }
}


// An artificial concept that branches depending on whether the id is a class
// or a slot name
RDFSClass IDClass() :
{
    String id;
}
{
    id=Identifier()
    {
        Frame frame = ParserUtils.getFrameByName(owlModel, id);
        if(frame instanceof RDFSClass) {
            return (RDFSClass) frame;
        }
        else {
            if(frame instanceof RDFProperty && !((RDFProperty)frame).isAnnotationProperty()) {
                recentHasValueProperty = (RDFProperty) frame;
                return Restriction(recentHasValueProperty);
            }
            else {
                nextCouldBeCls = true;
                nextCouldBeSlot = true;
                errorMessage = "Class or property name expected";
                throw generateParseException();
            }
        }
    }
}


OWLRestriction Restriction(RDFProperty property) :
{
    OWLRestriction result;
}
{
    (
        result=OWLCardinalityBase(property)
      | result=OWLHasValue(property)
      | result=OWLAllValuesFrom(property)
      | result=OWLSomeValuesFrom(property)
    )
    {
        return result;
    }
}


OWLCardinalityBase OWLCardinalityBase(RDFProperty property) :
{
    OWLCardinalityBase result;
    RDFSClass valuesFromClass = null;
}
{
    (
        result=OWLMaxCardinality(property)
      | result=OWLMinCardinality(property)
      | result=OWLCardinality(property)
    )  [ valuesFromClass = OWLUnionClass() ]
    {
        if(create && valuesFromClass != null) {
            result.setValuesFrom(valuesFromClass);
        }
        return result;
    }
}


OWLMaxCardinality OWLMaxCardinality(RDFProperty slot) :
{
    int card;
}
{
    "<" card=CardinalityValue()
    {
        checkFeatureSupported(OWLProfiles.MaxCardinality_Restrictions);
        if(create) {
            return owlModel.createOWLMaxCardinality(slot, card);
        }
        else {