asn_grammar.y

asn格式文件的编译器

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

/********/

ParameterizedAssignment
  : ParameterizedTypeAssignment
  | ParameterizedValueAssignment
  | ParameterizedValueSetTypeAssignment
/*  | ParameterizedObjectClassAssignment */
  | ParameterizedObjectAssignment 
  | ParameterizedObjectSetAssignment
  ;

ParameterizedTypeAssignment
  : PARAMETERIZEDTYPEREFERENCE ParameterList
      {
	DummyParameters = $2;
      }
    ASSIGNMENT Type
      {
	DummyParameters = NULL;
	$5->SetName(*$1); delete $1;
	$5->SetParameters(*$2); delete $2;
	Module->AddType(TypePtr($5));
      }
  ;

ParameterizedValueAssignment
  : PARAMETERIZEDVALUEREFERENCE ParameterList Type 
      {
	DummyParameters = $2;
      }
    ASSIGNMENT Value
      { 
	DummyParameters = NULL;
	  }
  ;

ParameterizedValueSetTypeAssignment
  : PARAMETERIZEDTYPEREFERENCE ParameterList Type
      {
	DummyParameters = $2;
      }
    ASSIGNMENT ValueSet
      { 
	DummyParameters = NULL;
	  }
  ;

/*
ParameterizedObjectClassAssignment
  : PARAMETERIZEDOBJECTCLASSREFERENCE ParameterList ASSIGNMENT ObjectClass 
    { }
  ;
*/

ParameterizedObjectAssignment
  : PARAMETERIZEDOBJECTREFERENCE ParameterList DefinedObjectClass
      {
	DummyParameters = $2;
	$3->BeginParseObject();
      }
    ASSIGNMENT Object
      { 
	$3->EndParseObject();
   	classStack->pop();
	DummyParameters = NULL;
	$6->SetName(*$1); delete $1;
    $6->SetObjectClass($3); 
	$6->SetParameters(std::auto_ptr<ParameterList>($2));
    Module->AddInformationObject(InformationObjectPtr($6));
	  }
  ;

ParameterizedObjectSetAssignment
  : PARAMETERIZEDOBJECTSETREFERENCE ParameterList DefinedObjectClass 
      {
	DummyParameters = $2;
    $3->BeginParseObjectSet();
      }
    ASSIGNMENT ObjectSet
      {
	DummyParameters = NULL;
    Module->AddInformationObjectSet(InformationObjectSetPtr(
		new InformationObjectSetDefn(*$1, 
		                            ObjectClassBasePtr($3), 
		                            ConstraintPtr($6), 
		                            ParameterListPtr($2)))); 
	delete $1;
    classStack->pop();
	  }
  ;

ParameterList
  : '{' Parameters '}'
      {
	$$ = $2;
      }
  ;

Parameters
  : Parameters ',' Parameter
      {
	$$ = $1;
	$$->Append(ParameterPtr($3));
      }
  | Parameter
      {
	$$ = new ParameterList;
	$$->Append(ParameterPtr($1));
      }
  ;

Parameter
  : Type ':' Reference
      {
	$$ = new ValueParameter(TypePtr($1),*$3); delete $1;
      }
  | DefinedObjectClass ':' Reference
      {
    $$ = new ObjectParameter(DefinedObjectClassPtr($1),*$3); delete $3;
	  }
  | Reference
      {
    $$ = new Parameter(*$1); delete $1;
	  }
  ;

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

SimpleDefinedType
  : TYPEREFERENCE
  | ExternalTypeReference 
  ;

ActualParameterList
  : '{' ActualParameters '}'
      {
	$$ = $2;
      }
  ;

ActualParameters
  : ActualParameters ',' ActualParameter
      {
	$1->push_back(ActualParameterPtr($3));
	$$ = $1;
      }
  | ActualParameter
      {
	$$ = new ActualParameterList;
	$$->push_back(ActualParameterPtr($1));
      }
  ;

ActualParameter
  : Type
      {
    $$ = new ActualTypeParameter(TypePtr($1)); 
	  }
  | Value
      {
    $$ = new ActualValueParameter(ValuePtr($1)); 
	  }
  | '{' DefinedType '}' /* ValueSet */
      {
    $$ = new ActualValueSetParameter(TypePtr($2) ); 
	  }
