slparser.java

java实现的P2P多agent中间件

      s = String();
        // if it is true or false, then converts the String into a Boolean
        if (CaseInsensitiveString.equalsIgnoreCase(s, "true"))
                val = AbsPrimitive.wrap(true);
        else if (CaseInsensitiveString.equalsIgnoreCase(s, "false"))
                val = AbsPrimitive.wrap(false);
        else {
        if (  (CaseInsensitiveString.equalsIgnoreCase(s,"\"true\""))
            ||(CaseInsensitiveString.equalsIgnoreCase(s,"\"false\"")) )
                  // in this case leading/trailing quotes were added by the
                  // encoder and now they must be removed. 
                  s = unescape(s);
                    val = AbsPrimitive.wrap(s);
        }
      break;
    case INTEGER:
    case HEXINTEGER:
    case FLOATONE:
    case FLOATTWO:
      val = Number();
      break;
    case DATETIME:
      t = jj_consume_token(DATETIME);
    try {
      Date d=jade.lang.acl.ISO8601.toDate(t.image);
      val = AbsPrimitive.wrap(d);
    } catch (Exception e) {
      val = AbsPrimitive.wrap(t.image);
                 }
      break;
    case PREFIXBYTELENGTHENCODEDSTRING:
      t = jj_consume_token(PREFIXBYTELENGTHENCODEDSTRING);
    val = AbsPrimitive.wrap(t.image.getBytes());
      break;
    default:
      jj_la1[7] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  {if (true) return val;}
    throw new Error("Missing return statement in function");
  }

  final public AbsConcept FunctionalTerm_NoBrace() throws ParseException {
  Token t; AbsTerm term1, term2; AbsConcept val=null; String s;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ARITHMETICOP:
      t = jj_consume_token(ARITHMETICOP);
      term1 = Term();
      term2 = Term();
        val = new AbsConcept(t.image);
        try {
           String slotNames[] = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], term1);
           val.set(slotNames[1], term2);
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", term1);
           val.set(Codec.UNNAMEDPREFIX+"1", term2);
        }
      break;
    case WORD:
    case STRING_LITERAL:
    case WORD2:
    case STRING_LITERAL2:
      s = String();
      if ( (SL0Vocabulary.SET.equalsIgnoreCase(s)) || (SL0Vocabulary.SEQUENCE.equalsIgnoreCase(s)))
         val = new AbsAggregate(s);
      else
         val = new AbsConcept(s);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
      case VARIABLE:
      case INTEGER:
      case HEXINTEGER:
      case FLOATONE:
      case FLOATTWO:
      case WORD:
      case STRING_LITERAL:
      case PARAMETERNAME:
      case PARAMETERNAME_STRING:
      case DATETIME:
      case PREFIXBYTELENGTHENCODEDSTRING:
      case METASYMBOL:
      case LBRACE2:
      case WORD2:
      case STRING_LITERAL2:
      case METASYMBOL2:
        FunctionalTermParameters(val);
        break;
      default:
        jj_la1[8] = jj_gen;
        ;
      }
      break;
    default:
      jj_la1[9] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  {if (true) return val;}
    throw new Error("Missing return statement in function");
  }

