asn_grammar.y

asn格式文件的编译器

      {
	$1->insert($1->begin(), NamedNumberPtr($3));
      }
  ;

NamedBit
  : IDENTIFIER '(' INTEGER ')' 
      {
	$$ = new NamedNumber($1, (int)$3);
      }
  | IDENTIFIER '(' DefinedValue ')'
      {
	$$ = new NamedNumber($1, ((DefinedValue*)$3)->GetReference());
	delete $3;
      }
  ;


BooleanType
  : BOOLEAN_t
      {
	$$ = new BooleanType;
      }
  ;


CharacterStringType
  : RestrictedCharacterStringType
  | UnrestrictedCharacterStringType
  ;

RestrictedCharacterStringType
  : BMPString
      {
	$$ = new BMPStringType;
      }
  | GeneralString
      {
	$$ = new GeneralStringType;
      }
  | GraphicString
      {
	$$ = new GraphicStringType;
      }
  | IA5String
      {
	$$ = new IA5StringType;
      }
  | ISO646String
      {
	$$ = new ISO646StringType;
      }
  | NumericString
      {
	$$ = new NumericStringType;
      }
  | PrintableString
      {
	$$ = new PrintableStringType;
      }
  | TeletexString
      {
	$$ = new TeletexStringType;
      }
  | T61String
      {
	$$ = new T61StringType;
      }
  | UniversalString
      {
	$$ = new UniversalStringType;
      }
  | VideotexString
      {
	$$ = new VideotexStringType;
      }
  | VisibleString
      {
	$$ = new VisibleStringType;
      }
  ;


UnrestrictedCharacterStringType
  : CHARACTER STRING
      {
	$$ = new UnrestrictedCharacterStringType;
      }
  ;


ChoiceType
  : CHOICE '{' 
      {
    ParsingConstructedType++;
	  }
    AlternativeTypeLists '}'
      {
	$$ = $4;
    ParsingConstructedType--;
      }
  ;

AlternativeTypeLists
  : AlternativeTypeList
      {
	$$ = new ChoiceType($1);
      }
  | AlternativeTypeList ',' ExtensionAndException
      {
	$$ = new ChoiceType($1, true);
      }
  | AlternativeTypeList ',' ExtensionAndException  ','  AlternativeTypeList
      {
	$$ = new ChoiceType($1, true, $5);
      }
  ;

AlternativeTypeList
  : NamedType	
      {
	$$ = new TypesVector;
	$$->push_back(TypePtr($1));
      }
  | AlternativeTypeList ',' NamedType
      {
	$1->push_back(TypePtr($3));
      }
  ;


ExtensionAndException
  : '.' '.' '.' ExceptionSpec
  ;


NamedType
  : IDENTIFIER Type
      {
	$2->SetName(*$1); delete $1;
	$$ = $2;
      }
  | Type	     /* ITU-T Rec. X.680 Appendix H.1 */
      {
	std::cerr << StdError(Warning) << "unnamed field." << std::endl;
	std::stringstream strm;
	strm << "_unnamed" << UnnamedFieldCount++<< std::ends;
	$1->SetName(strm.str());
      }
/*| SelectionType    /* Unnecessary as have rule in Type for this */
  ;


EmbeddedPDVType
  : EMBEDDED PDV
      {
	$$ = new EmbeddedPDVType;
      }
  ;


EnumeratedType
  : ENUMERATED '{' Enumerations '}'
      {
	$$ = $3;
      }
  ;

Enumerations
  : Enumeration
      {
	$$ = new EnumeratedType(*$1, false, NULL);
	delete $1;
      }
  | Enumeration  ',' '.' '.' '.'
      {
	$$ = new EnumeratedType(*$1, true, NULL);
	delete $1;
      }
  | Enumeration  ',' '.' '.' '.' ',' Enumeration
      {
	$$ = new EnumeratedType(*$1, true, $7);
	delete $1;
      }
  ;

Enumeration
  : EnumerationItem
      {
	$$ = new NamedNumberList;
	$$->push_back(NamedNumberPtr($1));
      }
  | Enumeration ',' EnumerationItem
      {
	$3->SetAutoNumber(*($1->back()));
	$1->push_back(NamedNumberPtr($3));
	$$ = $1;
      }
  ;

EnumerationItem
  : IDENTIFIER
      {
	$$ = new NamedNumber($1);
      }
  | NamedNumber
  ;

ExternalType
  : EXTERNAL
      {
	$$ = new ExternalType;
      }
  ;

AnyType
  : ANY
      {
	$$ = new AnyType(NULL);
      }
  | ANY DEFINED BY IDENTIFIER
      {
	$$ = new AnyType(*$4);
	delete $4;
      }
  ;


