asn_grammar.y

asn格式文件的编译器

%expect 14

%{

/*
 * asn_grammar.y
 *
 * ASN grammar file
 *
 * ASN.1 compiler to produce C++ classes.
 *
 * Copyright (c) 1997-1999 Equivalence Pty. Ltd.
 *
 * Copyright (c) 2001 Institute for Information Industry, Taiwan, Republic of China 
 * (http://www.iii.org.tw/iiia/ewelcome.htm)
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is ASN Parser.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * Vovida Networks, Inc. http://www.vovida.com.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ___________________.
 *
 * $Log: asn_grammar.y,v $
 * Revision 1.3  2002/07/02 02:03:25  mangelo
 * Remove Pwlib dependency
 *
 * Revision 1.2  2001/09/07 22:38:10  mangelo
 * add Log keyword substitution
 *
 *
 * March, 2001. Huang-Ming Huang
 *            Add support for Information Object Class.
 *
 */

#undef malloc
#undef calloc
#undef realloc
#undef free

#include "main.h"
#include <sstream>


extern int yylex();

extern int ReferenceTokenContext;
extern int IdentifierTokenContext;
extern int BraceTokenContext;
extern int NullTokenContext;
extern int InMacroContext;
extern int HasObjectTypeMacro;
extern int InMIBContext;
extern int InOIDContext ;

static int UnnamedFieldCount = 1;
extern int InWithSyntaxContext;
extern int InObjectSetContext;
extern const ObjectClassBase * InformationFromObjectContext;
extern TypePtr ValueTypeContext;
extern int ParsingConstructedType;


static std::string * ConcatNames(std::string * s1, char c, std::string * s2)
{
  *s1 += c;
  *s1 += *s2;
  delete s2;
  return s1;
}

#ifdef _MSC_VER
#pragma warning(disable:4701)
#endif

%}

%token MODULEREFERENCE 
%token TYPEREFERENCE   
%token OBJECTCLASSREFERENCE 
%token VALUEREFERENCE 
%token OBJECTREFERENCE 
%token OBJECTSETREFERENCE 

%token PARAMETERIZEDTYPEREFERENCE   
%token PARAMETERIZEDOBJECTCLASSREFERENCE 
%token PARAMETERIZEDVALUEREFERENCE 
%token PARAMETERIZEDOBJECTREFERENCE 
%token PARAMETERIZEDOBJECTSETREFERENCE

%token VALUESET_BRACE
%token OBJECT_BRACE
%token OBJECTSET_BRACE

%token IDENTIFIER
%token BIT_IDENTIFIER
%token OID_IDENTIFIER
%token IMPORT_IDENTIFIER
%token fieldreference
%token FieldReference
%token TYPEFIELDREFERENCE
%token FIXEDTYPEVALUEFIELDREFERENCE
%token VARIABLETYPEVALUEFIELDREFERENCE
%token FIXEDTYPEVALUESETFIELDREFERENCE 
%token VARIABLETYPEVALUESETFIELDREFERENCE 
%token OBJECTFIELDREFERENCE
%token OBJECTSETFIELDREFERENCE 
%token INTEGER

%token CSTRING
%token OS_BSTRING
%token BS_BSTRING
%token OS_HSTRING
%token BS_HSTRING


%token ABSENT           
%token ABSTRACT_SYNTAX  
%token ALL              
%token ANY
%token APPLICATION      
%token ASSIGNMENT
%token AUTOMATIC        
%token BEGIN_t
%token BIT              
%token BMPString
%token BOOLEAN_t
%token BY
%token CHARACTER        
%token CHOICE           
%token CLASS            
%token COMPONENT        
%token COMPONENTS       
%token CONSTRAINED      
%token DEFAULT          
%token DEFINED
%token DEFINITIONS      
%token EMBEDDED         
%token END
%token ENUMERATED       
%token EXCEPT           
%token EXPLICIT         
%token EXPORTS          
%token EXTERNAL         
%token FALSE_t           
%token FROM             
%token GeneralString    
%token GraphicString    
%token IA5String        
%token TYPE_IDENTIFIER 
%token IDENTIFIER_t
%token IMPLICIT         
%token IMPORTS          
%token INCLUDES         
%token INSTANCE         
%token INTEGER_t        
%token INTERSECTION     
%token ISO646String
%token MACRO
%token MAX              
%token MIN              
%token MINUS_INFINITY
%token NOTATION
%token NULL_VALUE
%token NULL_TYPE
%token NumericString    
%token OBJECT           
%token OCTET            
%token OF_t              
%token OPTIONAL_t
%token PDV              
%token PLUS_INFINITY    
%token PRESENT          
%token PrintableString  
%token PRIVATE          
%token REAL             
%token SEQUENCE         
%token SET              
%token SIZE_t            
%token STRING           
%token SYNTAX           
%token T61String        
%token TAGS             
%token TeletexString    
%token TRUE_t
%token TYPE_t
%token UNION            
%token UNIQUE           
%token UNIVERSAL        
%token UniversalString  
%token VideotexString   
%token VisibleString    
%token GeneralizedTime
%token UTCTime
%token VALUE
%token WITH