// artificial production, needed to avoid a bad warning from javacc
// val can be either an AbsConcept or an AbsAggregate
  final public void FunctionalTermParameters(AbsConcept val) throws ParseException {
  AbsTerm t; int slotNumber=0;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
    case VARIABLE:
    case INTEGER:
    case HEXINTEGER:
    case FLOATONE:
    case FLOATTWO:
    case WORD:
    case STRING_LITERAL:
    case DATETIME:
    case PREFIXBYTELENGTHENCODEDSTRING:
    case METASYMBOL:
    case LBRACE2:
    case WORD2:
    case STRING_LITERAL2:
    case METASYMBOL2:
       String slotNames[] = null;
         try {
           slotNames = curOntology.getSchema(val.getTypeName()).getNames();
         } catch (Exception e) {
         }
      label_2:
      while (true) {
        t = Term();
         try {
               val.set(slotNames[slotNumber], t);
         } catch (Exception e) {
               val.set(Codec.UNNAMEDPREFIX+slotNumber,t);
         }
        slotNumber++;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LBRACE:
        case VARIABLE:
        case INTEGER:
        case HEXINTEGER:
        case FLOATONE:
        case FLOATTWO:
        case WORD:
        case STRING_LITERAL:
        case DATETIME:
        case PREFIXBYTELENGTHENCODEDSTRING:
        case METASYMBOL:
        case LBRACE2:
        case WORD2:
        case STRING_LITERAL2:
        case METASYMBOL2:
          ;
          break;
        default:
          jj_la1[10] = jj_gen;
          break label_2;
        }
      }
      break;
    case PARAMETERNAME:
    case PARAMETERNAME_STRING:
      label_3:
      while (true) {
        Parameter(val);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PARAMETERNAME:
        case PARAMETERNAME_STRING:
          ;
          break;
        default:
          jj_la1[11] = jj_gen;
          break label_3;
        }
      }
      break;
    default:
      jj_la1[12] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void Parameter(AbsConcept val) throws ParseException {
  Token t; AbsTerm term; String slotName;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PARAMETERNAME:
      t = jj_consume_token(PARAMETERNAME);
                               slotName = t.image.substring(1);
      break;
    case PARAMETERNAME_STRING:
      t = jj_consume_token(PARAMETERNAME_STRING);
                               slotName = unescape(t.image.substring(1));
      break;
    default:
      jj_la1[13] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    term = Term();
                               val.set(slotName,term);
  }

  final public AbsAgentAction ActionExpression_NoBrace() throws ParseException {
  AbsAgentAction val=null; AbsTerm term1, term2; Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ACTION:
      t = jj_consume_token(ACTION);
      term1 = Term();
      term2 = Term();
       val = new AbsAgentAction(t.image);
       try {
           String slotNames[] = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], term1);
           val.set(slotNames[1], toAbsAgentAction(term2));
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", term1);
           val.set(Codec.UNNAMEDPREFIX+"1", toAbsAgentAction(term2));
        }
      break;
    case ACTIONOPLL:
      t = jj_consume_token(ACTIONOPLL);
                    if (slType<2) {if (true) throw new ParseException("NotFullSL_ActionOperatorExpression_NotParsable");}
      term1 = ActionExpression();
      term2 = ActionExpression();
       val = new AbsAgentAction(t.image);
       try {
           String slotNames[] = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], term1);
           val.set(slotNames[1], toAbsAgentAction(term2));
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", term1);
           val.set(Codec.UNNAMEDPREFIX+"1", toAbsAgentAction(term2));
        }
      break;
    default:
      jj_la1[14] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
   {if (true) return val;}
    throw new Error("Missing return statement in function");
  }

  final public AbsTerm ActionExpression() throws ParseException {
  AbsTerm val=null; String s;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
    case LBRACE2:
      LBrace();
      val = ActionExpression_NoBrace();
      RBrace();
      break;
    case METASYMBOL:
    case METASYMBOL2:
      s = MetaSymbol();
                     AbsVariable val1=new AbsVariable(); val1.setName(s); val1.setIsMetaTerm(true); val=val1;
      break;
    default:
      jj_la1[15] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
   {if (true) return val;}
    throw new Error("Missing return statement in function");
  }

  final public AbsPredicate Wff() throws ParseException {
  AbsPredicate val=null; String s;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case WORD:
    case STRING_LITERAL:
    case WORD2:
    case STRING_LITERAL2:
      s = String();
                 val = new AbsPredicate(s);
      break;
    case LBRACE:
    case LBRACE2:
      LBrace();
      val = Wff_NoBrace();
      RBrace();
      break;
    case METASYMBOL:
    case METASYMBOL2:
      s = MetaSymbol();
                     val=new AbsPredicate(s); val.setIsMetaFormula(true);
      break;
    default:
      jj_la1[16] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  {if (true) return val;}
    throw new Error("Missing return statement in function");
  }

  final public AbsPredicate Wff_NoBrace() throws ParseException {
  AbsPredicate arg1, arg2, val=null; Token t; AbsTerm term; String s;
  String slotNames[]=null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case UNARYLOGICALOP:
      t = jj_consume_token(UNARYLOGICALOP);
                        if (slType<1) {if (true) throw new ParseException("NotFullSL_NotExpression_NotParsable_UseAtLeastSL1");}
      arg1 = Wff();
    val = new AbsPredicate(t.image);
    try {
           slotNames = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], arg1);
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", arg1);
        }
      break;
    case BINARYLOGICALOP:
      t = jj_consume_token(BINARYLOGICALOP);
                         if (slType<1) {if (true) throw new ParseException("NotFullSL_BinaryLogicalExpression_NotParsable_UseAtLeastSL1");}
      arg1 = Wff();
      arg2 = Wff();
    val = new AbsPredicate(t.image);
    try {
           slotNames = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], arg1);
           val.set(slotNames[1], arg2);
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", arg1);
           val.set(Codec.UNNAMEDPREFIX+"1", arg2);
        }
      break;
    case QUANTIFIER:
      t = jj_consume_token(QUANTIFIER);
                    if (slType<2) {if (true) throw new ParseException("NotFullSL_QuantifierExpression_NotParsable_UseAtLeastSL2");} AbsVariable var;
      var = Variable();
      arg1 = Wff();
    val = new AbsPredicate(t.image);
    try {
           slotNames = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], var);
           val.set(slotNames[1], arg1);
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", var);
           val.set(Codec.UNNAMEDPREFIX+"1", arg1);
        }
      break;
    case MODALOP:
      t = jj_consume_token(MODALOP);
                 if (slType<2) {if (true) throw new ParseException("NotFullSL_ModalOperatorExpression_NotParsable_UseAtLeastSL2");}
      term = Term();
      arg1 = Wff();
    val = new AbsPredicate(t.image);
    try {
           slotNames = curOntology.getSchema(t.image).getNames();
           val.set(slotNames[0], term);
           val.set(slotNames[1], arg1);
        } catch (Exception e) {
           val.set(Codec.UNNAMEDPREFIX+"0", term);
           val.set(Codec.UNNAMEDPREFIX+"1", arg1);
        }
      break;