/*!!!
  | DefinedObjectClass
    { }
*/
  | ObjectParameter /* Object */
      {
    $$ = new ActualObjectParameter(InformationObjectPtr($1)); 
	  }
  | '{' ObjectSetParameter '}' /* ObjectSet */
      {
    $$ = new ActualObjectSetParameter(boost::shared_ptr<ObjectSetConstraintElement>($2)); 
	  }
  ;

ObjectParameter
  : DefinedObject
  | ParameterizedObject
  ;

ObjectSetParameter 
  : DefinedObjectSet
      {
  $$ = $1;
	  }
  | ParameterizedObjectSet
      {
  $$ = $1;
	  }
  ;
/********/

ValueAssignment 
  : VALUEREFERENCE Type
      {
    ValueTypeContext.reset($2);
	$2->BeginParseValue();
      }
    ASSIGNMENT Value
      {
	$2->EndParseValue();
	$5->SetValueName(*$1); delete $1;
	Module->AddValue(ValuePtr($5));
      }
  ;


Value
  : BuiltinValue
  | ReferencedValue
  ;


BuiltinValue
  : BitStringValue 
  | BooleanValue 
  | CharacterStringValue 
  | ChoiceValue 
/*| EmbeddedPDVValue  synonym to SequenceValue */
/*| EnumeratedValue   synonym to IDENTIFIER    */
/*| ExternalValue     synonym to SequenceValue */
/*| InstanceOfValue   synonym to Value */
  | SignedNumber      /* IntegerValue */
      {
	$$ = new IntegerValue($1);
      }
  | NullValue 
/*!!!
  | ObjectClassFieldValue
*/
  | ObjectIdentifierValue
  | OctetStringValue
  | RealValue 
  | SequenceValue 
/*!!!! 
  | SequenceOfValue
*/
/*| SetValue	      synonym to SequenceValue */
/*| SetOfValue	      synonym to SequenceOfValue */
/*| TaggedValue	      synonym to Value */
  ;


DefinedValue
  : VALUEREFERENCE
      {
	$$ = new DefinedValue(*$1); delete $1;
      }
  | ExternalValueReference
      {
	$$ = new DefinedValue(*$1); delete $1;
      }
/*
  | ParameterizedValue
*/
  ;

ExternalValueReference
  : MODULEREFERENCE '.' VALUEREFERENCE 
      {
	*$1 += *$3;
	delete $3;
      }
  ;

ObjectIdentifierValue
  : '{' ObjIdComponentList '}'
      {
	$$ = new ObjectIdentifierValue(*$2); delete $2;
      }
/*!!!
  | '{' DefinedValue_OID ObjIdComponentList '}'
      {
	$$ = new ObjectIdentifierValue($2);
      }
*/
  ;


ObjIdComponentList
  : ObjIdComponent
      {
	$$ = new StringList;
	$$->push_back(*$1);
	delete $1;
      }
/*  | ObjIdComponent ObjIdComponentList
      {
	$2->InsertAt(0, $1);
	$$ = $2;
      }
*/
	| ObjIdComponentList ObjIdComponent
      {
	$1->push_back(*$2);
	$$ = $1;
	delete $2
      }
  ;

ObjIdComponent
  : OID_IDENTIFIER
  | OID_INTEGER
  | OID_IDENTIFIER '(' NumberForm ')'
      {
	delete $1;
	$$ = $3;
      }
  ;

NumberForm
  : OID_INTEGER
  | ExternalValueReference 
  | VALUEREFERENCE
  ;


OctetStringValue
  : OS_BSTRING
      {
	$$ = new OctetStringValue(*$1); delete $1;
      }
  | OS_HSTRING
      {
	$$ = new OctetStringValue(*$1); delete $1;
      }
  ;

BitStringValue
  : BS_BSTRING
      {
	$$ = new BitStringValue(*$1); delete $1;
      }
  | BS_HSTRING
      {
	$$ = new BitStringValue(*$1); delete $1;
      }
  | '{' BitIdentifierList '}' 
      {
	$$ = new BitStringValue($2); 
      }
  ;


