/**
*
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated NOT
*/
public EList<Handler> getAllHandlers() {
EList<Handler> result = new BasicEList<Handler>();
for (Element child : getChildren()) {
result.addAll(child.getAllHandlers());
}
result.addAll(getHandlers());
return result;
}
/**
* Return the subLines and the cells of this line.
*
* @param line The line
* @return List of representations elements
*/
private EList<DRepresentationElement> getRepresentationElements(DLine line) {
EList<DRepresentationElement> result = new BasicEList<DRepresentationElement>();
result.add(line);
result.addAll(line.getCells());
for (DLine subLine : line.getLines()) {
result.addAll(getRepresentationElements(subLine));
}
return result;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.sirius.viewpoint.impl.DDiagramElementContainerImpl#getElements()
*/
@Override
public EList<DDiagramElement> getElements() {
final EList<DDiagramElement> result = new BasicEList<DDiagramElement>();
result.addAll(getOwnedBorderedNodes());
result.addAll(getOwnedElements());
return new EcoreEList.UnmodifiableEList<DDiagramElement>(
eInternalContainer(),
DiagramPackage.eINSTANCE.getDDiagramElementContainer_Elements(),
result.size(),
result.toArray());
}
/** {@inheritDoc} */
@Override
public EList<DRepresentationElement> getOwnedRepresentationElements() {
EList<DRepresentationElement> result =
new BasicEList<DRepresentationElement>(getColumns().size() + getLines().size());
result.addAll(getColumns());
result.addAll(getLines());
return new EcoreEList.UnmodifiableEList<DRepresentationElement>(
eInternalContainer(),
ViewpointPackage.eINSTANCE.getDRepresentation_OwnedRepresentationElements(),
result.size(),
result.toArray());
}
public String[] getValidInsertElements() {
VEXDocument doc = this.getDocument();
if (doc == null) return new String[0];
Validator validator = doc.getValidator();
if (validator == null) return new String[0];
int startOffset = this.getCaretOffset();
int endOffset = this.getCaretOffset();
if (this.hasSelection()) {
startOffset = this.getSelectionStart();
endOffset = this.getSelectionEnd();
}
VEXElement parent = doc.getElementAt(startOffset);
Set<String> validItems = validator.getValidItems(parent.getName());
List<String> candidates = new ArrayList<String>(validItems);
candidates.remove(Validator.PCDATA);
// filter invalid sequences
EList<String> nodesBefore = doc.getNodeNames(parent.getStartOffset() + 1, startOffset);
EList<String> nodesAfter = doc.getNodeNames(endOffset, parent.getEndOffset());
int sequenceLength = nodesBefore.size() + 1 + nodesAfter.size();
for (Iterator<String> iter = candidates.iterator(); iter.hasNext(); ) {
String candidate = iter.next();
EList<String> sequence = new BasicEList<String>(sequenceLength);
sequence.addAll(nodesBefore);
sequence.add(candidate);
sequence.addAll(nodesAfter);
if (!validator.isValidSequence(parent.getName(), sequence, true)) {
iter.remove();
}
}
// If there's a selection, root out those candidates that can't
// contain it.
if (hasSelection()) {
EList<String> selectedNodes = doc.getNodeNames(startOffset, endOffset);
for (Iterator<String> iter = candidates.iterator(); iter.hasNext(); ) {
String candidate = iter.next();
if (!validator.isValidSequence(candidate, selectedNodes, true)) {
iter.remove();
}
}
}
Collections.sort(candidates);
return (String[]) candidates.toArray(new String[candidates.size()]);
}
public EList<PartialStateDescription> getSubFormulas() {
EList<PartialStateDescription> result = new BasicEList<PartialStateDescription>();
if (leftStateFormula != null) {
result.add(leftStateFormula);
result.addAll(leftStateFormula.getSubFormulas());
}
if (rightStateFormula != null) {
result.add(rightStateFormula);
result.addAll(rightStateFormula.getSubFormulas());
}
return result;
}
public void addSrcDep(EList<MindRootSrc> dep) {
if (_allsrc == null) {
getAllsrc();
return;
}
_allsrc.addAll(dep);
}
public static void resolveMPE(
MindProject currentProject, EList<MindRootSrc> allsrc, MindPathEntry mpe) {
MindObject resolvedBy = mpe.getResolvedBy();
if (resolvedBy == null) return;
switch (mpe.getEntryKind()) {
case APPLI:
break;
case IMPORT_PACKAGE:
MindPackage mpackage = (MindPackage) resolvedBy;
addSourceOrLibrary(allsrc, mpackage.getRootsrc());
break;
case LIBRARY:
MindRootSrc rs = (MindRootSrc) resolvedBy;
addSourceOrLibrary(allsrc, rs);
break;
case PROJECT:
MindProject mp = (MindProject) resolvedBy;
if (mp != currentProject) allsrc.addAll(mp.getAllsrc());
break;
case SOURCE:
rs = (MindRootSrc) resolvedBy;
addSourceOrLibrary(allsrc, rs);
break;
default:
break;
}
}
private void copyFields(
final EObject objectWithReference,
final Iterable<XtendMember> members,
final Set<String> fieldNames) {
boolean _not = (!(objectWithReference instanceof XtendClass));
if (_not) {
return;
}
final XtendClass type = ((XtendClass) objectWithReference);
final ArrayList<XtendField> newFields = CollectionLiterals.<XtendField>newArrayList();
Iterable<XtendField> _filter = Iterables.<XtendField>filter(members, XtendField.class);
for (final XtendField field : _filter) {
String _name = field.getName();
boolean _contains = fieldNames.contains(_name);
boolean _not_1 = (!_contains);
if (_not_1) {
final XtendField copiedMember = this._expressionCopier.<XtendField>cloneWithProxies(field);
SourceAdapter.adapt(copiedMember, field);
newFields.add(((XtendField) copiedMember));
String _name_1 = field.getName();
fieldNames.add(_name_1);
}
}
EList<XtendMember> _members = type.getMembers();
_members.addAll(newFields);
}
/**
* return all model & instance files in a Workspace, i.e., files with the extension "aaxl"
*
* @return EList of IFiles that represent AADL model files
*/
public EList<IFile> getAllModelFiles() {
EList<IFile> result = new BasicEList<IFile>();
IAadlProject[] projects = getOpenAadlProjects();
for (int i = 0; i < projects.length; i++) {
result.addAll(projects[i].getAllModelFiles());
}
return result;
}
public void recomputeAllSrc() {
if (_allsrc == null) getAllsrc();
else {
BasicEList<MindRootSrc> newList = new BasicEList<MindRootSrc>();
computeAllSrc(newList);
_allsrc.retainAll(newList);
_allsrc.addAll(newList);
}
}
@Override
public EList<AbstractActor> getAllVertices() {
EList<AbstractActor> result = new BasicEList<AbstractActor>();
for (AbstractActor aa : getVertices()) {
result.add(aa);
if (aa instanceof PiGraph) {
result.addAll(((PiGraph) aa).getAllVertices());
} else if (aa instanceof Actor) {
Refinement refinement = ((Actor) aa).getRefinement();
if (refinement != null) {
AbstractActor subGraph = refinement.getAbstractActor();
if (subGraph != null && subGraph instanceof PiGraph) {
result.addAll(((PiGraph) subGraph).getAllVertices());
}
}
}
}
return result;
}
/* (non-Javadoc)
* @see com.hundsun.ares.studio.jres.model.core.impl.JRESResourceInfoImpl#getReferences()
*/
@Override
public EList<Reference> getReferences() {
// TODO 1、引用标准字段
// TODO 扩展属性表空间信息引用///////////未添加
EList<Reference> references = new BasicEList<Reference>();
// 表字段
references.addAll(getColumnRef(getColumns()));
// 表索引
for (TableIndex index : getIndexes()) {
references.addAll(getColumnIndexRef(index.getColumns()));
}
// 修订记录的扩展属性表空间
for (Iterator<EObject> it = EcoreUtil.getAllContents(this, true); it.hasNext(); ) {
EObject obj = it.next();
if (obj instanceof IReferenceProvider) {
references.addAll(((IReferenceProvider) obj).getReferences());
}
}
return references;
}
/**
* Save a list of EObjects to the resource with the given URI.
*
* @param eObjects the EObjects to be saved
* @param resourceURI the URI of the resource, which should be used to save the EObjects
* @throws IOException if saving to the resource fails
*/
public void saveEObjectToResource(List<? extends EObject> eObjects, URI resourceURI)
throws IOException {
ResourceSet resourceSet = new ResourceSetImpl();
Resource resource = resourceSet.createResource(resourceURI);
EList<EObject> contents = resource.getContents();
for (EObject eObject : eObjects) {
contents.add(eObject);
}
contents.addAll(eObjects);
resource.save(null);
}
public static void resolve(Context context, EList<BodyElement> elements) {
List<BodyElement> resolved = new ArrayList<BodyElement>();
for (int i = 0; i < elements.size(); i++) {
BodyElement element = elements.get(i);
if (element instanceof UnresolvedBodyElement) {
UnresolvedBodyElement unresolved = (UnresolvedBodyElement) element;
resolved.addAll(unresolved.resolve(context));
} else {
resolved.add(element);
}
}
elements.clear();
elements.addAll(resolved);
}
/**
* Given a BO (XSD Complex Type), return a list of the attributes within the complexType.
*
* @param bo
* @return List of XSDAttributeDeclaration
*/
public static List<XSDAttributeDeclaration> getChildAttributes(XSDComplexTypeDefinition bo) {
EList attrContents = bo.getAttributeContents();
List<XSDAttributeDeclaration> attrs = new ArrayList<XSDAttributeDeclaration>();
for (int i = 0; i < attrContents.size(); i++) {
Object next = attrContents.get(i);
// Attribute contents may include actual attribute declarations (wrapped in XSDAttributeUses)
// or
// attribute group definitions, containing bundles of attributes
if (next instanceof XSDAttributeUse) {
attrs.add(((XSDAttributeUse) next).getContent().getResolvedAttributeDeclaration());
} else if (next instanceof XSDAttributeGroupDefinition) {
// Add these attributes to the end of attrContents to be processed in turn
XSDAttributeGroupDefinition attrGroup = (XSDAttributeGroupDefinition) next;
if (attrGroup.getResolvedAttributeGroupDefinition() != null)
attrContents.addAll(attrGroup.getResolvedAttributeGroupDefinition().getAttributeUses());
}
}
return attrs;
}
/**
* Obtains the operations declared on the specified type.
*
* @param classifierName The name of the classifier which operation are sought.
* @return The operations it declares. <code>null</code> if none.
*/
public synchronized EList<EOperation> getExistingOperations(String classifierName) {
EList<EOperation> result = new BasicEList<EOperation>();
if (PRIMITIVE_STRING_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(stringType.getEOperations()));
} else if (TYPE_OCLANY_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(oclAnyType.getEOperations()));
} else if (TYPE_EOBJECT_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(eObjectType.getEOperations()));
} else if (TYPE_COLLECTION_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(collectionType.getEOperations()));
} else if (TYPE_ORDEREDSET_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(orderedSetType.getEOperations()));
} else if (TYPE_SEQUENCE_NAME.equals(classifierName)) {
result.addAll(EcoreUtil.copyAll(sequenceType.getEOperations()));
}
return result;
}
public boolean addAll(int index, java.util.Collection<? extends E> c) {
copy.addAll(index, c);
return original.addAll(index, c);
}
protected static void _privk3_step(
final RegionAspectRegionAspectProperties _self_,
final Region _self,
final Hashtable<String, Object> context,
final EList<String> events) {
boolean allJunctionsAttended = false;
while ((!allJunctionsAttended)) {
{
ArrayList<AbstractState> currentState =
RegionAspect.getCurrentState(_self, context, events);
ArrayList<Transition> currentTransitions = new ArrayList<Transition>();
ArrayList<AbstractState> attendedStates = new ArrayList<AbstractState>();
ArrayList<AbstractState> newStates = new ArrayList<AbstractState>();
EList<Transition> activeTransitions = new BasicEList<Transition>();
for (final AbstractState _state : currentState) {
EList<Transition> _activeTransitions =
RegionAspect.getActiveTransitions(_self, _state, events);
activeTransitions.addAll(_activeTransitions);
}
for (final Transition transition : activeTransitions) {
{
RegionAspect.findOldActiveStates(_self, attendedStates, transition, context);
RegionAspect.findNewActiveTransitions(_self, currentTransitions, transition, context);
RegionAspect.findNewActiveStates(
_self, newStates, transition, currentTransitions, context);
}
}
for (final AbstractState _attendedState : attendedStates) {
if ((_attendedState instanceof State)) {
StateAspect.exitState(((State) _attendedState), context);
}
}
RegionAspect.removeStatesFromContext(_self, context, attendedStates);
RegionAspect.addStatesToContext(_self, context, newStates);
final Consumer<Transition> _function =
(Transition transition_1) -> {
TransitionAspect.evalTransition(transition_1, context);
};
activeTransitions.forEach(_function);
final Consumer<Transition> _function_1 =
(Transition transition_1) -> {
boolean _alreadyFired = TransitionAspect.alreadyFired(transition_1, context);
boolean _not = (!_alreadyFired);
if (_not) {
TransitionAspect.evalTransition(transition_1, context);
}
};
currentTransitions.forEach(_function_1);
final Consumer<AbstractState> _function_2 =
(AbstractState state) -> {
EList<Transition> _outgoing = state.getOutgoing();
final Consumer<Transition> _function_3 =
(Transition transition_1) -> {
TransitionAspect.resetFired(transition_1);
};
_outgoing.forEach(_function_3);
};
newStates.forEach(_function_2);
final ArrayList<AbstractState> currentConditionalState = new ArrayList<AbstractState>();
Set<String> _keySet = context.keySet();
Iterator<String> _it = _keySet.iterator();
while (_it.hasNext()) {
{
String _key = _it.next();
Object _value = context.get(_key);
boolean _startsWith = _key.startsWith("currentState");
if (_startsWith) {
final Consumer<AbstractState> _function_3 =
(AbstractState _vertex) -> {
currentConditionalState.add(_vertex);
};
((ArrayList<AbstractState>) _value).forEach(_function_3);
}
}
}
String _name = _self.getName();
String _plus = ("currentState-" + _name);
Object _get = context.get(_plus);
currentState = ((ArrayList<AbstractState>) _get);
final Function1<AbstractState, Boolean> _function_3 =
(AbstractState _vertex) -> {
EList<Transition> _outgoing = _vertex.getOutgoing();
final Function1<Transition, Boolean> _function_4 =
(Transition _outgoing_1) -> {
boolean _and = false;
AbstractState _target = _outgoing_1.getTarget();
if (!(_target instanceof Pseudostate)) {
_and = false;
} else {
AbstractState _target_1 = _outgoing_1.getTarget();
_and = (_target_1 instanceof Junction);
}
return Boolean.valueOf(_and);
};
return Boolean.valueOf(IterableExtensions.<Transition>exists(_outgoing, _function_4));
};
boolean _exists = IterableExtensions.<AbstractState>exists(currentState, _function_3);
boolean _not = (!_exists);
allJunctionsAttended = _not;
}
}
}
/**
* Validate the model. All checks are performed for all automata in the file. This method checks
* that
*
* <ul>
* <li>only allowed extension are used. Allowed extension are {@link
* org.ect.ea.extensions.clocks.AutomatonClocksProvider}, {@link
* org.ect.ea.extensions.clocks.TCADataConstraintsProvider}, {@link
* org.ect.ea.extensions.constraints.ConstraintExtensionProvider}, {@link
* org.ect.ea.extensions.startstates.StartStateExtensionProvider}, {@link
* org.ect.ea.extensions.portnames.AutomatonPortNamesProvider}, {@link
* org.ect.ea.extensions.portnames.TransitionPortNamesProvider}, {@link
* org.ect.ea.extensions.clocks.TransitionUpdateProvider}, {@link
* org.ect.ea.extensions.clocks.TransitionGuardProvider}, {@link
* org.ect.ea.extension.stateMemory.StateMemoryExtensionProvider} and {@link
* org.ect.ea.extensions.clocks.StateInvariantProvider}.
* <li>all required extensions are used. Required extensions are {@link
* org.ect.ea.extensions.startstates.StartStateExtensionProvider}, {@link
* org.ect.ea.extensions.portnames.AutomatonPortNamesProvider} and {@link
* org.ect.ea.extensions.portnames.TransitionPortNamesProvider}.
* <li>depending on whether the automaton is a CA or a TCA, some other extensions are required
* and forbidden:
* <ul>
* <li>Required extensions of TCA are {@link
* org.ect.ea.extensions.clocks.TCADataConstraintsProvider}, {@link
* org.ect.ea.extensions.clocks.AutomatonClocksProvider}, {@link
* org.ect.ea.extensions.clocks.TransitionGuardProvider}, {@link
* org.ect.ea.extensions.clocks.TransitionUpdateProvider} and {@link
* org.ect.ea.extensions.clocks.StateInvariantProvider}. These are also the forbidden
* extensions for CA.
* <li>Forbidden extensions of TCA are {@link
* org.ect.ea.extensions.constraints.ConstraintExtensionProvider}. These are also the
* required extensions for CA.
* </ul>
* <li>all names (except for memory cells and ports) are unique within the system.
* <li>memory cell names may occur more than once in one automaton, but must be unique between
* different automata, and must not equal any other name.
* <li>port names may be shared between automata, but must be different from all other names
* <li>there exists exactly one start state per automaton.
* <li>untimed CA (that means without clock extensions) do not have transitions with empty name
* set
* <li>TCA transition with empty name set do not have an associated data constraint
* <li>there exist no names {@link org.ect.ea.extensions.clocks.ClockUtils#GLOBAL_CLOCK} or
* {@link org.ect.ea.extensions.clocks.ClockUtils#NO_FLOW_NAME}
* <li>the range of data values is well-formed, i.e. either on the form
* <tt>lowerBound..upperBound</tt>, with <tt>lowerBound=0</tt>, <tt>upperBound>=1</tt>, or
* empty (for infinite data domain)
* <li>integer values in the data constraints lie within the given range
* <li>unfolding depth is at least 1
* <li>the target language is one of [mathsat,msat]
* <li>the output file name is not empty
* </ul>
*/
public IStatus validateGenModel(IGenModel genModel) {
EList<Automaton> automata = ((Automaton) genModel.getTarget()).getModule().getAutomata();
String projectName = genModel.getProperty(IGenModel.PROJECT_NAME);
if (projectName == null || projectName.equals("")) {
return new Status(IStatus.ERROR, PLUGIN_ID, "Project name cannot be empty.");
}
String rng = genModel.getProperty(CodegenUtils.PROPERTY_RANGE);
// rng = rng.replace("..", ",");
String targetlang = genModel.getProperty("targetlang");
// for temporary usage
// String tempS = "";
EList<String> tempL = new BasicEList<String>();
boolean tempB;
/* check extensions */
/* Every automaton must support the automaton port names, transition
* port names, and start state extension, and may support the state
* memory extension.
* If the automaton is a CA (untimed), it must support the constraint
* extension, and must not support the TCA data constraint,
* automaton clocks, transition guard, transition update and
* invariant extension.
* If the automaton is a TCA (timed), it must support the TCA data
* constraint, automaton clocks, transition guard, transition update and
* invariant extension, and must not support the constraint extension.
* */
// check that only allowed extensions are used
// note that not all these extensions can be used at the same time
final EList<String> allowedExtensions = new BasicEList<String>();
allowedExtensions.add(ClockUtils.STATE_MEMORY_ID);
allowedExtensions.add(ClockUtils.AUTOMATON_CLOCKS_ID);
allowedExtensions.add(ClockUtils.TRANSITION_GUARD_ID);
allowedExtensions.add(ClockUtils.TRANSITION_UPDATE_ID);
allowedExtensions.add(ClockUtils.INVARIANT_ID);
allowedExtensions.add(ClockUtils.DATA_CONSTRAINT_ID);
allowedExtensions.add(ClockUtils.CONSTRAINT_ID);
allowedExtensions.add(ClockUtils.AUTOMATON_PORT_NAMES_ID);
allowedExtensions.add(ClockUtils.TRANSITION_PORT_NAMES_ID);
allowedExtensions.add(ClockUtils.START_STATE_ID);
final EList<String> requiredExtensions = new BasicEList<String>();
requiredExtensions.add(ClockUtils.START_STATE_ID);
requiredExtensions.add(ClockUtils.AUTOMATON_PORT_NAMES_ID);
requiredExtensions.add(ClockUtils.TRANSITION_PORT_NAMES_ID);
final EList<String> requiredCAExtensions = new BasicEList<String>();
requiredCAExtensions.add(ClockUtils.CONSTRAINT_ID);
final EList<String> forbiddenCAExtensions = new BasicEList<String>();
forbiddenCAExtensions.add(ClockUtils.DATA_CONSTRAINT_ID);
forbiddenCAExtensions.add(ClockUtils.AUTOMATON_CLOCKS_ID);
forbiddenCAExtensions.add(ClockUtils.TRANSITION_GUARD_ID);
forbiddenCAExtensions.add(ClockUtils.TRANSITION_UPDATE_ID);
forbiddenCAExtensions.add(ClockUtils.INVARIANT_ID);
final EList<String> requiredTCAExtensions = new BasicEList<String>(forbiddenCAExtensions);
final EList<String> forbiddenTCAExtensions = new BasicEList<String>(requiredCAExtensions);
EList<String> names = new BasicEList<String>(); // to check uniqueness of names
Set<String> portNames =
new HashSet<
String>(); // port names can be shared, but must be different from other names, use set
// to automatically remove duplicates
boolean timed = false;
boolean untimed = false;
boolean allMem = false;
boolean noMem = false;
for (Automaton automaton : automata) {
// add automaton name to global name set name
names.add(automaton.getName());
// check that only allowed extensions are used
final EList<String> usedExtensions = automaton.getUsedExtensionIds();
if (!allowedExtensions.containsAll(usedExtensions)) {
tempL.clear();
tempL.addAll(usedExtensions);
tempL.removeAll(allowedExtensions);
return new Status(
IStatus.ERROR, PLUGIN_ID, "Extension(s) used but not supported: " + tempL);
}
// check that all required extensions are used
if (!usedExtensions.containsAll(requiredExtensions)) {
tempL.clear();
tempL.addAll(requiredExtensions);
tempL.removeAll(usedExtensions);
return new Status(
IStatus.ERROR, PLUGIN_ID, automaton.getName() + "must support extension(s): " + tempL);
}
// check that exactly one of the constraint extensions is used, infer CA or TCA from that
if (usedExtensions.contains(ClockUtils.DATA_CONSTRAINT_ID)) {
timed = true;
if (untimed == true) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"All automata must support same constraint extension, either "
+ ClockUtils.DATA_CONSTRAINT_ID
+ " or "
+ ClockUtils.CONSTRAINT_ID);
}
}
if (usedExtensions.contains(ClockUtils.CONSTRAINT_ID)) {
untimed = true;
if (timed == true) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"All automata must support same constraint extension, either "
+ ClockUtils.DATA_CONSTRAINT_ID
+ " or "
+ ClockUtils.CONSTRAINT_ID);
}
}
if (!(timed || untimed)) { // no constraint extension is used
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"All automata must support same constraint extension, either "
+ ClockUtils.DATA_CONSTRAINT_ID
+ " or "
+ ClockUtils.CONSTRAINT_ID);
}
// if CA: check for required and forbidden extensions
if (untimed) {
if (!usedExtensions.containsAll(requiredCAExtensions)) {
tempL.clear();
tempL.addAll(requiredCAExtensions);
tempL.removeAll(usedExtensions);
return new Status(
IStatus.ERROR, PLUGIN_ID, "Untimed CA must support extension(s): " + tempL);
}
tempL.clear();
tempL.addAll(usedExtensions);
tempL.addAll(forbiddenCAExtensions);
tempL = new StringListExtension(tempL).getDuplicateEntries();
if (!tempL.isEmpty()) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Untimed CA must not support extension(s): " + tempL);
}
}
// if TCA: check for required and forbidden extensions
if (timed) {
if (!usedExtensions.containsAll(requiredTCAExtensions)) {
tempL.clear();
tempL.addAll(requiredTCAExtensions);
tempL.removeAll(usedExtensions);
return new Status(IStatus.ERROR, PLUGIN_ID, "TCA must support extension(s): " + tempL);
}
tempL.clear();
tempL.addAll(usedExtensions);
tempL.addAll(forbiddenTCAExtensions);
tempL = new StringListExtension(tempL).getDuplicateEntries();
if (!tempL.isEmpty()) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "TCA must not support extension(s): " + tempL);
}
}
// check that the automaton has states (otherwise, code generation does not make sense)
if (automaton.getStates().isEmpty()) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Automaton does not have states, code generation does not make sense.");
}
// check that the automaton has transitions (otherwise, code generation does not make sense)
if (automaton.getTransitions().isEmpty()) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Automaton does not have transitions, code generation does not make sense.");
}
// check for state memory extension
if (usedExtensions.contains(ClockUtils.STATE_MEMORY_ID)) {
allMem = true;
if (noMem) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"State memory must be support by all automata or not at all.");
}
} else {
noMem = true;
if (allMem) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"State memory must be support by all automata or not at all.");
}
}
// create EList of memory cell names (if memory cells are used)
if (allMem) {
EList<String> thisAutoMemCells = new BasicEList<String>();
for (State s : automaton.getStates()) {
try {
tempL =
StringListExtension.parse(s.findExtension(ClockUtils.STATE_MEMORY_ID).toString())
.getValues(); // memory cells of current state
if (!tempL.isEmpty()) { // empty if state does not have memory cells
thisAutoMemCells.addAll(tempL);
}
} catch (ParseException pe) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Unexpected error while trying to parse memory cells of " + s.getName());
}
}
// remove duplicate cells from current automaton
StringListExtension sle = new StringListExtension(thisAutoMemCells);
sle.removeDuplicateEntries();
// add names to global EList (checked later)
tempL = sle.getValues();
for (String s : tempL) {
names.add(s);
}
}
// add state names to global name set (checked later), and check for initial states
tempB = false; // for initial states
for (State s : automaton.getStates()) {
if (s.getName() == null || s.getName().equals("")) {
return new Status(IStatus.ERROR, PLUGIN_ID, "States must have a name.");
}
names.add(s.getName());
if (CA.isStartState(s)) {
if (tempB == true) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Each automaton must have exactly one initial location");
}
tempB = true;
}
if (!tempB) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Each automaton must have exactly one initial location");
}
}
// untimed CA transitions must not have empty name set
if (untimed) {
for (Transition t : automaton.getTransitions()) {
if (((StringListExtension) t.findExtension(ClockUtils.TRANSITION_PORT_NAMES_ID))
.getValues()
.isEmpty()) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Transitions of untimed CA must not have empty name set");
}
}
}
// TCA transitions with the empty name set must not have a data
// constraint on ports (only memory cells)
// actually this check should not be necessary, it is checked during editing (by the parser)
// already
if (timed) {
for (Transition t : automaton.getTransitions()) {
if (((StringListExtension) t.findExtension(ClockUtils.TRANSITION_PORT_NAMES_ID))
.getValues()
.isEmpty()) { // found transition with empty port set
// get the constraint
String cons = t.findExtension(ClockUtils.DATA_CONSTRAINT_ID).toString();
TCADataParser parser = new TCADataParser(cons);
try {
tempL = parser.get_port_names();
if (!tempL.isEmpty()) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Invisible transitions (with empty port set) must not have a data constraint on ports.");
}
} catch (RecognitionException pe) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Unexpected error while trying to parse " + cons);
}
}
}
}
// add clock names to global name set (checked later)
if (timed) {
for (String c : ClockUtils.getClocks(automaton)) {
names.add(c);
}
}
// add port names to global port name set (checked later)
for (String p :
((StringListExtension) automaton.findExtension(ClockUtils.AUTOMATON_PORT_NAMES_ID))
.getValues()) {
portNames.add(p);
}
}
// check range of data values
// either 'lowerBound..upperBound' or empty (=infinite)
if (rng.trim().equals("")) {
infinite = true;
} else {
infinite = false;
if (!rng.contains("..")) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Finite range must be given in the form '0..upperBound'.\nupperBound must be an integer value strictly greater than 0.");
}
try {
lowerBound = Integer.parseInt(rng.substring(0, rng.indexOf(".")));
if (lowerBound != 0) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Finite range must be given in the form '0..upperBound'.\nLower bounds other than 0 are not (yet) supported.");
}
} catch (NumberFormatException nfe) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Finite range must be given in the form '0..upperBound'.\nLower bounds other than 0 are not (yet) supported.");
}
try {
upperBound = Integer.parseInt(rng.substring(rng.lastIndexOf(".") + 1, rng.length()));
if (upperBound < 1) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Finite range must be given in the form '0..upperBound'.\nupperBound must be an integer value strictly greater than 0.");
}
} catch (NumberFormatException nfe) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Finite range must be given in the form '0..upperBound'.\nupperBound must be an integer value strictly greater than 0.");
}
}
// check that integer values used in data constraints are within the range (if finite)
if (!infinite) {
int min = -1;
int max = 0;
for (Automaton automaton : automata) {
for (Transition t : automaton.getTransitions()) {
String cons = t.findExtension(ClockUtils.DATA_CONSTRAINT_ID).toString();
TCADataParser parser = new TCADataParser(cons);
try {
tempL = parser.get_minmax_int_values();
min = Math.min(min, Integer.parseInt(tempL.get(0)));
max = Math.max(max, Integer.parseInt(tempL.get(1)));
} catch (RecognitionException re) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Unexpected error while trying to parse " + cons);
}
}
if ((min < -1) || (max > this.upperBound)) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Integer values in data constraints are outside declared range.");
}
}
}
// check for spaces in all but port names
for (String s : names) {
if (s.contains(" ")) {
return new Status(IStatus.ERROR, PLUGIN_ID, "Names must not contain spaces: '" + s + "'");
}
}
// check for duplicate names in all but port names
tempL = new StringListExtension(names).getDuplicateEntries();
if (!tempL.isEmpty()) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Names (except for port names) must not be shared between automata: "
+ tempL.toString().replace("[", "").replace("]", ""));
}
// check for spaces in port names
for (String p : portNames) {
if (p.contains(" ")) {
return new Status(IStatus.ERROR, PLUGIN_ID, "Names must not contain spaces: '" + p + "'");
}
}
// compare port names with all other names, check for duplicates between the two sets
StringListExtension sle = new StringListExtension(portNames);
sle.removeDuplicateEntries();
tempL = sle.getValues();
tempL.addAll(names);
tempL = new StringListExtension(tempL).getDuplicateEntries();
if (!tempL.isEmpty()) {
return new Status(
IStatus.ERROR,
PLUGIN_ID,
"Names must be unique: " + tempL.toString().replace("[", "").replace("]", ""));
}
// check for reserved names CodegenUtils.NO_FLOW_NAME and CodegenUtils.GLOBAL_CLOCK
if (names.contains(CodegenUtils.NO_FLOW_NAME)
|| portNames.contains(CodegenUtils.NO_FLOW_NAME)) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "'" + CodegenUtils.NO_FLOW_NAME + "' is a reserved name. ");
}
if (names.contains(CodegenUtils.GLOBAL_CLOCK)
|| portNames.contains(CodegenUtils.GLOBAL_CLOCK)) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "'" + CodegenUtils.GLOBAL_CLOCK + "' is a reserved name. ");
}
// check that the unfolding depth is at least 1
try {
unfoldingDepth = Integer.valueOf(genModel.getProperty(CodegenUtils.PROPERTY_DEPTH));
} catch (NumberFormatException nfe) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Not a valid unfolding depth: chose an integer > 0");
}
if (!(unfoldingDepth > 0)) {
return new Status(
IStatus.ERROR, PLUGIN_ID, "Not a valid unfolding depth: chose an integer > 0");
}
// check that target language is one of the supported languages, hard code for the moment
if (!targetlang.equalsIgnoreCase("mathsat") && !targetlang.equalsIgnoreCase("msat")) {
return new Status(IStatus.ERROR, PLUGIN_ID, "Target language must be one of [mathsat|msat]");
} else { // to standardise the property contents
genModel.setProperty("targetlang", mathsat);
}
// check that output file name is not empty
if (genModel.getProperty(CodegenUtils.PROPERTY_FILENAME).isEmpty()) {
return new Status(IStatus.ERROR, PLUGIN_ID, "Output file name cannot be empty");
}
/* If none of the above occurs, the model is ok */
return Status.OK_STATUS;
}