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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.function.BiConsumer;
import avatartranslator.*;
import avatartranslator.tosysmlv2.AvatarFromSysMLSyntax.*;
import static java_cup.runtime.ComplexSymbolFactory.*;
import java_cup.runtime.ComplexSymbolFactory;
import myutil.TraceManager;
public class AvatarFromSysML {
private AvatarSpecification avSpec;
private StxModel stxSpec;
private HashMap<StxSignal, AvatarSignal> signalMap;
private HashMap<StxBlock, AvatarBlock> blockMap;
private HashMap<StxState, AvatarStateMachineElement> stateMap;
private HashMap<AvatarStateMachineElement, StateTransitions> transitionMap;
public AvatarFromSysML(){
avSpec = null;
stxSpec = null;
signalMap = new HashMap<StxSignal, AvatarSignal>();
blockMap = new HashMap<StxBlock, AvatarBlock>();
stateMap = new HashMap<StxState, AvatarStateMachineElement>();
transitionMap = new HashMap<AvatarStateMachineElement, StateTransitions>();
private class StateTransitions {
private AvatarBlock block;
private List<AvatarTransition> transitions;
public StateTransitions (AvatarBlock _block, List<AvatarTransition> _transitions) {
block = _block;
transitions = _transitions;
}
public AvatarBlock getBlock() { return block; }
public List<AvatarTransition> getTransitions() { return transitions; }
}
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);
}
TraceManager.addDev("Parsing Model");
try { stxSpec = parser.parseModel(); }
catch (java.lang.Exception e) {
e.printStackTrace(out);
return new AvatarSpecification("DummySpec", null);
if (stxSpec == null) {
for(AvatarFromSysMLError e : parser.getErrors())
TraceManager.addDev(e.toString());
return new AvatarSpecification("DummySpec", null);
}
errors = stxSpec.getErrors();
TraceManager.addDev("Building Specification");
avSpec = new AvatarSpecification("FromSysMLV2_EXAMPLE_SPECIFICATION",null);
signalMap.clear();
blockMap.clear();
stateMap.clear();
TraceManager.addDev("Building DataTypes");
for(AvatarFromSysMLError e : errors)
TraceManager.addDev(e.toString());
private void addState(AvatarStateMachineElement e, AvatarBlock b) {
if (transitionMap.get(e) == null){
ArrayList<AvatarTransition> l = new ArrayList<AvatarTransition>();
transitionMap.put(e, new StateTransitions(b, l));
}
}
private void addTransition(AvatarTransition t, AvatarStateMachineElement e) {
transitionMap.get(e).getTransitions().add(t);
}
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 getOriginalAttributeByName(String _name, AvatarBlock _block) {
List<AvatarAttribute> l = _block.getOriginalAttributes();
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 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().replaceAll("\\.", "__"),_b), null, _b);
case AvatarFromSysMLSyntax.STXSTOPSTATE :
case AvatarFromSysMLSyntax.STXSENDSTATE :
case AvatarFromSysMLSyntax.STXRECEIVESTATE :
s = new AvatarActionOnSignal(_s.getName(), null, _b);
break;
case AvatarFromSysMLSyntax.STXPRESENDSTATE :
case AvatarFromSysMLSyntax.STXPRERECEIVESTATE :
addError(new AvatarFromSysMLError(AvatarFromSysMLError.BUGERROR, null,
"adding precom state (AvatarFromSysML.getState)", null));
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);
int nbFields = d.getSize();
for (int i = 0; i < nbFields; i++) {
String type = d.getFieldType(i);
if(type.equals("Integer")) {
AvatarAttribute aa = new AvatarAttribute(d.getFieldName(i),AvatarType.INTEGER,null,null);
dataType.addAttribute(aa, null);
}
else if(type.equals("Boolean")) {
AvatarAttribute aa = new AvatarAttribute(d.getFieldName(i),AvatarType.BOOLEAN,null,null);
dataType.addAttribute(aa, null);
}
else {
AvatarAttribute aa = new AvatarAttribute(d.getFieldName(i),AvatarType.UNDEFINED,null,null);
dataType.addAttribute(aa, type);
}
}
}
}
private void buildDataTypes(){
List<AvatarDataType> dtList = avSpec.getDataTypes();
stxSpec.getDataTypeMap().forEach(new BuildDataType());
for(int i = 0; i < size; i++) {
AvatarDataType dt = dtList.get(i);
AvatarDataType.finalize(dt, avSpec);
if (dt.getFullSize() == -1)
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, null, "datatype " + dt.getName() + " is not well defined", null));
}
// BUILDING BLOCKS (but not statemachines) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
private class BuildBlock implements BiConsumer<String, StxBlock> {
List<AvatarDataType> dataTypeList;
public BuildBlock(){}
public void accept(String n, StxBlock blk) {
if (!blk.isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR,
"block " + blk.getName() +"has been used but has not been declared"));
AvatarBlock theBlock = getBlock(blk);
avSpec.addBlock(theBlock);
// set father
StxBlock fth = blk.getFather();
if (fth != null) theBlock.setFather(getBlock(fth));
// add Attributes
int size = blk.getNbAttributes();
for (int i = 0; i < size; i++) {
StxAttribute a = blk.getAttribute(i);
AvatarAttribute aa;
AvatarAttribute ax;
if (a.getType().equals("Integer")) {
aa = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
aa.setInitialValue(a.getInit());
ax = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
ax.setInitialValue(a.getInit());
theBlock.addAttribute(ax);
ax.setAsConstant(false);
}
else if (a.getType().equals("Boolean")) {
aa = new AvatarAttribute(a.getName(), AvatarType.BOOLEAN, theBlock, null);
aa.setInitialValue(a.getInit());
ax = new AvatarAttribute(a.getName(), AvatarType.BOOLEAN, theBlock, null);
ax.setInitialValue(a.getInit());
theBlock.addAttribute(ax);
ax.setAsConstant(false);
aa = new AvatarAttribute(a.getName(), AvatarType.UNDEFINED, theBlock, null);
// aa.setInitialValue(a.getInit());
String aaName = a.getName() + "__";
int dtsize = adt.getFullSize();
for (int j = 0; j < dtsize; j++) {
ax = new AvatarAttribute(aaName + adt.getFieldString(j),
adt.getFieldStringType(j), theBlock, null);
theBlock.addAttribute(ax);
ax.setAsConstant(false);
}
theBlock.addOriginalAttribute(aa);
aa.setAsConstant(false);
}
// add Constants
size = blk.getNbConstants();
for (int i = 0; i < size; i++) {
StxAttribute a = blk.getConstant(i);
AvatarAttribute aa;
AvatarAttribute ax;
if (a.getType().equals("Integer")) {
aa = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
aa.setInitialValue(a.getInit());
theBlock.addAttribute(aa);
aa.setAsConstant(true);
ax = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
ax.setInitialValue(a.getInit());
theBlock.addAttribute(ax);
ax.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);
ax = new AvatarAttribute(a.getName(), AvatarType.INTEGER, theBlock, null);
ax.setInitialValue(a.getInit());
theBlock.addAttribute(ax);
ax.setAsConstant(true);
else
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR,
a.getLeft(), "datatype for constants is not supported", null));
// 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.addOriginalAttribute(aa);
aa.setAsConstant(false);
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 || returnType.length() == 0) continue;
if (returnType.equals("Integer")) {
am.addReturnParameter(new AvatarAttribute("return__0", AvatarType.INTEGER, theBlock, null));
am.addOriginalReturnParameter(new AvatarAttribute("return__", AvatarType.INTEGER, theBlock, null));
}
else if (returnType.equals("Boolean")) {
am.addReturnParameter(new AvatarAttribute("return__0", AvatarType.BOOLEAN, theBlock, null));
am.addOriginalReturnParameter(new AvatarAttribute("return__", AvatarType.BOOLEAN, theBlock, null));
}
else {
if (adt == null)
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, sm.getLeft(),
"unknown type for method return parameter", null));
AvatarAttribute ret = new AvatarAttribute("return__", AvatarType.UNDEFINED, theBlock, null);
ret.setDataType(adt);
am.addOriginalReturnParameter(ret);
int dtsize = adt.getFullSize();
for (int j = 0; j < dtsize; j++) {
adt.getFieldStringType(j), theBlock, null);
am.addReturnParameter(ret);
}
}
}
// 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);
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
StxChannel ch = ss.getChannel();
if (ch == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, ss.getLeft(),
"channel of signal " + ss.getName() + " has not been set"));
continue;
}
if (!ch.isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, ss.getLeft(),
"channel of signal " + theBlock.getName() + "." + ss.getName() + " has not been declared"));
continue;
}
if (ss.isInput()) {
StxInMessage im = ss.getChannel().getInProfile();
if (im == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, ss.getLeft(),
"input profile of signal " + ss.getName() + " has not been set"));
continue;
}
buildProfile(im, as, theBlock);
}
else {
StxOutMessage om = ss.getChannel().getOutProfile();
if (om == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, ss.getLeft(),
"output profile of signal " + ss.getName() + " has not been set"));
continue;
}
buildProfile(om, 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();
boolean undeclaredState = false;
if (! states[i].isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR,
"state " + theBlock.getName() + "." + states[i].getName() + " is used but not declared"));
stateType = AvatarFromSysMLSyntax.STXSTANDARDSTATE;
undeclaredState = true;
if (stateType != AvatarFromSysMLSyntax.STXPRESENDSTATE &&
stateType != AvatarFromSysMLSyntax.STXPRERECEIVESTATE &&
stateType != AvatarFromSysMLSyntax.STXSTOPSTATE ) {
if (undeclaredState) {
states[i].setType(AvatarFromSysMLSyntax.STXSTANDARDSTATE);
}
theSourceState = getState(states[i], theBlock);
asm.addElement(theSourceState);
if (stateType == AvatarFromSysMLSyntax.STXRANDOMSTATE) {
((AvatarRandom) theSourceState).setOriginalValues(states[i].getMinValue(), states[i].getMaxValue());
((AvatarRandom) theSourceState).setValues(
states[i].getMinValue().replaceAll("\\.", "__"),
states[i].getMaxValue().replaceAll("\\.", "__"));
((AvatarRandom) theSourceState).setVariable(states[i].getVariable().replaceAll("\\.", "__"));
} else if (stateType == AvatarFromSysMLSyntax.STXSTARTSTATE)
asm.setStartState((AvatarStartState) theSourceState);
// add transitions
List<StxTransition> transitions = states[i].getTransitions();
int tsize = transitions.size();
if (tsize > 1 && stateType != AvatarFromSysMLSyntax.STXSTANDARDSTATE) {
tsize = 1;
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, states[i].getTransitions().get(1).getLeft(),
"state " + states[i].getName() + " only accept one single outgoing transition",
states[i].getTransitions().get(1).getRleft()));
}
for (int j = 0; j < tsize; j++) {
StxTransition transition = transitions.get(j);
if (transition == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, states[i].getLeft(),
"something is wrong in state " + states[i].getName() + " : null transition found"));
continue;
}
if (! transition.isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"transition request in state " + states[i].getName() + " of block " + theBlock.getName() +
" has no associated declaration" ));
if (! transition.isRequested()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"transition has no request in state " + states[i].getName()));
continue;
}
AvatarTransition theTransition = new AvatarTransition(theBlock,"", null);
if (transition.getGuard() != null) {
theTransition.setGuard(
"[" + transition.getGuard().replaceAll("\\.", "__") + "]",
"[" + transition.getGuard() + "]");
}
String minDelay = transition.getMinDelay().trim();
String maxDelay = transition.getMaxDelay().trim();
if (minDelay.equals(maxDelay)) maxDelay = "";
theTransition.setDelays(
minDelay.replaceAll("\\.", "__"),
maxDelay.replaceAll("\\.", "__"),
minDelay,
maxDelay);
setDistributionLaw(theTransition, transition.getDelayDistributionLaw(),transition.getDelayExtra(), transition);
theTransition.setProbability(transition.getProbability());
// 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 originalLeftHandStr = action.getTarget();
String leftHandStr = extendIdent(action.getTarget().replaceAll("\\.", "__"), blk);
String originalRightHandStr;
String rightHandStr;
StxTerm value = action.getValue();
if (value instanceof StxId) {
originalRightHandStr = ((StxId)value).toString();
rightHandStr = ((StxId)value).toString().replaceAll("\\.", "__");
}
else if (value instanceof StxExpr){
originalRightHandStr = ((StxExpr)value).toString();
rightHandStr = ((StxExpr)value).toString().replaceAll("\\.", "__");
}
else {
originalRightHandStr = extendOriginalCall((StxCall)value,blk);
rightHandStr = extendCall((StxCall)value,blk);
}
theTransition.addAction(leftHandStr + "=" + rightHandStr,
originalLeftHandStr + "=" + originalRightHandStr);
}
else { // STXMETHODACTION
if (action.getValue() instanceof StxCall) { // else ERROR
String originalTermStr = extendOriginalCall((StxCall)action.getValue(),blk);
String termStr = extendCall((StxCall)action.getValue(),blk);
theTransition.addAction(termStr, originalTermStr);
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"something is wrong in transition : no target defined", transition.getLeft()));
continue;
}
if (transition.getTarget().getType() == AvatarFromSysMLSyntax.STXPRESENDSTATE ||
transition.getTarget().getType() == AvatarFromSysMLSyntax.STXPRERECEIVESTATE) {
if (transition.getTarget().getTransitions().size() == 0 ||
transition.getTarget().getTransition(0) == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getTarget().getLeft(),
"something is wrong in precommunication state " + transition.getTarget().getName() +
" : no outgoing transition"));
continue;
}
byte type = transition.getTarget().getType();
transition = transition.getTarget().getTransition(0);
if (type == AvatarFromSysMLSyntax.STXPRESENDSTATE &
! ( ( transition.getTarget().getType() == AvatarFromSysMLSyntax.STXSENDSTATE &&
transition.getType() == AvatarFromSysMLSyntax.STXSENDTRANSITION ) ||
( transition.getTarget().getType() == AvatarFromSysMLSyntax.STXSETTIMERSTATE &&
transition.getType() == AvatarFromSysMLSyntax.STXSETTIMERTRANSITION ) ||
( transition.getTarget().getType() == AvatarFromSysMLSyntax.STXRESETTIMERSTATE &&
transition.getType() == AvatarFromSysMLSyntax.STXRESETTIMERTRANSITION ) )) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getTarget().getLeft(),
"outgoing transitions from pre-send state must be sending transitions leading to some sending state " +
"(send/set timer /reset timer)", transition.getLeft()));
continue;
}
if (type == AvatarFromSysMLSyntax.STXPRERECEIVESTATE &
! ( ( transition.getTarget().getType() == AvatarFromSysMLSyntax.STXRECEIVESTATE &&
transition.getType() == AvatarFromSysMLSyntax.STXRECEIVETRANSITION ) ||
( transition.getTarget().getType() == AvatarFromSysMLSyntax.STXEXPIRETIMERSTATE &&
transition.getType() == AvatarFromSysMLSyntax.STXEXPIRETIMERTRANSITION ) )) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getTarget().getLeft(),
"outgoing transitions from pre-reveive state must be sending transitions leading to some " +
"receivinging state (receive/expire timer)", transition.getLeft()));
continue;
}
}
AvatarStateMachineElement tgtState;
if (transition.getTarget().getType() == AvatarFromSysMLSyntax.STXSTOPSTATE) {
if (transition.getTarget().getTransitions().size() != 0) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWWARNING, transition.getTarget().getLeft(),
"stopstate should not have outgoing transitions"));
}
tgtState = new AvatarStopState("StopState", null, theBlock);
addState(tgtState, theBlock);
else tgtState = getState(transition.getTarget(), theBlock);
addState(tgtState, theBlock);
byte tgtType = transition.getTarget().getType();
Location tgtLoc = transition.getTarget().getLeft();
if (transition.getType() == AvatarFromSysMLSyntax.STXSENDTRANSITION) {
if(tgtState instanceof AvatarActionOnSignal) {
AvatarActionOnSignal state = (AvatarActionOnSignal)tgtState;
if (transition.getSignal() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"sending transition should have an associated signal", transition.getLeft()));
continue;
}
state.setSignal( getSignal(transition.getSignal()));
if (state.getSignal().isIn()) {
new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"signal of sending transition must be an output signal", transition.getSignal().getLeft());
continue;
}
if (! transition.getSignal().isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, transition.getRleft(),
"transition uses a signal " + transition.getSignal().getName() + " that has not been declared"));
continue;
}
ArrayList<StxTerm> sendPayload = transition.getSendPayload();
if (sendPayload != null) {
int nbParam = sendPayload.size();
for(int u = 0; u < nbParam; u++) {
StxTerm p = sendPayload.get(u);
if (p instanceof StxId) {
state.addOriginalValue(((StxId)p).toString());
String[] ids = extendPath(
((StxId)p).toString().replaceAll("\\.", "__"),
blk).split(",");
int isize = ids.length;
for(int w = 0; w < isize; w++) state.addValue(ids[w]);
}
else if (p instanceof StxExpr) {
state.addOriginalValue( ((StxExpr)p).toString() );
state.addValue( ((StxExpr)p).toString().replaceAll("\\.", "__"));
}
else {
state.addOriginalValue(extendOriginalCall((StxCall)p,blk));
state.addValue(extendCall((StxCall)p,blk));
}
else {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"sending transition should lead to a send state", transition.getRleft()));
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXRECEIVETRANSITION) {
if(tgtState instanceof AvatarActionOnSignal) {
AvatarActionOnSignal state = (AvatarActionOnSignal)tgtState;
if (transition.getSignal() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"receiving transition should have an associated signal", transition.getLeft()));
continue;
}
state.setSignal(getSignal(transition.getSignal()));
if (! transition.getSignal().isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, transition.getRleft(),
"transition uses a signal " + transition.getSignal().getName() + " that has not been declared"));
continue;
}
if (state.getSignal().isOut()) {
new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"signal of receiving transition must be an input signal", transition.getSignal().getLeft());
continue;
}
if (transition.getSignal().getChannel() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getRleft(),
"signal of receiving transition doesn't have an associated channel", transition.getSignal().getLeft()));
continue;
}
StxOutMessage profile = transition.getSignal().getChannel().getOutProfile();
if (profile != null) {
HashMap<String, String> receivePayload = transition.getReceivePayload();
int nbParams = profile.getSize();
for (int k = 0; k < nbParams; k++) {
String value = receivePayload.get(profile.getFieldName(k));
state.addOriginalValue(value);
String[] ids = extendPath(value.replaceAll("\\.", "__"), blk).split(",");
int isize = ids.length;
for(int w = 0; w < isize; w++) state.addValue(ids[w]);
}
}
else {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"receiving transition should lead to a receive state", transition.getRleft()));
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXSETTIMERTRANSITION) {
if(tgtState instanceof AvatarSetTimer) {
AvatarSetTimer state = (AvatarSetTimer) tgtState;
if (transition.getTimer() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"set-timer transition has no associated timer", transition.getRleft()));
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
if (transition.getSendPayload() == null || transition.getSendPayload().size() != 1
|| !(transition.getSendPayload().get(0) instanceof StxExpr)) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"payload of set-timer transition is not well formed", transition.getRleft()));
continue;
}
state.setTimerValue(((StxExpr)transition.getSendPayload().get(0)).toString().replaceAll(".","__"));
state.setTimerOriginalValue(((StxExpr)transition.getSendPayload().get(0)).toString());
}
else {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"set-timer transition should lead to a set-timer state", transition.getRleft()));
}
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXRESETTIMERTRANSITION) {
if(tgtState instanceof AvatarResetTimer) {
AvatarResetTimer state = (AvatarResetTimer) tgtState;
if (transition.getTimer() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"reset-timer transition has no associated timer", transition.getRleft()));
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
}
else {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"reset-timer transition should lead to a reset-timer state", transition.getRleft()));
}
else if (transition.getType() == AvatarFromSysMLSyntax.STXEXPIRETIMERTRANSITION) {
if(tgtState instanceof AvatarExpireTimer) {
AvatarExpireTimer state = (AvatarExpireTimer) tgtState;
if (transition.getTimer() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"expire-timer transition has no associated timer", transition.getRleft()));
state.setTimer(getTimerByName(transition.getTimer(), theBlock));
else {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"expire-timer transition should lead to a expire-timer state", transition.getRleft()));
else if (! (tgtType == AvatarFromSysMLSyntax.STXSTOPSTATE ||
tgtType == AvatarFromSysMLSyntax.STXSTANDARDSTATE ||
tgtType == AvatarFromSysMLSyntax.STXRANDOMSTATE ||
tgtType == AvatarFromSysMLSyntax.STXCOUNTSTATE ||
tgtType == AvatarFromSysMLSyntax.STXSTARTSTATE) ) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, transition.getLeft(),
"transition type is not consistant with the type of its target state", tgtLoc));
continue;
}
asm.addElement(theTransition);
theSourceState.addNext(theTransition);
addTransition(theTransition, tgtState);
theTransition.addNext(tgtState); }
}
}
transitionMap.forEach(new CheckIncommings());
}
}
private class CheckIncommings implements BiConsumer<AvatarStateMachineElement, StateTransitions> {
List<AvatarDataType> dataTypeList;
public CheckIncommings(){}
public void accept(AvatarStateMachineElement e, StateTransitions st) {
int s = st.getTransitions().size();
if (s == 0 && ! (e instanceof AvatarStartState)) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, "state " + e.getName() +
" of block " + st.getBlock().getName() + " is unreachable --> removed"));
st.getBlock().getStateMachine().removeElement(e);
for(AvatarStateMachineElement x : e.getNexts())
st.getBlock().getStateMachine().removeElement(x);
}
if (s > 0 && (e instanceof AvatarStartState)) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, "start state in bloc " +
st.getBlock().getName() + " has some input transition"));
for(int i = 0; i < s; i++) {
st.getTransitions().get(i).getNexts().clear();
AvatarStopState nw = new AvatarStopState("errorstate",null, st.getBlock());
st.getTransitions().get(i).addNext(nw);
st.getBlock().getStateMachine().addElement(nw);
if (s > 1 && !(e instanceof AvatarStartState || e instanceof AvatarStateElement)) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, "state " + e.getName() + " in bloc " +
st.getBlock().getName() + " has more than one incomming transition"));
for(int i = 1; i < s; i++) {
st.getTransitions().get(i).getNexts().clear();
AvatarStopState nw = new AvatarStopState("errorstate",null, st.getBlock());
st.getTransitions().get(i).addNext(nw);
st.getBlock().getStateMachine().addElement(nw);
}
}
private void buildBlocks(){
stxSpec.getBlockMap().forEach(new BuildBlock());
}
private void setDistributionLaw(AvatarTransition _t, String distributionLaw, HashMap<String,String> delayExtra, StxTransition _st) {
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) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, _st.getLeft(),
"transition with unknown transition law : " + distributionLaw + " (set to uniform)"));
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 (extra1 == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, _st.getLeft(),
"transition law : " + distributionLaw + " requires a " + tmpString + " parameter"));
}
if (size > 1) {
extra2 = delayExtra.get(extra2);
if (extra2 == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, _st.getLeft(),
"transition law : " + distributionLaw + " requires a " + tmpString + " parameter"));
}
}
}
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWWARNING, _st.getLeft(),
"transition law : " + distributionLaw + " has too much parameters"));
}
_t.setDistributionLaw(law, extra1, extra2);
}
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);
aa.setAsConstant(false);
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);
aa.setAsConstant(false);
aa = new AvatarAttribute(ss.getFieldName(i), AvatarType.BOOLEAN, b, null);
am.addParameter(aa);
aa.setAsConstant(false);
if (adt == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWWARNING, ss.getLeft(),
"message profile uses undefined datatype " + type));
String aaName = ss.getFieldName(i);
aa = new AvatarAttribute(aaName, AvatarType.UNDEFINED, b, null);
aa.setDataType(adt);
am.addOriginalParameter(aa);
aa.setAsConstant(false);
aaName = aaName + "__";
int dtsize = adt.getFullSize();
for (int j = 0; j < dtsize; j++) {
aa = new AvatarAttribute(aaName + adt.getFieldString(j),
adt.getFieldStringType(j), b, null);
am.addParameter(aa);
aa.setAsConstant(false);
}
}
}
}
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++) {
if (adt == null) return null;
int j;
for (j = 0; j < nbFields; j++)
if (adt.getAttribute(j).getName().equals(path[i])) break;
if (j == nbFields) return null;
AvatarType adtType = adt.getAttribute(j).getType();
if (adtType == AvatarType.INTEGER)
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 == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, location, "attribute " + path.replaceAll("__", "\\.") + " is undefined"));
extendType = null;
return path;
}
if (extendString.equals("Integer") || extendString.equals("Boolean")) {
extendType = null;
return path;
}
extendType = avSpec.getDataTypeByName(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).replaceAll("\\.", "__"), b));
}
result.append(call.getSegment(i));
return result.toString().replaceAll("\\.", "__");
}
private String extendOriginalCall (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(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) {
if (!r.isDeclared()) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR,
"relation " + r.getName() +" has been used but has not been declared"));
int size = r.getSize();
if (size == 0) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWWARNING, r.getLeft(),
"relation is empty"));
return;
} else {
int i = 0;
while (i < size && (r.getChannel(i).getBlockA() == null || r.getChannel(i).getBlockB() == null)) i++;
if (i == size) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR,
"cannot determine blocs of relation " + r.getName()));
return;
}
r.setBlock1(stxSpec.getBlockMap().get(r.getChannel(i).getBlockA()));
r.setBlock2(stxSpec.getBlockMap().get(r.getChannel(i).getBlockB()));
if (r.getBlock1() == null || r.getBlock2() == null) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR,
"cannot determine blocs of relation " + r.getName()));
return;
}
}
}
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();
if (size == 0) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWWARNING, r.getLeft(),
for (int i = 0; i < size; i++) {
StxChannel c = r.getChannel(i);
c.commuteSignals(r.getBlock1().getName());
if (!blk1.getName().equals(c.getBlockA()) || !blk2.getName().equals(c.getBlockB())) {
addError(new AvatarFromSysMLError(AvatarFromSysMLError.HIGHERROR, c.getLeft(),
"inconsistency between blocs of channel " + c.getName() + " and relation " + r.getName()));
continue;
}
if (c.getSignalA() != null && c.getSignalB() != null)
theRelation.addSignals(getSignal(c.getSignalA()),getSignal(c.getSignalB()));
else
addError(new AvatarFromSysMLError(AvatarFromSysMLError.LOWERROR, c.getLeft(),