asnparser.jjt

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

/*
 *
 *  ASN.1 grammar  for JavaCC
 *
 *  Contributed by Helena Sarin ([e-mail])
 *
 *  Derived in part from the following work: snacc - a freeware ASN.1 to C or C++ compiler, v 1.3,
 *  yacc/lex source code ( parse-asn1.y, lex-asn1.l), 
 *  the free software, which is covered by GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or later
 *
 *  I tested it against several ASN.1 files used by CMIP;
 *  Additional work is reguired to fully support SNMP MIBs parsing
 *   
 *  Please let me know if you use this grammar: i'm using it to develop ASN.1/IDL compiler
 *  
 * SANITY_CHECK=true;
 * DEBUG_PARSER=false;
 * DEBUG_TOKEN_MANAGER=false;
 *
 */

options {
STATIC=false;
MULTI=true;
VISITOR=true;
NODE_USES_PARSER=true; 
}


PARSER_BEGIN(AsnParser)
//Title:       
//Version:     $Id: AsnParser.jjt,v 1.1.1.1 2000/12/21 06:33:43 ianibbo Exp $
//Copyright:   Copyright (C) 1999,2000 Knowledge Integration Ltd (See the file LICENSE for details.)
//Author:      Ian Ibbotson
//Company:     Knowledge Integration Ltd
//Description: 
//

package com.k_int.codec.comp;

import java.util.*;
import java.io.File;
import java.io.FileInputStream;

public class AsnParser {
  // public static void main(String args[]) throws ParseException {

  //   System.err.println("Args :"+args);

  //   for ( int i=0; i<args.length; i++ )
  //   {
  //     System.err.println("Processing asn source file : "+args[i]);

  //     File next_asn_file = new File(args[i]);

  //     if ( next_asn_file.exists() )       
  //     {
        // parser = new AsnParser(System.in);
  //       try 
  //       {
  //         AsnParser parser = new AsnParser(new FileInputStream(next_asn_file));
  //         parser.Input();	
  //         System.out.println("ASN.1 file parsed successfully... Calling pass1");
  //         parser.jjtree.rootNode().pass1();
  //         System.out.println("Calling outputJava");
          // parser.jjtree.rootNode().outputJava();
  //         CodecBuilderInfo.getInfo().create();
  //         System.out.println("Done outputting java");
  //       }
  //       catch(ParseException e)
  //       {
  //         System.out.println(e.toString());
  //         e.printStackTrace();
  //       }
  //       catch(java.io.FileNotFoundException fnfe)
  //       {
  //         System.out.println(fnfe.toString());
  //         fnfe.printStackTrace();
  //       }
  //     }
  //   }
  // }

  public static String usefulTypes[] = { 
        "GraphicString",  "NumericString", "PrintableString",
	"TeletexString", "T61String", "VideotexString", "IA5String",
	"VisibleString", "ISO646String", "GeneralizedTime", "UniversalString", "BMPString", "EXTERNAL" };

  public static String builtinTypes[] = {
        "Integer", "BitString", "SetOrSequenceType", "SetOrSequenceOfType", 
        "ChoiceType", "SelectionType", "TaggedType", "Any", "Enumerated",
        "OctetString", "OID", "REAL", "BOOL", "NULL" };
}

PARSER_END(AsnParser)

SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
}

SPECIAL_TOKEN :
{
  "--" : WithinASNComment
}

<WithinASNComment> SPECIAL_TOKEN :
{
  <("--" | "\n" | "\r" | "\r\n" )> : DEFAULT
}

<WithinASNComment> MORE :
{
  <~[]>
}

TOKEN : 
{
 <OBJECT_IDENTIFIER_TKN: "OBJECT" ([" ","\n","\t","\r"])? "IDENTIFIER">
}

TOKEN : 
{
 <BSTRING_TKN: "\'" (["0"-"1"])* "\'B">
}

TOKEN : 
{
 <HSTRING_TKN: "\'" (["0"-"9","A"-"F","a"-"f"])* "\'H">
}

TOKEN : 
{
 <CSTRING_TKN: "\"" ( ~["\""] )* "\"" >
}

TOKEN : 
{
 <NUMBER_ERANGE_TKN: ["1"-"9"](["0"-"9"])*>
}

