asn_grammar.y

asn格式文件的编译器

      {
	$$ = $2;
      }
/*| Type	 Actual grammar has INCLUDES keyword optional but this is
		 horribly ambiguous, so only support  a few specific Type
		 definitions */
  | ConstrainedType
  | BuiltinType
  | ReferencedType
  /*
  | DefinedType
  | UsefulType
  */
  ;


SizeConstraint
  : SIZE_t Constraint
      {
	$$ = new SizeConstraintElement(ConstraintPtr($2));
      }
  ;


InnerTypeConstraints
  : WITH COMPONENT Constraint
      {
	$$ = new WithComponentConstraintElement(NULL, ConstraintPtr($3), WithComponentConstraintElement::Default);
      }
  | WITH COMPONENTS MultipleTypeConstraints
      {
	$$ = $3;
      }
  ;

MultipleTypeConstraints
  : '{' TypeConstraints '}'			/* FullSpecification */
      {
	$$ = new InnerTypeConstraintElement(std::auto_ptr<ConstraintElementVector>($2), false);
      }
  | '{'  '.' '.' '.' ',' TypeConstraints '}'	/* PartialSpecification */
      {
	$$ = new InnerTypeConstraintElement(std::auto_ptr<ConstraintElementVector>($6), true);
      }
  ;

TypeConstraints
  : NamedConstraint
      {
    $$ = new ConstraintElementVector;
	$$->push_back(ConstraintElementPtr($1));
      }
  | NamedConstraint ',' TypeConstraints
      {
	$3->push_back(ConstraintElementPtr($1));
	$$ = $3;
      }
  ;

NamedConstraint
  : IDENTIFIER PresenceConstraint
      {
	$$ = new WithComponentConstraintElement(*$1, ConstraintPtr(), (int)$2); delete $1;
      }
  | IDENTIFIER Constraint PresenceConstraint 
      {
	$$ = new WithComponentConstraintElement(*$1, ConstraintPtr($2), (int)$3); delete $1;
      }
  ;

PresenceConstraint
  : PRESENT
      {
	$$ = WithComponentConstraintElement::Present;
      }
  | ABSENT 
      {
	$$ = WithComponentConstraintElement::Absent;
      }
  | OPTIONAL_t
      {
	$$ = WithComponentConstraintElement::Optional;
      }
  | /* empty */
      {
	$$ = WithComponentConstraintElement::Default;
      }
  ;


/*
GeneralConstraint
  : UserDefinedConstraint
  | TableConstraint
  ;
*/

UserDefinedConstraint
  : CONSTRAINED BY '{' UserDefinedConstraintParameterList '}'
    {
	  ConstraintElementPtr cons($4);
      $$ = new Constraint(cons);
    }
  ;

UserDefinedConstraintParameterList
  : /* empty */
      {
	$$ = new UserDefinedConstraintElement(ActualParameterListPtr());
      }
  | UserDefinedConstraintParameters
      {
	$$ = new UserDefinedConstraintElement(ActualParameterListPtr($1));
      }
  ;
 
UserDefinedConstraintParameters
  : UserDefinedConstraintParameter ',' UserDefinedConstraintParameters
      {
	$3->push_back(ActualParameterPtr($1));
	$$ = $3;
      }
  | UserDefinedConstraintParameter
      {
	$$ = new ActualParameterList;
	$$->push_back(ActualParameterPtr($1));
      }
  ;

UserDefinedConstraintParameter
  : Governor ':' ActualParameter
      {
	$$ = $3;
      }
  | ActualParameter
  ;

Governor
  : Type
      {
    delete $1;
      }
  | DefinedObjectClass
      {
    delete $1;
	  }

TableConstraint
  : SimpleTableConstraint 
  | ComponentRelationConstraint
  ;

SimpleTableConstraint
  : '{' DefinedObjectSet '}' /* '{' ObjectSet '}'*/
      {
    $$ = new TableConstraint(DefinedObjectSetPtr($2));
	  }
  ;

ComponentRelationConstraint
  : '{' DefinedObjectSet '}' '{' AtNotations '}'
      { 
	$$ = new TableConstraint(DefinedObjectSetPtr($2), std::auto_ptr<StringList>($5));  
	  }
  ;

