asnparser.java

ASN.1工具源代码,包括编译源码生成工具和各种基本类型构造类型的编解码实现代码

  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SET_TKN:
        jj_consume_token(SET_TKN);
                 jjtn000.which = 1;
        break;
      case SEQUENCE_TKN:
        jj_consume_token(SEQUENCE_TKN);
                                                         jjtn000.which = 2;
        break;
      default:
        jj_la1[29] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LEFTPAREN_TKN:
      case SIZE_TKN:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LEFTPAREN_TKN:
          jj_consume_token(LEFTPAREN_TKN);
          break;
        default:
          jj_la1[30] = jj_gen;
          ;
        }
                                                                                                     jjtn000.has_size_constraint = true;
        SizeConstraint();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RIGHTPAREN_TKN:
          jj_consume_token(RIGHTPAREN_TKN);
          break;
        default:
          jj_la1[31] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[32] = jj_gen;
        ;
      }
      jj_consume_token(OF_TKN);
      Type();
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void SetOrSequenceType() throws ParseException {
                            /*@bgen(jjtree) SetOrSequenceType */
  ASTSetOrSequenceType jjtn000 = new ASTSetOrSequenceType(this, JJTSETORSEQUENCETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SET_TKN:
        jj_consume_token(SET_TKN);
               jjtn000.which = 1;
        break;
      case SEQUENCE_TKN:
        jj_consume_token(SEQUENCE_TKN);
                                                       jjtn000.which = 2;
        break;
      default:
        jj_la1[33] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(LEFTBRACE_TKN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OBJECT_IDENTIFIER_TKN:
      case LEFTBRACKET_TKN:
      case BOOLEAN_TKN:
      case INTEGER_TKN:
      case BIT_TKN:
      case OCTET_TKN:
      case NULL_TKN:
      case SEQUENCE_TKN:
      case SET_TKN:
      case CHOICE_TKN:
      case ANY_TKN:
      case COMPONENTS_TKN:
      case ENUMERATED_TKN:
      case REAL_TKN:
      case LCASEFIRST_IDENT_TKN:
      case UCASEFIRST_IDENT_TKN:
        ElementTypeList();
        break;
      default:
        jj_la1[34] = jj_gen;
        ;
      }
      jj_consume_token(RIGHTBRACE_TKN);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ChoiceType() throws ParseException {
                     /*@bgen(jjtree) ChoiceType */
  ASTChoiceType jjtn000 = new ASTChoiceType(this, JJTCHOICETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(CHOICE_TKN);
      jj_consume_token(LEFTBRACE_TKN);
      ElementTypeList();
      jj_consume_token(RIGHTBRACE_TKN);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void ElementTypeList() throws ParseException {
                          /*@bgen(jjtree) ElementTypeList */
  ASTElementTypeList jjtn000 = new ASTElementTypeList(this, JJTELEMENTTYPELIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ElementType();
      label_7:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA_TKN:
          ;
          break;
        default:
          jj_la1[35] = jj_gen;
          break label_7;
        }
        jj_consume_token(COMMA_TKN);
        ElementType();
      }
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void ElementType() throws ParseException {
                      /*@bgen(jjtree) ElementType */
  ASTElementType jjtn000 = new ASTElementType(this, JJTELEMENTTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OBJECT_IDENTIFIER_TKN:
      case LEFTBRACKET_TKN:
      case BOOLEAN_TKN:
      case INTEGER_TKN:
      case BIT_TKN:
      case OCTET_TKN:
      case NULL_TKN:
      case SEQUENCE_TKN:
      case SET_TKN:
      case CHOICE_TKN:
      case ANY_TKN:
      case ENUMERATED_TKN:
      case REAL_TKN:
      case LCASEFIRST_IDENT_TKN:
      case UCASEFIRST_IDENT_TKN:
        NamedType();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OPTIONAL_TKN:
        case DEFAULT_TKN:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case OPTIONAL_TKN:
            jj_consume_token(OPTIONAL_TKN);
                                        jjtn000.optional = true;
            break;
          case DEFAULT_TKN:
            jj_consume_token(DEFAULT_TKN);
            NamedValue();
                                                    jjtn000.has_default = true;
            break;
          default:
            jj_la1[36] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[37] = jj_gen;
          ;
        }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.which = 1;
        break;
      case COMPONENTS_TKN:
        ComponentsType();
                     jjtree.closeNodeScope(jjtn000, true);
                     jjtc000 = false;
                     jjtn000.which = 2;
        break;
      default:
        jj_la1[38] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ComponentsType() throws ParseException {
                         /*@bgen(jjtree) ComponentsType */
  ASTComponentsType jjtn000 = new ASTComponentsType(this, JJTCOMPONENTSTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(COMPONENTS_TKN);
      jj_consume_token(OF_TKN);
      Type();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void NamedType() throws ParseException {
                    /*@bgen(jjtree) NamedType */
  ASTNamedType jjtn000 = new ASTNamedType(this, JJTNAMEDTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_6(2)) {
        identifier();
                               jjtn000.hasid = true;
      } else {
        ;
      }
      Type();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void SelectionType() throws ParseException {
                        /*@bgen(jjtree) SelectionType */
  ASTSelectionType jjtn000 = new ASTSelectionType(this, JJTSELECTIONTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      identifier();
      jj_consume_token(LESSTHAN_TKN);
      Type();
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}
     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void TaggedType() throws ParseException {
                     /*@bgen(jjtree) TaggedType */
  ASTTaggedType jjtn000 = new ASTTaggedType(this, JJTTAGGEDTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Tag();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IMPLICIT_TKN:
      case EXPLICIT_TKN:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case EXPLICIT_TKN:
          jj_consume_token(EXPLICIT_TKN);
                           jjtn000.imporexp = 0;
          break;
        case IMPLICIT_TKN:
          jj_consume_token(IMPLICIT_TKN);
                                                                       jjtn000.imporexp = 1;
          break;
        default:
          jj_la1[39] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[40] = jj_gen;
        ;
      }
      Type();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void Tag() throws ParseException {
              /*@bgen(jjtree) Tag */
  ASTTag jjtn000 = new ASTTag(this, JJTTAG);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(LEFTBRACKET_TKN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNIVERSAL_TKN:
      case APPLICATION_TKN:
      case PRIVATE_TKN:
        Class();
                                jjtn000.hasTagClass=true;
        break;
      default:
        jj_la1[41] = jj_gen;
        ;
      }
      ClassNumber();
      jj_consume_token(RIGHTBRACKET_TKN);
    } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       {if (true) throw (RuntimeException)jjte000;}