InstanceOfType
  : INSTANCE OF_t DefinedObjectClass
  ;


IntegerType
  : INTEGER_t
      {
	$$ = new IntegerType;
      }
  | INTEGER_t '{' NamedNumberList '}'
      {
	$$ = new IntegerType(*$3); delete $3;
      } 
  ;


NullType
  : NULL_TYPE
      {
	$$ = new NullType;
      }
  ;


ObjectClassFieldType
  : SimpleObjectClassFieldType
      {
  $$  = $1;
	  }
  | SimpleObjectClassFieldType '(' TableConstraint ExceptionSpec ')'
	  {
  $1->AddTableConstraint(boost::shared_ptr<TableConstraint>($3));
  $$ = $1;
	  }
  | SimpleObjectClassFieldType '(' ConstraintSpec ExceptionSpec ')'
      {
  $1->AddConstraint(ConstraintPtr($3));
  $$ = $1;
	  }
  ;
SimpleObjectClassFieldType
  : DefinedObjectClass
      {
    InformationFromObjectContext = $1;
	  }
	'.' FieldName
      {
	$$ = new ObjectClassFieldType(ObjectClassBasePtr($1), *$4); delete $4;
	InformationFromObjectContext = NULL;
      }
  ;


ObjectIdentifierType
  : OBJECT IDENTIFIER_t
      {
	$$ = new ObjectIdentifierType;
      }
  ;

OctetStringType
  : OCTET STRING
      {
	$$ = new OctetStringType;
      }
  ;


RealType
  : REAL
      {
	$$ = new RealType;
      }
  ;


SequenceType
  : SequenceAndBrace ComponentTypeLists '}'  
	  {
	$$ = $2;
    ParsingConstructedType--;
      }
  | SequenceAndBrace  '}'
      {
	$$ = new SequenceType(NULL, false, NULL);
    ParsingConstructedType--;
      }
  | SequenceAndBrace ExtensionAndException '}'
      {
	$$ = new SequenceType(NULL, true, NULL);
    ParsingConstructedType--;
      }
  ;

SequenceAndBrace
  : SEQUENCE 
	  {
    ParsingConstructedType++;
	  }
    '{'
  ;

ComponentTypeLists
  : ComponentTypeList
      {
	$$ = new SequenceType($1, false, NULL);
      }
  | ComponentTypeList ',' ExtensionAndException
      {
	$$ = new SequenceType($1, true, NULL);
      }
  | ComponentTypeList ',' ExtensionAndException ',' ComponentTypeList
      {
	$$ = new SequenceType($1, true, $5);
      }
  | ExtensionAndException ',' ComponentTypeList
      {
	$$ = new SequenceType(NULL, true, $3);
      }
  ;

ComponentTypeList
  : ComponentType
      {
	$$ = new TypesVector;
	$$->push_back(*$1);
	delete $1;
      }
  | ComponentTypeList ',' ComponentType
      {
	$1->push_back(*($3));
	delete $3;
      }
  ;

ComponentType
  : NamedType
      {
    $$ = new TypePtr($1);   
      }
  | NamedType OPTIONAL_t
      {
	$1->SetOptional();
	$$ = new TypePtr($1);
      }
  | NamedType 
      {
   	ValueTypeContext.reset($1);
    $1->BeginParseValue();
	  } 
	DEFAULT Value 
      {
   $1->SetDefaultValue(ValuePtr($4));
   $$ = new TypePtr(ValueTypeContext);
   $1->EndParseValue();
      }
  | COMPONENTS OF_t Type
      {
    $$ = new TypePtr($3);
      }
  ;


SequenceOfType
  : SEQUENCE OF_t Type
      {
	$$ = new SequenceOfType(TypePtr($3));
      }
  ;


SetType
  : SetAndBrace ComponentTypeLists '}' 
      {
	$$ = new SetType(*(SequenceType*)$2); delete $2;
    ParsingConstructedType--;
      }
  | SetAndBrace  '}'
      {
	$$ = new SetType;
    ParsingConstructedType--;
      }
  ;

SetAndBrace 
  : SET
      {
    ParsingConstructedType++;
	  } 
    '{'
  ;


SetOfType
  : SET OF_t Type
      {
	$$ = new SetOfType(TypePtr($3));
      }
  ;