AtNotations
  : AtNotations ',' AtNotation
      {
  $1->push_back(*$3);
  delete $3;
	  }
  | AtNotation
      {
  $$ = new StringList;
  $$->push_back(*$1);
  delete $1;
	  }
  ;

AtNotation
  : '@' ComponentIdList
      {
  $$ = $2;
	  }
  | '@' '.' ComponentIdList
      {
  $3->insert(0, ".");
  $$ = $3;
	  }
  ;

ComponentIdList
  : ComponentIdList '.' IDENTIFIER
      {
  *($1) += '.' ;
  *($1) += *($3);
  $$ = $1;
  delete $3;
	  }
  | IDENTIFIER
  ;


/********/
ObjectClassAssignment
  : OBJECTCLASSREFERENCE ASSIGNMENT ObjectClass 
    {
		$3->SetName(*$1); delete $1;
		Module->AddObjectClass(ObjectClassBasePtr($3));
	}
  ;


ObjectAssignment
  : OBJECTREFERENCE DefinedObjectClass 
    {
	   $2->BeginParseObject();
    }
  ASSIGNMENT Object
    {
	   $2->EndParseObject();
       classStack->pop();
	   $5->SetName(*$1); delete $1;
       $5->SetObjectClass($2); 
       Module->AddInformationObject(InformationObjectPtr($5));
	}
  ;

ObjectSetAssignment
  : OBJECTSETREFERENCE DefinedObjectClass  
    {
	   $2->BeginParseObjectSet();
	}
  ASSIGNMENT ObjectSet
    {
	   Module->AddInformationObjectSet(InformationObjectSetPtr(
			new InformationObjectSetDefn(*$1, 
			                             ObjectClassBasePtr($2), 
			                             ConstraintPtr($5))));  
	   delete $1;
       classStack->pop();
	}
  ;


ObjectClass
  : DefinedObjectClass
  {
		$$ = $1;
  }
  | ObjectClassDefn 
  {
		$$ = $1;
  }
/*  | ParameterizedObjectClass */
  ;

DefinedObjectClass
  : OBJECTCLASSREFERENCE
    {
  $$ = new DefinedObjectClass(*$1);
  delete $1;
	}
  | ExternalObjectClassReference
    {
  $$ = new DefinedObjectClass(*$1);		
  delete $1;
	}
  | UsefulObjectClassReference 
    {
  $$ = new DefinedObjectClass(*$1);
  delete $1;
	}
  ;

ExternalObjectClassReference
  : MODULEREFERENCE '.' OBJECTCLASSREFERENCE
      {
	$$ = ConcatNames($1, '.', $3);
      }
  ;

UsefulObjectClassReference
  : TYPE_IDENTIFIER
      {
	$$ = new std::string("TYPE-IDENTIFIER");
      }
  | ABSTRACT_SYNTAX
      {
	$$ = new std::string("ABSTRACT-SYNTAX");
      }
  ;

ObjectClassDefn
  : CLASS  '{'  FieldSpecs '}' WithSyntaxSpec
    {
	    ObjectClassDefn* ocd = new ObjectClassDefn;
		$$ = ocd;
		ocd->SetFieldSpecs(std::auto_ptr<FieldSpecsList>($3));
		ocd->SetWithSyntaxSpec(TokenGroupPtr($5));
		InWithSyntaxContext = false;
    }
  ;

FieldSpecs
  : FieldSpecs ',' FieldSpec
	{
		$1->push_back(FieldSpecPtr($3));
		$$=$1;
	}
  | FieldSpec
	{
		$$ = new FieldSpecsList;
		$$->push_back(FieldSpecPtr($1));
	}
  ;

FieldSpec
  : TypeFieldSpec
  | FixedTypeValueFieldSpec
  | VariableTypeValueFieldSpec
  | FixedTypeValueSetFieldSpec
  | VariableTypeValueSetFieldSpec
  | ObjectFieldSpec
  | ObjectSetFieldSpec
  ;

TypeFieldSpec
  : FieldReference 
    { 
		$$ = new TypeFieldSpec(*$1); delete $1;
	}
  | FieldReference OPTIONAL_t
    {
		$$ = new TypeFieldSpec(*$1, true); delete $1;

    }
  | FieldReference DEFAULT Type
    {
		$$ = new TypeFieldSpec(*$1, false, TypePtr($3)); delete $1;
    }
  ;


