parser.java

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

      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[17] = jj_gen;
        break label_9;
      }
    }
        Facet facet = getOrCreateFacet(facetName);
        ValueType type = facet.getValueType();
        List values = new ArrayList();
        Iterator i = rawvalues.iterator();
        while (i.hasNext()) {
            Object value = i.next();
            checkedValueAdd(values, type, value);
        }
        if (cls != null) {
                cls.setTemplateFacetValues(slot, facet, values);
        }
  }

  final public void templateSlotValueFacet(Cls cls, Slot slot) throws ParseException {
    List list = new ArrayList();
    Object value;
    ValueType type = getSlotType(cls, slot);
    jj_consume_token(VALUE);
    label_10:
    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[18] = jj_gen;
        break label_10;
      }
    }
        if (cls == null) {
            slot.setValues(list);
        } else {
            cls.setTemplateSlotValues(slot, list);
        }
  }

  final public void facet(Cls cls, Slot slot) throws ParseException {
    switch (jj_nt.kind) {
    case DEFAULT_:
      defaultFacet(cls, slot);
      break;
    case STORAGE:
      storageFacet(cls, slot);
      break;
    case ACCESS:
      accessFacet(cls, slot);
      break;
    case USER_FACET:
      userFacet(cls, slot);
      break;
    case PROPAGATION:
      propagationFacet(cls, slot);
      break;
    case SOURCE:
      sourceFacet(cls, slot);
      break;
    case PATTERN_MATCH:
      patternMatchFacet(cls, slot);
      break;
    case VISIBILITY:
      visibilityFacet(cls, slot);
      break;
    case CREATE_ACCESSOR:
      createAccessorFacet(cls, slot);
      break;
    case OVERRIDE_MESSAGE:
      overrideMessageFacet(cls, slot);
      break;
    case ALLOWED_FLOATS:
    case ALLOWED_INTEGERS:
    case ALLOWED_STRINGS:
    case ALLOWED_SYMBOLS:
    case ALLOWED_VALUES:
    case CARDINALITY:
    case RANGE:
    case TYPE:
      constraintValueDescription(cls, slot);
      break;
    case COMMENT:
      slotDocumentationFacet(cls, slot);
      break;
    case INVERSE_SLOT:
      inverseSlotProperty(cls, slot);
      break;
    case VALUE:
      templateSlotValueFacet(cls, slot);
      break;
    case SUBSLOT_OF:
      superslotProperty(cls, slot);
      break;
    case ASSOCIATED_FACET:
      associatedFacet(cls, slot);
      break;
    case ALLOWED_CLASSES:
    case ALLOWED_GRAMMAR:
    case ALLOWED_PARENTS:
      constraintValueDescriptionExtension(cls, slot);
      break;
    default:
      jj_la1[19] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void facetStatement(Cls cls, Slot slot) throws ParseException {
    switch (jj_nt.kind) {
    case EXTENSION:
      jj_consume_token(EXTENSION);
      break;
    default:
      jj_la1[20] = jj_gen;
      ;
    }
    jj_consume_token(LPAREN);
    facet(cls, slot);
    jj_consume_token(RPAREN);
  }

  final public void includeOntologies() throws ParseException {
    String name;
    List list = new ArrayList();
    jj_consume_token(EXTENSION);
    jj_consume_token(LPAREN);
    jj_consume_token(INCLUDE);
    label_11:
    while (true) {
      switch (jj_nt.kind) {
      case STRING_LITERAL:
        ;
        break;
      default:
        jj_la1[21] = jj_gen;
        break label_11;
      }
      name = string();
                                                   list.add(name);
    }
    jj_consume_token(RPAREN);

  }

  final public void instance() throws ParseException {
    String instanceName;
    Cls type;
    Collection types = new ArrayList();
    Instance instance;
    try {
      jj_consume_token(LPAREN);
      instanceName = instanceName();
      jj_consume_token(OF);
      label_12:
      while (true) {
        type = clsReference();
                                                                        types.add(type);
        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[22] = jj_gen;
          break label_12;
        }
      }
            instance=getInstance(instanceName, types);
      label_13:
      while (true) {
        switch (jj_nt.kind) {
        case LPAREN:
          ;
          break;
        default:
          jj_la1[23] = jj_gen;
          break label_13;
        }
        slotValue(instance, types);
      }
      jj_consume_token(RPAREN);
    } catch (Exception e) {
        handleException(e);
    } catch (TokenMgrError e) {
        handleException(e);
    }
  }

  final public String instanceName() throws ParseException {
    String name;
    Token t;
    t = jj_consume_token(INSTANCE_NAME_LITERAL);
        name = t.image;
        name = name.substring(1, name.length()-1);
        name = ClipsUtil.toInternalSymbol(name);
        {if (true) return name;}
    throw new Error("Missing return statement in function");
  }

  final public Instance instanceReference() throws ParseException {
    String name;
    name = instanceName();
        {if (true) return getInstance(name, null);}
    throw new Error("Missing return statement in function");
  }

  final public void oldStuff() throws ParseException {
    jj_consume_token(EXTENSION);
    string();
    jj_consume_token(EXTENSION);
    instanceName();

  }

  final public void overrideMessageFacet(Frame frame, Slot slot) throws ParseException {
    jj_consume_token(OVERRIDE_MESSAGE);
    switch (jj_nt.kind) {
    case QUESTION_DEFAULT:
      jj_consume_token(QUESTION_DEFAULT);
      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:
      symbol();
      break;
    default:
      jj_la1[24] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }

  }

  final public void versionInfo() throws ParseException {
    String version;
    String build;
    jj_consume_token(EXTENSION);
    jj_consume_token(LPAREN);
    jj_consume_token(VERSION);
    version = string();
    jj_consume_token(RPAREN);
    jj_consume_token(EXTENSION);
    jj_consume_token(LPAREN);
    jj_consume_token(BUILD);
    build = string();
    jj_consume_token(RPAREN);
    itsKB.setVersionString(version);
    itsKB.setBuildString(build);