%token ObjectDescriptor_t
%token WORD_t
%token OID_INTEGER

%type <ival> INTEGER
%type <ival> TagDefault
%type <ival> SignedNumber
%type <ival> Class ClassNumber
%type <ival> PresenceConstraint


%type <sval> CSTRING
%type <sval> BS_BSTRING
%type <sval> OS_BSTRING
%type <sval> BS_HSTRING
%type <sval> OS_HSTRING
%type <sval> IDENTIFIER
%type <sval> BIT_IDENTIFIER
%type <sval> OID_IDENTIFIER
%type <sval> IMPORT_IDENTIFIER
%type <sval> TYPEREFERENCE
%type <sval> MODULEREFERENCE  
%type <sval> OBJECTCLASSREFERENCE
%type <sval> VALUEREFERENCE
%type <sval> fieldreference FieldReference
%type <sval> TYPEFIELDREFERENCE
%type <sval> VALUEFIELDREFERENCE
%type <sval> FIXEDTYPEVALUEFIELDREFERENCE
%type <sval> VARIABLETYPEVALUEFIELDREFERENCE
%type <sval> VALUESETFIELDREFERENCE
%type <sval> FIXEDTYPEVALUESETFIELDREFERENCE
%type <sval> VARIABLETYPEVALUESETFIELDREFERENCE
%type <sval> OBJECTFIELDREFERENCE
%type <sval> OBJECTSETFIELDREFERENCE 
%type <sval> OBJECTREFERENCE
%type <sval> OBJECTSETREFERENCE
%type <sval> DefinitiveObjIdComponent
%type <sval> DefinitiveNameAndNumberForm
%type <sval> GlobalModuleReference
%type <sval> Reference
%type <sval> ExternalTypeReference ExternalValueReference
%type <sval> ObjIdComponent
%type <sval> NumberForm
%type <sval> SimpleDefinedType
%type <sval> CharsDefn
%type <sval> SimpleDefinedValue
%type <sval> FieldName PrimitiveFieldName
%type <sval> ExternalObjectClassReference
%type <sval> UsefulObjectClassReference 
%type <sval> OID_INTEGER

%type <sval> PARAMETERIZEDTYPEREFERENCE
%type <sval> PARAMETERIZEDOBJECTCLASSREFERENCE
%type <sval> PARAMETERIZEDVALUEREFERENCE
%type <sval> PARAMETERIZEDOBJECTREFERENCE
%type <sval> PARAMETERIZEDOBJECTSETREFERENCE

%type <slst> DefinitiveIdentifier
%type <slst> DefinitiveObjIdComponentList
%type <slst> ObjIdComponentList
%type <slst> BitIdentifierList
%type <slst> CharSyms

%type <tval> Type BuiltinType ReferencedType NamedType
%type <tval> DefinedType
%type <tval> ConstrainedType
%type <tval> TypeWithConstraint
%type <tval> BitStringType
%type <tval> BooleanType
%type <tval> CharacterStringType 
%type <tval> RestrictedCharacterStringType
%type <tval> UnrestrictedCharacterStringType
%type <tval> ChoiceType AlternativeTypeLists
%type <tval> EmbeddedPDVType
%type <tval> EnumeratedType Enumerations
%type <tval> ExternalType

%type <tval> AnyType
%type <tval> IntegerType
%type <tval> NullType
%type <tval> ObjectClassFieldType
%type <ocft> SimpleObjectClassFieldType
%type <tval> ObjectIdentifierType
%type <tval> OctetStringType 
%type <tval> RealType
%type <tval> SequenceType ComponentTypeLists
%type <tptr> ComponentType
%type <tval> SequenceOfType
%type <tval> SetType
%type <tval> SetOfType
%type <tval> TaggedType
%type <tval> ParameterizedType
%type <tval> SelectionType
%type <tval> UsefulType
%type <tval> TypeFromObject
%type <tval> ContainedSubtype


