use of org.osate.aadl2.ReferenceValue in project osate2 by osate.
the class CachePropertyAssociationsSwitch method cacheConnectionPropertyAssociations.
protected void cacheConnectionPropertyAssociations(final ConnectionInstance conni) {
PropertyAssociation setPA;
PropertyExpression defaultvalue;
try {
/*
* propertyFilter contains all properties used by the system, so, we try to
* use the one associated to the connection instance and their reference and
* see if the user declares a specific value.
*/
for (Property prop : propertyFilter) {
setPA = null;
defaultvalue = prop.getDefaultValue();
for (final ConnectionReference connRef : conni.getConnectionReferences()) {
/*
* In the following piece of code, we check that a property
* is consistent all along the connection reference.
* For example, we check that the timing property (immediate, delayed)
* is consistent for each connection.
*/
if (connRef.acceptsProperty(prop)) {
/*
* Just look up the property. The property doesn't yet have
* a local association, so lookup will get the value from
* the declarative model. Property lookup process now
* corrects reference values to instance reference values.
*/
final PropertyAssociation propAssociation = scProps.retrieveSCProperty(conni, prop, connRef.getConnection());
final EvaluationContext ctx = new EvaluationContext(connRef, classifierCache, propAssociation);
PropertyEvaluationResult result = prop.evaluate(ctx, 0);
List<EvaluatedProperty> evaluated = result.getEvaluated();
if (!evaluated.isEmpty()) {
PropertyAssociationInstance newPA = InstanceFactory.eINSTANCE.createPropertyAssociationInstance();
newPA.setProperty(prop);
newPA.setPropertyAssociation(getDeclarativePA(result.getPa()));
fillPropertyValue(connRef, newPA, evaluated);
if (!newPA.getOwnedValues().isEmpty()) {
/*
* FIXME JD
*
* Try to look if the property references a component or not.
* This was done to fix the issue related to the Bound Bus analysis plugin
*/
for (Iterator<Element> content = EcoreUtil.getAllProperContents(newPA, false); content.hasNext(); ) {
Element elem = content.next();
if (elem instanceof ModalPropertyValue) {
ModalPropertyValue mpv = (ModalPropertyValue) elem;
if (mpv.getOwnedValue() instanceof ListValue) {
ListValue lv = (ListValue) mpv.getOwnedValue();
for (Element e : lv.getOwnedListElements()) {
if (e instanceof ReferenceValue) {
PropertyExpression irv = ((ReferenceValue) e).instantiate(conni.getContainingComponentInstance());
if (irv != null) {
EcoreUtil.replace(e, irv);
}
}
}
}
}
if (elem instanceof ReferenceValue) {
PropertyExpression irv = ((ReferenceValue) elem).instantiate(conni.getContainingComponentInstance());
if (irv != null) {
EcoreUtil.replace(elem, irv);
}
}
}
scProps.recordSCProperty(conni, prop, connRef.getConnection(), newPA);
if (setPA == null) {
setPA = newPA;
conni.getOwnedPropertyAssociations().add(newPA);
} else {
// check consistency
for (Mode m : conni.getSystemInstance().getSystemOperationModes()) {
PropertyExpression newVal = newPA.valueInMode(m);
PropertyExpression setVal = setPA.valueInMode(m);
if (!newVal.sameAs(setVal)) {
error(conni, "Value for property " + setPA.getProperty().getQualifiedName() + " not consistent along connection");
break;
}
}
}
}
}
}
}
checkIfCancelled();
if (cancelled()) {
break;
}
}
} catch (IllegalStateException e) {
// circular dependency
// xxx: this is a misleading place to put the marker
error(conni, e.getMessage());
System.out.println("IllegalStateException raised in cacheConnectionPropertyAssociations");
} catch (InvalidModelException e) {
error(conni, e.getMessage());
System.out.println("InvalidModelException raised in cacheConnectionPropertyAssociations");
}
}
use of org.osate.aadl2.ReferenceValue in project osate2 by osate.
the class CachePropertyAssociationsSwitch method fillPropertyValue.
private void fillPropertyValue(InstanceObject io, PropertyAssociation pa, List<EvaluatedProperty> values) {
PropertyExpression lexp;
List<PropertyExpression> elems;
final Iterator<EvaluatedProperty> valueIter = values.iterator();
final EvaluatedProperty value = valueIter.next();
final List<MpvProxy> proxies = value.getProxies();
for (MpvProxy proxy : proxies) {
ModalPropertyValue newVal = Aadl2Factory.eINSTANCE.createModalPropertyValue();
List<SystemOperationMode> inSOMs = new ArrayList<SystemOperationMode>();
newVal.setOwnedValue(EcoreUtil.copy(proxy.getValue()));
// process list appends
while (valueIter.hasNext()) {
MpvProxy prx = valueIter.next().getProxies().get(0);
if (prx.isModal()) {
throw new InvalidModelException(pa, "Trying to append to a modal list value");
}
lexp = EcoreUtil.copy(prx.getValue());
elems = ((ListValue) lexp).getOwnedListElements();
((ListValue) newVal.getOwnedValue()).getOwnedListElements().addAll(0, elems);
}
boolean valueIsUsed = false;
if (!proxy.isModal()) {
valueIsUsed = true;
pa.getOwnedValues().add(newVal);
} else {
List<Mode> modes = proxy.getModes();
for (Mode mode : modes) {
if (mode instanceof SystemOperationMode) {
inSOMs.add((SystemOperationMode) mode);
} else {
if (io instanceof ConnectionReference) {
List<SystemOperationMode> conniModes = ((ConnectionInstance) io.eContainer()).getInSystemOperationModes();
if (conniModes.isEmpty()) {
conniModes = io.getSystemInstance().getSystemOperationModes();
}
List<ModeInstance> holderModes = ((ConnectionReference) io).getContext().getModeInstances();
for (ModeInstance mi : holderModes) {
if (mi.getMode() == mode) {
for (SystemOperationMode som : conniModes) {
if (som.getCurrentModes().contains(mi)) {
inSOMs.add(som);
}
}
break;
}
}
} else {
List<ModeInstance> holderModes = (io instanceof ComponentInstance) ? ((ComponentInstance) io).getModeInstances() : io.getContainingComponentInstance().getModeInstances();
for (ModeInstance mi : holderModes) {
if (mi.getMode() == mode) {
if (mode2som.containsKey(mi)) {
inSOMs.addAll(mode2som.get(mi));
break;
}
}
}
}
}
}
for (SystemOperationMode som : inSOMs) {
if (io.isActive(som)) {
newVal.getInModes().add(som);
}
}
if (!newVal.getInModes().isEmpty()) {
valueIsUsed = true;
pa.getOwnedValues().add(newVal);
}
}
if (valueIsUsed) {
// replace reference values in the context of the contained PA's owner
for (Iterator<Element> content = EcoreUtil.getAllProperContents(newVal, false); content.hasNext(); ) {
Element elem = content.next();
if (elem instanceof ReferenceValue) {
try {
PropertyExpression irv = ((ReferenceValue) elem).instantiate(io);
if (irv != null) {
EcoreUtil.replace(elem, irv);
}
} catch (InvalidModelException e) {
error(io, e.getMessage());
}
}
}
}
}
}
use of org.osate.aadl2.ReferenceValue in project osate2 by osate.
the class AbstractInstanceSemanticSequencer method sequence.
@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
EPackage epackage = semanticObject.eClass().getEPackage();
ParserRule rule = context.getParserRule();
Action action = context.getAssignedAction();
Set<Parameter> parameters = context.getEnabledBooleanParameters();
if (epackage == Aadl2Package.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case Aadl2Package.ARRAY_RANGE:
sequence_ArrayRange(context, (ArrayRange) semanticObject);
return;
case Aadl2Package.BASIC_PROPERTY_ASSOCIATION:
sequence_FieldPropertyAssociation(context, (BasicPropertyAssociation) semanticObject);
return;
case Aadl2Package.BOOLEAN_LITERAL:
sequence_BooleanLiteral(context, (BooleanLiteral) semanticObject);
return;
case Aadl2Package.CLASSIFIER_VALUE:
sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
return;
case Aadl2Package.COMPUTED_VALUE:
sequence_ComputedTerm(context, (ComputedValue) semanticObject);
return;
case Aadl2Package.CONTAINED_NAMED_ELEMENT:
sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
return;
case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
return;
case Aadl2Package.INTEGER_LITERAL:
sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
return;
case Aadl2Package.LIST_VALUE:
sequence_ListTerm(context, (ListValue) semanticObject);
return;
case Aadl2Package.MODAL_PROPERTY_VALUE:
if (rule == grammarAccess.getModalPropertyValueRule()) {
sequence_ModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getOptionalModalPropertyValueRule()) {
sequence_OptionalModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyValueRule()) {
sequence_PropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else
break;
case Aadl2Package.NAMED_VALUE:
if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
sequence_ConstantValue(context, (NamedValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
return;
} else
break;
case Aadl2Package.OPERATION:
sequence_SignedConstant(context, (Operation) semanticObject);
return;
case Aadl2Package.PROPERTY_ASSOCIATION:
if (rule == grammarAccess.getBasicPropertyAssociationRule()) {
sequence_BasicPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPModelRule() || rule == grammarAccess.getContainedPropertyAssociationRule()) {
sequence_ContainedPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyAssociationRule()) {
sequence_PropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else
break;
case Aadl2Package.RANGE_VALUE:
sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
return;
case Aadl2Package.REAL_LITERAL:
sequence_RealTerm(context, (RealLiteral) semanticObject);
return;
case Aadl2Package.RECORD_VALUE:
if (rule == grammarAccess.getOldRecordTermRule()) {
sequence_OldRecordTerm(context, (RecordValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
sequence_RecordTerm(context, (RecordValue) semanticObject);
return;
} else
break;
case Aadl2Package.REFERENCE_VALUE:
sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
return;
case Aadl2Package.STRING_LITERAL:
sequence_StringTerm(context, (StringLiteral) semanticObject);
return;
}
else if (epackage == InstancePackage.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case InstancePackage.COMPONENT_INSTANCE:
sequence_ComponentInstance(context, (ComponentInstance) semanticObject);
return;
case InstancePackage.CONNECTION_INSTANCE:
sequence_ConnectionInstance(context, (ConnectionInstance) semanticObject);
return;
case InstancePackage.CONNECTION_REFERENCE:
sequence_ConnectionReference(context, (ConnectionReference) semanticObject);
return;
case InstancePackage.END_TO_END_FLOW_INSTANCE:
sequence_EndToEndFlowInstance(context, (EndToEndFlowInstance) semanticObject);
return;
case InstancePackage.FEATURE_INSTANCE:
sequence_FeatureInstance(context, (FeatureInstance) semanticObject);
return;
case InstancePackage.FLOW_SPECIFICATION_INSTANCE:
sequence_FlowSpecificationInstance(context, (FlowSpecificationInstance) semanticObject);
return;
case InstancePackage.INSTANCE_REFERENCE_VALUE:
sequence_InstanceReferenceValue(context, (InstanceReferenceValue) semanticObject);
return;
case InstancePackage.MODE_INSTANCE:
sequence_ModeInstance(context, (ModeInstance) semanticObject);
return;
case InstancePackage.MODE_TRANSITION_INSTANCE:
sequence_ModeTransitionInstance(context, (ModeTransitionInstance) semanticObject);
return;
case InstancePackage.PROPERTY_ASSOCIATION_INSTANCE:
sequence_PropertyAssociationInstance(context, (PropertyAssociationInstance) semanticObject);
return;
case InstancePackage.SYSTEM_INSTANCE:
sequence_SystemInstance(context, (SystemInstance) semanticObject);
return;
case InstancePackage.SYSTEM_OPERATION_MODE:
sequence_SystemOperationMode(context, (SystemOperationMode) semanticObject);
return;
}
if (errorAcceptor != null)
errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}
use of org.osate.aadl2.ReferenceValue in project AGREE by loonwerks.
the class AbstractAgreeSemanticSequencer method sequence.
@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
EPackage epackage = semanticObject.eClass().getEPackage();
ParserRule rule = context.getParserRule();
Action action = context.getAssignedAction();
Set<Parameter> parameters = context.getEnabledBooleanParameters();
if (epackage == Aadl2Package.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case Aadl2Package.ARRAY_RANGE:
sequence_ArrayRange(context, (ArrayRange) semanticObject);
return;
case Aadl2Package.BASIC_PROPERTY_ASSOCIATION:
sequence_FieldPropertyAssociation(context, (BasicPropertyAssociation) semanticObject);
return;
case Aadl2Package.BOOLEAN_LITERAL:
sequence_BooleanLiteral(context, (BooleanLiteral) semanticObject);
return;
case Aadl2Package.CLASSIFIER_VALUE:
sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
return;
case Aadl2Package.COMPUTED_VALUE:
sequence_ComputedTerm(context, (ComputedValue) semanticObject);
return;
case Aadl2Package.CONTAINED_NAMED_ELEMENT:
sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
return;
case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
return;
case Aadl2Package.INTEGER_LITERAL:
sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
return;
case Aadl2Package.LIST_VALUE:
sequence_ListTerm(context, (ListValue) semanticObject);
return;
case Aadl2Package.MODAL_PROPERTY_VALUE:
if (rule == grammarAccess.getModalPropertyValueRule()) {
sequence_ModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getOptionalModalPropertyValueRule()) {
sequence_OptionalModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyValueRule()) {
sequence_PropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else
break;
case Aadl2Package.NAMED_VALUE:
if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
sequence_ConstantValue(context, (NamedValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
return;
} else
break;
case Aadl2Package.OPERATION:
sequence_SignedConstant(context, (Operation) semanticObject);
return;
case Aadl2Package.PROPERTY_ASSOCIATION:
if (rule == grammarAccess.getBasicPropertyAssociationRule()) {
sequence_BasicPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPModelRule() || rule == grammarAccess.getContainedPropertyAssociationRule()) {
sequence_ContainedPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyAssociationRule()) {
sequence_PropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else
break;
case Aadl2Package.RANGE_VALUE:
sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
return;
case Aadl2Package.REAL_LITERAL:
sequence_RealTerm(context, (RealLiteral) semanticObject);
return;
case Aadl2Package.RECORD_VALUE:
if (rule == grammarAccess.getOldRecordTermRule()) {
sequence_OldRecordTerm(context, (RecordValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
sequence_RecordTerm(context, (RecordValue) semanticObject);
return;
} else
break;
case Aadl2Package.REFERENCE_VALUE:
sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
return;
case Aadl2Package.STRING_LITERAL:
sequence_StringTerm(context, (StringLiteral) semanticObject);
return;
}
else if (epackage == AgreePackage.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case AgreePackage.AGREE_CONTRACT:
sequence_AgreeContract(context, (AgreeContract) semanticObject);
return;
case AgreePackage.AGREE_CONTRACT_LIBRARY:
sequence_AgreeLibrary(context, (AgreeContractLibrary) semanticObject);
return;
case AgreePackage.AGREE_CONTRACT_SUBCLAUSE:
sequence_AgreeSubclause(context, (AgreeContractSubclause) semanticObject);
return;
case AgreePackage.ALWAYS_STATEMENT:
sequence_PatternStatement(context, (AlwaysStatement) semanticObject);
return;
case AgreePackage.ARG:
sequence_Arg(context, (Arg) semanticObject);
return;
case AgreePackage.ARRAY_LITERAL_EXPR:
sequence_ArrayLiteralExpr(context, (ArrayLiteralExpr) semanticObject);
return;
case AgreePackage.ARRAY_SUB_EXPR:
sequence_ArraySubExpr(context, (ArraySubExpr) semanticObject);
return;
case AgreePackage.ARRAY_TYPE:
sequence_Type(context, (ArrayType) semanticObject);
return;
case AgreePackage.ARRAY_UPDATE_EXPR:
sequence_ArrayUpdateExpr(context, (ArrayUpdateExpr) semanticObject);
return;
case AgreePackage.ASSERT_STATEMENT:
sequence_NamedSpecStatement(context, (AssertStatement) semanticObject);
return;
case AgreePackage.ASSIGN_STATEMENT:
sequence_AssignStatement(context, (AssignStatement) semanticObject);
return;
case AgreePackage.ASSUME_STATEMENT:
sequence_NamedSpecStatement(context, (AssumeStatement) semanticObject);
return;
case AgreePackage.ASYNCH_STATEMENT:
sequence_SynchStatement(context, (AsynchStatement) semanticObject);
return;
case AgreePackage.BINARY_EXPR:
sequence_AddSubExpr_AndExpr_ArrowExpr_EquivExpr_ImpliesExpr_MultDivExpr_OrExpr_PowerExpr_RelateExpr(context, (BinaryExpr) semanticObject);
return;
case AgreePackage.BOOL_LIT_EXPR:
sequence_TermExpr(context, (BoolLitExpr) semanticObject);
return;
case AgreePackage.CALEN_STATEMENT:
sequence_SynchStatement(context, (CalenStatement) semanticObject);
return;
case AgreePackage.CALL_EXPR:
sequence_TermExpr(context, (CallExpr) semanticObject);
return;
case AgreePackage.CLOSED_TIME_INTERVAL:
sequence_TimeInterval(context, (ClosedTimeInterval) semanticObject);
return;
case AgreePackage.CONNECTION_STATEMENT:
sequence_SpecStatement(context, (ConnectionStatement) semanticObject);
return;
case AgreePackage.CONST_STATEMENT:
sequence_ConstStatement(context, (ConstStatement) semanticObject);
return;
case AgreePackage.DOUBLE_DOT_REF:
sequence_DoubleDotRef(context, (DoubleDotRef) semanticObject);
return;
case AgreePackage.ENUM_LIT_EXPR:
sequence_TermExpr(context, (EnumLitExpr) semanticObject);
return;
case AgreePackage.ENUM_STATEMENT:
sequence_EnumStatement(context, (EnumStatement) semanticObject);
return;
case AgreePackage.EQ_STATEMENT:
sequence_EqStatement(context, (EqStatement) semanticObject);
return;
case AgreePackage.EVENT_EXPR:
sequence_TermExpr(context, (EventExpr) semanticObject);
return;
case AgreePackage.EXISTS_EXPR:
sequence_ExistsExpr(context, (ExistsExpr) semanticObject);
return;
case AgreePackage.FLATMAP_EXPR:
sequence_FlatmapExpr(context, (FlatmapExpr) semanticObject);
return;
case AgreePackage.FLOOR_CAST:
sequence_TermExpr(context, (FloorCast) semanticObject);
return;
case AgreePackage.FN_DEF:
sequence_FnDef(context, (FnDef) semanticObject);
return;
case AgreePackage.FOLD_LEFT_EXPR:
sequence_FoldLeftExpr(context, (FoldLeftExpr) semanticObject);
return;
case AgreePackage.FOLD_RIGHT_EXPR:
sequence_FoldRightExpr(context, (FoldRightExpr) semanticObject);
return;
case AgreePackage.FORALL_EXPR:
sequence_ForallExpr(context, (ForallExpr) semanticObject);
return;
case AgreePackage.GET_PROPERTY_EXPR:
sequence_PreDefFnExpr(context, (GetPropertyExpr) semanticObject);
return;
case AgreePackage.GUARANTEE_STATEMENT:
sequence_NamedSpecStatement(context, (GuaranteeStatement) semanticObject);
return;
case AgreePackage.IF_THEN_ELSE_EXPR:
sequence_IfThenElseExpr(context, (IfThenElseExpr) semanticObject);
return;
case AgreePackage.INDICES_EXPR:
sequence_TermExpr(context, (IndicesExpr) semanticObject);
return;
case AgreePackage.INITIAL_STATEMENT:
sequence_SpecStatement(context, (InitialStatement) semanticObject);
return;
case AgreePackage.INPUT_STATEMENT:
sequence_InputStatement(context, (InputStatement) semanticObject);
return;
case AgreePackage.INT_LIT_EXPR:
sequence_TermExpr(context, (IntLitExpr) semanticObject);
return;
case AgreePackage.LATCHED_EXPR:
sequence_TermExpr(context, (LatchedExpr) semanticObject);
return;
case AgreePackage.LATCHED_STATEMENT:
sequence_SynchStatement(context, (LatchedStatement) semanticObject);
return;
case AgreePackage.LEMMA_STATEMENT:
sequence_NamedSpecStatement(context, (LemmaStatement) semanticObject);
return;
case AgreePackage.LIBRARY_FN_DEF:
sequence_LibraryFnDef(context, (LibraryFnDef) semanticObject);
return;
case AgreePackage.LIFT_CONTRACT_STATEMENT:
sequence_SpecStatement(context, (LiftContractStatement) semanticObject);
return;
case AgreePackage.LINEARIZATION_DEF:
sequence_LinearizationDef(context, (LinearizationDef) semanticObject);
return;
case AgreePackage.LINEARIZATION_INTERVAL:
sequence_LinearizationInterval(context, (LinearizationInterval) semanticObject);
return;
case AgreePackage.MN_SYNCH_STATEMENT:
sequence_SynchStatement(context, (MNSynchStatement) semanticObject);
return;
case AgreePackage.NAMED_ELM_EXPR:
sequence_TermExpr(context, (NamedElmExpr) semanticObject);
return;
case AgreePackage.NAMED_ID:
sequence_NamedID(context, (NamedID) semanticObject);
return;
case AgreePackage.NODE_BODY_EXPR:
sequence_NodeBodyExpr(context, (NodeBodyExpr) semanticObject);
return;
case AgreePackage.NODE_DEF:
sequence_NodeDef(context, (NodeDef) semanticObject);
return;
case AgreePackage.NODE_EQ:
sequence_NodeStmt(context, (NodeEq) semanticObject);
return;
case AgreePackage.NODE_LEMMA:
sequence_NodeStmt(context, (NodeLemma) semanticObject);
return;
case AgreePackage.OPEN_LEFT_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenLeftTimeInterval) semanticObject);
return;
case AgreePackage.OPEN_RIGHT_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenRightTimeInterval) semanticObject);
return;
case AgreePackage.OPEN_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenTimeInterval) semanticObject);
return;
case AgreePackage.ORDER_STATEMENT:
sequence_OrderStatement(context, (OrderStatement) semanticObject);
return;
case AgreePackage.PARAM_STATEMENT:
sequence_SpecStatement(context, (ParamStatement) semanticObject);
return;
case AgreePackage.PERIODIC_STATEMENT:
sequence_RealTimeStatement(context, (PeriodicStatement) semanticObject);
return;
case AgreePackage.PRE_EXPR:
sequence_TermExpr(context, (PreExpr) semanticObject);
return;
case AgreePackage.PREV_EXPR:
sequence_PreDefFnExpr(context, (PrevExpr) semanticObject);
return;
case AgreePackage.PRIM_TYPE:
sequence_BaseType(context, (PrimType) semanticObject);
return;
case AgreePackage.PROPERTY_STATEMENT:
sequence_PropertyStatement(context, (PropertyStatement) semanticObject);
return;
case AgreePackage.REACHABLE_STATEMENT:
sequence_NamedSpecStatement(context, (ReachableStatement) semanticObject);
return;
case AgreePackage.REAL_CAST:
sequence_TermExpr(context, (RealCast) semanticObject);
return;
case AgreePackage.REAL_LIT_EXPR:
sequence_TermExpr(context, (RealLitExpr) semanticObject);
return;
case AgreePackage.RECORD_DEF:
sequence_RecordDef(context, (RecordDef) semanticObject);
return;
case AgreePackage.RECORD_LIT_EXPR:
sequence_TermExpr(context, (RecordLitExpr) semanticObject);
return;
case AgreePackage.RECORD_UPDATE_EXPR:
sequence_RecordUpdateExpr(context, (RecordUpdateExpr) semanticObject);
return;
case AgreePackage.SELECTION_EXPR:
sequence_SelectionExpr(context, (SelectionExpr) semanticObject);
return;
case AgreePackage.SPORADIC_STATEMENT:
sequence_RealTimeStatement(context, (SporadicStatement) semanticObject);
return;
case AgreePackage.SYNCH_STATEMENT:
sequence_SynchStatement(context, (SynchStatement) semanticObject);
return;
case AgreePackage.TAG_EXPR:
sequence_TagExpr(context, (TagExpr) semanticObject);
return;
case AgreePackage.THIS_REF:
sequence_ComponentRef(context, (ThisRef) semanticObject);
return;
case AgreePackage.TIME_EXPR:
sequence_TermExpr(context, (TimeExpr) semanticObject);
return;
case AgreePackage.TIME_FALL_EXPR:
sequence_TermExpr(context, (TimeFallExpr) semanticObject);
return;
case AgreePackage.TIME_OF_EXPR:
sequence_TermExpr(context, (TimeOfExpr) semanticObject);
return;
case AgreePackage.TIME_RISE_EXPR:
sequence_TermExpr(context, (TimeRiseExpr) semanticObject);
return;
case AgreePackage.UNARY_EXPR:
sequence_UnaryExpr(context, (UnaryExpr) semanticObject);
return;
case AgreePackage.UNINTERPRETED_FN_DEF:
sequence_UninterpretedFnDef(context, (UninterpretedFnDef) semanticObject);
return;
case AgreePackage.WHEN_HOLDS_STATEMENT:
sequence_WhenStatement(context, (WhenHoldsStatement) semanticObject);
return;
case AgreePackage.WHEN_OCCURS_STATMENT:
sequence_WhenStatement(context, (WhenOccursStatment) semanticObject);
return;
case AgreePackage.WHENEVER_BECOMES_TRUE_STATEMENT:
sequence_WheneverStatement(context, (WheneverBecomesTrueStatement) semanticObject);
return;
case AgreePackage.WHENEVER_HOLDS_STATEMENT:
sequence_WheneverStatement(context, (WheneverHoldsStatement) semanticObject);
return;
case AgreePackage.WHENEVER_IMPLIES_STATEMENT:
sequence_WheneverStatement(context, (WheneverImpliesStatement) semanticObject);
return;
case AgreePackage.WHENEVER_OCCURS_STATEMENT:
sequence_WheneverStatement(context, (WheneverOccursStatement) semanticObject);
return;
}
if (errorAcceptor != null)
errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}
Aggregations