TOKEN : 
{
 <NUMBER_TKN: "0">
}

TOKEN :
{
  <DOT_TKN: ".">
| <COMMA_TKN: ",">
| <LEFTBRACE_TKN: "{">
| <RIGHTBRACE_TKN: "}">
| <LEFTPAREN_TKN: "(">
| <RIGHTPAREN_TKN: ")">
| <LEFTBRACKET_TKN: "[">
| <RIGHTBRACKET_TKN: "]">
| <LESSTHAN_TKN: "<">
| <MINUS_TKN: "-">
| <GETS_TKN: "::=">
| <BAR_TKN: "|">
| <SEMI_COLON_TKN: ";">
| <SELECTOR_TKN: ":">
| <TAGS_TKN: "TAGS">
| <BOOLEAN_TKN: "BOOLEAN">
| <INTEGER_TKN: "INTEGER">
| <BIT_TKN: "BIT">
| <STRING_TKN: "STRING">
| <OCTET_TKN: "OCTET">
| <NULL_TKN: "NULL">
| <SEQUENCE_TKN: "SEQUENCE">
| <OF_TKN: "OF">
| <SET_TKN: "SET">
| <IMPLICIT_TKN: "IMPLICIT">
| <CHOICE_TKN: "CHOICE">
| <ANY_TKN: "ANY">
| <OPTIONAL_TKN: "OPTIONAL">
| <DEFAULT_TKN: "DEFAULT">
| <COMPONENTS_TKN: "COMPONENTS">
| <UNIVERSAL_TKN: "UNIVERSAL">
| <APPLICATION_TKN: "APPLICATION">
| <PRIVATE_TKN: "PRIVATE">
| <TRUE_TKN: "TRUE">
| <FALSE_TKN: "FALSE">
| <BEGIN_TKN: "BEGIN">
| <END_TKN: "END">
| <DEFINITIONS_TKN: "DEFINITIONS">
| <EXPLICIT_TKN: "EXPLICIT">
| <ENUMERATED_TKN: "ENUMERATED">
| <EXPORTS_TKN: "EXPORTS">
| <IMPORTS_TKN: "IMPORTS">
| <REAL_TKN: "REAL">
| <INCLUDES_TKN: "INCLUDES">
| <MIN_TKN: "MIN">
| <MAX_TKN: "MAX">
| <SIZE_TKN: "SIZE">
| <FROM_TKN: "FROM">
| <WITH_TKN: "WITH">
| <COMPONENT_TKN: "COMPONENT">
| <PRESENT_TKN: "PRESENT">
| <ABSENT_TKN: "ABSENT">
| <DEFINED_TKN: "DEFINED">
| <BY_TKN: "BY">
| <PLUS_INFINITY_TKN: "PLUS-INFINITY">
| <MINUS_INFINITY_TKN: "MINUS-INFINITY">
| <OBJECTTYPE_TKN: "OBJECT-TYPE">
| <SYNTAX_TKN: "SYNTAX">
| <ACCESS_TKN: "ACCESS">
| <STATUS_TKN: "STATUS">
| <DESCRIPTION_TKN: "DESCRIPTION">
| <REFERENCE_TKN: "REFERENCE">
| <INDEX_TKN: "INDEX">
| <DEFVAL_TKN: "DEFVAL">
| <DHINT: "DISPLAY-HINT">
| <TC_TKN: "TEXTUAL-CONVENTION"> 
| <MACRO_TKN: "MACRO"> 
}

TOKEN : 
{
 <LCASEFIRST_IDENT_TKN: ["a"-"z"] (("-"["a"-"z","A"-"Z","0"-"9"])|["a"-"z","A"-"Z","0"-"9"])*>
}


TOKEN : 
{
 <UCASEFIRST_IDENT_TKN: ["A"-"Z"](("-"["a"-"z","A"-"Z","0"-"9"])|["a"-"z","A"-"Z","0"-"9"])*>
}

void Input() : {} 
{ 
 (ModuleDefinition())*
}

void ModuleDefinition() : { Token t; } 
{ 
  ModuleIdentifier() <DEFINITIONS_TKN> [TagDefault()] <GETS_TKN> <BEGIN_TKN> ModuleBody() <END_TKN> 
}