TaggedType
  : Tag Type
      {
	$2->SetTag($1.tagClass, $1.tagNumber, Module->GetDefaultTagMode());
	$$ = $2;
      }
  | Tag IMPLICIT Type  
      {
	$3->SetTag($1.tagClass, $1.tagNumber, Tag::Implicit);
	$$ = $3;
      }
  | Tag EXPLICIT Type
      {
	$3->SetTag($1.tagClass, $1.tagNumber, Tag::Explicit);
	$$ = $3;
      }
  ;

Tag
  : '[' Class ClassNumber ']'
      {
	$$.tagClass = (Tag::Type)$2;
	$$.tagNumber = (int)$3;
      }
  ;

ClassNumber
  : INTEGER 
  | DefinedValue
      {
    IntegerValue* val = dynamic_cast<IntegerValue*>($1);
	if (val) {
	  $$ = *val;
	  delete $1;
	}
	else
	  std::cerr << StdError(Fatal) << "incorrect value type." << std::endl;
      }
  ;

Class
  : UNIVERSAL
      {
	$$ = Tag::Universal;
      }
  | APPLICATION
      {
	$$ = Tag::Application;
      }
  | PRIVATE
      {
	$$ = Tag::Private;
      }
  | /* empty */
      {
	$$ = Tag::ContextSpecific;
      }
  ;


SelectionType
  : IDENTIFIER '<' Type
      {
	$$ = new SelectionType(*$1, TypePtr($3)); delete $1;
      }
  ;


UsefulType
  : GeneralizedTime
      {
	$$ = new GeneralizedTimeType;
      }
  | UTCTime
      {
	$$ = new UTCTimeType;
      }
  | ObjectDescriptor_t
      {
	$$ = new ObjectDescriptorType;
      }
  ;


TypeFromObject
  : ReferencedObjectDot TYPEFIELDREFERENCE
    {
	  $$ = new TypeFromObject(InformationObjectPtr($1), *$2); delete $2;
	  InformationFromObjectContext = NULL; 
	}
  ;


ValueSetFromObjects
  : ReferencedObjectsDot FIXEDTYPEVALUEFIELDREFERENCE
   {
	  $$ = new ValueSetFromObjects(ObjectSetConstraintElementPtr($1), *$2); delete $2;
	  InformationFromObjectContext = NULL; 
   }
  | ReferencedObjectsDot FIXEDTYPEVALUESETFIELDREFERENCE
   {
	  $$ = new ValueSetFromObjects(ObjectSetConstraintElementPtr($1), *$2); delete $2;
	  InformationFromObjectContext = NULL; 
   }
  | ValueSetFromObject
  ;

ObjectSetFromObjects 
  : ReferencedObjectsDot OBJECTFIELDREFERENCE
    {
	  $$ = new ObjectSetFromObjects(ObjectSetConstraintElementPtr($1), *$2); delete $2;
	  InformationFromObjectContext = NULL; 
	}
  | ReferencedObjectsDot OBJECTSETFIELDREFERENCE
    {
	  $$ = new ObjectSetFromObjects(ObjectSetConstraintElementPtr($1), *$2); delete $2;
	  InformationFromObjectContext = NULL; 
	}
  | ObjectSetFromObject
  ;


ReferencedObjects
  : DefinedObjectSet
      {
  $$ = $1;
	  }
  | ObjectSetFromObjects
      {
  $$ = $1;
	  }
  | ParameterizedObjectSet
      {
  $$ = $1;
	  }
  ;

ReferencedObject
  : DefinedObject
  | ObjectFromObject
  | ParameterizedObject
  ;

ParameterizedObject
  : PARAMETERIZEDOBJECTREFERENCE ActualParameterList 
      { 
	  }
  | MODULEREFERENCE '.' PARAMETERIZEDOBJECTREFERENCE ActualParameterList 
      {
	  }
  ;


/********/

ConstrainedType
  : Type Constraint
      {
	$1->AddConstraint(ConstraintPtr($2));
      }
  | TypeWithConstraint
  ;


TypeWithConstraint
  : SET Constraint OF_t Type
      {
	$$ = new SetOfType(TypePtr($4), ConstraintPtr($2));
      }
  | SET SizeConstraint OF_t Type
      {
	ConstraintElementPtr cons($2);
	$$ = new SetOfType(TypePtr($4), ConstraintPtr(new Constraint(cons)));
      }
  | SEQUENCE Constraint OF_t Type
      {
	$$ = new SequenceOfType(TypePtr($4), ConstraintPtr($2));
      }
  | SEQUENCE SizeConstraint OF_t Type
      {
	ConstraintElementPtr cons($2);
	$$ = new SequenceOfType(TypePtr($4), ConstraintPtr(new Constraint(cons)));
      }
  ;

