Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
*
* ludovic.apvrille AT enst.fr
*
* This software is a computer program whose purpose is to allow the
* edition of TURTLE analysis, design and deployment diagrams, to
* allow the generation of RT-LOTOS or Java code from this diagram,
* and at last to allow the analysis of formal validation traces
* obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
* from INRIA Rhone-Alpes.
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*/
package avatartranslator.tosysmlv2;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.function.BiConsumer;
import avatartranslator.*;
import avatartranslator.tosysmlv2.AvatarFromSysMLSyntax.*;
import java_cup.runtime.ComplexSymbolFactory;
public class AvatarFromSysML {
private AvatarSpecification avSpec;
private StxModel stxSpec;
private ArrayList<AvatarTransition> transitionList;
private HashMap<StxSignal, AvatarSignal> signalMap;
private HashMap<StxBlock, AvatarBlock> blockMap;
private HashMap<StxState, AvatarStateMachineElement> stateMap;
public AvatarFromSysML(){
avSpec = null;
stxSpec = null;
transitionList = new ArrayList<AvatarTransition>();
signalMap = new HashMap<StxSignal, AvatarSignal>();
blockMap = new HashMap<StxBlock, AvatarBlock>();
stateMap = new HashMap<StxState, AvatarStateMachineElement>();
errors = null;
}
private void addError(AvatarFromSysMLError _err) {
errors.add(_err);
public AvatarSpecification sysMLtoSpec(String _fileName) {
AvatarFromSysMLParser parser;
try { parser =
new AvatarFromSysMLParser(new AvatarFromSysMLLexer(new FileReader(_fileName)),
new ComplexSymbolFactory()); }
catch (java.lang.Exception e) {
e.printStackTrace(out);
return new AvatarSpecification("DummySpec", null);
}
try { stxSpec = parser.parseModel(); }
catch (java.lang.Exception e) {
e.printStackTrace(out);
return new AvatarSpecification("DummySpec", null);
errors = stxSpec.getErrors();
avSpec = new AvatarSpecification("FromSysMLV2_EXAMPLE_SPECIFICATION",null);
transitionList.clear();
signalMap.clear();
blockMap.clear();
stateMap.clear();
buildDataTypes();
buildBlocks();
private AvatarBlock getBlock(StxBlock _b) {
AvatarBlock b = blockMap.get(_b);
if (b == null) {
b = new AvatarBlock(_b.getName(), avSpec, null);
blockMap.put(_b, b);
}
return b;
}
private AvatarSignal getSignal(StxSignal _b) {
AvatarSignal b = signalMap.get(_b);
if (b == null) {
if (_b.isInput())
b = new AvatarSignal(_b.getName(), AvatarSignal.IN, null);
else
b = new AvatarSignal(_b.getName(), AvatarSignal.OUT, null);
signalMap.put(_b, b);
}
return b;
}
private AvatarAttribute getAttributeByName(String _name, AvatarBlock _block) {
List<AvatarAttribute> l = _block.getAttributes();
int size = l.size();
for (int i = 0; i < size; i++)
if(l.get(i).getName().equals(_name)) return l.get(i);
return null;
}
private AvatarAttribute getTimerByName(String _name, AvatarBlock _block) {
AvatarAttribute res = getAttributeByName(_name, _block);
if (res != null && res.getType() == AvatarType.TIMER) return res;
return null;
}
private AvatarStateMachineElement getState(StxState _s, AvatarBlock _b) {
AvatarStateMachineElement s = stateMap.get(_s);
if (s == null) {
switch(_s.getType()) {
case AvatarFromSysMLSyntax.STXSTARTSTATE :
s = new AvatarStartState("StartState", null, _b);
break;
case AvatarFromSysMLSyntax.STXSTANDARDSTATE :
s = new AvatarState(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXRANDOMSTATE :
s = new AvatarRandom(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXCOUNTSTATE :
s = new AvatarQueryOnSignal(_s.getName(), getSignal(_s.getSignal()),
getAttributeByName(_s.getVariable(),_b), null, _b);
break;
case AvatarFromSysMLSyntax.STXSTOPSTATE :
case AvatarFromSysMLSyntax.STXSENDSTATE :
case AvatarFromSysMLSyntax.STXRECEIVESTATE :
s = new AvatarActionOnSignal(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXPRESENDSTATE :
case AvatarFromSysMLSyntax.STXPRERECEIVESTATE : break;
case AvatarFromSysMLSyntax.STXSETTIMERSTATE :
s = new AvatarSetTimer(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXRESETTIMERSTATE :
s = new AvatarResetTimer(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXEXPIRETIMERSTATE :
s = new AvatarExpireTimer(_s.getName(), null, _b);
}
if (s != null) stateMap.put(_s, s);
}
return s;
}
// BUILDING DATATYPES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
private class BuildDataType implements BiConsumer<String, StxDataType> {
public BuildDataType(){}
public void accept(String n, StxDataType d) {
AvatarDataType dataType = new AvatarDataType(d.getName(),null);
AvatarDataType.dataTypeMap.put(d.getName(), dataType);
avSpec.getDataTypes().add(dataType);
int nbFields = d.getSize();
for (int i = 0; i < nbFields; i++) {
String type = d.getFieldType(i);
if(type.equals("Integer"))
dataType.addField(d.getFieldName(i), AvatarDataType.INTEGER, null);
else if(type.equals("Boolean"))
dataType.addField(d.getFieldName(i), AvatarDataType.BOOLEAN, null);
else
dataType.addField(d.getFieldName(i), AvatarDataType.DATATYPE, type);
}
}
}
private void buildDataTypes(){
List<AvatarDataType> dtList = avSpec.getDataTypes();
AvatarDataType.dataTypeMap.clear();
stxSpec.getDataTypeMap().forEach(new BuildDataType());
int size = dtList.size();
for(int i = 0; i < size; i++)
AvatarDataType.finalize(dtList.get(i));
// BUILDING BLOCKS (but not statemachines) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
private class BuildBlock implements BiConsumer<String, StxBlock> {
List<AvatarDataType> dataTypeList;
public BuildBlock(){}
public void accept(String n, StxBlock blk) {
AvatarBlock theBlock = getBlock(blk);
avSpec.addBlock(theBlock);
// set father
StxBlock fth = blk.getFather();
if (fth != null) theBlock.setFather(getBlock(fth));
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
// add Attributes
int size = blk.getNbAttributes();
for (int i = 0; i < size; i++) {
StxAttribute a = blk.getAttribute(i);
AvatarAttribute aa;
if (a.getType().equals("Integer")) {
aa = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
aa.setInitialValue(a.getInit());
theBlock.addAttribute(aa);
aa.setAsConstant(false);
}
else if (a.getType().equals("Boolean")) {
aa = new AvatarAttribute(a.getName(), AvatarType.BOOLEAN, theBlock, null);
aa.setInitialValue(a.getInit());
theBlock.addAttribute(aa);
aa.setAsConstant(false);
}
else {
AvatarDataType adt = AvatarDataType.dataTypeMap.get(a.getType());
int tsize = adt.getFullSize();
for(int j = 0; j < tsize; j++) {
aa = new AvatarAttribute(
a.getName() + "__" + adt.getFieldString(j),
(adt.getFieldStringType(j) == AvatarDataType.BOOLEAN ? AvatarType.BOOLEAN : AvatarType.INTEGER),
theBlock, null);
theBlock.addAttribute(aa);
aa.setAsConstant(false);
if (j == 0) aa.setDataType(adt);
}
}
}
// add Constants
size = blk.getNbConstants();
for (int i = 0; i < size; i++) {
StxAttribute a = blk.getConstant(i);
AvatarAttribute aa;
if (a.getType().equals("Integer")) {
aa = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
aa.setInitialValue(a.getInit());
theBlock.addAttribute(aa);
aa.setAsConstant(true);
}
else if (a.getType().equals("Boolean")) {
aa = new AvatarAttribute(a.getName(), AvatarType.BOOLEAN, theBlock, null);
aa.setInitialValue(a.getInit());
theBlock.addAttribute(aa);
aa.setAsConstant(true);
}
else {
AvatarDataType adt = AvatarDataType.dataTypeMap.get(a.getType());
int tsize = adt.getFullSize();
for(int j = 0; j < tsize; j++) {
aa = new AvatarAttribute(
a.getName() + "__" + adt.getFieldString(j),
(adt.getFieldStringType(j) == AvatarDataType.BOOLEAN ? AvatarType.BOOLEAN : AvatarType.INTEGER),
theBlock, null);
theBlock.addAttribute(aa);
aa.setAsConstant(true);
if (j == 0) aa.setDataType(adt);
}
}
}
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
// add Timers
size = blk.getNbTimers();
for (int i = 0; i < size; i++) {
AvatarAttribute aa = new AvatarAttribute(blk.getTimer(i).getName(), AvatarType.TIMER, theBlock, null);
theBlock.addAttribute(aa);
aa.setAsConstant(false);
}
// add Methods
size = blk.getNbMethods();
for (int i = 0; i < size; i++) {
StxMethod sm = blk.getMethod(i);
AvatarMethod am = new AvatarMethod(sm.getName(),null);
theBlock.addMethod(am);
buildProfile(sm, am, theBlock);
String returnType = sm.getReturnType();
if (returnType == null) continue;
if (returnType.equals("Integer"))
am.addReturnParameter(new AvatarAttribute("return__0", AvatarType.INTEGER, theBlock, null));
else if (returnType.equals("Boolean"))
am.addReturnParameter(new AvatarAttribute("return__0", AvatarType.BOOLEAN, theBlock, null));
else {
AvatarDataType adt = AvatarDataType.dataTypeMap.get(returnType);
int nbFields = adt.getNbFields();
for (int j = 0; j < nbFields; j++) {
AvatarType type = (adt.getFieldStringType(j) == AvatarDataType.INTEGER ? AvatarType.INTEGER : AvatarType.BOOLEAN);
am.addReturnParameter(new AvatarAttribute("return__" + j, type, theBlock, null));
}
}
}
// add Signals (build profile delayed)
size = blk.getNbSignals();
for (int i = 0; i < size; i++) {
StxSignal ss = blk.getSignal(i);
AvatarSignal as = getSignal(ss);
theBlock.addSignal(as);
buildProfile((ss.isInput() ? ss.getChannel().getInProfile() : ss.getChannel().getOutProfile()), as, theBlock);
// add states
StxState[] states = blk.getStates();
AvatarStateMachine asm = theBlock.getStateMachine();
AvatarStateMachineElement theSourceState;
size = states.length;
for (int i = 0; i < size; i++) {
byte stateType = states[i].getType();
if (stateType != AvatarFromSysMLSyntax.STXPRESENDSTATE &&
stateType != AvatarFromSysMLSyntax.STXPRERECEIVESTATE &&
stateType != AvatarFromSysMLSyntax.STXSTOPSTATE ) {
theSourceState = getState(states[i], theBlock);
asm.addElement(theSourceState);
if (stateType == AvatarFromSysMLSyntax.STXRANDOMSTATE) {
((AvatarRandom) theSourceState).setValues(states[i].getMinValue(), states[i].getMaxValue());
((AvatarRandom) theSourceState).setVariable(states[i].getVariable());
} else if (stateType == AvatarFromSysMLSyntax.STXSTARTSTATE)
asm.setStartState((AvatarStartState) theSourceState);
// add transitions
List<StxTransition> transitions = states[i].getTransitions();
int tsize = transitions.size();
for (int j = 0; j < tsize; j++) {
StxTransition transition = transitions.get(j);
AvatarTransition theTransition = new AvatarTransition(theBlock,"", null);
transitionList.add(theTransition);
theSourceState.addNext(theTransition);
theTransition.setGuard(transition.getGuard());
String minDelay = transition.getMinDelay().trim();
String maxDelay = transition.getMaxDelay().trim();
if (minDelay.equals(maxDelay)) maxDelay = "";
theTransition.setDelays(minDelay, maxDelay);
setDistributionLaw(theTransition, transition.getDelayDistributionLaw(),transition.getDelayExtra());
// add actions
List<StxAction> actions = transition.getActions(); // should exist only in some cases...
int asize = actions.size();
for (int k = 0; k < asize; k++) {
StxAction action = actions.get(k);
if(action.getType() == AvatarFromSysMLSyntax.STXASSIGNACTION){
String leftHandStr = extendIdent(action.getTarget(),blk);
String rightHandStr;
StxTerm value = action.getValue();
if (value instanceof StxId){ rightHandStr = extendIdent(((StxId)value).getString(),blk); }
else if (value instanceof StxExpr){ rightHandStr = ((StxExpr)value).getString(); }
else { rightHandStr = extendCall((StxCall)value,blk); }
AvatarAction act = AvatarTerm.createActionFromString(theBlock, leftHandStr + "=" + rightHandStr);
theTransition.addAction(act);
if(dataType != null && act != null && ((AvatarActionAssignment)act).getLeftHand() instanceof AvatarTuple ) {
AvatarAttribute head =
(AvatarAttribute)((AvatarTuple) ((AvatarActionAssignment)act).getLeftHand()).getComponents().get(0);
head.setDataType(dataType);
}
//!!! Ajouter le tagging datatype
}
else { // STXMETHODACTION
if (action.getValue() instanceof StxCall) { // else ERROR
String termStr = extendCall((StxCall)action.getValue(),blk);
theTransition.addAction(AvatarTerm.createActionFromString(theBlock, termStr));
}
}
}
if(transition.getTarget().getType() == AvatarFromSysMLSyntax.STXPRESENDSTATE ||
transition.getTarget().getType() == AvatarFromSysMLSyntax.STXPRERECEIVESTATE)
transition = transition.getTarget().getTransition(0);
AvatarStateMachineElement tgtState;
if (transition.getTarget().getType() == AvatarFromSysMLSyntax.STXSTOPSTATE) {
tgtState = new AvatarStopState("StopState", null, theBlock);
asm.addElement(tgtState);
}
else tgtState =getState(transition.getTarget(), theBlock);
theTransition.addNext(tgtState);
if (transition.getType() == AvatarFromSysMLSyntax.STXSENDTRANSITION) {
if(tgtState instanceof AvatarActionOnSignal) {
AvatarActionOnSignal state = (AvatarActionOnSignal)tgtState;
state.setSignal( getSignal(transition.getSignal()));
ArrayList<StxTerm> sendPayload = transition.getSendPayload();
int nbParam = sendPayload.size();
for(int u = 0; u < nbParam; u++) {
StxTerm p = sendPayload.get(u);
if (p instanceof StxId){
String[] ids = extendPath(((StxId)p).getString(),blk).split(",");
for (String id : ids) { state.addValue(id.trim()); }
}
else if (p instanceof StxExpr){ state.addValue( ((StxExpr)p).getString() ); }
else { state.addValue( extendCall((StxCall)p,blk) ); }
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXRECEIVETRANSITION) {
if(tgtState instanceof AvatarActionOnSignal) {
AvatarActionOnSignal state = (AvatarActionOnSignal)tgtState;
state.setSignal(getSignal(transition.getSignal()));
StxOutMessage profile = transition.getSignal().getChannel().getOutProfile();
HashMap<String, String> receivePayload = transition.getReceivePayload();
int nbParams = profile.getSize();
for (int k = 0; k < nbParams; k++) {
String[] ids = extendPath( receivePayload.get(profile.getFieldName(k)), blk).split(",");
for (String id : ids) state.addValue(id);
}
}
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXSETTIMERTRANSITION) {
if(tgtState instanceof AvatarSetTimer) {
AvatarSetTimer state = (AvatarSetTimer) tgtState;
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
state.setTimerValue(((StxExpr)transition.getSendPayload().get(0)).getString());
}
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXRESETTIMERTRANSITION) {
if(tgtState instanceof AvatarResetTimer) {
AvatarResetTimer state = (AvatarResetTimer) tgtState;
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
}
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXEXPIRETIMERTRANSITION) {
if(tgtState instanceof AvatarExpireTimer) {
AvatarExpireTimer state = (AvatarExpireTimer) tgtState;
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
}
}
private void buildBlocks(){
stxSpec.getBlockMap().forEach(new BuildBlock());
}
private void setDistributionLaw(AvatarTransition _t, String distributionLaw, HashMap<String,String> delayExtra) {
int law = -1;
int size;
if (distributionLaw == null || distributionLaw.equals("")) law = AvatarTransition.DELAY_UNIFORM_LAW;
else {
size = _t.DISTRIBUTION_LAWS.length;
for (int i = 0; i < size; i++) {
if (_t.DISTRIBUTION_LAWS[i].equals(distributionLaw)) {
law = i;
break;
}
}
if (law == -1) law = AvatarTransition.DELAY_UNIFORM_LAW;
}
String extra1 = _t.LABELS_OF_EXTRA_ATTRIBUTES_1[law];
String extra2 = _t.LABELS_OF_EXTRA_ATTRIBUTES_2[law];
size = _t.NB_OF_EXTRA_ATTRIBUTES[law];
if (size > 0) {
extra1 = delayExtra.get(extra1);
if (size > 1) {
extra2 = delayExtra.get(extra2);
}
}
_t.setDistributionLaw(law, extra1, extra2);
}
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
private void buildProfile(StxStructure ss, AvatarMethod am, AvatarBlock b) {
AvatarAttribute aa;
int size = ss.getSize();
for (int i = 0; i < size; i++) {
String type = ss.getFieldType(i);
if (type.equals("Integer")){
aa = new AvatarAttribute(ss.getFieldName(i), AvatarType.INTEGER, b, null);
am.addParameter(aa);
aa.setAsConstant(false);
} else if (type.equals("Boolean")) {
aa = new AvatarAttribute(ss.getFieldName(i), AvatarType.BOOLEAN, b, null);
am.addParameter(aa);
aa.setAsConstant(false);
} else {
AvatarDataType adt = AvatarDataType.dataTypeMap.get(type);
int tsize = adt.getFullSize();
for(int j = 0; j < tsize; j++) {
aa = new AvatarAttribute(
ss.getFieldName(i) + "__" + adt.getFieldString(j),
(adt.getFieldStringType(j) == AvatarDataType.BOOLEAN ? AvatarType.BOOLEAN : AvatarType.INTEGER),
b, null);
am.addParameter(aa);
aa.setAsConstant(false);
if (j == 0) aa.setDataType(adt);
}
}
}
}
private String getStxAttributeType(String name, StxBlock blk){
int size = blk.getNbAttributes();
for (int i = 0; i < size; i++) {
if (blk.getAttribute(i).getName().equals(name)) return blk.getAttribute(i).getType();
}
return null;
}
private String getStxPathType(String s, StxBlock b) {
String[] path = s.split("__");
String type = getStxAttributeType(path[0], b);
int size = path.length;
for (int i = 1; i < size; i++) {
AvatarDataType adt = AvatarDataType.dataTypeMap.get(type);
if (adt == null) return null;
int nbFields = adt.getNbFields();
int j;
for (j = 0; j < nbFields; j++)
if (adt.getFieldName(j).equals(path[i])) break;
if (j == nbFields) return null;
int adtType = adt.getFieldType(j);
if (adtType == AvatarDataType.INTEGER)
type = "Integer";
else if (adtType == AvatarDataType.BOOLEAN)
type = "Boolean";
else
type = adt.getDataTypeName(j);
}
return type;
}
private String extendString;
private AvatarDataType extendType;
private String extendPath(String path, StxBlock b) {
extendString = getStxPathType(path, b);
if (extendString.equals("Integer") || extendString.equals("Boolean")) {
extendType = null;
return path;
}
extendType = AvatarDataType.dataTypeMap.get(extendString);
int size = extendType.getFullSize() - 1;
if (size == -1) return path;
StringBuffer res = new StringBuffer();
int i;
for (i = 0; i < size; i++)
res.append(path + "__" + extendType.getFieldString(i) + ", ");
res.append(path + "__" + extendType.getFieldString(i));
return res.toString();
}
private String extendIdent (String path, StxBlock b) {
String result = extendPath(path, b);
return (result.indexOf(',') == -1 ? result : "(" + result + ")");
}
private String extendCall (StxCall call, StxBlock b) {
StringBuffer result = new StringBuffer();
int size = call.getNbIdents();
int i;
for (i =0 ; i < size; i++) {
result.append(call.getSegment(i));
result.append(extendPath(call.getIdent(i), b));
}
result.append(call.getSegment(i));
return result.toString();
}
// BUILD RELATIONS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
private void buildRelations(){
stxSpec.getRelationMap().forEach(new BuildRelation());
}
private class BuildRelation implements BiConsumer<String, StxRelation> {
public BuildRelation() {
}
public void accept(String n, StxRelation r) {
AvatarBlock blk1 = getBlock(r.getBlock1());
AvatarBlock blk2 = getBlock(r.getBlock2());
AvatarRelation theRelation = new AvatarRelation(n, blk1, blk2, null);
avSpec.addRelation(theRelation);
theRelation.setAsynchronous(r.getAsynchronous());
theRelation.setPrivate(r.getPrivate());
theRelation.setLossy(r.getLossy());
theRelation.setBlocking(r.getBlocking());
theRelation.setSizeOfFIFO(r.getFifoSize());
int size = r.getSize();
for (int i = 0; i < size; i++) {
StxChannel c = r.getChannel(i);
c.commuteSignals(r.getBlock1().getName());
theRelation.addSignals(getSignal(c.getSignalA()),getSignal(c.getSignalB()));
}
}
}
void rebuildDataTypes(AvatarSpecification as){}
// handle attribute list
// handle signal profiles
// handle methods (profiles and return type
// statemachine state: handle send action
// statemachine state: handle receive action
// statemachine transaction: handle method call
// statemachine transaction: handle assignment target
// statemachine transaction: handle right method call
// handle expressions in ui ???