parser.java

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

  }

  final public void parseKnowledgeBase() throws ParseException {
    if (jj_2_1(3)) {
      oldStuff();
    } else {
      ;
    }
    switch (jj_nt.kind) {
    case EXTENSION:
      versionInfo();
      break;
    default:
      jj_la1[25] = jj_gen;
      ;
    }
    label_14:
    while (true) {
      switch (jj_nt.kind) {
      case LPAREN:
        ;
        break;
      default:
        jj_la1[26] = jj_gen;
        break label_14;
      }
      instance();
    }
    jj_consume_token(0);
  }

  final public void parseOntology() throws ParseException {
    if (jj_2_2(3)) {
      includeOntologies();
    } else {
      ;
    }
    switch (jj_nt.kind) {
    case EXTENSION:
      versionInfo();
      break;
    default:
      jj_la1[27] = jj_gen;
      ;
    }
    label_15:
    while (true) {
      switch (jj_nt.kind) {
      case LPAREN:
        ;
        break;
      default:
        jj_la1[28] = jj_gen;
        break label_15;
      }
      cls();
    }
    jj_consume_token(0);
  }

  final public void patternMatchFacet(Frame frame, Slot slot) throws ParseException {
    jj_consume_token(PATTERN_MATCH);
    switch (jj_nt.kind) {
    case REACTIVE:
      jj_consume_token(REACTIVE);
      break;
    case NON_REACTIVE:
      jj_consume_token(NON_REACTIVE);
      break;
    default:
      jj_la1[29] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

  }

  final public void patternMatchRole(Frame frame, Slot slot) throws ParseException {
    jj_consume_token(LPAREN);
    jj_consume_token(PATTERN_MATCH);
    switch (jj_nt.kind) {
    case REACTIVE:
      jj_consume_token(REACTIVE);
      break;
    case NON_REACTIVE:
      jj_consume_token(NON_REACTIVE);
      break;
    default:
      jj_la1[30] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(RPAREN);

  }

  final public void propagationFacet(Frame frame, Slot slot) throws ParseException {
    jj_consume_token(PROPAGATION);
    switch (jj_nt.kind) {
    case INHERIT:
      jj_consume_token(INHERIT);
      break;
    case NO_INHERIT:
      jj_consume_token(NO_INHERIT);
      break;
    default:
      jj_la1[31] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

  }

  final public void rangeValueDescription(Cls cls, Slot slot) throws ParseException {
    String min;
    String max;
    jj_consume_token(RANGE);
    min = symbol();
    max = symbol();
        Float minValue = toFloat(min);
        Float maxValue = toFloat(max);
        if (cls == null) {
            slot.setMinimumValue(minValue);
            slot.setMaximumValue(maxValue);
        } else {
            cls.setTemplateSlotMinimumValue(slot, minValue);
            cls.setTemplateSlotMaximumValue(slot, maxValue);
        }
  }

  final public void slot(Cls cls) throws ParseException {
    boolean isTopLevel;
    boolean isSingle;
    String name;
    Slot slot;
    try {
      jj_consume_token(LPAREN);
      isSingle = slotCardinality();
      name = slotName();
            isTopLevel = (cls == null) || !hasSlot(name);
            slot=createTemplateSlot(name, isSingle, cls, isTopLevel);
            if (isTopLevel) {
                cls = null;
            }
      label_16:
      while (true) {
        switch (jj_nt.kind) {
        case LPAREN:
        case EXTENSION:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_16;
        }
        facetStatement(cls, slot);
      }
      jj_consume_token(RPAREN);
    } catch (Exception e) {
        handleException(e);
    }
  }

  final public boolean slotCardinality() throws ParseException {
    boolean single = true;
    switch (jj_nt.kind) {
    case SLOT:
      jj_consume_token(SLOT);
      break;
    case SINGLE_SLOT:
      jj_consume_token(SINGLE_SLOT);
      break;
    case MULTISLOT:
      jj_consume_token(MULTISLOT);
                                           single=false;
      break;
    default:
      jj_la1[33] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return single;}
    throw new Error("Missing return statement in function");
  }

  final public void slotDocumentationFacet(Cls cls, Slot slot) throws ParseException {
    String s;
    jj_consume_token(COMMENT);
    s = string();
        if (cls == null) {
            slot.setDocumentation(s);
        } else {
            cls.setTemplateSlotDocumentation(slot, s);
        }
  }

  final public void inverseSlotProperty(Cls cls, Slot slot) throws ParseException {
    String s;
    jj_consume_token(INVERSE_SLOT);
    s = slotName();
        Slot inverseSlot = getSlot(s);
        addInverseSlotPair(slot, inverseSlot);
  }

  final public void superslotProperty(Cls cls, Slot slot) throws ParseException {
    String s;
    Collection superslots = new ArrayList();
    jj_consume_token(SUBSLOT_OF);
    label_17:
    while (true) {
      switch (jj_nt.kind) {
      case ABSTRACT:
      case ACCESS:
      case ALLOWED_CLASSES:
      case ALLOWED_FLOATS:
      case ALLOWED_GRAMMAR:
      case ALLOWED_INTEGERS:
      case ALLOWED_PARENTS:
      case ALLOWED_STRINGS:
      case ALLOWED_SYMBOLS:
      case ALLOWED_VALUES:
      case ANY:
      case ASSOCIATED_FACET:
      case BUILD:
      case CARDINALITY:
      case COMMENT:
      case COMPOSITE:
      case CONCRETE:
      case CREATE_ACCESSOR:
      case DEFAULT_:
      case DEFCLASS:
      case EXCLUSIVE:
      case FLOAT:
      case INCLUDE:
      case INHERIT:
      case INITIALIZER_ONLY:
      case INSTANCE:
      case INTEGER:
      case INVERSE_SLOT:
      case IS_A:
      case LOCAL:
      case MULTISLOT:
      case NO_INHERIT:
      case NON_REACTIVE:
      case NOTE:
      case OF:
      case OVERRIDE_MESSAGE:
      case PATTERN_MATCH:
      case PRIVATE:
      case PROPAGATION:
      case PUBLIC:
      case RANGE:
      case REACTIVE:
      case READ:
      case READ_ONLY:
      case READ_WRITE:
      case ROLE:
      case SINGLE_SLOT:
      case SHARED:
      case SLOT:
      case SOURCE:
      case STORAGE:
      case STRING:
      case SUBSLOT_OF:
      case SYMBOL:
      case TYPE:
      case USER_FACET:
      case VALUE:
      case VISIBILITY:
      case VERSION:
      case WRITE:
      case SYMBOL_LITERAL:
        ;
        break;
      default:
        jj_la1[34] = jj_gen;
        break label_17;
      }
      s = slotName();
                                superslots.add(s);
    }
        addSuperslots(slot, superslots);
  }

  final public void associatedFacet(Cls cls, Slot slot) throws ParseException {
    String facetName;
    jj_consume_token(ASSOCIATED_FACET);
    facetName = facetName();
        Facet facet = getOrCreateFacet(facetName);
        slot.setAssociatedFacet(facet);
        facet.setAssociatedSlot(slot);
  }

  final public String slotName() throws ParseException {
    String s;
    s = symbol();
        if (s.equals("name_")) {
            s = "name";
        } else if (s.equals("is-a_")) {
            s = "is-a";
        } else if (s.charAt(0) == ':') {
            // hack for old tables project
            if (s.equals(":domain-value")
                    || s.equals(":range-value")
                    || s.equals(":entry-slot")
                    || s.equals(":domain-value-slots")
                    || s.equals(":range-value-slots")) {
                s = s.substring(1, s.length());
            }
        }
        {if (true) return s;}
    throw new Error("Missing return statement in function");
  }

  final public void slotValue(Instance instance, Collection directTypes) throws ParseException {
    String name;
    Collection values;
    Slot slot;
    ValueType valueType;
    jj_consume_token(LPAREN);
    name = slotName();
        slot=getExistingSlot(name);
        valueType = getOwnSlotValueType(instance, directTypes, slot);
    values = slotValueFields(instance, slot, valueType);
    jj_consume_token(RPAREN);
        if (slot == null) {
            recordError("value for unknown slot: " + name + " in instance " + instance);
        } else {
            instance.setOwnSlotValues(slot, values);
        }
  }

  final public Collection slotValueFields(Instance instance, Slot slot, ValueType type) throws ParseException {
    Collection values = new ArrayList();
    Object value;
    label_18:
    while (true) {
      switch (jj_nt.kind) {
      case ABSTRACT:
      case ACCESS:
      case ALLOWED_CLASSES:
      case ALLOWED_FLOATS:
      case ALLOWED_GRAMMAR:
      case ALLOWED_INTEGERS:
      case ALLOWED_PARENTS:
      case ALLOWED_STRINGS:
      case ALLOWED_SYMBOLS:
      case ALLOWED_VALUES:
      case ANY:
      case ASSOCIATED_FACET:
      case BUILD:
      case CARDINALITY:
      case COMMENT:
      case COMPOSITE:
      case CONCRETE:
      case CREATE_ACCESSOR:
      case DEFAULT_:
      case DEFCLASS:
      case EXCLUSIVE:
      case FLOAT:
      case INCLUDE:
      case INHERIT:
      case INITIALIZER_ONLY:
      case INSTANCE:
      case INTEGER:
      case INVERSE_SLOT:
      case IS_A:
      case LOCAL:
      case MULTISLOT:
      case NO_INHERIT:
      case NON_REACTIVE:
      case NOTE:
      case OF:
      case OVERRIDE_MESSAGE:
      case PATTERN_MATCH:
      case PRIVATE:
      case PROPAGATION:
      case PUBLIC:
      case RANGE:
      case REACTIVE:
      case READ:
      case READ_ONLY:
      case READ_WRITE:
      case ROLE:
      case SINGLE_SLOT:
      case SHARED:
      case SLOT:
      case SOURCE:
      case STORAGE:
      case STRING:
      case SUBSLOT_OF:
      case SYMBOL:
      case TYPE:
      case USER_FACET:
      case VALUE:
      case VISIBILITY:
      case VERSION:
      case WRITE:
      case INSTANCE_NAME_LITERAL:
      case STRING_LITERAL:
      case SYMBOL_LITERAL:
        ;
        break;
      default:
        jj_la1[35] = jj_gen;
        break label_18;
      }
      value = constant();
                        checkedValueAdd(values, type, value);
    }
        {if (true) return values;}
    throw new Error("Missing return statement in function");
  }

  final public void slotValueFieldProperty() throws ParseException {
    jj_consume_token(LPAREN);
    symbol();
    label_19:
    while (true) {
      switch (jj_nt.kind) {
      case ABSTRACT:
      case ACCESS:
      case ALLOWED_CLASSES:
      case ALLOWED_FLOATS:
      case ALLOWED_GRAMMAR:
      case ALLOWED_INTEGERS:
      case ALLOWED_PARENTS:
      case ALLOWED_STRINGS:
      case ALLOWED_SYMBOLS:
      case ALLOWED_VALUES:
      case ANY:
      case ASSOCIATED_FACET:
      case BUILD:
      case CARDINALITY:
      case COMMENT:
      case COMPOSITE:
      case CONCRETE:
      case CREATE_ACCESSOR:
      case DEFAULT_:
      case DEFCLASS:
      case EXCLUSIVE:
      case FLOAT:
      case INCLUDE:
      case INHERIT:
      case INITIALIZER_ONLY:
      case INSTANCE:
      case INTEGER:
      case INVERSE_SLOT:
      case IS_A:
      case LOCAL:
      case MULTISLOT:
      case NO_INHERIT:
      case NON_REACTIVE:
      case NOTE:
      case OF:
      case OVERRIDE_MESSAGE:
      case PATTERN_MATCH:
      case PRIVATE:
      case PROPAGATION:
      case PUBLIC:
      case RANGE:
      case REACTIVE:
      case READ:
      case READ_ONLY:
      case READ_WRITE:
      case ROLE:
      case SINGLE_SLOT:
      case SHARED:
      case SLOT:
      case SOURCE:
      case STORAGE:
      case STRING:
      case SUBSLOT_O