FixedTypeValueFieldSpec
  : fieldreference Type  /* Unique ValueOptionalitySpec */
    { 
	  $$ = new FixedTypeValueFieldSpec(*$1, TypePtr($2));	  
	  delete $1;
	}
  | fieldreference Type UNIQUE
    {
	  $$ = new FixedTypeValueFieldSpec(*$1, TypePtr($2), false, true);
  	  delete $1;	  
	}
  | fieldreference Type OPTIONAL_t
    {
	  $$ = new FixedTypeValueFieldSpec(*$1, TypePtr($2), true);	  
  	  delete $1;	  
	}
  | fieldreference Type 
    {
      ValueTypeContext.reset($2);
  	  $2->BeginParseValue();
	} 
	DEFAULT Value
	{
	  FixedTypeValueFieldSpec* spec = new FixedTypeValueFieldSpec(*$1, ValueTypeContext);	 
  	  $2->EndParseValue();
	  spec->SetDefault(ValuePtr($5));
	  $$ = spec;
  	  delete $1;	  
	}
  | fieldreference Type UNIQUE OPTIONAL_t
    {
	  $$ = new FixedTypeValueFieldSpec(*$1, TypePtr($2), true, true);	  
  	  delete $1;	  
	}
  | fieldreference Type UNIQUE
    {
	  ValueTypeContext.reset($2);
	  $2->BeginParseValue();
	} 
	DEFAULT Value
	{
	  TypePtr t = ValueTypeContext;
	  $2->EndParseValue();
	  FixedTypeValueFieldSpec* spec = new FixedTypeValueFieldSpec(*$1, t, false, true);	 
	  spec->SetDefault(ValuePtr($6));
	  $$ = spec;
  	  delete $1;	  
	}
 ;



VariableTypeValueFieldSpec
  : fieldreference FieldReference /*  : valuefieldreference FieldName */
    { 
		$$ = new VariableTypeValueFieldSpec(*$1, *$2); delete $1; delete $2;
	}
  | fieldreference FieldReference OPTIONAL_t /*  | valuefieldreference FieldName OPTIONAL_t */
    {
		$$ = new VariableTypeValueFieldSpec(*$1, *$2, true); delete $1; delete $2;
	}
/*  | valuefieldreference FieldName DEFAULT Value */
  ;

FixedTypeValueSetFieldSpec
  : FieldReference Type 
      { 
	$$ = new FixedTypeValueSetFieldSpec(*$1, TypePtr($2));
	delete $1;
	  }
  | FieldReference Type OPTIONAL_t 
      {
	$$ = new FixedTypeValueSetFieldSpec(*$1, TypePtr($2), true);
	delete $1;
	  }
  | FieldReference Type
      {
    ValueTypeContext.reset($2);
	$2->BeginParseValueSet();
	  }
    DEFAULT ValueSet
	  {
	FixedTypeValueSetFieldSpec* spec = new FixedTypeValueSetFieldSpec(*$1, ValueTypeContext);
	$2->EndParseValueSet();
	spec->SetDefault(ValueSetPtr($5));
	$$ = spec;
	  }
  ;


VariableTypeValueSetFieldSpec 
   : FieldReference FieldReference /* : VALUESETFIELDREFERENCE FieldName */
       { 
	 $$ = new VariableTypeValueSetFieldSpec(*$1, *$2); delete $1; delete $2;
	   }
   | FieldReference FieldReference OPTIONAL_t /* | VALUESETFIELDREFERENCE FieldName OPTIONAL_t */
       {
	 $$ = new VariableTypeValueSetFieldSpec(*$1, *$2, true); delete $1; delete $2;
	   }
/*  | FieldReference FieldName DEFAULT ValueSet */
  ;

ObjectFieldSpec
  : fieldreference DefinedObjectClass
      {
	$$ = new  ObjectFieldSpec(*$1, $2); delete $1;
	  }
  | fieldreference DefinedObjectClass OPTIONAL_t
      {
	$$ = new  ObjectFieldSpec(*$1, $2, true); delete $1;
	  }
  | fieldreference DefinedObjectClass 
      {
	$2->BeginParseObject();
	  }
    DEFAULT Object
      {
	$2->EndParseObject();
    classStack->pop();
	ObjectFieldSpec* spec = new  ObjectFieldSpec(*$1, $2); delete $1;
	spec->SetDefault(InformationObjectPtr($5));
	$$ = spec;
	  }
  ;


