Add QPC-C target

README.md

@@ -70,6 +70,7 @@ The following target platforms are supported:
   - *SCXML* Transforms the input model into SCXML document(s). The generated SCXML document can be executed by an SCXML interpreted.
   - *ELT-MAL* Transforms the input model into XML/MAL ICD. The generated XML file can be transformed into code using CII tools.
   - *ELT-RAD* Transforms the input model into C++ code, SCXML, XML/MAL ICD, for the Rapid Application Development toolkit (RAD). The generated code can be compiled and executed on a machine installed with the ELT Development Environment and RAD.
+  - *QPC-C* Transofrms the input model into C code representing the state machine logic and structure, using the [Quantum Framework (QP/C)](https://www.state-machine.com/qpc/). 
   - *QPC-QM* Transofrms the input model into a QM file for the [Quantum Modeler](https://www.state-machine.com/qm/). This also generates implementation files that are used for the C code QM will generate.
 
 Generation Modes

comodo2/src/comodo2/engine/Config.java

@@ -28,6 +28,7 @@ public class Config {
 	public final static  String TARGET_PLATFORM_ELT_RAD = "ELT-RAD";    // RAD application (SCXML, MAL, rad.ev)
 	public final static  String TARGET_PLATFORM_ELT_MAL = "ELT-MAL";    // MAL ICD only
 	public final static  String TARGET_PLATFORM_QPC_QM = "QPC-QM";    	// Quantum Framework: Quantum Modeler file format
+	public final static  String TARGET_PLATFORM_QPC_C = "QPC-C";    	// Quantum Framework: direct C generation
 
 	/**
 	 * Platforms specific configuration options

comodo2/src/comodo2/engine/Main.java

@@ -56,7 +56,7 @@ public Options getOptions() {
 		opt.addOption("d", "debug", false, "Enable printing of debug information.");	
 		opt.addOption("i", "input-model", true, "Filepath of the model to transform. Model should be in EMF XMI (.uml) format.");
 		opt.addOption("o", "output-path", true, "Output directory path.");
-		opt.addOption("t", "target-platform", true, "Target platform [SCXML|ELT-RAD|ELT-MAL].");		
+		opt.addOption("t", "target-platform", true, "Target platform [SCXML|ELT-RAD|ELT-MAL|QPC-QM|QPC-C].");		
 		opt.addOption("c", "target-platform-config", true, "Configuration parameters specific to the target platform [NOACTIONSSTD].");
 		opt.addOption("g", "generation-mode", true, "Generation mode [DEFAULT|UPDATE|ALL].");
 		opt.addOption("n", "no-backup", false, "Disable automatic backup of overwritten files.");

comodo2/src/comodo2/queries/QEvent.java

@@ -25,6 +25,10 @@ public String getTimeEventName(final Event e) {
 		}
 	}
 
+	public String getTimeEventDurationString(final TimeEvent e) {
+		return e.getWhen().getExpr().stringValue();
+	}
+
 	public boolean isTimeEvent(final Event e) {
 		return (e instanceof TimeEvent);
 	}

comodo2/src/comodo2/queries/QRegion.java

@@ -49,17 +49,25 @@ public String getRegionName(final Region r) {
 	}
 	 */
 	public String getInitialStateName(final Region r) {
+		State s = this.getInitialState(r);
+		if (s != null) {
+			return mQState.getStateName(s);
+		}
+		return "";
+	}
+
+	public State getInitialState(final Region r) {
 		for (final Pseudostate ps : Iterables.<Pseudostate>filter(r.allOwnedElements(), Pseudostate.class)) {
 			if ((ps.getKind() == PseudostateKind.INITIAL_LITERAL) &&
 			    Objects.equal(ps.getContainer().getOwner(), this.getParentState(r)) &&
 				(ps.getOutgoings().size() == 1)) {
 				Vertex v = ps.getOutgoings().get(0).getTarget();
 				if (v != null) {
-					return  mQState.getStateName((State)v);
+					return  (State)v;
 				}
 			}
 		}
-		return "";
+		return null;
 	}
 
 	public boolean isTopState(final Region r) {

comodo2/src/comodo2/queries/QState.java

@@ -93,18 +93,55 @@ public Iterable<State> getAllFinalSubstates(final State s) {
 		return res;		
 	}
 
+	public Boolean hasInitialSubstate(final State s) {
+		State sub = this.getInitialSubstate(s);
+		if (sub != null) {
+			return true;
+		}		
+		return false;
+	}
+
 	public String getInitialSubstateName(final State s) {
+		State sub = this.getInitialSubstate(s);
+		if (sub != null) {
+			return getStateName(sub);
+		}		
+		return "";
+	}
+
+	/**
+	 * @return The substate of a composite state that is pointed at by the initial node.
+	 */
+	public State getInitialSubstate(final State s) {
 		Iterable<Pseudostate> _filter = Iterables.<Pseudostate>filter(s.allOwnedElements(), Pseudostate.class);		
 		for (final Pseudostate ps : _filter) {
 			if (((((ps.getKind() == PseudostateKind.INITIAL_LITERAL) && 
 					Objects.equal(ps.getContainer().getOwner(), s)) && 
 					(ps.getOutgoings().size() == 1)) && 
 					(Iterables.<Transition>getFirst(ps.getOutgoings(), null).getTarget() != null))) {
-				return getStateName( ((State) Iterables.<Transition>getFirst(ps.getOutgoings(), null).getTarget()) );
+						return ( ((State) Iterables.<Transition>getFirst(ps.getOutgoings(), null).getTarget()) );
 			}
 		}
 
-		return "";
+		return null;
+	}
+
+	/**
+	 * Returns the initial transition of a composite state.
+	 * This is used when the initial transition of a composite state points to a pseudostate (like a choice node)
+	 * which makes getInitialSubstateName(s) throws a ClassCastException.
+	 */
+	public Transition getInitialSubstateTransition(final State s) {
+		Iterable<Pseudostate> _filter = Iterables.<Pseudostate>filter(s.allOwnedElements(), Pseudostate.class);		
+		for (final Pseudostate ps : _filter) {
+			if (((((ps.getKind() == PseudostateKind.INITIAL_LITERAL) && 
+					Objects.equal(ps.getContainer().getOwner(), s)) && 
+					(ps.getOutgoings().size() == 1)) && 
+					(Iterables.<Transition>getFirst(ps.getOutgoings(), null).getTarget() != null))) {
+				return ps.getOutgoings().get(0);
+			}
+		}
+		return null;
 	}
 
 	/**
@@ -234,12 +271,24 @@ public boolean hasTimerTransition(final State s) {
 		}
 		/*
 		final Function1<Transition, Boolean> _function = (Transition e) -> {
-			return Boolean.valueOf((mQTransition.isTimerTransition(e) && e.getSource().getName().matches(s.getName())));
+			return Boolean.valueOf((mQTransition.isTimerTransitionWithEvent(e) && e.getSource().getName().matches(s.getName())));
 		};
 		return !IterableExtensions.isEmpty(IterableExtensions.<Transition>filter(Iterables.<Transition>filter(this.getParentState(s).allOwnedElements(), Transition.class), _function));
 		*/
 		for (Transition e : Iterables.<Transition>filter(getParentState(s).allOwnedElements(), Transition.class)) {
-			if (mQTransition.isTimerTransition(e) && e.getSource().getName().matches(s.getName())) {
+			if (mQTransition.isTimerTransitionWithEvent(e) && e.getSource().getName().matches(s.getName())) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * @return True if State s has at least one outgoing transition that carries a TimeEvent. False otherwise.
+	 */
+	public boolean hasOutgoingTimerTransition(final State s) {
+		for (Transition t : s.getOutgoings()){
+			if (mQTransition.isTimerTransition(t)) {
 				return true;
 			}
 		}
@@ -263,4 +312,100 @@ public boolean hasHistory(final State s) {
 		}
 		return false;
 	}
+
+	/**
+	 * Returns all the pseudostates that are directly owned by State s.
+	 */
+	public Iterable<Pseudostate> getAllDirectlyOwnedPseudostates(final State s) {
+
+		BasicEList<Pseudostate> res = new BasicEList<Pseudostate>();		
+		for (Pseudostate ps : Iterables.<Pseudostate>filter(s.allOwnedElements(), Pseudostate.class)) {
+			if (ps.getKind() == PseudostateKind.ENTRY_POINT_LITERAL || 
+				ps.getKind() == PseudostateKind.EXIT_POINT_LITERAL){
+				// Entry and exit points are directly owned by the composite state
+					if (((State)ps.getOwner()).equals(s)) {
+					res.add(ps);
+				}
+			// other pseudostates are owned by the state's region
+			} else if (ps.getContainer().getState().equals(s)){
+				res.add(ps);
+			}
+		}
+		return res;
+	}
+
+	/**
+	 * Returns all the substates that are directly owned by State s.
+	 */
+	public Iterable<State> getAllDirectSubstates(final State s) {
+		BasicEList<State> res = new BasicEList<State>();
+		for (State e : Iterables.<State>filter(s.allOwnedElements(), State.class)) {
+			if (Objects.equal(getParentState(e), s)) {
+				res.add(e);
+			}
+		}
+		return res;		
+	}
+
+	/**
+	 * Returns all the History nodes that this state is tracked by.
+	 * That is, shallowHistory at depth +1 and all deepHistory that are owned by
+	 * a composite state that also owns this state.
+	 */
+	public BasicEList<Pseudostate> getAllParentHistoryNodes(final State s) {
+		BasicEList<Pseudostate> res = new BasicEList<Pseudostate>();		
+		State p = getParentState(s);
+		Integer depth = 1;
+
+		while (p!=null){
+			for (Pseudostate ps : getAllDirectlyOwnedPseudostates(p)) {
+				// We care about shallow history only at depth 0
+				if ((isHistoryState(ps) && depth <= 1) || ps.getKind() == PseudostateKind.DEEP_HISTORY_LITERAL) {
+					res.add(ps);
+				}
+			}
+			p = getParentState(p);
+			depth++;
+		}
+		return res;
+	}	
+
+	/**
+	 * Returns the duration string of the first TimeEvent that the transitions of the state carry.
+	 * A state should only have one TimeEvent transition.
+	 */
+	public String getFirstTimeEventDurationString(final State s) {		
+		for (Transition t : s.getOutgoings()){
+			if (mQTransition.hasTimeEvent(t)){
+				return mQTransition.getFirstTimeEventDurationString(t);
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the orthogonal region (belonging to an orthogonal state) that State s
+	 * is in, if any. If s in not within any orthogonal region, returns null.
+	 */
+	public Region getParentOrthogonalRegion(final State s) {
+
+		Region parent_region = getParentRegion(s);
+		State parent_state = null;
+
+		if (parent_region == null) {
+			return null;
+		}
+
+		while (parent_region!=null){
+			parent_state = mQRegion.getParentState(parent_region);
+			if (parent_state==null){
+				return null;
+			}
+			if (parent_state.isOrthogonal()){
+				return parent_region;
+			}
+			parent_region = getParentRegion(parent_state);
+		}
+		return null;
+	}
 }