%type <tlst> AlternativeTypeList
%type <tlst> ComponentTypeList

%type <symb> Symbol
%type <syml> SymbolList

%type <vval> Value BuiltinValue
%type <vval> AssignedIdentifier
%type <vval> DefinedValue 
%type <vval> ObjectIdentifierValue
%type <vval> OctetStringValue
%type <vval> BitStringValue
%type <vval> ExceptionSpec
%type <vval> ExceptionIdentification
%type <vval> LowerEndpoint LowerEndValue UpperEndpoint UpperEndValue
%type <vval> ReferencedValue
%type <vval> BooleanValue
%type <vval> CharacterStringValue RestrictedCharacterStringValue
%type <vval> CharacterStringList Quadruple Tuple
%type <vval> ChoiceValue
%type <vval> NullValue
%type <vval> RealValue NumericRealValue SpecialRealValue 
%type <vval> SequenceValue NamedValue
/*!!!! %type <vval> SequenceOfValue */
%type <vval> ParameterizedValue
%type <vval> ValueFromObject

%type <vlst> ComponentValueList

%type <nval> NamedBit
%type <nval> EnumerationItem
%type <nval> NamedNumber

%type <nlst> NamedBitList
%type <nlst> Enumeration
%type <nlst> NamedNumberList

%type <elmt> IntersectionElements
%type <elmt> Elements
%type <elmt> Exclusions
%type <elmt> SubtypeElements
%type <elmt> ObjectSetElements
%type <elmt> ValueRange
%type <elmt> PermittedAlphabet
%type <elmt> InnerTypeConstraints
%type <elmt> MultipleTypeConstraints
%type <elmt> SizeConstraint
%type <elmt> UserDefinedConstraintParameterList
%type <elmt> NamedConstraint

%type <elst> ElementSetSpec Unions Intersections TypeConstraints 

%type <cons> Constraint
%type <cons> ConstraintSpec
%type <cons> ElementSetSpecs ObjectSetSpec 
/* %type <cons> GeneralConstraint */
%type <cons> UserDefinedConstraint
%type <tcons> TableConstraint
%type <tcons> SimpleTableConstraint
%type <tcons> ComponentRelationConstraint
%type <tagv> Tag

%type <fspc> FieldSpec 
%type <fspc> TypeFieldSpec
%type <fspc> FixedTypeValueFieldSpec
%type <fspc> VariableTypeValueFieldSpec
%type <fspc> FixedTypeValueSetFieldSpec
%type <fspc> VariableTypeValueSetFieldSpec
%type <fspc> ObjectFieldSpec
%type <fspc> ObjectSetFieldSpec

%type <flst> FieldSpecs

%type <objc> ObjectClass ObjectClassDefn 
%type <dobj> DefinedObjectClass
%type <tgrp> WithSyntaxSpec SyntaxList TokenOrGroupSpecs 
%type <togs> TokenOrGroupSpec RequiredToken OptionalGroup
%type <sval> Literal
%type <sett> Setting

%type <sval> ExternalObjectReference
%type <objt> Object
%type <objt> ObjectDefn
%type <objt> DefinedObject
%type <objt> ObjectFromObject
%type <objt> ReferencedObject ReferencedObjectDot
%type <objt> ParameterizedObject ObjectParameter

%type <fldl> FieldSettings
%type <fldl> DefaultSyntax
%type <bldr> DefinedSyntax
%type <bldr> DefinedSyntaxTokens
%type <tken> DefinedSyntaxToken

%type <sval> WORD_t

%type <vset> ValueSet 
%type <vset> ValueSetFromObject ValueSetFromObjects

%type <sval> ExternalObjectSetReference
%type <cons> ObjectSet 
%type <dos> DefinedObjectSet ParameterizedObjectSet
%type <osce> ReferencedObjects ReferencedObjectsDot
%type <osce> ObjectSetFromObject ObjectSetFromObjects
%type <osce> ObjectSetParameter

%type <para> Parameter
%type <plst> ParameterList Parameters
%type <apar> ActualParameter
%type <aplt> ActualParameterList ActualParameters
%type <apar> UserDefinedConstraintParameter
%type <aplt> UserDefinedConstraintParameters

%type <sval> AtNotation ComponentIdList
%type <slst> AtNotations

