summaryrefslogtreecommitdiffstats
path: root/src/uscxml/transform/ChartToPromela.h
blob: fe0660f7a369c643954674446d3852c43a25f745 (plain)
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
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
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
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
/**
 *  @file
 *  @author     2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
 *  @copyright  Simplified BSD
 *
 *  @cond
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the FreeBSD license as published by the FreeBSD
 *  project.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 *  You should have received a copy of the FreeBSD license along with this
 *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
 *  @endcond
 */

#ifndef CHARTTOPROMELA_H_RP48RFDJ
#define CHARTTOPROMELA_H_RP48RFDJ

#include "Transformer.h"
#include "ChartToFSM.h"
#include "uscxml/interpreter/InterpreterDraft6.h"
#include "uscxml/DOMUtils.h"
#include "uscxml/util/Trie.h"

#include <DOM/Document.hpp>
#include <DOM/Node.hpp>
#include <XPath/XPath.hpp>
#include <ostream>

namespace uscxml {

class PromelaCodeAnalyzer;
	
class USCXML_API PromelaInline {
public:
	PromelaInline() : type(PROMELA_NIL) {}

	operator bool() {
		return (type != PROMELA_NIL);
	}

	void dump();

	enum PromelaInlineType {
		PROMELA_NIL,
		PROMELA_CODE,
		PROMELA_EVENT_SOURCE,
		PROMELA_EVENT_SOURCE_CUSTOM,
		PROMELA_PROGRESS_LABEL,
		PROMELA_ACCEPT_LABEL,
		PROMELA_END_LABEL
	};

	std::string content;
	PromelaInlineType type;
};

class USCXML_API PromelaEventSource {
public:
	
	enum PromelaEventSourceType {
		PROMELA_EVENT_SOURCE_INVALID,
		PROMELA_EVENT_SOURCE_INVOKER,
		PROMELA_EVENT_SOURCE_GLOBAL,
	};
	
	PromelaEventSource();
	PromelaEventSource(const PromelaInline& source, uint32_t externalQueueLength = 0);
	
	void writeStart(std::ostream& stream, int indent = 0);
	void writeStop(std::ostream& stream, int indent = 0);
	void writeDeclarations(std::ostream& stream, int indent = 0);
	void writeBody(std::ostream& stream);
	
	operator bool() {
		return type != PROMELA_EVENT_SOURCE_INVALID;
	}
	
	PromelaInline source;
	std::string name;
	uint32_t externalQueueLength;
	
	Arabica::DOM::Node<std::string> container;
	std::list<std::list<std::string> > sequences;
	PromelaEventSourceType type;
	PromelaCodeAnalyzer* analyzer;
};

class USCXML_API PromelaInlines {
public:
	
	static PromelaInlines fromNodeSet(const Arabica::XPath::NodeSet<std::string>& node, bool recurse = false);
	static PromelaInlines fromNode(const Arabica::DOM::Node<std::string>& node);
	static PromelaInlines fromString(const std::string& text);
	
	PromelaInlines(const std::string& text, const Arabica::DOM::Node<std::string>& node);
	PromelaInlines();

	void merge(const PromelaInlines& other) {
		code.insert(code.end(), other.code.begin(), other.code.end());
		nrProgressLabels += other.nrProgressLabels;
		nrAcceptLabels += other.nrAcceptLabels;
		nrEndLabels += other.nrEndLabels;
		nrEventSources += other.nrEventSources;
		nrCodes += other.nrCodes;
	}

	operator bool() {
		return code.size() > 0;
	}

	std::list<PromelaInline> code;
	int nrProgressLabels;
	int nrAcceptLabels;
	int nrEndLabels;
	int nrEventSources;
	int nrCodes;
};

class USCXML_API PromelaCodeAnalyzer {
public:
	class PromelaTypedef {
	public:
		PromelaTypedef() : arraySize(0), minValue(0), maxValue(0) {}
		std::string name;
		std::string type;
		size_t arraySize;
		size_t minValue;
		size_t maxValue;
		std::map<std::string, PromelaTypedef> types;

		bool operator==(const PromelaTypedef& other) const {
			return name == other.name;
		}

	};

	PromelaCodeAnalyzer() : _eventTrie("."), _lastStrIndex(1), _lastStateIndex(0), _lastEventIndex(1), _usesInPredicate(false), _usesPlatformVars(false) {
	}

	void addCode(const std::string& code);
	void addEvent(const std::string& eventName);
	void addState(const std::string& stateName);
	void addOrigState(const std::string& stateName);
	void addLiteral(const std::string& stateName, int forceIndex = -1);

	bool usesComplexEventStruct() {
		return _typeDefs.types.find("_event") != _typeDefs.types.end() && _typeDefs.types["_event"].types.size() > 0;
	}
	bool usesEventField(const std::string& fieldName) {
		if (usesComplexEventStruct() && _typeDefs.types["_event"].types.find(fieldName) != _typeDefs.types["_event"].types.end())
			return true;
		return false;
	}

	bool usesInPredicate() {
		return _usesInPredicate;
	}
	bool usesPlatformVars() {
		return _usesPlatformVars;
	}

	std::string macroForLiteral(const std::string& literal);
	int indexForLiteral(const std::string& literal);

	std::set<std::string> getLiterals() {
		return _strLiterals;
	}
	std::set<std::string> getEventsWithPrefix(const std::string& prefix);
	std::map<std::string, int>& getEvents() {
		return _events;
	}

	std::map<std::string, int>& getStates() {
		return _states;
	}

	std::map<std::string, int>& getOrigStates() {
		return _origStateIndex;
	}


