diff options
Diffstat (limited to 'plugins/org.eclipse.etrice.generator/xtend-gen')
7 files changed, 3383 insertions, 0 deletions
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/PrepareFileSystem.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/PrepareFileSystem.java new file mode 100644 index 000000000..93397251d --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/PrepareFileSystem.java @@ -0,0 +1,85 @@ +package org.eclipse.etrice.generator.extensions;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.generator.base.ILogger;
+import org.eclipse.etrice.generator.etricegen.Root;
+import org.eclipse.etrice.generator.extensions.RoomExtensions;
+import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+import org.eclipse.xtext.xtend2.lib.StringConcatenation;
+
+@SuppressWarnings("all")
+@Singleton
+public class PrepareFileSystem {
+ @Inject
+ private RoomExtensions roomExt;
+
+ @Inject
+ private JavaIoFileSystemAccess fileAccess;
+
+ @Inject
+ private ILogger logger;
+
+ public void prepare(final Resource resource) {
+ HashSet<String> _hashSet = new HashSet<String>();
+ Set<String> pathes = _hashSet;
+ EList<EObject> _contents = resource.getContents();
+ for (final EObject e : _contents) {
+ if ((e instanceof Root)) {
+ EList<RoomModel> _usedRoomModels = ((Root) e).getUsedRoomModels();
+ for (final RoomModel mdl : _usedRoomModels) {
+ String _generationTargetPath = this.roomExt.getGenerationTargetPath(mdl);
+ pathes.add(_generationTargetPath);
+ }
+ }
+ }
+ for (final String path : pathes) {
+ {
+ String _operator_plus = StringExtensions.operator_plus("clearing ", path);
+ this.logger.logInfo(_operator_plus);
+ File _file = new File(path);
+ File f = _file;
+ this.eraseContents(f);
+ this.fileAccess.setOutputPath(path);
+ StringConcatenation _readmeText = this.readmeText();
+ this.fileAccess.generateFile("readme.txt", _readmeText);
+ }
+ }
+ }
+
+ public void eraseContents(final File f) {
+ boolean _isDirectory = f.isDirectory();
+ if (_isDirectory) {
+ {
+ File[] _listFiles = f.listFiles();
+ File[] children = _listFiles;
+ for (final File child : children) {
+ {
+ this.eraseContents(child);
+ child.delete();
+ }
+ }
+ }
+ }
+ }
+
+ public StringConcatenation readmeText() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("This directory is an eTrice code generation target.");
+ _builder.newLine();
+ _builder.append("It will be erased every time the generator is executed.");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("DO NOT PLACE OTHER FILES HERE!");
+ _builder.newLine();
+ return _builder;
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/RoomExtensions.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/RoomExtensions.java new file mode 100644 index 000000000..48ce1ef2a --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/extensions/RoomExtensions.java @@ -0,0 +1,1020 @@ +package org.eclipse.etrice.generator.extensions;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.BaseState;
+import org.eclipse.etrice.core.room.DataClass;
+import org.eclipse.etrice.core.room.DetailCode;
+import org.eclipse.etrice.core.room.ExternalPort;
+import org.eclipse.etrice.core.room.Guard;
+import org.eclipse.etrice.core.room.InitialTransition;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageHandler;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.PortClass;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.RefableType;
+import org.eclipse.etrice.core.room.RefinedState;
+import org.eclipse.etrice.core.room.RoomClass;
+import org.eclipse.etrice.core.room.RoomModel;
+import org.eclipse.etrice.core.room.SAPRef;
+import org.eclipse.etrice.core.room.SPPRef;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.State;
+import org.eclipse.etrice.core.room.StateGraph;
+import org.eclipse.etrice.core.room.TrPoint;
+import org.eclipse.etrice.core.room.Transition;
+import org.eclipse.etrice.core.room.TransitionPoint;
+import org.eclipse.etrice.core.room.Trigger;
+import org.eclipse.etrice.core.room.TriggeredTransition;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.base.DetailCodeTranslator;
+import org.eclipse.etrice.generator.etricegen.ActiveTrigger;
+import org.eclipse.etrice.generator.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.generator.etricegen.TransitionChain;
+import org.eclipse.etrice.generator.extensions.RoomNameProv;
+import org.eclipse.xtext.xbase.lib.BooleanExtensions;
+import org.eclipse.xtext.xbase.lib.CollectionExtensions;
+import org.eclipse.xtext.xbase.lib.ComparableExtensions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+@Singleton
+public class RoomExtensions {
+ @Inject
+ private RoomNameProv nameProvider;
+
+ public <T extends Object> List<T> union(final List<T> l1, final List<T> l2) {
+ ArrayList<T> _arrayList = new ArrayList<T>();
+ ArrayList<T> ret = _arrayList;
+ ret.addAll(l1);
+ ret.addAll(l2);
+ return ret;
+ }
+
+ public <T extends Object> Iterable<T> union(final Iterable<T> l1, final Iterable<T> l2) {
+ ArrayList<T> _arrayList = new ArrayList<T>();
+ ArrayList<T> ret = _arrayList;
+ CollectionExtensions.<T>addAll(ret, l1);
+ CollectionExtensions.<T>addAll(ret, l2);
+ return ret;
+ }
+
+ public List<Port> punion(final List<Port> in1, final List<ExternalPort> in2) {
+ ArrayList<Port> _arrayList = new ArrayList<Port>();
+ ArrayList<Port> ret = _arrayList;
+ for (final ExternalPort ele : in2) {
+ Port _ifport = ele.getIfport();
+ ret.add(_ifport);
+ }
+ ret.addAll(in1);
+ return ret;
+ }
+
+ public String getGenerationPathSegment() {
+ return "/src-gen/";
+ }
+
+ public String getDocGenerationPathSegment() {
+ return "/doc-gen/";
+ }
+
+ public String getModelPath(final EObject e) {
+ Resource _eResource = e.eResource();
+ Resource res = _eResource;
+ boolean _operator_equals = ObjectExtensions.operator_equals(res, null);
+ if (_operator_equals) {
+ return "";
+ } else {
+ URI _uRI = res.getURI();
+ String _fileString = _uRI.toFileString();
+ return _fileString;
+ }
+ }
+
+ public String getPackage(final RoomClass rc) {
+ EObject _eContainer = rc.eContainer();
+ String _name = ((RoomModel) _eContainer).getName();
+ return _name;
+ }
+
+ public String getPathFromPackage(final String packageName) {
+ String _replaceAll = packageName.replaceAll("\\.", "/");
+ String _operator_plus = StringExtensions.operator_plus(_replaceAll, "/");
+ return _operator_plus;
+ }
+
+ public String getPath(final RoomClass rc) {
+ String _package = this.getPackage(rc);
+ String _pathFromPackage = this.getPathFromPackage(_package);
+ return _pathFromPackage;
+ }
+
+ public String getProjectPath(final EObject e) {
+ Resource _eResource = e.eResource();
+ Resource res = _eResource;
+ boolean _operator_equals = ObjectExtensions.operator_equals(res, null);
+ if (_operator_equals) {
+ return "";
+ } else {
+ {
+ File _file = new File("");
+ File tmpf = _file;
+ URI _uRI = res.getURI();
+ String _fileString = _uRI.toFileString();
+ File _file_1 = new File(_fileString);
+ tmpf = _file_1;
+ boolean _isFile = tmpf.isFile();
+ boolean _operator_not = BooleanExtensions.operator_not(_isFile);
+ if (_operator_not) {
+ return "";
+ }
+ boolean isProject = false;
+ Boolean _xdowhileexpression;
+ do {
+ {
+ File _parentFile = tmpf.getParentFile();
+ tmpf = _parentFile;
+ String[] _list = tmpf.list();
+ String[] contents = _list;
+ for (final String f : contents) {
+ boolean _equals = f.equals(".project");
+ if (_equals) {
+ isProject = true;
+ }
+ }
+ }
+ boolean _operator_and = false;
+ boolean _operator_not_1 = BooleanExtensions.operator_not(isProject);
+ if (!_operator_not_1) {
+ _operator_and = false;
+ } else {
+ File _parentFile_1 = tmpf.getParentFile();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_parentFile_1, null);
+ _operator_and = BooleanExtensions.operator_and(_operator_not_1, _operator_notEquals);
+ }
+ _xdowhileexpression = _operator_and;
+ } while(_xdowhileexpression);
+ String _absolutePath = tmpf.getAbsolutePath();
+ return _absolutePath;
+ }
+ }
+ }
+
+ public String getGenerationTargetPath(final EObject e) {
+ String _projectPath = this.getProjectPath(e);
+ String _generationPathSegment = this.getGenerationPathSegment();
+ String _operator_plus = StringExtensions.operator_plus(_projectPath, _generationPathSegment);
+ return _operator_plus;
+ }
+
+ public String getDocGenerationTargetPath(final EObject e) {
+ String _projectPath = this.getProjectPath(e);
+ String _docGenerationPathSegment = this.getDocGenerationPathSegment();
+ String _operator_plus = StringExtensions.operator_plus(_projectPath, _docGenerationPathSegment);
+ return _operator_plus;
+ }
+
+ public List<Port> getEndPorts(final ActorClass ac) {
+ EList<Port> _intPorts = ac.getIntPorts();
+ EList<ExternalPort> _extPorts = ac.getExtPorts();
+ List<Port> _punion = this.punion(_intPorts, _extPorts);
+ return _punion;
+ }
+
+ public List<Port> getAllEndPorts(final ActorClass ac) {
+ List<Port> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ List<Port> _endPorts = this.getEndPorts(ac);
+ return _endPorts;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ List<Port> _allEndPorts = this.getAllEndPorts(_base_1);
+ List<Port> _endPorts_1 = this.getEndPorts(ac);
+ List<Port> _union = this.<Port>union(_allEndPorts, _endPorts_1);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public List<SAPRef> getAllSAPs(final ActorClass ac) {
+ List<SAPRef> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ EList<SAPRef> _strSAPs = ac.getStrSAPs();
+ return _strSAPs;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ EList<SAPRef> _strSAPs_1 = _base_1.getStrSAPs();
+ EList<SAPRef> _strSAPs_2 = ac.getStrSAPs();
+ List<SAPRef> _union = this.<SAPRef>union(_strSAPs_1, _strSAPs_2);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public List<ServiceImplementation> getAllServiceImplementations(final ActorClass ac) {
+ List<ServiceImplementation> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ EList<ServiceImplementation> _serviceImplementations = ac.getServiceImplementations();
+ return _serviceImplementations;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ EList<ServiceImplementation> _serviceImplementations_1 = _base_1.getServiceImplementations();
+ EList<ServiceImplementation> _serviceImplementations_2 = ac.getServiceImplementations();
+ List<ServiceImplementation> _union = this.<ServiceImplementation>union(_serviceImplementations_1, _serviceImplementations_2);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public String getPathName(final String path) {
+ String _replaceAll = path.replaceAll("/", "_");
+ return _replaceAll;
+ }
+
+ public List<Attribute> getAllAttributes(final DataClass dc) {
+ List<Attribute> _xifexpression = null;
+ DataClass _base = dc.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ EList<Attribute> _attributes = dc.getAttributes();
+ return _attributes;
+ } else {
+ DataClass _base_1 = dc.getBase();
+ EList<Attribute> _attributes_1 = _base_1.getAttributes();
+ List<Attribute> _allAttributes = this.getAllAttributes(dc);
+ List<Attribute> _union = this.<Attribute>union(_attributes_1, _allAttributes);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public List<Attribute> getAllAttributes(final ActorClass ac) {
+ List<Attribute> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ EList<Attribute> _attributes = ac.getAttributes();
+ return _attributes;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ EList<Attribute> _attributes_1 = _base_1.getAttributes();
+ List<Attribute> _allAttributes = this.getAllAttributes(ac);
+ List<Attribute> _union = this.<Attribute>union(_attributes_1, _allAttributes);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public String getPortClassName(final ProtocolClass p, final boolean conj) {
+ String _portClassName = this.getPortClassName(p, conj, false);
+ return _portClassName;
+ }
+
+ public String getPortClassName(final ProtocolClass p, final boolean conj, final boolean repl) {
+ String _name = p.getName();
+ String _xifexpression = null;
+ if (conj) {
+ _xifexpression = "Conj";
+ } else {
+ _xifexpression = "";
+ }
+ String _operator_plus = StringExtensions.operator_plus(_name, _xifexpression);
+ String _xifexpression_1 = null;
+ if (repl) {
+ _xifexpression_1 = "Repl";
+ } else {
+ _xifexpression_1 = "";
+ }
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, _xifexpression_1);
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, "Port");
+ return _operator_plus_2;
+ }
+
+ public String getPortClassName(final Port p) {
+ ProtocolClass _protocol = p.getProtocol();
+ boolean _isConjugated = p.isConjugated();
+ boolean _isReplicated = p.isReplicated();
+ String _portClassName = this.getPortClassName(_protocol, _isConjugated, _isReplicated);
+ return _portClassName;
+ }
+
+ public String getPortClassName(final ExternalPort p) {
+ Port _ifport = p.getIfport();
+ String _portClassName = this.getPortClassName(_ifport);
+ return _portClassName;
+ }
+
+ public String getPortClassName(final SAPRef sap) {
+ ProtocolClass _protocol = sap.getProtocol();
+ String _portClassName = this.getPortClassName(_protocol, true);
+ return _portClassName;
+ }
+
+ public String getPortClassName(final ServiceImplementation svc) {
+ SPPRef _spp = svc.getSpp();
+ ProtocolClass _protocol = _spp.getProtocol();
+ String _portClassName = this.getPortClassName(_protocol, false, true);
+ return _portClassName;
+ }
+
+ public String getPortClassName(final SPPRef spp) {
+ ProtocolClass _protocol = spp.getProtocol();
+ String _portClassName = this.getPortClassName(_protocol, false, true);
+ return _portClassName;
+ }
+
+ public List<Message> getAllIncomingMessages(final ProtocolClass pc) {
+ ProtocolClass _base = pc.getBase();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_base, null);
+ if (_operator_notEquals) {
+ ProtocolClass _base_1 = pc.getBase();
+ List<Message> _allIncomingMessages = this.getAllIncomingMessages(_base_1);
+ EList<Message> _incomingMessages = pc.getIncomingMessages();
+ List<Message> _union = this.<Message>union(_allIncomingMessages, _incomingMessages);
+ return _union;
+ } else {
+ EList<Message> _incomingMessages_1 = pc.getIncomingMessages();
+ return _incomingMessages_1;
+ }
+ }
+
+ public List<Message> getAllOutgoingMessages(final ProtocolClass pc) {
+ EList<Message> _xifexpression = null;
+ ProtocolClass _base = pc.getBase();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_base, null);
+ if (_operator_notEquals) {
+ ProtocolClass _base_1 = pc.getBase();
+ List<Message> _allOutgoingMessages = this.getAllOutgoingMessages(_base_1);
+ EList<Message> _outgoingMessages = pc.getOutgoingMessages();
+ List<Message> _union = this.<Message>union(_allOutgoingMessages, _outgoingMessages);
+ return _union;
+ } else {
+ EList<Message> _outgoingMessages_1 = pc.getOutgoingMessages();
+ _xifexpression = _outgoingMessages_1;
+ }
+ return _xifexpression;
+ }
+
+ public List<Message> getIncoming(final ProtocolClass pc, final boolean conj) {
+ if (conj) {
+ List<Message> _allOutgoingMessages = this.getAllOutgoingMessages(pc);
+ return _allOutgoingMessages;
+ } else {
+ List<Message> _allIncomingMessages = this.getAllIncomingMessages(pc);
+ return _allIncomingMessages;
+ }
+ }
+
+ public List<Message> getOutgoing(final ProtocolClass pc, final boolean conj) {
+ if (conj) {
+ List<Message> _allIncomingMessages = this.getAllIncomingMessages(pc);
+ return _allIncomingMessages;
+ } else {
+ List<Message> _allOutgoingMessages = this.getAllOutgoingMessages(pc);
+ return _allOutgoingMessages;
+ }
+ }
+
+ public PortClass getPortClass(final ProtocolClass pc, final boolean conj) {
+ if (conj) {
+ PortClass _conjugate = pc.getConjugate();
+ return _conjugate;
+ } else {
+ PortClass _regular = pc.getRegular();
+ return _regular;
+ }
+ }
+
+ public boolean handlesSend(final ProtocolClass pc, final boolean conj) {
+ PortClass _portClass = this.getPortClass(pc, conj);
+ boolean _operator_equals = ObjectExtensions.operator_equals(_portClass, null);
+ if (_operator_equals) {
+ return false;
+ } else {
+ PortClass _portClass_1 = this.getPortClass(pc, conj);
+ EList<MessageHandler> _msgHandlers = _portClass_1.getMsgHandlers();
+ for (final MessageHandler hdlr : _msgHandlers) {
+ List<Message> _outgoing = this.getOutgoing(pc, conj);
+ Message _msg = hdlr.getMsg();
+ boolean _contains = _outgoing.contains(_msg);
+ if (_contains) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean handlesReceive(final ProtocolClass pc, final boolean conj) {
+ PortClass _portClass = this.getPortClass(pc, conj);
+ boolean _operator_equals = ObjectExtensions.operator_equals(_portClass, null);
+ if (_operator_equals) {
+ return false;
+ } else {
+ PortClass _portClass_1 = this.getPortClass(pc, conj);
+ EList<MessageHandler> _msgHandlers = _portClass_1.getMsgHandlers();
+ for (final MessageHandler hdlr : _msgHandlers) {
+ List<Message> _incoming = this.getIncoming(pc, conj);
+ Message _msg = hdlr.getMsg();
+ boolean _contains = _incoming.contains(_msg);
+ if (_contains) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public List<MessageHandler> getReceiveHandlers(final ProtocolClass pc, final boolean conj) {
+ PortClass _portClass = this.getPortClass(pc, conj);
+ boolean _operator_equals = ObjectExtensions.operator_equals(_portClass, null);
+ if (_operator_equals) {
+ ArrayList<MessageHandler> _arrayList = new ArrayList<MessageHandler>();
+ return _arrayList;
+ } else {
+ {
+ ArrayList<MessageHandler> _arrayList_1 = new ArrayList<MessageHandler>();
+ ArrayList<MessageHandler> res = _arrayList_1;
+ PortClass _portClass_1 = this.getPortClass(pc, conj);
+ EList<MessageHandler> _msgHandlers = _portClass_1.getMsgHandlers();
+ for (final MessageHandler hdlr : _msgHandlers) {
+ List<Message> _incoming = this.getIncoming(pc, conj);
+ Message _msg = hdlr.getMsg();
+ boolean _contains = _incoming.contains(_msg);
+ if (_contains) {
+ res.add(hdlr);
+ }
+ }
+ return res;
+ }
+ }
+ }
+
+ public List<MessageHandler> getSendHandlers(final ProtocolClass pc, final boolean conj) {
+ PortClass _portClass = this.getPortClass(pc, conj);
+ boolean _operator_equals = ObjectExtensions.operator_equals(_portClass, null);
+ if (_operator_equals) {
+ ArrayList<MessageHandler> _arrayList = new ArrayList<MessageHandler>();
+ return _arrayList;
+ } else {
+ {
+ ArrayList<MessageHandler> _arrayList_1 = new ArrayList<MessageHandler>();
+ ArrayList<MessageHandler> res = _arrayList_1;
+ PortClass _portClass_1 = this.getPortClass(pc, conj);
+ EList<MessageHandler> _msgHandlers = _portClass_1.getMsgHandlers();
+ for (final MessageHandler hdlr : _msgHandlers) {
+ List<Message> _outgoing = this.getOutgoing(pc, conj);
+ Message _msg = hdlr.getMsg();
+ boolean _contains = _outgoing.contains(_msg);
+ if (_contains) {
+ res.add(hdlr);
+ }
+ }
+ return res;
+ }
+ }
+ }
+
+ public MessageHandler getSendHandler(final Message m, final boolean conj) {
+ EObject _eContainer = m.eContainer();
+ List<MessageHandler> _sendHandlers = this.getSendHandlers(((ProtocolClass) _eContainer), conj);
+ final Function1<MessageHandler,Boolean> _function = new Function1<MessageHandler,Boolean>() {
+ public Boolean apply(final MessageHandler e) {
+ Message _msg = e.getMsg();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_msg, m);
+ return ((Boolean)_operator_equals);
+ }
+ };
+ MessageHandler _findFirst = IterableExtensions.<MessageHandler>findFirst(_sendHandlers, _function);
+ return _findFirst;
+ }
+
+ public boolean isIncoming(final Message m) {
+ EObject _eContainer = m.eContainer();
+ List<Message> _allIncomingMessages = this.getAllIncomingMessages(((ProtocolClass) _eContainer));
+ boolean _contains = _allIncomingMessages.contains(m);
+ return _contains;
+ }
+
+ public String getCodeName(final Message m) {
+ boolean _isIncoming = this.isIncoming(m);
+ if (_isIncoming) {
+ String _name = m.getName();
+ String _operator_plus = StringExtensions.operator_plus("IN_", _name);
+ return _operator_plus;
+ } else {
+ String _name_1 = m.getName();
+ String _operator_plus_1 = StringExtensions.operator_plus("OUT_", _name_1);
+ return _operator_plus_1;
+ }
+ }
+
+ public boolean isLeaf(final State s) {
+ StateGraph _subgraph = s.getSubgraph();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_subgraph, null);
+ return _operator_equals;
+ }
+
+ public List<State> getLeafStateList(final StateGraph sg) {
+ ArrayList<State> _arrayList = new ArrayList<State>();
+ ArrayList<State> res = _arrayList;
+ EList<State> _states = sg.getStates();
+ for (final State s : _states) {
+ List<State> _leafStateList = this.getLeafStateList(s);
+ res.addAll(_leafStateList);
+ }
+ return res;
+ }
+
+ public List<State> getLeafStateList(final State s) {
+ boolean _isLeaf = this.isLeaf(s);
+ if (_isLeaf) {
+ {
+ ArrayList<State> _arrayList = new ArrayList<State>();
+ ArrayList<State> res = _arrayList;
+ res.add(s);
+ return res;
+ }
+ } else {
+ StateGraph _subgraph = s.getSubgraph();
+ List<State> _leafStateList = this.getLeafStateList(_subgraph);
+ return _leafStateList;
+ }
+ }
+
+ public List<State> getStateList(final StateGraph sg) {
+ ArrayList<State> _arrayList = new ArrayList<State>();
+ ArrayList<State> ret = _arrayList;
+ EList<State> _states = sg.getStates();
+ for (final State e : _states) {
+ {
+ ret.add(e);
+ StateGraph _subgraph = e.getSubgraph();
+ StateGraph tmp = _subgraph;
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(tmp, null);
+ if (_operator_notEquals) {
+ StateGraph _subgraph_1 = e.getSubgraph();
+ List<State> _stateList = this.getStateList(_subgraph_1);
+ ret.addAll(_stateList);
+ }
+ }
+ }
+ return ret;
+ }
+
+ public List<State> getBaseStateList(final StateGraph sg) {
+ ArrayList<State> _arrayList = new ArrayList<State>();
+ ArrayList<State> ret = _arrayList;
+ List<State> _stateList = this.getStateList(sg);
+ for (final State e : _stateList) {
+ if ((e instanceof BaseState)) {
+ ret.add(e);
+ }
+ }
+ return ret;
+ }
+
+ public ArrayList<State> getLeafStatesLast(final List<State> states) {
+ ArrayList<State> _arrayList = new ArrayList<State>();
+ ArrayList<State> leaf = _arrayList;
+ ArrayList<State> _arrayList_1 = new ArrayList<State>();
+ ArrayList<State> nonLeaf = _arrayList_1;
+ for (final State state : states) {
+ boolean _isLeaf = this.isLeaf(state);
+ if (_isLeaf) {
+ leaf.add(state);
+ } else {
+ nonLeaf.add(state);
+ }
+ }
+ nonLeaf.addAll(leaf);
+ return nonLeaf;
+ }
+
+ public List<State> getAllBaseStates(final ActorClass ac) {
+ List<State> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ StateGraph _stateMachine = ac.getStateMachine();
+ List<State> _baseStateList = this.getBaseStateList(_stateMachine);
+ return _baseStateList;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ List<State> _allBaseStates = this.getAllBaseStates(_base_1);
+ StateGraph _stateMachine_1 = ac.getStateMachine();
+ List<State> _baseStateList_1 = this.getBaseStateList(_stateMachine_1);
+ List<State> _union = this.<State>union(_allBaseStates, _baseStateList_1);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public List<State> getAllBaseStatesLeavesLast(final ActorClass ac) {
+ List<State> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ StateGraph _stateMachine = ac.getStateMachine();
+ List<State> _baseStateList = this.getBaseStateList(_stateMachine);
+ ArrayList<State> _leafStatesLast = this.getLeafStatesLast(_baseStateList);
+ return _leafStatesLast;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ List<State> _allBaseStates = this.getAllBaseStates(_base_1);
+ ArrayList<State> _leafStatesLast_1 = this.getLeafStatesLast(_allBaseStates);
+ StateGraph _stateMachine_1 = ac.getStateMachine();
+ List<State> _baseStateList_1 = this.getBaseStateList(_stateMachine_1);
+ ArrayList<State> _leafStatesLast_2 = this.getLeafStatesLast(_baseStateList_1);
+ List<State> _union = this.<State>union(_leafStatesLast_1, _leafStatesLast_2);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public List<State> getAllLeafStates(final ActorClass ac) {
+ List<State> _xifexpression = null;
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ StateGraph _stateMachine = ac.getStateMachine();
+ List<State> _leafStateList = this.getLeafStateList(_stateMachine);
+ return _leafStateList;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ List<State> _allLeafStates = this.getAllLeafStates(_base_1);
+ StateGraph _stateMachine_1 = ac.getStateMachine();
+ List<State> _leafStateList_1 = this.getLeafStateList(_stateMachine_1);
+ List<State> _union = this.<State>union(_allLeafStates, _leafStateList_1);
+ _xifexpression = _union;
+ }
+ return _xifexpression;
+ }
+
+ public boolean overridesStop(final ActorClass ac) {
+ boolean _operator_or = false;
+ EList<StandardOperation> _operations = ac.getOperations();
+ final Function1<StandardOperation,Boolean> _function = new Function1<StandardOperation,Boolean>() {
+ public Boolean apply(final StandardOperation e) {
+ boolean _operator_and = false;
+ boolean _operator_and_1 = false;
+ String _name = e.getName();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_name, "stop");
+ if (!_operator_equals) {
+ _operator_and_1 = false;
+ } else {
+ EList<VarDecl> _arguments = e.getArguments();
+ boolean _isEmpty = _arguments.isEmpty();
+ _operator_and_1 = BooleanExtensions.operator_and(_operator_equals, _isEmpty);
+ }
+ if (!_operator_and_1) {
+ _operator_and = false;
+ } else {
+ RefableType _returntype = e.getReturntype();
+ boolean _operator_equals_1 = ObjectExtensions.operator_equals(_returntype, null);
+ _operator_and = BooleanExtensions.operator_and(_operator_and_1, _operator_equals_1);
+ }
+ return ((Boolean)_operator_and);
+ }
+ };
+ boolean _exists = IterableExtensions.<StandardOperation>exists(_operations, _function);
+ if (_exists) {
+ _operator_or = true;
+ } else {
+ boolean _operator_and = false;
+ ActorClass _base = ac.getBase();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_base, null);
+ if (!_operator_notEquals) {
+ _operator_and = false;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ boolean _overridesStop = this.overridesStop(_base_1);
+ _operator_and = BooleanExtensions.operator_and(_operator_notEquals, _overridesStop);
+ }
+ _operator_or = BooleanExtensions.operator_or(_exists, _operator_and);
+ }
+ return _operator_or;
+ }
+
+ public int getNumberOfInheritedStates(final ActorClass ac) {
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ return 0;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ StateGraph _stateMachine = _base_1.getStateMachine();
+ List<State> _stateList = this.getStateList(_stateMachine);
+ int _size = _stateList.size();
+ ActorClass _base_2 = ac.getBase();
+ int _numberOfInheritedStates = this.getNumberOfInheritedStates(_base_2);
+ int _operator_plus = IntegerExtensions.operator_plus(((Integer)_size), ((Integer)_numberOfInheritedStates));
+ return _operator_plus;
+ }
+ }
+
+ public int getNumberOfInheritedBaseStates(final ActorClass ac) {
+ ActorClass _base = ac.getBase();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_base, null);
+ if (_operator_equals) {
+ return 0;
+ } else {
+ ActorClass _base_1 = ac.getBase();
+ StateGraph _stateMachine = _base_1.getStateMachine();
+ List<State> _baseStateList = this.getBaseStateList(_stateMachine);
+ int _size = _baseStateList.size();
+ ActorClass _base_2 = ac.getBase();
+ int _numberOfInheritedBaseStates = this.getNumberOfInheritedBaseStates(_base_2);
+ int _operator_plus = IntegerExtensions.operator_plus(((Integer)_size), ((Integer)_numberOfInheritedBaseStates));
+ return _operator_plus;
+ }
+ }
+
+ public String getStateId(final State s) {
+ String _genStateId = RoomNameProv.getGenStateId(s);
+ return _genStateId;
+ }
+
+ public String getStatePathName(final State s) {
+ String _genStatePathName = RoomNameProv.getGenStatePathName(s);
+ return _genStatePathName;
+ }
+
+ public String getChainId(final TransitionChain t) {
+ String _genChainId = RoomNameProv.getGenChainId(t);
+ return _genChainId;
+ }
+
+ public boolean hasGuard(final Trigger tr) {
+ boolean _operator_and = false;
+ boolean _operator_and_1 = false;
+ Guard _guard = tr.getGuard();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_guard, null);
+ if (!_operator_notEquals) {
+ _operator_and_1 = false;
+ } else {
+ Guard _guard_1 = tr.getGuard();
+ DetailCode _guard_2 = _guard_1.getGuard();
+ boolean _operator_notEquals_1 = ObjectExtensions.operator_notEquals(_guard_2, null);
+ _operator_and_1 = BooleanExtensions.operator_and(_operator_notEquals, _operator_notEquals_1);
+ }
+ if (!_operator_and_1) {
+ _operator_and = false;
+ } else {
+ Guard _guard_3 = tr.getGuard();
+ DetailCode _guard_4 = _guard_3.getGuard();
+ EList<String> _commands = _guard_4.getCommands();
+ int _size = _commands.size();
+ boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)_size), ((Integer)0));
+ _operator_and = BooleanExtensions.operator_and(_operator_and_1, _operator_greaterThan);
+ }
+ return _operator_and;
+ }
+
+ public boolean hasGuard(final ExpandedActorClass ac, final ActiveTrigger at) {
+ boolean hasGuard = false;
+ EList<TriggeredTransition> _transitions = at.getTransitions();
+ for (final TriggeredTransition t : _transitions) {
+ EList<Trigger> _triggers = t.getTriggers();
+ final Function1<Trigger,Boolean> _function = new Function1<Trigger,Boolean>() {
+ public Boolean apply(final Trigger e) {
+ boolean _operator_and = false;
+ String _trigger = at.getTrigger();
+ boolean _isMatching = ac.isMatching(e, _trigger);
+ if (!_isMatching) {
+ _operator_and = false;
+ } else {
+ boolean _hasGuard = RoomExtensions.this.hasGuard(e);
+ _operator_and = BooleanExtensions.operator_and(_isMatching, _hasGuard);
+ }
+ return ((Boolean)_operator_and);
+ }
+ };
+ boolean _exists = IterableExtensions.<Trigger>exists(_triggers, _function);
+ if (_exists) {
+ hasGuard = true;
+ }
+ }
+ return hasGuard;
+ }
+
+ public boolean empty(final DetailCode dc) {
+ boolean _operator_or = false;
+ boolean _operator_equals = ObjectExtensions.operator_equals(dc, null);
+ if (_operator_equals) {
+ _operator_or = true;
+ } else {
+ EList<String> _commands = dc.getCommands();
+ boolean _isEmpty = _commands.isEmpty();
+ _operator_or = BooleanExtensions.operator_or(_operator_equals, _isEmpty);
+ }
+ return _operator_or;
+ }
+
+ public boolean hasEntryCode(final State s) {
+ DetailCode _entryCode = s.getEntryCode();
+ boolean _empty = this.empty(_entryCode);
+ boolean _operator_not = BooleanExtensions.operator_not(_empty);
+ return _operator_not;
+ }
+
+ public boolean hasExitCode(final State s) {
+ DetailCode _exitCode = s.getExitCode();
+ boolean _empty = this.empty(_exitCode);
+ boolean _operator_not = BooleanExtensions.operator_not(_empty);
+ return _operator_not;
+ }
+
+ public boolean hasDoCode(final State s) {
+ DetailCode _doCode = s.getDoCode();
+ boolean _empty = this.empty(_doCode);
+ boolean _operator_not = BooleanExtensions.operator_not(_empty);
+ return _operator_not;
+ }
+
+ public String getEntryCode(final ExpandedActorClass ac, final State s, final DetailCodeTranslator dct) {
+ String _xifexpression = null;
+ if ((s instanceof RefinedState)) {
+ String _entryCodeOperationName = RoomNameProv.getEntryCodeOperationName(s);
+ String _operator_plus = StringExtensions.operator_plus("super.", _entryCodeOperationName);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, "();\n");
+ DetailCode _entryCode = s.getEntryCode();
+ String _code = ac.getCode(_entryCode);
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, _code);
+ _xifexpression = _operator_plus_2;
+ } else {
+ DetailCode _entryCode_1 = s.getEntryCode();
+ String _translateDetailCode = dct.translateDetailCode(_entryCode_1);
+ _xifexpression = _translateDetailCode;
+ }
+ return _xifexpression;
+ }
+
+ public String getExitCode(final ExpandedActorClass ac, final State s, final DetailCodeTranslator dct) {
+ String _xifexpression = null;
+ if ((s instanceof RefinedState)) {
+ DetailCode _exitCode = s.getExitCode();
+ String _code = ac.getCode(_exitCode);
+ String _operator_plus = StringExtensions.operator_plus(_code, "super.");
+ String _exitCodeOperationName = RoomNameProv.getExitCodeOperationName(s);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, _exitCodeOperationName);
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, "();\n");
+ _xifexpression = _operator_plus_2;
+ } else {
+ DetailCode _exitCode_1 = s.getExitCode();
+ String _translateDetailCode = dct.translateDetailCode(_exitCode_1);
+ _xifexpression = _translateDetailCode;
+ }
+ return _xifexpression;
+ }
+
+ public String getDoCode(final ExpandedActorClass ac, final State s, final DetailCodeTranslator dct) {
+ String _xifexpression = null;
+ if ((s instanceof RefinedState)) {
+ DetailCode _doCode = s.getDoCode();
+ String _code = ac.getCode(_doCode);
+ String _operator_plus = StringExtensions.operator_plus(_code, "super.");
+ String _doCodeOperationName = RoomNameProv.getDoCodeOperationName(s);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, _doCodeOperationName);
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, "();\n");
+ _xifexpression = _operator_plus_2;
+ } else {
+ DetailCode _doCode_1 = s.getDoCode();
+ String _translateDetailCode = dct.translateDetailCode(_doCode_1);
+ _xifexpression = _translateDetailCode;
+ }
+ return _xifexpression;
+ }
+
+ public boolean hasActionCode(final Transition t) {
+ boolean _operator_and = false;
+ DetailCode _action = t.getAction();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_action, null);
+ if (!_operator_notEquals) {
+ _operator_and = false;
+ } else {
+ DetailCode _action_1 = t.getAction();
+ EList<String> _commands = _action_1.getCommands();
+ int _size = _commands.size();
+ boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)_size), ((Integer)0));
+ _operator_and = BooleanExtensions.operator_and(_operator_notEquals, _operator_greaterThan);
+ }
+ return _operator_and;
+ }
+
+ public String getActionCode(final ExpandedActorClass ac, final Transition t, final DetailCodeTranslator dct) {
+ DetailCode _action = t.getAction();
+ String _translateDetailCode = dct.translateDetailCode(_action);
+ return _translateDetailCode;
+ }
+
+ public String getContextId(final TransitionChain tc) {
+ State _stateContext = tc.getStateContext();
+ String _stateId = this.getStateId(_stateContext);
+ return _stateId;
+ }
+
+ public Transition getInitTransition(final StateGraph sg) {
+ EList<Transition> _transitions = sg.getTransitions();
+ for (final Transition tr : _transitions) {
+ if ((tr instanceof InitialTransition)) {
+ return tr;
+ }
+ }
+ return null;
+ }
+
+ public boolean hasInitTransition(final StateGraph sg) {
+ EList<Transition> _transitions = sg.getTransitions();
+ for (final Transition tr : _transitions) {
+ if ((tr instanceof InitialTransition)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public boolean hasNonEmptyStateMachine(final ActorClass ac) {
+ boolean _operator_and = false;
+ StateGraph _stateMachine = ac.getStateMachine();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_stateMachine, null);
+ if (!_operator_notEquals) {
+ _operator_and = false;
+ } else {
+ StateGraph _stateMachine_1 = ac.getStateMachine();
+ EList<State> _states = _stateMachine_1.getStates();
+ boolean _isEmpty = _states.isEmpty();
+ boolean _operator_not = BooleanExtensions.operator_not(_isEmpty);
+ _operator_and = BooleanExtensions.operator_and(_operator_notEquals, _operator_not);
+ }
+ return _operator_and;
+ }
+
+ public List<Transition> getTransitionList(final State s) {
+ boolean _isLeaf = this.isLeaf(s);
+ if (_isLeaf) {
+ ArrayList<Transition> _arrayList = new ArrayList<Transition>();
+ return _arrayList;
+ } else {
+ StateGraph _subgraph = s.getSubgraph();
+ List<Transition> _transitionList = this.getTransitionList(_subgraph);
+ return _transitionList;
+ }
+ }
+
+ public List<Transition> getTransitionList(final StateGraph sg) {
+ EList<Transition> _transitions = sg.getTransitions();
+ ArrayList<Transition> _arrayList = new ArrayList<Transition>(_transitions);
+ ArrayList<Transition> res = _arrayList;
+ EList<State> _states = sg.getStates();
+ for (final State s : _states) {
+ List<Transition> _transitionList = this.getTransitionList(s);
+ res.addAll(_transitionList);
+ }
+ return res;
+ }
+
+ public List<Transition> getOutgoingTransitionsHierarchical(final ExpandedActorClass ac, final State s) {
+ ArrayList<Transition> _arrayList = new ArrayList<Transition>();
+ ArrayList<Transition> result = _arrayList;
+ EList<Transition> _outgoingTransitions = ac.getOutgoingTransitions(s);
+ result.addAll(_outgoingTransitions);
+ EObject _eContainer = s.eContainer();
+ StateGraph sg = ((StateGraph) _eContainer);
+ EList<TrPoint> _trPoints = sg.getTrPoints();
+ for (final TrPoint tp : _trPoints) {
+ if ((tp instanceof TransitionPoint)) {
+ EList<Transition> _outgoingTransitions_1 = ac.getOutgoingTransitions(tp);
+ result.addAll(_outgoingTransitions_1);
+ }
+ }
+ EObject _eContainer_1 = sg.eContainer();
+ if ((_eContainer_1 instanceof State)) {
+ EObject _eContainer_2 = sg.eContainer();
+ List<Transition> _outgoingTransitionsHierarchical = this.getOutgoingTransitionsHierarchical(ac, ((State) _eContainer_2));
+ result.addAll(_outgoingTransitionsHierarchical);
+ }
+ return result;
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericActorClassGenerator.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericActorClassGenerator.java new file mode 100644 index 000000000..554c7593f --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericActorClassGenerator.java @@ -0,0 +1,93 @@ +package org.eclipse.etrice.generator.generic;
+
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.SAPRef;
+import org.eclipse.etrice.core.room.SPPRef;
+import org.eclipse.etrice.core.room.ServiceImplementation;
+import org.eclipse.etrice.generator.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.generator.extensions.RoomExtensions;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.util.Tuples;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+public class GenericActorClassGenerator {
+ @Inject
+ private ILanguageExtension langExt;
+
+ @Inject
+ private RoomExtensions roomExt;
+
+ public String genInterfaceItemConstants(final ExpandedActorClass xpac, final ActorClass ac) {
+ List<Port> _xifexpression = null;
+ boolean _usesInheritance = this.langExt.usesInheritance();
+ if (_usesInheritance) {
+ List<Port> _endPorts = this.roomExt.getEndPorts(ac);
+ _xifexpression = _endPorts;
+ } else {
+ List<Port> _allEndPorts = this.roomExt.getAllEndPorts(ac);
+ _xifexpression = _allEndPorts;
+ }
+ List<Port> endPorts = _xifexpression;
+ List<SAPRef> _xifexpression_1 = null;
+ boolean _usesInheritance_1 = this.langExt.usesInheritance();
+ if (_usesInheritance_1) {
+ EList<SAPRef> _strSAPs = ac.getStrSAPs();
+ _xifexpression_1 = _strSAPs;
+ } else {
+ List<SAPRef> _allSAPs = this.roomExt.getAllSAPs(ac);
+ _xifexpression_1 = _allSAPs;
+ }
+ List<SAPRef> strSAPs = _xifexpression_1;
+ List<ServiceImplementation> _xifexpression_2 = null;
+ boolean _usesInheritance_2 = this.langExt.usesInheritance();
+ if (_usesInheritance_2) {
+ EList<ServiceImplementation> _serviceImplementations = ac.getServiceImplementations();
+ _xifexpression_2 = _serviceImplementations;
+ } else {
+ List<ServiceImplementation> _allServiceImplementations = this.roomExt.getAllServiceImplementations(ac);
+ _xifexpression_2 = _allServiceImplementations;
+ }
+ List<ServiceImplementation> svcImpls = _xifexpression_2;
+ ArrayList<Pair<String,String>> _arrayList = new ArrayList<Pair<String,String>>();
+ ArrayList<Pair<String,String>> list = _arrayList;
+ for (final Port ep : endPorts) {
+ String _name = ep.getName();
+ String _operator_plus = StringExtensions.operator_plus("IFITEM_", _name);
+ int _interfaceItemLocalId = xpac.getInterfaceItemLocalId(ep);
+ int _operator_plus_1 = IntegerExtensions.operator_plus(((Integer)1), ((Integer)_interfaceItemLocalId));
+ String _string = ((Integer)_operator_plus_1).toString();
+ Pair<String,String> _pair = Tuples.<String, String>pair(_operator_plus, _string);
+ list.add(_pair);
+ }
+ for (final SAPRef sap : strSAPs) {
+ String _name_1 = sap.getName();
+ String _operator_plus_2 = StringExtensions.operator_plus("IFITEM_", _name_1);
+ int _interfaceItemLocalId_1 = xpac.getInterfaceItemLocalId(sap);
+ int _operator_plus_3 = IntegerExtensions.operator_plus(((Integer)1), ((Integer)_interfaceItemLocalId_1));
+ String _string_1 = ((Integer)_operator_plus_3).toString();
+ Pair<String,String> _pair_1 = Tuples.<String, String>pair(_operator_plus_2, _string_1);
+ list.add(_pair_1);
+ }
+ for (final ServiceImplementation svc : svcImpls) {
+ SPPRef _spp = svc.getSpp();
+ String _name_2 = _spp.getName();
+ String _operator_plus_4 = StringExtensions.operator_plus("IFITEM_", _name_2);
+ SPPRef _spp_1 = svc.getSpp();
+ int _interfaceItemLocalId_2 = xpac.getInterfaceItemLocalId(_spp_1);
+ int _operator_plus_5 = IntegerExtensions.operator_plus(((Integer)1), ((Integer)_interfaceItemLocalId_2));
+ String _string_2 = ((Integer)_operator_plus_5).toString();
+ Pair<String,String> _pair_2 = Tuples.<String, String>pair(_operator_plus_4, _string_2);
+ list.add(_pair_2);
+ }
+ String _genEnumeration = this.langExt.genEnumeration("interface_items", list);
+ return _genEnumeration;
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericProtocolClassGenerator.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericProtocolClassGenerator.java new file mode 100644 index 000000000..5e02b60cf --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericProtocolClassGenerator.java @@ -0,0 +1,131 @@ +package org.eclipse.etrice.generator.generic;
+
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.etrice.core.room.InterfaceItem;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageFromIf;
+import org.eclipse.etrice.core.room.Port;
+import org.eclipse.etrice.core.room.ProtocolClass;
+import org.eclipse.etrice.core.room.SAPRef;
+import org.eclipse.etrice.core.room.SPPRef;
+import org.eclipse.etrice.generator.extensions.RoomExtensions;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.util.Tuples;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+public class GenericProtocolClassGenerator {
+ @Inject
+ private ILanguageExtension langExt;
+
+ @Inject
+ private RoomExtensions roomExt;
+
+ public String genMessageIDs(final ProtocolClass pc) {
+ int offset = 0;
+ ArrayList<Pair<String,String>> _arrayList = new ArrayList<Pair<String,String>>();
+ ArrayList<Pair<String,String>> list = _arrayList;
+ String _name = pc.getName();
+ String _memberInDeclaration = this.langExt.memberInDeclaration(_name, "MSG_MIN");
+ String _string = ((Integer)offset).toString();
+ Pair<String,String> _pair = Tuples.<String, String>pair(_memberInDeclaration, _string);
+ list.add(_pair);
+ List<Message> _allOutgoingMessages = this.roomExt.getAllOutgoingMessages(pc);
+ for (final Message msg : _allOutgoingMessages) {
+ {
+ int _operator_plus = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)1));
+ offset = _operator_plus;
+ String _name_1 = pc.getName();
+ String _name_2 = msg.getName();
+ String _operator_plus_1 = StringExtensions.operator_plus("OUT_", _name_2);
+ String _memberInDeclaration_1 = this.langExt.memberInDeclaration(_name_1, _operator_plus_1);
+ String _string_1 = ((Integer)offset).toString();
+ Pair<String,String> _pair_1 = Tuples.<String, String>pair(_memberInDeclaration_1, _string_1);
+ list.add(_pair_1);
+ }
+ }
+ List<Message> _allIncomingMessages = this.roomExt.getAllIncomingMessages(pc);
+ for (final Message msg_1 : _allIncomingMessages) {
+ {
+ int _operator_plus_2 = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)1));
+ offset = _operator_plus_2;
+ String _name_3 = pc.getName();
+ String _name_4 = msg_1.getName();
+ String _operator_plus_3 = StringExtensions.operator_plus("IN_", _name_4);
+ String _memberInDeclaration_2 = this.langExt.memberInDeclaration(_name_3, _operator_plus_3);
+ String _string_2 = ((Integer)offset).toString();
+ Pair<String,String> _pair_2 = Tuples.<String, String>pair(_memberInDeclaration_2, _string_2);
+ list.add(_pair_2);
+ }
+ }
+ int _operator_plus_4 = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)1));
+ offset = _operator_plus_4;
+ String _name_5 = pc.getName();
+ String _memberInDeclaration_3 = this.langExt.memberInDeclaration(_name_5, "MSG_MAX");
+ String _string_3 = ((Integer)offset).toString();
+ Pair<String,String> _pair_3 = Tuples.<String, String>pair(_memberInDeclaration_3, _string_3);
+ list.add(_pair_3);
+ String _name_6 = pc.getName();
+ String _memberInDeclaration_4 = this.langExt.memberInDeclaration(_name_6, "msg_ids");
+ String _genEnumeration = this.langExt.genEnumeration(_memberInDeclaration_4, list);
+ return _genEnumeration;
+ }
+
+ public String getMessageID(final MessageFromIf mif) {
+ Message _message = mif.getMessage();
+ InterfaceItem _from = mif.getFrom();
+ String _messageID = this.getMessageID(_message, _from);
+ return _messageID;
+ }
+
+ public String getMessageID(final Message msg, final InterfaceItem item) {
+ if ((item instanceof Port)) {
+ {
+ Port p = ((Port) item);
+ String _xifexpression = null;
+ boolean _isConjugated = p.isConjugated();
+ if (_isConjugated) {
+ _xifexpression = "OUT_";
+ } else {
+ _xifexpression = "IN_";
+ }
+ String direction = _xifexpression;
+ ProtocolClass _protocol = p.getProtocol();
+ String _name = _protocol.getName();
+ String _name_1 = msg.getName();
+ String _operator_plus = StringExtensions.operator_plus(direction, _name_1);
+ String _memberInUse = this.langExt.memberInUse(_name, _operator_plus);
+ return _memberInUse;
+ }
+ } else {
+ if ((item instanceof SAPRef)) {
+ {
+ SAPRef sap = ((SAPRef) item);
+ ProtocolClass _protocol_1 = sap.getProtocol();
+ String _name_2 = _protocol_1.getName();
+ String _name_3 = msg.getName();
+ String _operator_plus_1 = StringExtensions.operator_plus("OUT_", _name_3);
+ String _memberInUse_1 = this.langExt.memberInUse(_name_2, _operator_plus_1);
+ return _memberInUse_1;
+ }
+ } else {
+ if ((item instanceof SPPRef)) {
+ {
+ SPPRef spp = ((SPPRef) item);
+ ProtocolClass _protocol_2 = spp.getProtocol();
+ String _name_4 = _protocol_2.getName();
+ String _name_5 = msg.getName();
+ String _operator_plus_2 = StringExtensions.operator_plus("IN_", _name_5);
+ String _memberInUse_2 = this.langExt.memberInUse(_name_4, _operator_plus_2);
+ return _memberInUse_2;
+ }
+ }
+ }
+ }
+ return "unknown interface item";
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java new file mode 100644 index 000000000..f7ca3297a --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/GenericStateMachineGenerator.java @@ -0,0 +1,1336 @@ +package org.eclipse.etrice.generator.generic;
+
+import com.google.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.ActorCommunicationType;
+import org.eclipse.etrice.core.room.DetailCode;
+import org.eclipse.etrice.core.room.Guard;
+import org.eclipse.etrice.core.room.GuardedTransition;
+import org.eclipse.etrice.core.room.InterfaceItem;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.MessageFromIf;
+import org.eclipse.etrice.core.room.NonInitialTransition;
+import org.eclipse.etrice.core.room.State;
+import org.eclipse.etrice.core.room.StateGraph;
+import org.eclipse.etrice.core.room.Transition;
+import org.eclipse.etrice.core.room.Trigger;
+import org.eclipse.etrice.core.room.TriggeredTransition;
+import org.eclipse.etrice.generator.base.DetailCodeTranslator;
+import org.eclipse.etrice.generator.base.ITranslationProvider;
+import org.eclipse.etrice.generator.etricegen.ActiveTrigger;
+import org.eclipse.etrice.generator.etricegen.ExpandedActorClass;
+import org.eclipse.etrice.generator.etricegen.TransitionChain;
+import org.eclipse.etrice.generator.extensions.RoomExtensions;
+import org.eclipse.etrice.generator.extensions.RoomNameProv;
+import org.eclipse.etrice.generator.generic.AbstractLanguageGenerator;
+import org.eclipse.etrice.generator.generic.GenericProtocolClassGenerator;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.xtext.util.Pair;
+import org.eclipse.xtext.util.Tuples;
+import org.eclipse.xtext.xbase.lib.BooleanExtensions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+import org.eclipse.xtext.xtend2.lib.StringConcatenation;
+
+@SuppressWarnings("all")
+public class GenericStateMachineGenerator {
+ @Inject
+ protected ILanguageExtension langExt;
+
+ @Inject
+ protected RoomExtensions roomExt;
+
+ @Inject
+ protected GenericProtocolClassGenerator pcGen;
+
+ @Inject
+ protected AbstractLanguageGenerator languageGen;
+
+ @Inject
+ protected ITranslationProvider translator;
+
+ private String genStateIdConstants(final ExpandedActorClass xpac, final ActorClass ac) {
+ int _xifexpression = (int) 0;
+ boolean _usesInheritance = this.langExt.usesInheritance();
+ if (_usesInheritance) {
+ int _numberOfInheritedBaseStates = this.roomExt.getNumberOfInheritedBaseStates(ac);
+ _xifexpression = _numberOfInheritedBaseStates;
+ } else {
+ _xifexpression = 0;
+ }
+ int _operator_plus = IntegerExtensions.operator_plus(((Integer)2), ((Integer)_xifexpression));
+ int offset = _operator_plus;
+ List<State> _xifexpression_1 = null;
+ boolean _usesInheritance_1 = this.langExt.usesInheritance();
+ if (_usesInheritance_1) {
+ StateGraph _stateMachine = ac.getStateMachine();
+ List<State> _baseStateList = this.roomExt.getBaseStateList(_stateMachine);
+ _xifexpression_1 = _baseStateList;
+ } else {
+ StateGraph _stateMachine_1 = xpac.getStateMachine();
+ List<State> _baseStateList_1 = this.roomExt.getBaseStateList(_stateMachine_1);
+ _xifexpression_1 = _baseStateList_1;
+ }
+ List<State> baseStates = _xifexpression_1;
+ ArrayList<State> _leafStatesLast = this.roomExt.getLeafStatesLast(baseStates);
+ baseStates = _leafStatesLast;
+ ArrayList<Pair<String,String>> _arrayList = new ArrayList<Pair<String,String>>();
+ ArrayList<Pair<String,String>> list = _arrayList;
+ boolean _usesInheritance_2 = this.langExt.usesInheritance();
+ boolean _operator_not = BooleanExtensions.operator_not(_usesInheritance_2);
+ if (_operator_not) {
+ {
+ Pair<String,String> _pair = Tuples.<String, String>pair("NO_STATE", "0");
+ list.add(_pair);
+ Pair<String,String> _pair_1 = Tuples.<String, String>pair("STATE_TOP", "1");
+ list.add(_pair_1);
+ }
+ }
+ for (final State state : baseStates) {
+ {
+ String _stateId = this.roomExt.getStateId(state);
+ String _string = ((Integer)offset).toString();
+ Pair<String,String> _pair_2 = Tuples.<String, String>pair(_stateId, _string);
+ list.add(_pair_2);
+ int _operator_plus_1 = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)1));
+ offset = _operator_plus_1;
+ }
+ }
+ String _genEnumeration = this.langExt.genEnumeration("state_ids", list);
+ return _genEnumeration;
+ }
+
+ private String genTransitionChainConstants(final ExpandedActorClass xpac, final ActorClass ac) {
+ EList<TransitionChain> _xifexpression = null;
+ boolean _usesInheritance = this.langExt.usesInheritance();
+ if (_usesInheritance) {
+ EList<TransitionChain> _ownTransitionChains = xpac.getOwnTransitionChains();
+ _xifexpression = _ownTransitionChains;
+ } else {
+ EList<TransitionChain> _transitionChains = xpac.getTransitionChains();
+ _xifexpression = _transitionChains;
+ }
+ EList<TransitionChain> chains = _xifexpression;
+ int _xifexpression_1 = (int) 0;
+ boolean _usesInheritance_1 = this.langExt.usesInheritance();
+ if (_usesInheritance_1) {
+ EList<TransitionChain> _transitionChains_1 = xpac.getTransitionChains();
+ int _size = _transitionChains_1.size();
+ int _size_1 = chains.size();
+ int _operator_minus = IntegerExtensions.operator_minus(((Integer)_size), ((Integer)_size_1));
+ _xifexpression_1 = _operator_minus;
+ } else {
+ _xifexpression_1 = 0;
+ }
+ int offset = _xifexpression_1;
+ ArrayList<Pair<String,String>> _arrayList = new ArrayList<Pair<String,String>>();
+ ArrayList<Pair<String,String>> list = _arrayList;
+ for (final TransitionChain chain : chains) {
+ {
+ int _operator_plus = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)1));
+ offset = _operator_plus;
+ String _chainId = this.roomExt.getChainId(chain);
+ String _string = ((Integer)offset).toString();
+ Pair<String,String> _pair = Tuples.<String, String>pair(_chainId, _string);
+ list.add(_pair);
+ }
+ }
+ String _genEnumeration = this.langExt.genEnumeration("chain_ids", list);
+ return _genEnumeration;
+ }
+
+ private String genTriggerConstants(final ExpandedActorClass xpac, final ActorClass ac) {
+ EList<MessageFromIf> _xifexpression = null;
+ boolean _usesInheritance = this.langExt.usesInheritance();
+ if (_usesInheritance) {
+ EList<MessageFromIf> _ownTriggers = xpac.getOwnTriggers();
+ _xifexpression = _ownTriggers;
+ } else {
+ EList<MessageFromIf> _triggers = xpac.getTriggers();
+ _xifexpression = _triggers;
+ }
+ EList<MessageFromIf> triggers = _xifexpression;
+ ArrayList<Pair<String,String>> _arrayList = new ArrayList<Pair<String,String>>();
+ ArrayList<Pair<String,String>> list = _arrayList;
+ Pair<String,String> _pair = Tuples.<String, String>pair("POLLING", "0");
+ list.add(_pair);
+ for (final MessageFromIf mif : triggers) {
+ String _triggerCodeName = xpac.getTriggerCodeName(mif);
+ InterfaceItem _from = mif.getFrom();
+ String _name = _from.getName();
+ String _operator_plus = StringExtensions.operator_plus("IFITEM_", _name);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, " + EVT_SHIFT*");
+ String _messageID = this.pcGen.getMessageID(mif);
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, _messageID);
+ Pair<String,String> _pair_1 = Tuples.<String, String>pair(_triggerCodeName, _operator_plus_2);
+ list.add(_pair_1);
+ }
+ String _genEnumeration = this.langExt.genEnumeration("triggers", list);
+ return _genEnumeration;
+ }
+
+ public StringConcatenation genStateMachine(final ExpandedActorClass xpac, final ActorClass ac) {
+ StringConcatenation _xblockexpression = null;
+ {
+ this.translator.setActorClass(ac);
+ DetailCodeTranslator _detailCodeTranslator = new DetailCodeTranslator(ac, this.translator);
+ DetailCodeTranslator dct = _detailCodeTranslator;
+ ActorCommunicationType _commType = ac.getCommType();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_commType, ActorCommunicationType.ASYNCHRONOUS);
+ boolean async = _operator_equals;
+ ActorCommunicationType _commType_1 = ac.getCommType();
+ boolean _operator_equals_1 = ObjectExtensions.operator_equals(_commType_1, ActorCommunicationType.EVENT_DRIVEN);
+ boolean eventDriven = _operator_equals_1;
+ ActorCommunicationType _commType_2 = ac.getCommType();
+ boolean _operator_equals_2 = ObjectExtensions.operator_equals(_commType_2, ActorCommunicationType.DATA_DRIVEN);
+ boolean dataDriven = _operator_equals_2;
+ boolean _operator_or = false;
+ if (async) {
+ _operator_or = true;
+ } else {
+ _operator_or = BooleanExtensions.operator_or(async, eventDriven);
+ }
+ boolean handleEvents = _operator_or;
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.newLine();
+ _builder.append("/* state IDs */");
+ _builder.newLine();
+ String _genStateIdConstants = this.genStateIdConstants(xpac, ac);
+ _builder.append(_genStateIdConstants, "");
+ _builder.newLineIfNotEmpty();
+ _builder.newLine();
+ _builder.append("/* transition chains */");
+ _builder.newLine();
+ String _genTransitionChainConstants = this.genTransitionChainConstants(xpac, ac);
+ _builder.append(_genTransitionChainConstants, "");
+ _builder.newLineIfNotEmpty();
+ _builder.newLine();
+ _builder.append("/* triggers */");
+ _builder.newLine();
+ String _genTriggerConstants = this.genTriggerConstants(xpac, ac);
+ _builder.append(_genTriggerConstants, "");
+ _builder.newLineIfNotEmpty();
+ _builder.newLine();
+ StringConcatenation _genExtra = this.genExtra(xpac, ac);
+ _builder.append(_genExtra, "");
+ _builder.newLineIfNotEmpty();
+ _builder.newLine();
+ _builder.append("/* Entry and Exit Codes */");
+ _builder.newLine();
+ {
+ StateGraph _stateMachine = xpac.getStateMachine();
+ List<State> _stateList = this.roomExt.getStateList(_stateMachine);
+ for(final State state : _stateList) {
+ {
+ boolean _operator_or_1 = false;
+ boolean _usesInheritance = this.langExt.usesInheritance();
+ boolean _operator_not = BooleanExtensions.operator_not(_usesInheritance);
+ if (_operator_not) {
+ _operator_or_1 = true;
+ } else {
+ boolean _isOwnObject = xpac.isOwnObject(state);
+ _operator_or_1 = BooleanExtensions.operator_or(_operator_not, _isOwnObject);
+ }
+ if (_operator_or_1) {
+ {
+ boolean _hasEntryCode = this.roomExt.hasEntryCode(state);
+ if (_hasEntryCode) {
+ String _accessLevelProtected = this.langExt.accessLevelProtected();
+ _builder.append(_accessLevelProtected, "");
+ _builder.append("void ");
+ String _entryCodeOperationName = RoomNameProv.getEntryCodeOperationName(state);
+ _builder.append(_entryCodeOperationName, "");
+ _builder.append("(");
+ String _name = ac.getName();
+ String _selfPointer = this.langExt.selfPointer(_name, false);
+ _builder.append(_selfPointer, "");
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _entryCode = this.roomExt.getEntryCode(xpac, state, dct);
+ _builder.append(_entryCode, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ {
+ boolean _hasExitCode = this.roomExt.hasExitCode(state);
+ if (_hasExitCode) {
+ String _accessLevelProtected_1 = this.langExt.accessLevelProtected();
+ _builder.append(_accessLevelProtected_1, "");
+ _builder.append("void ");
+ String _exitCodeOperationName = RoomNameProv.getExitCodeOperationName(state);
+ _builder.append(_exitCodeOperationName, "");
+ _builder.append("(");
+ String _name_1 = ac.getName();
+ String _selfPointer_1 = this.langExt.selfPointer(_name_1, false);
+ _builder.append(_selfPointer_1, "");
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _exitCode = this.roomExt.getExitCode(xpac, state, dct);
+ _builder.append(_exitCode, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ {
+ boolean _hasDoCode = this.roomExt.hasDoCode(state);
+ if (_hasDoCode) {
+ _builder.append("static void ");
+ String _doCodeOperationName = RoomNameProv.getDoCodeOperationName(state);
+ _builder.append(_doCodeOperationName, "");
+ _builder.append("(");
+ String _name_2 = ac.getName();
+ String _selfPointer_2 = this.langExt.selfPointer(_name_2, false);
+ _builder.append(_selfPointer_2, "");
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _doCode = this.roomExt.getDoCode(xpac, state, dct);
+ _builder.append(_doCode, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ }
+ }
+ _builder.newLine();
+ _builder.append("/* Action Codes */");
+ _builder.newLine();
+ {
+ StateGraph _stateMachine_1 = xpac.getStateMachine();
+ List<Transition> _transitionList = this.roomExt.getTransitionList(_stateMachine_1);
+ for(final Transition tr : _transitionList) {
+ {
+ boolean _operator_and = false;
+ boolean _isOwnObject_1 = xpac.isOwnObject(tr);
+ if (!_isOwnObject_1) {
+ _operator_and = false;
+ } else {
+ boolean _hasActionCode = this.roomExt.hasActionCode(tr);
+ _operator_and = BooleanExtensions.operator_and(_isOwnObject_1, _hasActionCode);
+ }
+ if (_operator_and) {
+ TransitionChain _chain = xpac.getChain(tr);
+ Transition _transition = _chain.getTransition();
+ Transition start = _transition;
+ _builder.newLineIfNotEmpty();
+ boolean _operator_and_1 = false;
+ if (!(start instanceof NonInitialTransition)) {
+ _operator_and_1 = false;
+ } else {
+ boolean _operator_not_1 = BooleanExtensions.operator_not((start instanceof GuardedTransition));
+ _operator_and_1 = BooleanExtensions.operator_and((start instanceof NonInitialTransition), _operator_not_1);
+ }
+ boolean hasArgs = _operator_and_1;
+ _builder.newLineIfNotEmpty();
+ String _accessLevelProtected_2 = this.langExt.accessLevelProtected();
+ _builder.append(_accessLevelProtected_2, "");
+ _builder.append("void ");
+ String _actionCodeOperationName = RoomNameProv.getActionCodeOperationName(tr);
+ _builder.append(_actionCodeOperationName, "");
+ _builder.append("(");
+ String _name_3 = ac.getName();
+ String _selfPointer_3 = this.langExt.selfPointer(_name_3, hasArgs);
+ _builder.append(_selfPointer_3, "");
+ {
+ if (hasArgs) {
+ _builder.append("InterfaceItemBase ifitem");
+ String _argumentList = this.languageGen.getArgumentList(xpac, tr);
+ _builder.append(_argumentList, "");
+ }
+ }
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _actionCode = this.roomExt.getActionCode(xpac, tr, dct);
+ _builder.append(_actionCode, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ _builder.newLine();
+ _builder.append("/**");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* calls exit codes while exiting from the current state to one of its");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* parent states while remembering the history");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param current - the current state");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param to - the final parent state");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param handler - entry and exit codes are called only if not handler (for handler TransitionPoints)");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("*/");
+ _builder.newLine();
+ String _accessLevelPrivate = this.langExt.accessLevelPrivate();
+ _builder.append(_accessLevelPrivate, "");
+ _builder.append("void exitTo(");
+ String _name_4 = ac.getName();
+ String _selfPointer_4 = this.langExt.selfPointer(_name_4, true);
+ _builder.append(_selfPointer_4, "");
+ _builder.append("int current, int to, boolean handler) {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("while (current!=to) {");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("switch (current) {");
+ _builder.newLine();
+ {
+ StateGraph _stateMachine_2 = xpac.getStateMachine();
+ List<State> _baseStateList = this.roomExt.getBaseStateList(_stateMachine_2);
+ for(final State state_1 : _baseStateList) {
+ _builder.append("\t\t\t");
+ _builder.append("case ");
+ String _stateId = this.roomExt.getStateId(state_1);
+ _builder.append(_stateId, " ");
+ _builder.append(":");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ {
+ boolean _hasExitCode_1 = this.roomExt.hasExitCode(state_1);
+ if (_hasExitCode_1) {
+ _builder.append("if (!handler) ");
+ String _exitCodeOperationName_1 = RoomNameProv.getExitCodeOperationName(state_1);
+ _builder.append(_exitCodeOperationName_1, " ");
+ _builder.append("(");
+ String _selfPointer_5 = this.langExt.selfPointer(false);
+ _builder.append(_selfPointer_5, " ");
+ _builder.append(");");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ String _memberAccess = this.langExt.memberAccess();
+ _builder.append(_memberAccess, " ");
+ _builder.append("history[");
+ String _parentStateId = RoomNameProv.getParentStateId(state_1);
+ _builder.append(_parentStateId, " ");
+ _builder.append("] = ");
+ String _stateId_1 = this.roomExt.getStateId(state_1);
+ _builder.append(_stateId_1, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("current = ");
+ String _parentStateId_1 = RoomNameProv.getParentStateId(state_1);
+ _builder.append(_parentStateId_1, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("break;");
+ _builder.newLine();
+ }
+ }
+ _builder.append("\t\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("}");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("/**");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* calls action, entry and exit codes along a transition chain. The generic data are cast to typed data");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* matching the trigger of this chain. The ID of the final state is returned");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param chain - the chain ID");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param generic_data - the generic data pointer");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @return the ID of the final state");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("*/");
+ _builder.newLine();
+ String _accessLevelPrivate_1 = this.langExt.accessLevelPrivate();
+ _builder.append(_accessLevelPrivate_1, "");
+ _builder.append("int executeTransitionChain(");
+ String _name_5 = ac.getName();
+ String _selfPointer_6 = this.langExt.selfPointer(_name_5, true);
+ _builder.append(_selfPointer_6, "");
+ _builder.append("int chain");
+ {
+ if (handleEvents) {
+ _builder.append(", InterfaceItemBase ifitem, ");
+ String _voidPointer = this.langExt.voidPointer();
+ _builder.append(_voidPointer, "");
+ _builder.append(" generic_data");
+ }
+ }
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("switch (chain) {");
+ _builder.newLine();
+ _builder.append("\t\t");
+ EList<TransitionChain> _transitionChains = xpac.getTransitionChains();
+ EList<TransitionChain> allchains = _transitionChains;
+ _builder.newLineIfNotEmpty();
+ {
+ for(final TransitionChain tc : allchains) {
+ _builder.append("\t\t");
+ _builder.append("case ");
+ String _chainId = this.roomExt.getChainId(tc);
+ _builder.append(_chainId, " ");
+ _builder.append(":");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("{");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("\t");
+ String _executeChain = this.languageGen.getExecuteChain(xpac, tc, dct);
+ _builder.append(_executeChain, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("return NO_STATE;");
+ _builder.newLine();
+ _builder.append("}");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("/**");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* calls entry codes while entering a state\'s history. The ID of the final leaf state is returned");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param state - the state which is entered");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @param handler - entry code is executed if not handler");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("* @return - the ID of the final leaf state");
+ _builder.newLine();
+ _builder.append(" ");
+ _builder.append("*/");
+ _builder.newLine();
+ String _accessLevelPrivate_2 = this.langExt.accessLevelPrivate();
+ _builder.append(_accessLevelPrivate_2, "");
+ _builder.append("int enterHistory(");
+ String _name_6 = ac.getName();
+ String _selfPointer_7 = this.langExt.selfPointer(_name_6, true);
+ _builder.append(_selfPointer_7, "");
+ _builder.append("int state, boolean handler, boolean skip_entry) {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("while (");
+ String _booleanConstant = this.langExt.booleanConstant(true);
+ _builder.append(_booleanConstant, " ");
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("switch (state) {");
+ _builder.newLine();
+ {
+ StateGraph _stateMachine_3 = xpac.getStateMachine();
+ List<State> _baseStateList_1 = this.roomExt.getBaseStateList(_stateMachine_3);
+ for(final State state_2 : _baseStateList_1) {
+ _builder.append("\t\t\t");
+ _builder.append("case ");
+ String _stateId_2 = this.roomExt.getStateId(state_2);
+ _builder.append(_stateId_2, " ");
+ _builder.append(":");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ {
+ boolean _hasEntryCode_1 = this.roomExt.hasEntryCode(state_2);
+ if (_hasEntryCode_1) {
+ _builder.append("if (!(skip_entry || handler)) ");
+ String _entryCodeOperationName_1 = RoomNameProv.getEntryCodeOperationName(state_2);
+ _builder.append(_entryCodeOperationName_1, " ");
+ _builder.append("(");
+ String _selfPointer_8 = this.langExt.selfPointer(false);
+ _builder.append(_selfPointer_8, " ");
+ _builder.append(");");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ {
+ boolean _isLeaf = this.roomExt.isLeaf(state_2);
+ if (_isLeaf) {
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("// in leaf state: return state id");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("return ");
+ String _stateId_3 = this.roomExt.getStateId(state_2);
+ _builder.append(_stateId_3, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ } else {
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("// state has a sub graph");
+ _builder.newLine();
+ {
+ StateGraph _subgraph = state_2.getSubgraph();
+ boolean _hasInitTransition = this.roomExt.hasInitTransition(_subgraph);
+ if (_hasInitTransition) {
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("// with init transition");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("if (");
+ String _memberAccess_1 = this.langExt.memberAccess();
+ _builder.append(_memberAccess_1, " ");
+ _builder.append("history[");
+ String _stateId_4 = this.roomExt.getStateId(state_2);
+ _builder.append(_stateId_4, " ");
+ _builder.append("]==NO_STATE) {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ StateGraph _subgraph_1 = state_2.getSubgraph();
+ Transition _initTransition = this.roomExt.getInitTransition(_subgraph_1);
+ Transition sub_initt = _initTransition;
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("state = executeTransitionChain(");
+ String _selfPointer_9 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_9, " ");
+ TransitionChain _chain_1 = xpac.getChain(sub_initt);
+ String _chainId_1 = this.roomExt.getChainId(_chain_1);
+ _builder.append(_chainId_1, " ");
+ {
+ if (handleEvents) {
+ _builder.append(", ");
+ String _nullPointer = this.langExt.nullPointer();
+ _builder.append(_nullPointer, " ");
+ _builder.append(", ");
+ String _nullPointer_1 = this.langExt.nullPointer();
+ _builder.append(_nullPointer_1, " ");
+ }
+ }
+ _builder.append(");");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("else {");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("state = ");
+ String _memberAccess_2 = this.langExt.memberAccess();
+ _builder.append(_memberAccess_2, " ");
+ _builder.append("history[");
+ String _stateId_5 = this.roomExt.getStateId(state_2);
+ _builder.append(_stateId_5, " ");
+ _builder.append("];");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ } else {
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("// without init transition");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("state = ");
+ String _memberAccess_3 = this.langExt.memberAccess();
+ _builder.append(_memberAccess_3, " ");
+ _builder.append("history[");
+ String _stateId_6 = this.roomExt.getStateId(state_2);
+ _builder.append(_stateId_6, " ");
+ _builder.append("];");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _builder.append("\t\t\t");
+ _builder.append("\t");
+ _builder.append("break;");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ _builder.append("\t\t\t");
+ _builder.append("case STATE_TOP:");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("state = ");
+ String _memberAccess_4 = this.langExt.memberAccess();
+ _builder.append(_memberAccess_4, " ");
+ _builder.append("history[STATE_TOP];");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t\t\t");
+ _builder.append("break;");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("skip_entry = ");
+ String _booleanConstant_1 = this.langExt.booleanConstant(false);
+ _builder.append(_booleanConstant_1, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("//return NO_STATE; // required by CDT but detected as unreachable by JDT because of while (true)");
+ _builder.newLine();
+ _builder.append("}");
+ _builder.newLine();
+ _builder.newLine();
+ {
+ boolean _usesInheritance_1 = this.langExt.usesInheritance();
+ if (_usesInheritance_1) {
+ String _accessLevelPublic = this.langExt.accessLevelPublic();
+ _builder.append(_accessLevelPublic, "");
+ } else {
+ String _accessLevelPrivate_3 = this.langExt.accessLevelPrivate();
+ _builder.append(_accessLevelPrivate_3, "");
+ }
+ }
+ _builder.append("void executeInitTransition(");
+ String _name_7 = ac.getName();
+ String _selfPointer_10 = this.langExt.selfPointer(_name_7, false);
+ _builder.append(_selfPointer_10, "");
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ StateGraph _stateMachine_4 = xpac.getStateMachine();
+ Transition _initTransition_1 = this.roomExt.getInitTransition(_stateMachine_4);
+ Transition initt = _initTransition_1;
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("int chain = ");
+ TransitionChain _chain_2 = xpac.getChain(initt);
+ String _chainId_2 = this.roomExt.getChainId(_chain_2);
+ _builder.append(_chainId_2, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("int next = executeTransitionChain(");
+ String _selfPointer_11 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_11, " ");
+ _builder.append("chain");
+ {
+ if (handleEvents) {
+ _builder.append(", ");
+ String _nullPointer_2 = this.langExt.nullPointer();
+ _builder.append(_nullPointer_2, " ");
+ _builder.append(", ");
+ String _nullPointer_3 = this.langExt.nullPointer();
+ _builder.append(_nullPointer_3, " ");
+ }
+ }
+ _builder.append(");");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("next = enterHistory(");
+ String _selfPointer_12 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_12, " ");
+ _builder.append("next, ");
+ String _booleanConstant_2 = this.langExt.booleanConstant(false);
+ _builder.append(_booleanConstant_2, " ");
+ _builder.append(", ");
+ String _booleanConstant_3 = this.langExt.booleanConstant(false);
+ _builder.append(_booleanConstant_3, " ");
+ _builder.append(");");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("setState(");
+ String _selfPointer_13 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_13, " ");
+ _builder.append("next);");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("/* receiveEvent contains the main implementation of the FSM */");
+ _builder.newLine();
+ {
+ boolean _usesInheritance_2 = this.langExt.usesInheritance();
+ if (_usesInheritance_2) {
+ String _accessLevelPublic_1 = this.langExt.accessLevelPublic();
+ _builder.append(_accessLevelPublic_1, "");
+ } else {
+ String _accessLevelPrivate_4 = this.langExt.accessLevelPrivate();
+ _builder.append(_accessLevelPrivate_4, "");
+ }
+ }
+ _builder.append("void receiveEvent(");
+ String _name_8 = ac.getName();
+ String _selfPointer_14 = this.langExt.selfPointer(_name_8, handleEvents);
+ _builder.append(_selfPointer_14, "");
+ {
+ if (handleEvents) {
+ _builder.append("InterfaceItemBase ifitem, int evt, ");
+ String _voidPointer_1 = this.langExt.voidPointer();
+ _builder.append(_voidPointer_1, "");
+ _builder.append(" generic_data");
+ }
+ }
+ _builder.append(") {");
+ _builder.newLineIfNotEmpty();
+ {
+ if (async) {
+ _builder.append("\t");
+ _builder.append("int trigger = (ifitem==");
+ String _nullPointer_4 = this.langExt.nullPointer();
+ _builder.append(_nullPointer_4, " ");
+ _builder.append(")? POLLING : ");
+ {
+ boolean _usesInheritance_3 = this.langExt.usesInheritance();
+ if (_usesInheritance_3) {
+ _builder.append("ifitem.getLocalId()");
+ } else {
+ _builder.append("ifitem->localId");
+ }
+ }
+ _builder.append(" + EVT_SHIFT*evt;");
+ _builder.newLineIfNotEmpty();
+ } else {
+ if (eventDriven) {
+ _builder.append("\t");
+ _builder.append("int trigger = ");
+ {
+ boolean _usesInheritance_4 = this.langExt.usesInheritance();
+ if (_usesInheritance_4) {
+ _builder.append("ifitem.getLocalId()");
+ } else {
+ _builder.append("ifitem->localId");
+ }
+ }
+ _builder.append(" + EVT_SHIFT*evt;");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ }
+ _builder.append("\t");
+ _builder.append("int chain = NOT_CAUGHT;");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("int catching_state = NO_STATE;");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("boolean is_handler = ");
+ String _booleanConstant_4 = this.langExt.booleanConstant(false);
+ _builder.append(_booleanConstant_4, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("boolean skip_entry = ");
+ String _booleanConstant_5 = this.langExt.booleanConstant(false);
+ _builder.append(_booleanConstant_5, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.newLine();
+ {
+ if (handleEvents) {
+ _builder.append("\t");
+ _builder.append("if (!handleSystemEvent(ifitem, evt, generic_data)) {");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ StringConcatenation _genStateSwitch = this.genStateSwitch(xpac, dct);
+ _builder.append(_genStateSwitch, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ } else {
+ _builder.append("\t");
+ StringConcatenation _genStateSwitch_1 = this.genStateSwitch(xpac, dct);
+ _builder.append(_genStateSwitch_1, " ");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _builder.append("\t");
+ _builder.append("if (chain != NOT_CAUGHT) {");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("exitTo(");
+ String _selfPointer_15 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_15, " ");
+ String _memberAccess_5 = this.langExt.memberAccess();
+ _builder.append(_memberAccess_5, " ");
+ _builder.append("state, catching_state, is_handler);");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("int next = executeTransitionChain(");
+ String _selfPointer_16 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_16, " ");
+ _builder.append("chain");
+ {
+ if (handleEvents) {
+ _builder.append(", ifitem, generic_data");
+ }
+ }
+ _builder.append(");");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("next = enterHistory(");
+ String _selfPointer_17 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_17, " ");
+ _builder.append("next, is_handler, skip_entry);");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t\t");
+ _builder.append("setState(");
+ String _selfPointer_18 = this.langExt.selfPointer(true);
+ _builder.append(_selfPointer_18, " ");
+ _builder.append("next);");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("}");
+ _builder.newLine();
+ _builder.append("\t ");
+ _builder.newLine();
+ _builder.append("//******************************************");
+ _builder.newLine();
+ _builder.append("// END of generated code for FSM");
+ _builder.newLine();
+ _builder.append("//******************************************");
+ _builder.newLine();
+ _xblockexpression = (_builder);
+ }
+ return _xblockexpression;
+ }
+
+ private StringConcatenation genStateSwitch(final ExpandedActorClass xpac, final DetailCodeTranslator dct) {
+ StringConcatenation _xblockexpression = null;
+ {
+ ActorClass _actorClass = xpac.getActorClass();
+ ActorCommunicationType _commType = _actorClass.getCommType();
+ boolean _operator_equals = ObjectExtensions.operator_equals(_commType, ActorCommunicationType.ASYNCHRONOUS);
+ boolean async = _operator_equals;
+ ActorClass _actorClass_1 = xpac.getActorClass();
+ ActorCommunicationType _commType_1 = _actorClass_1.getCommType();
+ boolean _operator_equals_1 = ObjectExtensions.operator_equals(_commType_1, ActorCommunicationType.EVENT_DRIVEN);
+ boolean eventDriven = _operator_equals_1;
+ ActorClass _actorClass_2 = xpac.getActorClass();
+ ActorCommunicationType _commType_2 = _actorClass_2.getCommType();
+ boolean _operator_equals_2 = ObjectExtensions.operator_equals(_commType_2, ActorCommunicationType.DATA_DRIVEN);
+ boolean dataDriven = _operator_equals_2;
+ boolean _operator_or = false;
+ if (async) {
+ _operator_or = true;
+ } else {
+ _operator_or = BooleanExtensions.operator_or(async, eventDriven);
+ }
+ boolean handleEvents = _operator_or;
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("switch (");
+ String _memberAccess = this.langExt.memberAccess();
+ _builder.append(_memberAccess, "");
+ _builder.append("state) {");
+ _builder.newLineIfNotEmpty();
+ {
+ StateGraph _stateMachine = xpac.getStateMachine();
+ List<State> _leafStateList = this.roomExt.getLeafStateList(_stateMachine);
+ for(final State state : _leafStateList) {
+ _builder.append("\t");
+ _builder.append("case ");
+ String _stateId = this.roomExt.getStateId(state);
+ _builder.append(_stateId, " ");
+ _builder.append(":");
+ _builder.newLineIfNotEmpty();
+ {
+ if (async) {
+ _builder.append("\t");
+ _builder.append("\t");
+ EList<ActiveTrigger> _activeTriggers = xpac.getActiveTriggers(state);
+ EList<ActiveTrigger> atlist = _activeTriggers;
+ _builder.newLineIfNotEmpty();
+ {
+ boolean _isEmpty = atlist.isEmpty();
+ boolean _operator_not = BooleanExtensions.operator_not(_isEmpty);
+ if (_operator_not) {
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("switch(trigger) {");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("case POLLING:");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ StringConcatenation _genDataDrivenTriggers = this.genDataDrivenTriggers(xpac, state, dct);
+ _builder.append(_genDataDrivenTriggers, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("break;");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ StringConcatenation _genEventDrivenTriggers = this.genEventDrivenTriggers(xpac, state, atlist, dct);
+ _builder.append(_genEventDrivenTriggers, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ } else {
+ if (dataDriven) {
+ _builder.append("\t");
+ _builder.append("\t");
+ StringConcatenation _genDataDrivenTriggers_1 = this.genDataDrivenTriggers(xpac, state, dct);
+ _builder.append(_genDataDrivenTriggers_1, " ");
+ _builder.newLineIfNotEmpty();
+ } else {
+ if (eventDriven) {
+ _builder.append("\t");
+ _builder.append("\t");
+ EList<ActiveTrigger> _activeTriggers_1 = xpac.getActiveTriggers(state);
+ EList<ActiveTrigger> atlist_1 = _activeTriggers_1;
+ _builder.newLineIfNotEmpty();
+ {
+ boolean _isEmpty_1 = atlist_1.isEmpty();
+ boolean _operator_not_1 = BooleanExtensions.operator_not(_isEmpty_1);
+ if (_operator_not_1) {
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("switch(trigger) {");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("\t");
+ StringConcatenation _genEventDrivenTriggers_1 = this.genEventDrivenTriggers(xpac, state, atlist_1, dct);
+ _builder.append(_genEventDrivenTriggers_1, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ }
+ }
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("break;");
+ _builder.newLine();
+ }
+ }
+ _builder.append("}");
+ _builder.newLine();
+ _xblockexpression = (_builder);
+ }
+ return _xblockexpression;
+ }
+
+ private StringConcatenation genDataDrivenTriggers(final ExpandedActorClass xpac, final State state, final DetailCodeTranslator dct) {
+ StringConcatenation _builder = new StringConcatenation();
+ StringConcatenation _genDoCodes = this.genDoCodes(state);
+ _builder.append(_genDoCodes, "");
+ _builder.newLineIfNotEmpty();
+ List<Transition> _outgoingTransitionsHierarchical = this.roomExt.getOutgoingTransitionsHierarchical(xpac, state);
+ final Function1<Transition,Boolean> _function = new Function1<Transition,Boolean>() {
+ public Boolean apply(final Transition t) {
+ return ((Boolean)(t instanceof GuardedTransition));
+ }
+ };
+ Iterable<Transition> _filter = IterableExtensions.<Transition>filter(_outgoingTransitionsHierarchical, _function);
+ Iterable<Transition> transitions = _filter;
+ _builder.newLineIfNotEmpty();
+ {
+ for(final Transition tr : transitions) {
+ _builder.append("if (");
+ DetailCode _guard = ((GuardedTransition) tr).getGuard();
+ String _translateDetailCode = dct.translateDetailCode(_guard);
+ _builder.append(_translateDetailCode, "");
+ _builder.append(")");
+ _builder.newLineIfNotEmpty();
+ _builder.append("{");
+ _builder.newLine();
+ _builder.append("\t");
+ TransitionChain _chain = xpac.getChain(tr);
+ TransitionChain chain = _chain;
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("chain = ");
+ String _chainId = this.roomExt.getChainId(chain);
+ _builder.append(_chainId, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("catching_state = ");
+ String _contextId = this.roomExt.getContextId(chain);
+ _builder.append(_contextId, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ {
+ boolean _isHandler = chain.isHandler();
+ if (_isHandler) {
+ _builder.append("is_handler = TRUE;");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ {
+ boolean _isSkipEntry = chain.isSkipEntry();
+ if (_isSkipEntry) {
+ _builder.append("skip_entry = TRUE;");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ {
+ Transition _last = IterableExtensions.<Transition>last(transitions);
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(tr, _last);
+ if (_operator_notEquals) {
+ _builder.append("else ");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ private StringConcatenation genEventDrivenTriggers(final ExpandedActorClass xpac, final State state, final List<ActiveTrigger> atlist, final DetailCodeTranslator dct) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ for(final ActiveTrigger at : atlist) {
+ _builder.append("case ");
+ String _trigger = at.getTrigger();
+ String _triggerCodeName = xpac.getTriggerCodeName(_trigger);
+ _builder.append(_triggerCodeName, "");
+ _builder.append(":");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ boolean _hasGuard = this.roomExt.hasGuard(xpac, at);
+ boolean needData = _hasGuard;
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ {
+ if (needData) {
+ _builder.append("{ ");
+ Message _msg = at.getMsg();
+ String _typedDataDefinition = this.langExt.getTypedDataDefinition(_msg);
+ _builder.append(_typedDataDefinition, " ");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ {
+ EList<TriggeredTransition> _transitions = at.getTransitions();
+ boolean hasAnyElements = false;
+ for(final TriggeredTransition tt : _transitions) {
+ if (!hasAnyElements) {
+ hasAnyElements = true;
+ } else {
+ _builder.appendImmediate(" else ", " ");
+ }
+ _builder.append("\t");
+ TransitionChain _chain = xpac.getChain(tt);
+ TransitionChain chain = _chain;
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ Transition _transition = chain.getTransition();
+ String _trigger_1 = at.getTrigger();
+ StringConcatenation _guard = this.guard(_transition, _trigger_1, xpac, dct);
+ _builder.append(_guard, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("{");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("chain = ");
+ String _chainId = this.roomExt.getChainId(chain);
+ _builder.append(_chainId, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ _builder.append("catching_state = ");
+ String _contextId = this.roomExt.getContextId(chain);
+ _builder.append(_contextId, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ {
+ boolean _isHandler = chain.isHandler();
+ if (_isHandler) {
+ _builder.append("is_handler = ");
+ String _booleanConstant = this.langExt.booleanConstant(true);
+ _builder.append(_booleanConstant, " ");
+ _builder.append(";");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("\t");
+ {
+ boolean _isSkipEntry = chain.isSkipEntry();
+ if (_isSkipEntry) {
+ _builder.append("skip_entry = ");
+ String _booleanConstant_1 = this.langExt.booleanConstant(true);
+ _builder.append(_booleanConstant_1, " ");
+ _builder.append(";");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ _builder.append("\t");
+ {
+ if (needData) {
+ _builder.append("}");
+ }
+ }
+ _builder.newLineIfNotEmpty();
+ _builder.append("break;");
+ _builder.newLine();
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation genExtra(final ExpandedActorClass xpac, final ActorClass ac) {
+ StringConcatenation _builder = new StringConcatenation();
+ return _builder;
+ }
+
+ private StringConcatenation _guard(final TriggeredTransition tt, final String trigger, final ExpandedActorClass ac, final DetailCodeTranslator dct) {
+ StringConcatenation _xblockexpression = null;
+ {
+ EList<Trigger> _triggers = tt.getTriggers();
+ final Function1<Trigger,Boolean> _function = new Function1<Trigger,Boolean>() {
+ public Boolean apply(final Trigger e) {
+ boolean _isMatching = ac.isMatching(e, trigger);
+ return ((Boolean)_isMatching);
+ }
+ };
+ Trigger _findFirst = IterableExtensions.<Trigger>findFirst(_triggers, _function);
+ Trigger tr = _findFirst;
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ boolean _hasGuard = this.roomExt.hasGuard(tr);
+ if (_hasGuard) {
+ _builder.append("if (");
+ Guard _guard = tr.getGuard();
+ DetailCode _guard_1 = _guard.getGuard();
+ String _translateDetailCode = dct.translateDetailCode(_guard_1);
+ _builder.append(_translateDetailCode, "");
+ _builder.append(")");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _xblockexpression = (_builder);
+ }
+ return _xblockexpression;
+ }
+
+ private StringConcatenation _guard(final Transition t, final String trigger, final ExpandedActorClass ac, final DetailCodeTranslator dct) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("/* error */");
+ _builder.newLine();
+ return _builder;
+ }
+
+ private StringConcatenation genDoCodes(final State state) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ boolean _hasDoCode = this.roomExt.hasDoCode(state);
+ if (_hasDoCode) {
+ String _doCodeOperationName = RoomNameProv.getDoCodeOperationName(state);
+ _builder.append(_doCodeOperationName, "");
+ _builder.append("(self);");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ {
+ EObject _eContainer = state.eContainer();
+ EObject _eContainer_1 = _eContainer.eContainer();
+ if ((_eContainer_1 instanceof State)) {
+ EObject _eContainer_2 = state.eContainer();
+ EObject _eContainer_3 = _eContainer_2.eContainer();
+ StringConcatenation _genDoCodes = this.genDoCodes(((State) _eContainer_3));
+ _builder.append(_genDoCodes, "");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ return _builder;
+ }
+
+ private StringConcatenation guard(final Transition tt, final String trigger, final ExpandedActorClass ac, final DetailCodeTranslator dct) {
+ if (tt instanceof TriggeredTransition) {
+ return _guard((TriggeredTransition)tt, trigger, ac, dct);
+ } else {
+ return _guard(tt, trigger, ac, dct);
+ }
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java new file mode 100644 index 000000000..d12a0c7d9 --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/ProcedureHelpers.java @@ -0,0 +1,653 @@ +package org.eclipse.etrice.generator.generic;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.etrice.core.room.ActorClass;
+import org.eclipse.etrice.core.room.Attribute;
+import org.eclipse.etrice.core.room.ComplexType;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.DetailCode;
+import org.eclipse.etrice.core.room.Operation;
+import org.eclipse.etrice.core.room.RefableType;
+import org.eclipse.etrice.core.room.StandardOperation;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.core.room.util.RoomHelpers;
+import org.eclipse.etrice.generator.base.DetailCodeTranslator;
+import org.eclipse.etrice.generator.base.ILogger;
+import org.eclipse.etrice.generator.base.ITranslationProvider;
+import org.eclipse.etrice.generator.generic.ILanguageExtension;
+import org.eclipse.etrice.generator.generic.TypeHelpers;
+import org.eclipse.xtext.xbase.lib.BooleanExtensions;
+import org.eclipse.xtext.xbase.lib.ComparableExtensions;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+import org.eclipse.xtext.xtend2.lib.StringConcatenation;
+
+@SuppressWarnings("all")
+@Singleton
+public class ProcedureHelpers {
+ @Inject
+ private ILanguageExtension languageExt;
+
+ @Inject
+ public ITranslationProvider translator;
+
+ @Inject
+ private TypeHelpers _typeHelpers;
+
+ @Inject
+ private ILogger logger;
+
+ public StringConcatenation userCode(final DetailCode dc) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(dc, null);
+ if (_operator_notEquals) {
+ _builder.append("/*--------------------- begin user code ---------------------*/");
+ _builder.newLine();
+ {
+ EList<String> _commands = dc.getCommands();
+ for(final String command : _commands) {
+ _builder.append("\t");
+ _builder.append(command, "");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _builder.append("/*--------------------- end user code ---------------------*/");
+ _builder.newLine();
+ }
+ }
+ return _builder;
+ }
+
+ /**
+ * TODO: add ref type
+ */
+ public StringConcatenation attributes(final List<Attribute> attribs) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("/*--------------------- attributes ---------------------*/");
+ _builder.newLine();
+ {
+ for(final Attribute attribute : attribs) {
+ {
+ int _size = attribute.getSize();
+ boolean _operator_equals = ObjectExtensions.operator_equals(((Integer)_size), ((Integer)0));
+ if (_operator_equals) {
+ RefableType _refType = attribute.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ _builder.append(" ");
+ String _name = attribute.getName();
+ _builder.append(_name, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ } else {
+ RefableType _refType_1 = attribute.getRefType();
+ DataType _type_1 = _refType_1.getType();
+ String _typeName_1 = this._typeHelpers.typeName(_type_1);
+ int _size_1 = attribute.getSize();
+ String _name_1 = attribute.getName();
+ String _arrayDeclaration = this.languageExt.arrayDeclaration(_typeName_1, _size_1, _name_1);
+ _builder.append(_arrayDeclaration, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ public String arrayInitializer(final Attribute att) {
+ String _xifexpression = null;
+ String _defaultValueLiteral = att.getDefaultValueLiteral();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_defaultValueLiteral, null);
+ if (_operator_notEquals) {
+ String _defaultValueLiteral_1 = att.getDefaultValueLiteral();
+ _xifexpression = _defaultValueLiteral_1;
+ } else {
+ RefableType _refType = att.getRefType();
+ DataType _type = _refType.getType();
+ String _defaultValue = this._typeHelpers.defaultValue(_type);
+ _xifexpression = _defaultValue;
+ }
+ String dflt = _xifexpression;
+ boolean _startsWith = dflt.startsWith("{");
+ if (_startsWith) {
+ {
+ String[] _split = dflt.split(",");
+ int _size = ((List<String>)Conversions.doWrapArray(_split)).size();
+ int _size_1 = att.getSize();
+ boolean _operator_notEquals_1 = ObjectExtensions.operator_notEquals(((Integer)_size), ((Integer)_size_1));
+ if (_operator_notEquals_1) {
+ String _name = att.getName();
+ String _operator_plus = StringExtensions.operator_plus("WARNING: array size determined by initializer differs from attribute size (", _name);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, "[");
+ int _size_2 = att.getSize();
+ String _operator_plus_2 = StringExtensions.operator_plus(_operator_plus_1, ((Integer)_size_2));
+ String _operator_plus_3 = StringExtensions.operator_plus(_operator_plus_2, "] <-> ");
+ String _operator_plus_4 = StringExtensions.operator_plus(_operator_plus_3, dflt);
+ String _operator_plus_5 = StringExtensions.operator_plus(_operator_plus_4, ")");
+ this.logger.logInfo(_operator_plus_5);
+ }
+ return dflt;
+ }
+ }
+ String result = "{";
+ int i = 0;
+ int _size_3 = att.getSize();
+ boolean _operator_lessThan = ComparableExtensions.<Integer>operator_lessThan(((Integer)i), ((Integer)_size_3));
+ Boolean _xwhileexpression = _operator_lessThan;
+ while (_xwhileexpression) {
+ {
+ String _operator_plus_6 = StringExtensions.operator_plus(result, dflt);
+ result = _operator_plus_6;
+ int _operator_plus_7 = IntegerExtensions.operator_plus(((Integer)i), ((Integer)1));
+ i = _operator_plus_7;
+ int _size_4 = att.getSize();
+ boolean _operator_lessThan_1 = ComparableExtensions.<Integer>operator_lessThan(((Integer)i), ((Integer)_size_4));
+ if (_operator_lessThan_1) {
+ String _operator_plus_8 = StringExtensions.operator_plus(result, ", ");
+ result = _operator_plus_8;
+ }
+ }
+ int _size_5 = att.getSize();
+ boolean _operator_lessThan_2 = ComparableExtensions.<Integer>operator_lessThan(((Integer)i), ((Integer)_size_5));
+ _xwhileexpression = _operator_lessThan_2;
+ }
+ String _operator_plus_9 = StringExtensions.operator_plus(result, "}");
+ return _operator_plus_9;
+ }
+
+ public StringConcatenation attributeInitialization(final List<Attribute> attribs, final boolean useClassDefaultsOnly) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("// initialize attributes");
+ _builder.newLine();
+ {
+ for(final Attribute a : attribs) {
+ {
+ String _defaultValueLiteral = a.getDefaultValueLiteral();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(_defaultValueLiteral, null);
+ if (_operator_notEquals) {
+ {
+ int _size = a.getSize();
+ boolean _operator_equals = ObjectExtensions.operator_equals(((Integer)_size), ((Integer)0));
+ if (_operator_equals) {
+ String _name = a.getName();
+ _builder.append(_name, "");
+ _builder.append(" = ");
+ String _defaultValueLiteral_1 = a.getDefaultValueLiteral();
+ _builder.append(_defaultValueLiteral_1, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ } else {
+ String _defaultValueLiteral_2 = a.getDefaultValueLiteral();
+ boolean _startsWith = _defaultValueLiteral_2.startsWith("{");
+ if (_startsWith) {
+ String _name_1 = a.getName();
+ _builder.append(_name_1, "");
+ _builder.append(" = new ");
+ RefableType _refType = a.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ _builder.append("[] ");
+ String _defaultValueLiteral_3 = a.getDefaultValueLiteral();
+ _builder.append(_defaultValueLiteral_3, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ } else {
+ String _name_2 = a.getName();
+ _builder.append(_name_2, "");
+ _builder.append(" = new ");
+ RefableType _refType_1 = a.getRefType();
+ DataType _type_1 = _refType_1.getType();
+ String _typeName_1 = this._typeHelpers.typeName(_type_1);
+ _builder.append(_typeName_1, "");
+ _builder.append("[");
+ int _size_1 = a.getSize();
+ _builder.append(_size_1, "");
+ _builder.append("];");
+ _builder.newLineIfNotEmpty();
+ _builder.append("for (int i=0;i<");
+ int _size_2 = a.getSize();
+ _builder.append(_size_2, "");
+ _builder.append(";i++){");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _name_3 = a.getName();
+ _builder.append(_name_3, " ");
+ _builder.append("[i] = ");
+ String _defaultValueLiteral_4 = a.getDefaultValueLiteral();
+ _builder.append(_defaultValueLiteral_4, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ } else {
+ boolean _operator_or = false;
+ boolean _operator_or_1 = false;
+ RefableType _refType_2 = a.getRefType();
+ DataType _type_2 = _refType_2.getType();
+ if ((_type_2 instanceof ComplexType)) {
+ _operator_or_1 = true;
+ } else {
+ int _size_3 = a.getSize();
+ boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)_size_3), ((Integer)1));
+ _operator_or_1 = BooleanExtensions.operator_or((_type_2 instanceof ComplexType), _operator_greaterThan);
+ }
+ if (_operator_or_1) {
+ _operator_or = true;
+ } else {
+ boolean _operator_not = BooleanExtensions.operator_not(useClassDefaultsOnly);
+ _operator_or = BooleanExtensions.operator_or(_operator_or_1, _operator_not);
+ }
+ if (_operator_or) {
+ {
+ int _size_4 = a.getSize();
+ boolean _operator_equals_1 = ObjectExtensions.operator_equals(((Integer)_size_4), ((Integer)0));
+ if (_operator_equals_1) {
+ String _name_4 = a.getName();
+ _builder.append(_name_4, "");
+ _builder.append(" = ");
+ RefableType _refType_3 = a.getRefType();
+ DataType _type_3 = _refType_3.getType();
+ String _defaultValue = this._typeHelpers.defaultValue(_type_3);
+ _builder.append(_defaultValue, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ } else {
+ String _name_5 = a.getName();
+ _builder.append(_name_5, "");
+ _builder.append(" = new ");
+ RefableType _refType_4 = a.getRefType();
+ DataType _type_4 = _refType_4.getType();
+ String _typeName_2 = this._typeHelpers.typeName(_type_4);
+ _builder.append(_typeName_2, "");
+ _builder.append("[");
+ int _size_5 = a.getSize();
+ _builder.append(_size_5, "");
+ _builder.append("];");
+ _builder.newLineIfNotEmpty();
+ {
+ boolean _operator_not_1 = BooleanExtensions.operator_not(useClassDefaultsOnly);
+ if (_operator_not_1) {
+ _builder.append("for (int i=0;i<");
+ int _size_6 = a.getSize();
+ _builder.append(_size_6, "");
+ _builder.append(";i++){");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ String _name_6 = a.getName();
+ _builder.append(_name_6, " ");
+ _builder.append("[i] = ");
+ RefableType _refType_5 = a.getRefType();
+ DataType _type_5 = _refType_5.getType();
+ String _defaultValue_1 = this._typeHelpers.defaultValue(_type_5);
+ _builder.append(_defaultValue_1, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation attributeSettersGettersDeclaration(final List<Attribute> attribs, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("//--------------------- attribute setters and getters");
+ _builder.newLine();
+ {
+ for(final Attribute attribute : attribs) {
+ StringConcatenation _setterHeader = this.setterHeader(attribute, classname);
+ _builder.append(_setterHeader, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ StringConcatenation _terHeader = this.getterHeader(attribute, classname);
+ _builder.append(_terHeader, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation attributeSettersGettersImplementation(final List<Attribute> attribs, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("//--------------------- attribute setters and getters");
+ _builder.newLine();
+ {
+ for(final Attribute attribute : attribs) {
+ StringConcatenation _setterHeader = this.setterHeader(attribute, classname);
+ _builder.append(_setterHeader, "");
+ _builder.append(" {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t ");
+ String _memberAccess = this.languageExt.memberAccess();
+ _builder.append(_memberAccess, " ");
+ String _name = attribute.getName();
+ _builder.append(_name, " ");
+ _builder.append(" = ");
+ String _name_1 = attribute.getName();
+ _builder.append(_name_1, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ StringConcatenation _terHeader = this.getterHeader(attribute, classname);
+ _builder.append(_terHeader, "");
+ _builder.append(" {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ _builder.append("return ");
+ String _memberAccess_1 = this.languageExt.memberAccess();
+ _builder.append(_memberAccess_1, " ");
+ String _name_2 = attribute.getName();
+ _builder.append(_name_2, " ");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ return _builder;
+ }
+
+ private StringConcatenation setterHeader(final Attribute attribute, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ String _accessLevelPublic = this.languageExt.accessLevelPublic();
+ _builder.append(_accessLevelPublic, "");
+ _builder.append("void set");
+ String _name = attribute.getName();
+ String _firstUpper = StringExtensions.toFirstUpper(_name);
+ _builder.append(_firstUpper, "");
+ _builder.append(" (");
+ String _selfPointer = this.languageExt.selfPointer(classname, true);
+ _builder.append(_selfPointer, "");
+ RefableType _refType = attribute.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ {
+ int _size = attribute.getSize();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(((Integer)_size), ((Integer)0));
+ if (_operator_notEquals) {
+ _builder.append("[]");
+ }
+ }
+ _builder.append(" ");
+ String _name_1 = attribute.getName();
+ _builder.append(_name_1, "");
+ _builder.append(")");
+ return _builder;
+ }
+
+ private StringConcatenation getterHeader(final Attribute attribute, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ String _accessLevelPublic = this.languageExt.accessLevelPublic();
+ _builder.append(_accessLevelPublic, "");
+ RefableType _refType = attribute.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ {
+ int _size = attribute.getSize();
+ boolean _operator_notEquals = ObjectExtensions.operator_notEquals(((Integer)_size), ((Integer)0));
+ if (_operator_notEquals) {
+ _builder.append("[]");
+ }
+ }
+ _builder.append(" get");
+ String _name = attribute.getName();
+ String _firstUpper = StringExtensions.toFirstUpper(_name);
+ _builder.append(_firstUpper, "");
+ _builder.append(" (");
+ String _selfPointer = this.languageExt.selfPointer(classname, false);
+ _builder.append(_selfPointer, "");
+ _builder.append(")");
+ return _builder;
+ }
+
+ public StringConcatenation argList(final List<Attribute> attributes) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ boolean hasAnyElements = false;
+ for(final Attribute a : attributes) {
+ if (!hasAnyElements) {
+ hasAnyElements = true;
+ } else {
+ _builder.appendImmediate(", ", "");
+ }
+ RefableType _refType = a.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ {
+ int _size = a.getSize();
+ boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)_size), ((Integer)1));
+ if (_operator_greaterThan) {
+ _builder.append("[]");
+ }
+ }
+ _builder.append(" ");
+ String _name = a.getName();
+ _builder.append(_name, "");
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation operationsDeclaration(final List<? extends Operation> operations, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("/*--------------------- operations ---------------------*/");
+ _builder.newLine();
+ {
+ for(final Operation operation : operations) {
+ {
+ boolean _operator_and = false;
+ boolean _usesInheritance = this.languageExt.usesInheritance();
+ if (!_usesInheritance) {
+ _operator_and = false;
+ } else {
+ boolean _isConstructor = RoomHelpers.isConstructor(operation);
+ _operator_and = BooleanExtensions.operator_and(_usesInheritance, _isConstructor);
+ }
+ boolean _operator_not = BooleanExtensions.operator_not(_operator_and);
+ if (_operator_not) {
+ StringConcatenation _operationSignature = this.operationSignature(operation, classname, true);
+ _builder.append(_operationSignature, "");
+ _builder.append(";");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation operationsImplementation(final List<? extends Operation> operations, final String classname) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("/*--------------------- operations ---------------------*/");
+ _builder.newLine();
+ {
+ for(final Operation operation : operations) {
+ {
+ boolean _operator_and = false;
+ boolean _usesInheritance = this.languageExt.usesInheritance();
+ if (!_usesInheritance) {
+ _operator_and = false;
+ } else {
+ boolean _isConstructor = RoomHelpers.isConstructor(operation);
+ _operator_and = BooleanExtensions.operator_and(_usesInheritance, _isConstructor);
+ }
+ boolean _operator_not = BooleanExtensions.operator_not(_operator_and);
+ if (_operator_not) {
+ StringConcatenation _operationSignature = this.operationSignature(operation, classname, false);
+ _builder.append(_operationSignature, "");
+ _builder.append(" {");
+ _builder.newLineIfNotEmpty();
+ {
+ DetailCode _detailCode = operation.getDetailCode();
+ EList<String> _commands = _detailCode.getCommands();
+ for(final String command : _commands) {
+ _builder.append("\t");
+ _builder.append(command, " ");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ public StringConcatenation operationsImplementation(final ActorClass ac) {
+ StringConcatenation _xblockexpression = null;
+ {
+ this.translator.setActorClass(ac);
+ DetailCodeTranslator _detailCodeTranslator = new DetailCodeTranslator(ac, this.translator);
+ DetailCodeTranslator dct = _detailCodeTranslator;
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("/*--------------------- operations ---------------------*/");
+ _builder.newLine();
+ {
+ EList<StandardOperation> _operations = ac.getOperations();
+ for(final StandardOperation operation : _operations) {
+ {
+ boolean _operator_and = false;
+ boolean _usesInheritance = this.languageExt.usesInheritance();
+ if (!_usesInheritance) {
+ _operator_and = false;
+ } else {
+ boolean _isConstructor = RoomHelpers.isConstructor(operation);
+ _operator_and = BooleanExtensions.operator_and(_usesInheritance, _isConstructor);
+ }
+ boolean _operator_not = BooleanExtensions.operator_not(_operator_and);
+ if (_operator_not) {
+ String _name = ac.getName();
+ StringConcatenation _operationSignature = this.operationSignature(operation, _name, false);
+ _builder.append(_operationSignature, "");
+ _builder.append(" {");
+ _builder.newLineIfNotEmpty();
+ _builder.append("\t");
+ DetailCode _detailCode = operation.getDetailCode();
+ String _translateDetailCode = dct.translateDetailCode(_detailCode);
+ _builder.append(_translateDetailCode, " ");
+ _builder.newLineIfNotEmpty();
+ _builder.append("}");
+ _builder.newLine();
+ }
+ }
+ }
+ }
+ _xblockexpression = (_builder);
+ }
+ return _xblockexpression;
+ }
+
+ private StringConcatenation operationSignature(final Operation operation, final String classname, final boolean isDeclaration) {
+ StringConcatenation _xifexpression = null;
+ boolean _isConstructor = RoomHelpers.isConstructor(operation);
+ if (_isConstructor) {
+ String _constructorName = this.languageExt.constructorName(classname);
+ String _constructorReturnType = this.languageExt.constructorReturnType();
+ StringConcatenation _classOperationSignature = this.classOperationSignature(classname, _constructorName, "", _constructorReturnType, isDeclaration);
+ _xifexpression = _classOperationSignature;
+ } else {
+ StringConcatenation _xifexpression_1 = null;
+ boolean _isDestructor = RoomHelpers.isDestructor(operation);
+ if (_isDestructor) {
+ String _destructorName = this.languageExt.destructorName(classname);
+ String _destructorReturnType = this.languageExt.destructorReturnType();
+ StringConcatenation _classOperationSignature_1 = this.classOperationSignature(classname, _destructorName, "", _destructorReturnType, isDeclaration);
+ _xifexpression_1 = _classOperationSignature_1;
+ } else {
+ String _name = operation.getName();
+ EList<VarDecl> _arguments = operation.getArguments();
+ StringConcatenation _BuildArgumentList = this.BuildArgumentList(_arguments);
+ String _string = _BuildArgumentList.toString();
+ RefableType _returntype = operation.getReturntype();
+ String _dataTypeToString = this.dataTypeToString(_returntype);
+ StringConcatenation _classOperationSignature_2 = this.classOperationSignature(classname, _name, _string, _dataTypeToString, isDeclaration);
+ _xifexpression_1 = _classOperationSignature_2;
+ }
+ _xifexpression = _xifexpression_1;
+ }
+ return _xifexpression;
+ }
+
+ private String dataTypeToString(final RefableType type) {
+ String _xifexpression = null;
+ boolean _operator_equals = ObjectExtensions.operator_equals(type, null);
+ if (_operator_equals) {
+ _xifexpression = "void";
+ } else {
+ DataType _type = type.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _xifexpression = _typeName;
+ }
+ return _xifexpression;
+ }
+
+ /**
+ * builds comma separated argument list as string from EList<VarDecl> arguments
+ */
+ private StringConcatenation BuildArgumentList(final EList<VarDecl> arguments) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ boolean hasAnyElements = false;
+ for(final VarDecl argument : arguments) {
+ if (!hasAnyElements) {
+ hasAnyElements = true;
+ } else {
+ _builder.appendImmediate(", ", "");
+ }
+ RefableType _refType = argument.getRefType();
+ DataType _type = _refType.getType();
+ String _typeName = this._typeHelpers.typeName(_type);
+ _builder.append(_typeName, "");
+ _builder.append(" ");
+ String _name = argument.getName();
+ _builder.append(_name, "");
+ }
+ }
+ return _builder;
+ }
+
+ private StringConcatenation classOperationSignature(final String classname, final String operationname, final String argumentList, final String returnType, final boolean isDeclaration) {
+ StringConcatenation _builder = new StringConcatenation();
+ String _accessLevelPublic = this.languageExt.accessLevelPublic();
+ _builder.append(_accessLevelPublic, "");
+ _builder.append(returnType, "");
+ _builder.append(" ");
+ String _memberInDeclaration = this.languageExt.memberInDeclaration(classname, operationname);
+ _builder.append(_memberInDeclaration, "");
+ _builder.append("(");
+ boolean _isEmpty = argumentList.isEmpty();
+ boolean _operator_not = BooleanExtensions.operator_not(_isEmpty);
+ String _selfPointer = this.languageExt.selfPointer(classname, _operator_not);
+ _builder.append(_selfPointer, "");
+ _builder.append(argumentList, "");
+ _builder.append(")");
+ return _builder;
+ }
+}
diff --git a/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TypeHelpers.java b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TypeHelpers.java new file mode 100644 index 000000000..32d8572db --- /dev/null +++ b/plugins/org.eclipse.etrice.generator/xtend-gen/org/eclipse/etrice/generator/generic/TypeHelpers.java @@ -0,0 +1,65 @@ +package org.eclipse.etrice.generator.generic;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.eclipse.etrice.core.room.DataType;
+import org.eclipse.etrice.core.room.ExternalType;
+import org.eclipse.etrice.core.room.Message;
+import org.eclipse.etrice.core.room.PrimitiveType;
+import org.eclipse.etrice.core.room.RefableType;
+import org.eclipse.etrice.core.room.VarDecl;
+import org.eclipse.etrice.generator.generic.AbstractLanguageGenerator;
+import org.eclipse.xtext.xbase.lib.StringExtensions;
+
+@SuppressWarnings("all")
+@Singleton
+public class TypeHelpers {
+ @Inject
+ private AbstractLanguageGenerator languageGen;
+
+ public String typeName(final DataType type) {
+ if ((type instanceof PrimitiveType)) {
+ String _targetName = ((PrimitiveType) type).getTargetName();
+ return _targetName;
+ } else {
+ if ((type instanceof ExternalType)) {
+ String _targetName_1 = ((ExternalType) type).getTargetName();
+ return _targetName_1;
+ } else {
+ String _name = type.getName();
+ return _name;
+ }
+ }
+ }
+
+ public String defaultValue(final DataType dt) {
+ if ((dt instanceof PrimitiveType)) {
+ String _defaultValueLiteral = ((PrimitiveType) dt).getDefaultValueLiteral();
+ return _defaultValueLiteral;
+ } else {
+ if ((dt instanceof ExternalType)) {
+ String _targetName = ((ExternalType) dt).getTargetName();
+ String _operator_plus = StringExtensions.operator_plus("new ", _targetName);
+ String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, "()");
+ return _operator_plus_1;
+ } else {
+ String _name = dt.getName();
+ String _operator_plus_2 = StringExtensions.operator_plus("new ", _name);
+ String _operator_plus_3 = StringExtensions.operator_plus(_operator_plus_2, "()");
+ return _operator_plus_3;
+ }
+ }
+ }
+
+ public String defaultValue(final VarDecl a) {
+ RefableType _refType = a.getRefType();
+ DataType _type = _refType.getType();
+ String _defaultValue = this.defaultValue(_type);
+ return _defaultValue;
+ }
+
+ public String getTypedDataDefinition(final Message m) {
+ String _typedData = this.languageGen.getTypedData(m);
+ return _typedData;
+ }
+}
|