%union {
  boost::int64_t       ival;
  std::string	        * sval;
  StringList	    * slst;
  TypeBase	        * tval;
  TypePtr           * tptr;
  TypesVector       * tlst;
  ValueBase	        * vval;
  ValuesList            * vlst;
  NamedNumber	        * nval;
  NamedNumberList       * nlst;
  Constraint            * cons;
  ConstraintElementVector * elst;
  ConstraintElementBase * elmt;
  FieldSpec             * fspc;
  FieldSpecsList		* flst;
  ObjectClassBase		* objc;
  DefinedObjectClass    * dobj;
  TokenGroup            * tgrp;
  TokenOrGroupSpec      * togs;
  Setting				* sett;
  InformationObject     * objt;
  InformationObjectSet  * objs;
  FieldSettingList      * fldl;
  DefaultSyntaxBuilder  * bldr;
  DefinedSyntaxToken    * tken;
  ValueSet              * vset;
  ObjectSetConstraintElement* osce;
  Symbol                * symb;
  SymbolList            * syml;
  Parameter             * para;
  ParameterList         * plst;
  ActualParameter       * apar;
  ActualParameterList   * aplt;
  TableConstraint       * tcons;
  ObjectClassFieldType  * ocft;
  DefinedObjectSet      * dos;

  struct {
    Tag::Type tagClass;
    unsigned tagNumber;
  } tagv;
}


%%

ModuleDefinitionList
  : ModuleDefinitionList ModuleDefinition
    {  }
  | ModuleDefinition
    {  }

ModuleDefinition
  : MODULEREFERENCE DefinitiveIdentifier DEFINITIONS TagDefault ASSIGNMENT BEGIN_t 
      {
	Module = FindModule($1->c_str());
	if ($2) {
		Module->SetDefinitiveObjId(*$2); delete $2;
	}
      }
    ModuleBody END
	  {
	Module->ResolveObjectClassReferences();
    Module = NULL;
	  }
  ;

DefinitiveIdentifier
  : '{' DefinitiveObjIdComponentList '}'
	{
	  $$ = $2;
	}
  | /* empty */
	{
	  $$ = NULL;
	}
  ;

DefinitiveObjIdComponentList
  : DefinitiveObjIdComponent
      {
	$$ = new StringList;
	$$->push_back($1->c_str());
	delete $1;
      }
  | DefinitiveObjIdComponent DefinitiveObjIdComponentList
      {
	$2->insert($2->begin(), std::string(*$1));
	$$ = $2;
      }
  ;

DefinitiveObjIdComponent
  : IDENTIFIER	
  | INTEGER
      {
    char buf[10];
    sprintf(buf, "%u", static_cast<unsigned>($1));
	$$ = new std::string(buf);
      }
  | DefinitiveNameAndNumberForm
  ;

DefinitiveNameAndNumberForm
  : IDENTIFIER '(' INTEGER ')'
      {
	delete $1;
    char buf[10];
    sprintf(buf, "%u", static_cast<unsigned>($3));
	$$ = new std::string(buf);
      }
  ;

TagDefault
  : EXPLICIT TAGS
      {
	$$ = Tag::Explicit;
      }
  | IMPLICIT TAGS 
      {
	$$ = Tag::Implicit;
      }
  | AUTOMATIC TAGS 
      {
	$$ = Tag::Automatic;
      }
  | /* empty */
      {
	$$ = Tag::Explicit;
      }
  ;


/*************************************/

ModuleBody
  : Exports Imports AssignmentList
  | /* empty */
  ;


Exports
  : EXPORTS SymbolsExported ';'
  | /* empty */
  ;


SymbolsExported
  : SymbolList
      {
/*	Module->SetExports($1); */
  delete $1;
      }
  | /* empty */
      {
/*	Module->SetExportAll(); */
      }
  ;


Imports
  : IMPORTS SymbolsImported ';' 
  | /* empty */
  ;


SymbolsImported
  : SymbolsFromModuleList
  | /* empty */
  ;

SymbolsFromModuleList
  : SymbolsFromModule
  | SymbolsFromModuleList SymbolsFromModule
  ;


SymbolsFromModule
  : SymbolList FROM GlobalModuleReference
      {
	if (!HasObjectTypeMacro) {
	  HasObjectTypeMacro = FindWithName(*$1,"OBJECT-TYPE").get() != NULL;
	  if (HasObjectTypeMacro)
	    std::cerr << "Info: including OBJECT-TYPE macro" << std::endl;
	}
	Module->AddImport(ImportModulePtr(new ImportModule($3, $1)));
      }
  ;