	Trie& getTrie() {
		return _eventTrie;
	}

	std::string replaceLiterals(const std::string code);

	PromelaTypedef& getTypes() {
		return _typeDefs;
	}

protected:
	std::string createMacroName(const std::string& literal);
	int enumerateLiteral(const std::string& literal, int forceIndex = -1);

	std::set<std::string> _strLiterals;                 // all string literals
	std::map<std::string, std::string> _strMacroNames;  // macronames for string literals
	std::map<std::string, int> _strIndex;               // integer enumeration for string
	std::map<std::string, int> _origStateIndex;         // state enumeration for original states

	std::map<std::string, int> _states;
	std::map<std::string, int> _events;

	PromelaTypedef _typeDefs;

	Trie _eventTrie;

private:
	std::set<std::string> _macroNameSet; // helper set for uniqueness of macros
	int _lastStrIndex;
	int _lastStateIndex;
	int _lastEventIndex;
	bool _usesInPredicate;
	bool _usesPlatformVars;
};

class ExecContentSeqItem {
public:
	enum ExecContentType {
		EXEC_CONTENT_ALL_BUT,
		EXEC_CONTENT_ONLY_FOR,
		EXEC_CONTENT_EVERY
	};

	ExecContentSeqItem(ExecContentType type, const std::set<GlobalTransition*>& transitions, const GlobalTransition::Action& action)
	: type(type), transitions(transitions), action(action) {}
	ExecContentSeqItem(ExecContentType type, GlobalTransition* transition, const GlobalTransition::Action& action)
	: type(type), action(action) {
		transitions.insert(transition);
	}
	
	ExecContentType type;
	std::set<GlobalTransition*> transitions;
	GlobalTransition::Action action;
};

class HistoryTransitionClass {
public:
	HistoryTransitionClass(GlobalTransition* transition);
	HistoryTransitionClass(const std::string& from, const std::string& to);
	
	void init(const std::string& from, const std::string& to);
	
	std::map<std::string, std::set<std::string> > toRemember;
	std::map<std::string, std::set<std::string> > toKeep;
	std::map<std::string, std::set<std::string> > toForget;
	
	std::set<GlobalTransition*> members;


	void merge(const HistoryTransitionClass& other);
	bool matches(const HistoryTransitionClass& other);
};
	
class USCXML_API ChartToPromela : public TransformerImpl, public ChartToFSM {
public:

	virtual ~ChartToPromela() {}
	static Transformer transform(const Interpreter& other);
	
	void writeTo(std::ostream& stream);
	
protected:
	ChartToPromela(const Interpreter& other) : TransformerImpl(), ChartToFSM(other) {}

	void initNodes();

	static std::string beautifyIndentation(const std::string& code, int indent = 0);

	void writeProgram(std::ostream& stream);

	void writeEvents(std::ostream& stream);
	void writeStates(std::ostream& stream);
	void writeStateMap(std::ostream& stream);
	void writeHistoryArrays(std::ostream& stream);
	void writeTypeDefs(std::ostream& stream);
	void writeStrings(std::ostream& stream);
	void writeDeclarations(std::ostream& stream);
	void writeEventSources(std::ostream& stream);
	void writeTransition(std::ostream& stream, GlobalTransition* transition, int indent = 0);
	std::string conditionalizeForHist(const std::set<GlobalTransition*>& transitions, int indent = 0);
	std::string conditionalizeForHist(GlobalTransition* transition, int indent = 0);
	void writeHistoryAssignments(std::ostream& stream, GlobalTransition* transition, int indent = 0);
	void writeTransitionClosure(std::ostream& stream, GlobalTransition* transition, GlobalState* state, int indent = 0);

	void writeExecutableContent(std::ostream& stream, const Arabica::DOM::Node<std::string>& node, int indent = 0);
	void writeInlineComment(std::ostream& stream, const Arabica::DOM::Node<std::string>& node);
	void writeFSM(std::ostream& stream);
	void writeEventDispatching(std::ostream& stream);
	void writeMain(std::ostream& stream);

	void writeIfBlock(std::ostream& stream, const Arabica::XPath::NodeSet<std::string>& condChain, int indent = 0);
	void writeDispatchingBlock(std::ostream& stream, std::list<GlobalTransition*>, int indent = 0);

	Arabica::XPath::NodeSet<std::string> getTransientContent(const Arabica::DOM::Element<std::string>& state, const std::string& source = "");
	//Arabica::DOM::Node<std::string> getUltimateTarget(const Arabica::DOM::Element<std::string>& transition);
	
	static std::string declForRange(const std::string& identifier, long minValue, long maxValue, bool nativeOnly = false);
	static std::string conditionForHistoryTransition(const GlobalTransition* transition);

//	std::string replaceStringsInExpression(const std::string& expr);

	std::string sanitizeCode(const std::string& code);

//	Arabica::XPath::NodeSet<std::string> _globalStates;
//	Arabica::DOM::Node<std::string> _startState;
//	std::map<std::string, Arabica::DOM::Element<std::string> > _states;
//	std::map<Arabica::DOM::Element<std::string>, int> _transitions;

	std::list<std::string> _varInitializers; // pending initializations for arrays

	PromelaCodeAnalyzer _analyzer;

	uint32_t _externalQueueLength;
	uint32_t _internalQueueLength;
	
	std::map<std::string, PromelaEventSource> _invokers;
	PromelaEventSource _globalEventSource;
	
	std::map<std::string, std::map<std::string, size_t> > _historyMembers; // ids of all history states

	friend class PromelaEventSource;
};

}

#endif /* end of include guard: CHARTTOPROMELA_H_RP48RFDJ */