void TagDefault() : {} 
{ 	
   (<EXPLICIT_TKN> { jjtThis.which = 1; } |  <IMPLICIT_TKN> { jjtThis.which = 2; }) <TAGS_TKN> 
}

void ModuleIdentifier() : {  } 
{ 
   modulereference() [AssignedIdentifier()]
}

void AssignedIdentifier() : {} 
{ 
   ObjectIdentifierValue() 
}

void ModuleBody() : {} 
{ 
  [Exports()] [Imports()] [AssignmentList()] 
}

void Exports() : {} 
{ 
  <EXPORTS_TKN> [SymbolsExported()] <SEMI_COLON_TKN> 
}

void SymbolsExported() : {} 
{ 
   ExportSymbolList() 
}

void ExportSymbolList() : {} 
{ 
   Symbol() (<COMMA_TKN> Symbol())*
}

void Imports() : {} 
{ 
   <IMPORTS_TKN> [SymbolsImported()] <SEMI_COLON_TKN> 
}

void SymbolsImported() : {} 
{ 
   SymbolsFromModuleList() 
}

void SymbolsFromModuleList() : {} 
{ 
   SymbolsFromModule() (SymbolsFromModule())*
}

void SymbolsFromModule() : { String module; } 
{ 
   SymbolList() <FROM_TKN>  ModuleIdentifier() 
}

void SymbolList() : {} 
{ 
   Symbol() (<COMMA_TKN> Symbol())* 
}

void Symbol() : {} 
{ 
   typereference() { jjtThis.which = 1; }
 | identifier() { jjtThis.which = 2; }
 | DefinedMacroName() { jjtThis.which = 3; }
}

void AssignmentList() : {} 
{ 
  Assignment() [<SEMI_COLON_TKN>] ( Assignment() [<SEMI_COLON_TKN>] )*
}

void Assignment() : {} 
{ 
   LOOKAHEAD(2)  MacroDefinition() |  TypeAssignment() |  ValueAssignment()
}

void MacroDefinition() : { } 
{
   (<TC_TKN> | <OBJECTTYPE_TKN> | typereference()) <MACRO_TKN> <GETS_TKN> 
	<BEGIN_TKN>  MacroBody() <END_TKN>
}

JAVACODE
void MacroBody() {	
  Token tok;
  int nesting = 1;
  while (true) {
    tok = getToken(1);
    if (tok.kind == END_TKN) {
	break;	
    }
    tok = getNextToken();
  }
}

void MacroReference() : {} 
{ 
   typereference() | DefinedMacroName() 
}

void TypeAssignment() : { }
{
   typereference()  <GETS_TKN>   GlobalType()
}

void GlobalType() : { }
{
  ( 
    Type() { jjtThis.which = 1; }
   |  
    DefinedMacroType() { jjtThis.which = 2; }
  )
}

void Type() : { }
{ 
   (
     LOOKAHEAD(2) BuiltinType() { jjtThis.which = 1; }
    |  
     DefinedType() { jjtThis.which = 2; }
   )  [LOOKAHEAD(2) SubtypeSpec()] 
}

void DefinedType() : { } 
{  
  [LOOKAHEAD(2) modulereference() <DOT_TKN>]  typereference() 
}

void BuiltinType() : {} 
{ 
  IntegerType() { jjtThis.which = 0; }
| BitStringType() { jjtThis.which = 1; }
| LOOKAHEAD(2) SetOrSequenceType() { jjtThis.which = 2; }
| SetOrSequenceOfType(){ jjtThis.which = 3; }
| ChoiceType() { jjtThis.which = 4; }
| SelectionType() { jjtThis.which = 5; }
| TaggedType() { jjtThis.which = 6; }
| AnyType() { jjtThis.which = 7; }
| EnumeratedType() { jjtThis.which = 8; }
| <OCTET_TKN> <STRING_TKN> { jjtThis.which = 9; }
| <OBJECT_IDENTIFIER_TKN>{ jjtThis.which = 10; }
| <REAL_TKN>{ jjtThis.which = 11; }
| <BOOLEAN_TKN>{ jjtThis.which = 12; }
| <NULL_TKN> { jjtThis.which = 13; }
}

void EnumeratedType() : {} 
{ 
   <ENUMERATED_TKN> <LEFTBRACE_TKN> NamedNumberList() <RIGHTBRACE_TKN>