ObjectSetFieldSpec
  : FieldReference DefinedObjectClass 
    { 
		$$ = new  ObjectSetFieldSpec(*$1, DefinedObjectClassPtr($2)); delete $1;
	}
  | FieldReference DefinedObjectClass OPTIONAL_t
    {
		$$ = new  ObjectSetFieldSpec(*$1, DefinedObjectClassPtr($2), true); delete $1;
	}
  | FieldReference DefinedObjectClass
    {
	    $2->BeginParseObjectSet();
	} 
  DEFAULT ObjectSet
    {
	    ObjectSetFieldSpec* spec = new  ObjectSetFieldSpec(*$1, DefinedObjectClassPtr($2));
	    delete $1;
		spec->SetDefault(ConstraintPtr($5));
		$$= spec;
    	classStack->pop();
	}
  ;


WithSyntaxSpec
  : WITH SYNTAX
    {
      InWithSyntaxContext = true;
	}
   SyntaxList
	{
	  $$ = $4;
      InWithSyntaxContext = false;
	}
  | /* empty */
    {
	  $$ = NULL;
	}
  ;

SyntaxList
  : '{' TokenOrGroupSpecs '}'
    {
		$$ = $2;
    }
  | '{' '}'
    {
	    $$ = NULL;
	}
  ;

TokenOrGroupSpecs
  : TokenOrGroupSpecs TokenOrGroupSpec
	{
		$$ = $1;
		$$->AddToken(TokenOrGroupSpecPtr($2));
		
	}
  | TokenOrGroupSpec
    {
		$$ = new TokenGroup;
		$$->AddToken(TokenOrGroupSpecPtr($1));
    }
  ;

TokenOrGroupSpec
  : RequiredToken
  | OptionalGroup
  ;

OptionalGroup
  : '[' TokenOrGroupSpecs ']'
  {
	$2->SetOptional();	  
    $$ = $2;
  }
  ;

RequiredToken
  : Literal
    {
		$$= new Literal(*$1); delete $1;
    }
  | FieldReference
    {
		$$ = new PrimitiveFieldName(*$1); delete $1;
	}
  | fieldreference
    {
		$$ = new PrimitiveFieldName(*$1); delete $1;
	}
  ;

Literal
  : WORD_t
	{
		$$ = $1;
	}
  | ','
    {
	    $$ = new std::string(",");
	}
  ;


DefinedObject
  : OBJECTREFERENCE
    {
  $$ = new DefinedObject(*$1);
  delete $1;
	}
  | ExternalObjectReference
    {
  $$ = new DefinedObject(*$1);
  delete $1;
	}
  ;


ExternalObjectReference
  : MODULEREFERENCE '.' OBJECTREFERENCE
    {
  $$ = ConcatNames($1, '.', $3);
	}
  ;

/*
ParameterizedObjectClass
  : DefinedObjectClass ActualParameterList 
    { }
  ;
*/

DefinedObjectSet
  : OBJECTSETREFERENCE
    {
		$$ = new DefinedObjectSet(*$1); 
		delete $1;
	}
  | ExternalObjectSetReference
    {
		$$ = new DefinedObjectSet(*$1);
		delete $1;
	}
  ;

ExternalObjectSetReference
  : MODULEREFERENCE '.' OBJECTSETREFERENCE 
      {
	$$ = ConcatNames($1, '.', $3);	 
	  }
  ;

ParameterizedObjectSet
  : PARAMETERIZEDOBJECTSETREFERENCE ActualParameterList
      {
	$$ = new ParameterizedObjectSet(*$1, ActualParameterListPtr($2));  delete $1;
	  }
  | MODULEREFERENCE '.' PARAMETERIZEDOBJECTSETREFERENCE ActualParameterList
      {
    std::string* str = ConcatNames($1, '.', $3);
	$$ = new ParameterizedObjectSet(*str, ActualParameterListPtr($4));
	delete str;
	  }
  ;

FieldName
  : FieldName '.' PrimitiveFieldName
      {
	$$ = ConcatNames($1, '.', $3);
      }
  | PrimitiveFieldName
  ;