BitIdentifierList
  : BIT_IDENTIFIER
      {
	// Look up $1
	$$ = new StringList;
      }
  | BitIdentifierList ',' BIT_IDENTIFIER
      {
	// Look up $3
	$1->push_back(std::string("0"));
      }
  ;


BooleanValue
  : TRUE_t
      {
	$$ = new BooleanValue(true);
      }
  | FALSE_t
      {
	$$ = new BooleanValue(false);
      }
  ;


CharacterStringValue
  : RestrictedCharacterStringValue
/*!!!
  | UnrestrictedCharacterStringValue
*/
  ;

RestrictedCharacterStringValue
  : CSTRING
      {
	$$ = new CharacterStringValue(*$1); delete $1;
      }
  | CharacterStringList
  | Quadruple
  | Tuple
  ;

CharacterStringList
  : '{' CharSyms '}'
      {
	$$ = new CharacterStringValue(*$2); delete $2;
      }
  ;

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

CharsDefn
  : CSTRING 
  | DefinedValue
      {
	std::cerr << StdError(Warning) << "DefinedValue in string unsupported" << std::endl;
      }
  ;

Quadruple
  :  '{'  INTEGER  ','  INTEGER  ','  INTEGER  ','  INTEGER '}'
      {
	if ($2 != 0 || $4 != 0 || $6 > 255 || $8 > 255)
	  std::cerr << StdError(Warning) << "Illegal value in Character Quadruple" << std::endl;
	$$ = new CharacterValue((unsigned char)$2, (unsigned char)$4, (unsigned char)$6, (unsigned char)$8);
      }
  ;

Tuple
  :  '{' INTEGER ',' INTEGER '}'
      {
	if ($2 > 255 || $4 > 255)
	  std::cerr << StdError(Warning) << "Illegal value in Character Tuple" << std::endl;
	$$ = new CharacterValue((unsigned char)$2, (unsigned char)$4);
      }
  ;


ChoiceValue
  : IDENTIFIER ':' Value
      {
	$$ = new ChoiceValue(ValueTypeContext, *$1, ValuePtr($3)); delete $1;
      }
  ;


NullValue
  : NULL_VALUE
      {
	$$ = new NullValue;
      }
  ;


RealValue
  : NumericRealValue 
  | SpecialRealValue
  ;

NumericRealValue
  :  '0'
      {
	$$ = new RealValue(0);
      }
/*!!!
  | SequenceValue
*/
  ;

SpecialRealValue
  : PLUS_INFINITY
      {
	$$ = new RealValue(0);
      }
  | MINUS_INFINITY
      {
	$$ = new RealValue(0);
      }
  ;


SequenceValue
  : '{' ComponentValueList '}' 
      {
	$$ = new SequenceValue($2);
      }
  | '{'  '}'
      {
	$$ = new SequenceValue;
      }
  ;

ComponentValueList
  : NamedValue
      {
	$$ = new ValuesList;
	$$->push_back(ValuePtr($1));
      }
  | ComponentValueList ',' NamedValue
      {
	$1->push_back(ValuePtr($3));
      }
  ;

NamedValue
  : IDENTIFIER Value
      {
	$2->SetValueName(*$1); delete $1;
	$$ = $2;
      }
  ;


/*!!!! 
SequenceOfValue
  : '{' ValueList '}' 
      {
	$$ = NULL;
      }
  | '{'  '}'
      {
	$$ = NULL;
      }
  ;

ValueList
  : Value
      { }
  | ValueList ',' Value
      { }
  ;
*/ 


/*!!!
ObjectClassFieldValue
  : OpenTypeFieldVal
  | Value
  ;

OpenTypeFieldVal
  : Type ':' Value
  ;
*/


ReferencedValue
  : DefinedValue
  | ValueFromObject
  ;

ValueFromObject
  : ReferencedObjectDot VALUEFIELDREFERENCE
    {
	  ValueSetting* setting = (ValueSetting*) $1->GetSetting(*$2);
	  $$ = new DefinedValue(setting->GetValue());
	  delete $1;
	  delete $2;
      InformationFromObjectContext = NULL; 
	}
  ;

VALUEFIELDREFERENCE 
  : FIXEDTYPEVALUEFIELDREFERENCE
  | VARIABLETYPEVALUEFIELDREFERENCE
  ;

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