GlobalModuleReference
  : MODULEREFERENCE 
      {
	InOIDContext = 1;
      }
    AssignedIdentifier
      {
    InOIDContext = 0;
	delete $3;
      }
  ;


AssignedIdentifier
  : DefinedValue
  | ObjectIdentifierValue
  | /* empty */
      {
	$$ = NULL;
      }
  ;


SymbolList
  : Symbol
      {
	$$ = new SymbolList;
	$$->push_back(SymbolPtr($1));
      }
  | Symbol ',' SymbolList
      {
	$3->push_back(SymbolPtr($1));
	$$ = $3;
      }
  ;


Symbol
  : TYPEREFERENCE
      {
	$$ = new TypeReference(*$1, false); delete $1;
      }
  | VALUEREFERENCE 
      {
    $$ = new ValueReference(*$1, false); delete $1;
	  }
  | OBJECTCLASSREFERENCE 
      {
    $$ = new ObjectClassReference(*$1, false); delete $1;
	  }
  | OBJECTREFERENCE
      {
    $$ = new ObjectReference(*$1, false); delete $1;
	  }
  | OBJECTSETREFERENCE
      {
    $$ = new ObjectSetReference(*$1, false); delete $1;
	  }
  | PARAMETERIZEDTYPEREFERENCE '{' '}'
      {
	$$ = new TypeReference(*$1, true); delete $1;
      }
  | PARAMETERIZEDVALUEREFERENCE '{' '}'
      {
    $$ = new ValueReference(*$1, true); delete $1;
	  }
  | PARAMETERIZEDOBJECTCLASSREFERENCE '{' '}'
      {
    $$ = new ObjectClassReference(*$1, true); delete $1;
	  }
  | PARAMETERIZEDOBJECTREFERENCE '{' '}'
      {
    $$ = new ObjectReference(*$1, true); delete $1;
	  }
  | PARAMETERIZEDOBJECTSETREFERENCE '{' '}'
      {
    $$ = new ObjectSetReference(*$1, true); delete $1;
	  }
  ;


/*************************************/

AssignmentList: Assignment 
  | AssignmentList Assignment
  ;


Assignment
  : TypeAssignment
  | ValueAssignment
  | ValueSetTypeAssignment 
  | ObjectClassAssignment
  | ObjectAssignment
  | ObjectSetAssignment
  | ParameterizedAssignment
  ;


ValueSetTypeAssignment
  : TYPEREFERENCE Type
      {
	$2->SetName(*$1); delete $1;
    ValueTypeContext.reset($2);
	$2->BeginParseValueSet();
      }
    ASSIGNMENT ValueSet
      {
	Module->AddType($5->MakeValueSetType());
	delete $5;
      }
  ;




/********/

TypeAssignment
  : TYPEREFERENCE ASSIGNMENT Type
      {
	$3->SetName(*$1); delete $1;
	Module->AddType(TypePtr($3));
      }
  ;


Type
  : ConstrainedType
  | ReferencedType
  | BuiltinType
  ;


BuiltinType
  : BitStringType
  | BooleanType 
  | CharacterStringType 
  | ChoiceType 
  | EmbeddedPDVType 
  | EnumeratedType 
  | ExternalType  
  | AnyType 
  | InstanceOfType
    { }
  | IntegerType 
  | NullType 
  | ObjectClassFieldType
  | ObjectIdentifierType 
  | OctetStringType 
  | RealType 
  | SequenceType 
  | SequenceOfType 
  | SetType 
  | SetOfType 
  | TaggedType
  ;


ReferencedType
  : DefinedType
  | UsefulType
  | SelectionType
  | TypeFromObject
  | ValueSetFromObjects
    {
  $$= $1->MakeValueSetType().get();
  delete $1;
    }
  ;


DefinedType
  : SimpleDefinedType 
      {
	$$ = new DefinedType(*$1);
	delete $1;
      }
  | ParameterizedType 
/*| ParameterizedValueSetType	synonym for ParameterizedType */
  ;


ExternalTypeReference
  : MODULEREFERENCE '.' TYPEREFERENCE 
      {
	*$1 += *$3;
	delete $3;
      }
  ;

BitStringType
  : BIT STRING 
      {
	$$ = new BitStringType;
      }
  | BIT STRING '{' NamedBitList '}'
      {
	$$ = new BitStringType(*$4);
	delete $4;
      }
  ;


NamedBitList
  : NamedBit 
      {
	$$ = new NamedNumberList;
	$$->push_back(NamedNumberPtr($1));
      }
  | NamedBitList ',' NamedBit