Constraint
  : '(' ConstraintSpec ExceptionSpec ')'
      {
	$$ = $2;
      }
  ;

ConstraintSpec
  : ElementSetSpecs
  | UserDefinedConstraint /* GeneralConstraint */
  ;


ExceptionSpec
  : '!' ExceptionIdentification 
      {
	$$ = $2;
      }
  | /* empty */
      {
	$$ = NULL;
      }
  ;


ExceptionIdentification
  : SignedNumber
      {
	$$ = new IntegerValue($1);
      }
  | DefinedValue
  | Type
      {
   	ValueTypeContext.reset($1);
    $1->BeginParseValue(); 
	  }
    ':' Value
      {
	$1->EndParseValue();
	$$ = $4;
      }
  ;


ElementSetSpecs
  : ElementSetSpec
      {
	$$ = new Constraint(std::auto_ptr<ConstraintElementVector>($1), false);
      }
  | ElementSetSpec  ',' '.' '.' '.'
      {
	$$ = new Constraint(std::auto_ptr<ConstraintElementVector>($1), true);
      }
  | '.' '.' '.' ',' ElementSetSpec
      {
	$$ = new Constraint(std::auto_ptr<ConstraintElementVector>(), 
						true, 
						std::auto_ptr<ConstraintElementVector>($5));
      }
  | ElementSetSpec  ',' '.' '.' '.' ',' ElementSetSpec
      {
	$$ = new Constraint(std::auto_ptr<ConstraintElementVector>($1), 
						true, 
						std::auto_ptr<ConstraintElementVector>($7));
      }
  ;


ElementSetSpec
  : Unions
  | ALL Exclusions
      {
    $$ = new ConstraintElementVector;
	$$->push_back(ConstraintElementPtr(
				new ConstrainAllConstraintElement(
					ConstraintElementPtr($2))));
      }
  ;


Unions
  : Intersections
      {
	if ($1->size() == 1)
	  $$= $1;
	else
	{
	  $$ = new ConstraintElementVector;
	  $$->push_back(ConstraintElementPtr(new ElementListConstraintElement(
												std::auto_ptr<ConstraintElementVector>($1))));
	}
      }
  | Unions UnionMark Intersections
      {
    if ($3->size() == 1)
	{
	  $$->push_back( (*$3)[0]);
	  delete $3;
	}
	else 
	  $$->push_back(ConstraintElementPtr(new ElementListConstraintElement(
				std::auto_ptr<ConstraintElementVector>($3))));
      }
  ;

Intersections
  : IntersectionElements 
      {
	$$ = new ConstraintElementVector;
	$$->push_back(ConstraintElementPtr($1));

      }
  | Intersections IntersectionMark IntersectionElements
      {
   	$$->push_back(ConstraintElementPtr($3));
      }
  ;

IntersectionElements
  : Elements 
  | Elements Exclusions
      {
	$1->SetExclusions(ConstraintElementPtr($2));
      }
  ;

Exclusions
  : EXCEPT Elements
      {
	$$ = $2;
      }
  ;

UnionMark
  : '|'	
  | UNION
  ;

IntersectionMark
  : '^'	
  | INTERSECTION
  ;

Elements
  : SubtypeElements
  | ObjectSetElements
  | '(' ElementSetSpec ')'
      {
	$$ = new ElementListConstraintElement(std::auto_ptr<ConstraintElementVector>($2));
      }
  ;


SubtypeElements
  : Value
      {
	$$ = new SingleValueConstraintElement(ValuePtr($1));
      }
  | ContainedSubtype
      {
	$$ = new SubTypeConstraintElement(TypePtr($1));
      }
  | ValueRange
  | PermittedAlphabet
  | SizeConstraint
/*| TypeConstraint  This is really Type and causes ambiguity with ContainedSubtype */
  | InnerTypeConstraints
  ;

ValueRange
  : LowerEndpoint '.' '.' UpperEndpoint
      {
	$$ = new ValueRangeConstraintElement(ValuePtr($1), ValuePtr($4));
      }
  ;

LowerEndpoint
  : LowerEndValue
  | LowerEndValue '<'
  ;

UpperEndpoint
  : UpperEndValue
  | '<' UpperEndValue
      {
	$$ = $2;
      }
  ;

LowerEndValue
  : Value 
  | MIN
      {
	$$ = new MinValue;
      }
  ;

UpperEndValue
  : Value 
  | MAX
      {
	$$ = new MaxValue;
      }
  ;

PermittedAlphabet
  : FROM Constraint
      {
	$$ = new FromConstraintElement(ConstraintPtr($2));
      }
  ;

ContainedSubtype
  : INCLUDES Type