VALUESETFIELDREFERENCE 
  : FIXEDTYPEVALUESETFIELDREFERENCE
  | VARIABLETYPEVALUESETFIELDREFERENCE
  ;

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

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


ParameterizedValue
  : PARAMETERIZEDVALUEREFERENCE ActualParameterList
    { }
  | MODULEREFERENCE '.' PARAMETERIZEDVALUEREFERENCE ActualParameterList
    { }
  ;

SimpleDefinedValue
  : VALUEREFERENCE
  | ExternalValueReference 
  ;




ValueSet
  : VALUESET_BRACE ElementSetSpecs '}'
	{
  if (ValueTypeContext.get() == NULL)
     std::cerr << StdError(Warning) << "";
  // $$ = new ValueSetDefn(TypePtr(new DefinedType(ValueTypeContext)), ConstraintPtr($2));
  $$ = new ValueSetDefn(ValueTypeContext, ConstraintPtr($2));
  ValueTypeContext->EndParseValueSet();
	}
  ;



MacroDefinition
  : TYPEREFERENCE MACRO ASSIGNMENT MacroSubstance
      {
	std::cerr << StdError(Warning) << "MACRO unsupported" << std::endl;
      }
  ;

MacroSubstance
  : BEGIN_t
      {
	InMacroContext = true;
      }
    MacroBody END
      {
	InMacroContext = false;
      }
  | TYPEREFERENCE
      {}
  | TYPEREFERENCE '.' TYPEREFERENCE
      {}
  ;

MacroBody
  : TypeProduction ValueProduction /*SupportingProductions*/
  ;

TypeProduction
  : TYPE_t NOTATION ASSIGNMENT MacroAlternativeList
  ;

ValueProduction
  : VALUE NOTATION ASSIGNMENT MacroAlternativeList
  ;


/*
SupportingProductions
  : ProductionList
  | /* empty *//*
  ;

ProductionList
  : Production
  | ProductionList Production
  ;

Production
  : TYPEREFERENCE ASSIGNMENT MacroAlternativeList

  ;
*/

MacroAlternativeList
  : MacroAlternative
  | MacroAlternative '|' MacroAlternativeList
  ;

MacroAlternative
  : SymbolElement
  | SymbolElement MacroAlternative
  ;

SymbolElement
  : SymbolDefn
  | EmbeddedDefinitions
  ;

SymbolDefn
  : CSTRING
      {}
  | TYPEREFERENCE
      {}
  | TYPEREFERENCE ASSIGNMENT
      {}
  ;

EmbeddedDefinitions
  : '<' EmbeddedDefinitionList '>'
  ;

EmbeddedDefinitionList
  : EmbeddedDefinition
  | EmbeddedDefinitionList EmbeddedDefinition
  ;

EmbeddedDefinition
  : LocalTypeAssignment
  | LocalValueAssignment
  ;

LocalTypeAssignment
  : TYPEREFERENCE ASSIGNMENT Type
      {}
  ;

LocalValueAssignment
  : IDENTIFIER Type ASSIGNMENT Value
      {}
  ;


/********/

/********/

/*!!! Not actually referenced by any other part of grammar
AbsoluteReference
  : '@' GlobalModuleReference '.' ItemSpec
  ;

ItemSpec
  : TYPEREFERENCE
  |  ItemId '.' ComponentId
  ;

ItemId
  : ItemSpec
  ;

ComponentId 
  : IDENTIFIER
  | INTEGER
  | '*'
  ;
*/


Reference
  : TYPEREFERENCE
  | VALUEREFERENCE 
  | OBJECTCLASSREFERENCE 
  | OBJECTREFERENCE
  | OBJECTSETREFERENCE
  | PARAMETERIZEDTYPEREFERENCE
  | PARAMETERIZEDVALUEREFERENCE 
  | PARAMETERIZEDOBJECTCLASSREFERENCE 
  | PARAMETERIZEDOBJECTREFERENCE
  | PARAMETERIZEDOBJECTSETREFERENCE
  | IDENTIFIER
  ;


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

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


SignedNumber
  :  INTEGER 
  | '-' INTEGER
      {
	$$ = -$2;
      }
  ;

/** End of File ****/