PrimitiveFieldName
  : TYPEFIELDREFERENCE
  | VALUEFIELDREFERENCE
  | VALUESETFIELDREFERENCE
  | OBJECTFIELDREFERENCE
  | OBJECTSETFIELDREFERENCE 
  ;



Object
  : DefinedObject
  | ObjectDefn
  | ObjectFromObject
/*
  | ParameterizedObject
    { }
*/
  ;


ObjectDefn
  : DefinedSyntax 
    {
		$$ = new DefaultObjectDefn($1->GetDefaultSyntax());
		delete $1;
	}
  | DefaultSyntax
    {
		$$ = new DefaultObjectDefn(std::auto_ptr<FieldSettingList>($1));
	}  
;

DefaultSyntax
  : OBJECT_BRACE FieldSettings '}'
      {
    $$ = $2;
    if (InObjectSetContext)
	  classStack->top()->PreParseObject();
	  }
  ;

FieldSettings
  : FieldSettings ',' PrimitiveFieldName 
      {
	classStack->top()->GetField(*$3)->BeginParseSetting($1);
	  }
	Setting
	  {
	$$ = $1;
	classStack->top()->GetField(*$3)->EndParseSetting();
    $1->push_back(FieldSettingPtr(new FieldSetting(*$3, std::auto_ptr<Setting>($5))));
    delete $3;
	  }
  | PrimitiveFieldName
	  {
	classStack->top()->GetField(*$1)->BeginParseSetting(NULL);
	  }
	Setting
	  {
	$$ = new FieldSettingList;
	classStack->top()->GetField(*$1)->EndParseSetting();
	$$->push_back(FieldSettingPtr(new FieldSetting(*$1, std::auto_ptr<Setting>($3))));
	delete $1;
	  }
  ;


DefinedSyntax
  : OBJECT_BRACE DefinedSyntaxTokens '}'
	  {
	$$ = $2;
	$$->ResetTokenGroup();
    if (InObjectSetContext)
	  classStack->top()->PreParseObject();
	  }
  ;

DefinedSyntaxTokens
  : DefinedSyntaxTokens DefinedSyntaxToken
	{
		$$ = $1;
		$$->AddToken($2);
	}
  | /* empty */
  {
		$$ = new DefaultSyntaxBuilder(classStack->top()->GetWithSyntax());
  }
  ;

DefinedSyntaxToken
  : Literal
  {
	$$ = new LiteralToken(*$1); delete $1;
  }
  | Setting
  {
	$$ = new SettingToken(std::auto_ptr<Setting>($1)); 
  }
  ;


Setting
  : Type
	{
		$$ = new TypeSetting(TypePtr($1));
	}
  | Value
    {
	    if (ValueTypeContext.get() == NULL)
		  std::cerr << StdError(Fatal) << "Parsing Error\n";
		$$ = new ValueSetting(ValueTypeContext,ValuePtr($1));
	}
  | ValueSet
    {
		$$ = new ValueSetSetting(ValueSetPtr($1));
	}
  | Object
    {
		$$ = new ObjectSetting(InformationObjectPtr($1),classStack->top());
	}
  | ObjectSet
    {
	    $$ = new ObjectSetSetting(ConstraintPtr($1), classStack->top());
    	classStack->pop();
	}
  ;


ObjectSet
  : OBJECTSET_BRACE ObjectSetSpec '}'
      {
	$$ = $2;
	classStack->top()->EndParseObjectSet();
	  }
  ;

ObjectSetSpec
  : ElementSetSpecs
  | '.''.''.'
    {
	  $$ = new Constraint(std::auto_ptr<ConstraintElementVector>(), true); 
	}
  ;


ObjectSetElements
  : Object
      {
	$$ = new SingleObjectConstraintElement(InformationObjectPtr($1));
      }
  | DefinedObjectSet
      {
	$$ = $1;
      }
  | ObjectSetFromObjects
      {
	$$ = $1;
      }
  | ParameterizedObjectSet
      {
	$$ = $1;
      }
  ;

/*!!!
ObjectSetFromObjects
  : ReferencedObjectsDot FieldName
  ;
*/

ReferencedObjectsDot
  : ReferencedObjects 
    {
  InformationFromObjectContext = $1->GetObjectClass();
    }
  '.'
    {
  $$ = $1;
	}
  ;

ReferencedObjectDot