asnparser.java

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

     }
     if (jjte000 instanceof ParseException) {
       {if (true) throw (ParseException)jjte000;}
     }
     {if (true) throw (Error)jjte000;}
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void ClassNumber() throws ParseException {
                      /*@bgen(jjtree) ClassNumber */
  ASTClassNumber jjtn000 = new ASTClassNumber(this, JJTCLASSNUMBER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NUMBER_ERANGE_TKN:
      case NUMBER_TKN:
        number();
              jjtree.closeNodeScope(jjtn000, true);
              jjtc000 = false;
              jjtn000.which=1;
        break;
      case LCASEFIRST_IDENT_TKN:
      case UCASEFIRST_IDENT_TKN:
        DefinedValue();
                                                    jjtree.closeNodeScope(jjtn000, true);
                                                    jjtc000 = false;
                                                    jjtn000.which=2;
        break;
      default:
        jj_la1[42] = 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 Class() throws ParseException {
                /*@bgen(jjtree) Class */
  ASTClass jjtn000 = new ASTClass(this, JJTCLASS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNIVERSAL_TKN:
        jj_consume_token(UNIVERSAL_TKN);
                     jjtree.closeNodeScope(jjtn000, true);
                     jjtc000 = false;
                     jjtn000.tag_class = 0x00;
        break;
      case APPLICATION_TKN:
        jj_consume_token(APPLICATION_TKN);
                       jjtree.closeNodeScope(jjtn000, true);
                       jjtc000 = false;
                       jjtn000.tag_class = 0x40;
        break;
      case PRIVATE_TKN:
        jj_consume_token(PRIVATE_TKN);
                   jjtree.closeNodeScope(jjtn000, true);
                   jjtc000 = false;
                   jjtn000.tag_class = 0xC0;
        break;
      default:
        jj_la1[43] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
    }
  }

  final public void AnyType() throws ParseException {
                  /*@bgen(jjtree) AnyType */
  ASTAnyType jjtn000 = new ASTAnyType(this, JJTANYTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(ANY_TKN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DEFINED_TKN:
        jj_consume_token(DEFINED_TKN);
        jj_consume_token(BY_TKN);
        identifier();
        break;
      default:
        jj_la1[44] = jj_gen;
        ;
      }
    } 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 SubtypeSpec() throws ParseException {
                      /*@bgen(jjtree) SubtypeSpec */
  ASTSubtypeSpec jjtn000 = new ASTSubtypeSpec(this, JJTSUBTYPESPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(LEFTPAREN_TKN);
      SubtypeValueSetList();
      jj_consume_token(RIGHTPAREN_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 SubtypeValueSetList() throws ParseException {
                              /*@bgen(jjtree) SubtypeValueSetList */
  ASTSubtypeValueSetList jjtn000 = new ASTSubtypeValueSetList(this, JJTSUBTYPEVALUESETLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      SubtypeValueSet();
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BAR_TKN:
          ;
          break;
        default:
          jj_la1[45] = jj_gen;
          break label_8;
        }
        jj_consume_token(BAR_TKN);
        SubtypeValueSet();
      }
    } 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 SubtypeValueSet() throws ParseException {
                          /*@bgen(jjtree) SubtypeValueSet */
  ASTSubtypeValueSet jjtn000 = new ASTSubtypeValueSet(this, JJTSUBTYPEVALUESET);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BSTRING_TKN:
      case HSTRING_TKN:
      case CSTRING_TKN:
      case NUMBER_ERANGE_TKN:
      case NUMBER_TKN:
      case LEFTBRACE_TKN:
      case MINUS_TKN:
      case NULL_TKN:
      case TRUE_TKN:
      case FALSE_TKN:
      case MIN_TKN:
      case PLUS_INFINITY_TKN:
      case MINUS_INFINITY_TKN:
      case LCASEFIRST_IDENT_TKN:
      case UCASEFIRST_IDENT_TKN:
        ValueRange();
        break;
      case INCLUDES_TKN:
        ContainedSubtype();
        break;
      case FROM_TKN:
        PermittedAlphabet();
        break;
      case SIZE_TKN:
        SizeConstraint();
        break;
      case WITH_TKN:
        InnerTypeConstraints();
        break;
      default:
        jj_la1[46] = 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 ContainedSubtype() throws ParseException {
                           /*@bgen(jjtree) ContainedSubtype */
  ASTContainedSubtype jjtn000 = new ASTContainedSubtype(this, JJTCONTAINEDSUBTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(INCLUDES_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 SingleValue() throws ParseException {
                      /*@bgen(jjtree) SingleValue */
  ASTSingleValue jjtn000 = new ASTSingleValue(this, JJTSINGLEVALUE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Value();
    } 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 ValueRange() throws ParseException {
                     /*@bgen(jjtree) ValueRange */
  ASTValueRange jjtn000 = new ASTValueRange(this, JJTVALUERANGE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BSTRING_TKN:
      case HSTRING_TKN:
      case CSTRING_TKN:
      case NUMBER_ERANGE_TKN:
      case NUMBER_TKN:
      case LEFTBRACE_TKN:
      case MINUS_TKN:
      case NULL_TKN:
      case TRUE_TKN:
      case FALSE_TKN:
      case PLUS_INFINITY_TKN:
      case MINUS_INFINITY_TKN:
      case LCASEFIRST_IDENT_TKN:
      case UCASEFIRST_IDENT_TKN:
        Value();
        break;
      case MIN_TKN:
        jj_consume_token(MIN_TKN);
        break;
      default:
        jj_la1[47] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DOT_TKN:
      case LESSTHAN_TKN:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LESSTHAN_TKN:
          jj_consume_token(LESSTHAN_TKN);
          break;
        default:
          jj_la1[48] = jj_gen;
          ;
        }
        jj_consume_token(DOT_TKN);
        jj_consume_token(DOT_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LESSTHAN_TKN:
          jj_consume_token(LESSTHAN_TKN);
          break;
        default:
          jj_la1[49] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BSTRING_TKN:
        case HSTRING_TKN:
        case CSTRING_TKN:
        case NUMBER_ERANGE_TKN:
        case NUMBER_TKN:
        case LEFTBRACE_TKN:
        case MINUS_TKN:
        case NULL_TKN:
        case TRUE_TKN:
        case FALSE_TKN:
        case PLUS_INFINITY_TKN:
        case MINUS_INFINITY_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          Value();
          break;
        case MAX_TKN:
          jj_consume_token(MAX_TKN);
          break;
        default:
          jj_la1[50] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[51] = jj_gen;
        ;
      }
    } 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 SizeConstraint() throws ParseException {
                         /*@bgen(jjtree) SizeConstraint */
  ASTSizeConstraint jjtn000 = new ASTSizeConstraint(this, JJTSIZECONSTRAINT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(SIZE_TKN);
      SubtypeSpec();
    } 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 PermittedAlphabet() throws ParseException {
                            /*@bgen(jjtree) PermittedAlphabet */
  ASTPermittedAlphabet jjtn000 = new ASTPermittedAlphabet(this, JJTPERMITTEDALPHABET);
  boolean jjtc