parser.java

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

        switch (jj_nt.kind) {
        case LPAREN:
          ;
          break;
        default:
          jj_la1[9] = jj_gen;
          break label_5;
        }
        slot(cls);
      }
      jj_consume_token(RPAREN);
    } catch (Exception e) {
        handleException(e);
    } catch (TokenMgrError e) {
        handleException(e);
    }
  }

  final public Cls clsReference() throws ParseException {
    String name;
    name = symbol();
        {if (true) return getCls(name, null, Collections.EMPTY_LIST, false);}
    throw new Error("Missing return statement in function");
  }

  final public List clsesList() throws ParseException {
    List clses = new ArrayList();
    Cls cls;
    label_6:
    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[10] = jj_gen;
        break label_6;
      }
      cls = clsReference();
                         clses.add(cls);
    }
        {if (true) return clses;}
    throw new Error("Missing return statement in function");
  }

  final public void clsRole(Cls cls) throws ParseException {
    boolean isAbstract;
    jj_consume_token(LPAREN);
    jj_consume_token(ROLE);
    switch (jj_nt.kind) {
    case CONCRETE:
      jj_consume_token(CONCRETE);
                                 isAbstract = false;
      break;
    case ABSTRACT:
      jj_consume_token(ABSTRACT);
                            isAbstract = true;
      break;
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(RPAREN);
        if (cls != null) {
            cls.setAbstract(isAbstract);
        }
  }

  final public Object constant() throws ParseException {
    Object o;
    switch (jj_nt.kind) {
    case STRING_LITERAL:
      o = string();
      break;
    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:
      o = symbol();
      break;
    case INSTANCE_NAME_LITERAL:
      o = instanceReference();
      break;
    default:
      jj_la1[12] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return o;}
    throw new Error("Missing return statement in function");
  }

  final public List constants() throws ParseException {
    Object value;
    List list = new ArrayList();
    label_7:
    while (true) {
      value = constant();
                         list.add(value);
      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[13] = jj_gen;
        break label_7;
      }
    }
        {if (true) return list;}
    throw new Error("Missing return statement in function");
  }

  final public void constraintValueDescription(Cls cls, Slot slot) throws ParseException {
    switch (jj_nt.kind) {
    case TYPE:
      typeValueDescription(cls, slot);
      break;
    case ALLOWED_FLOATS:
    case ALLOWED_INTEGERS:
    case ALLOWED_STRINGS:
    case ALLOWED_SYMBOLS:
    case ALLOWED_VALUES:
      allowedConstantValueDescription(cls, slot);
      break;
    case RANGE:
      rangeValueDescription(cls, slot);
      break;
    case CARDINALITY:
      cardinalityValueDescription(cls, slot);
      break;
    default:
      jj_la1[14] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void constraintValueDescriptionExtension(Cls cls, Slot slot) throws ParseException {
    allowedConstantValueDescriptionExtension(cls, slot);
  }

  final public void createAccessorFacet(Cls cls, Slot slot) throws ParseException {
    jj_consume_token(CREATE_ACCESSOR);
    switch (jj_nt.kind) {
    case QUESTION_NONE:
      jj_consume_token(QUESTION_NONE);
      break;
    case READ:
      jj_consume_token(READ);
      break;
    case WRITE:
      jj_consume_token(WRITE);
      break;
    case READ_WRITE:
      jj_consume_token(READ_WRITE);
      break;
    default:
      jj_la1[15] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

  }

  final public void defaultFacet(Cls cls, Slot slot) throws ParseException {
    List list = new ArrayList();
    Object value;
    ValueType type = getSlotType(cls, slot);
    jj_consume_token(DEFAULT_);
    label_8:
    while (true) {
      value = constant();
                                  checkedValueAdd(list, type, value);
      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[16] = jj_gen;
        break label_8;
      }
    }
        if (cls == null) {
            slot.setDefaultValues(list);
        } else {
            cls.setTemplateSlotDefaultValues(slot, list);
        }
  }

  final public String facetName() throws ParseException {
    String name;
    name = symbol();
        {if (true) return name;}
    throw new Error("Missing return statement in function");
  }

  final public void userFacet(Cls cls, Slot slot) throws ParseException {
    List rawvalues = new ArrayList();
    String facetName;
    Object rawvalue;
    jj_consume_token(USER_FACET);
    facetName = facetName();
    label_9:
    while (true) {
      rawvalue = constant();
                                                             rawvalues.add(rawvalue);
      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: