added metadepth and pypdevs exporter

plugins/exportmmtomd.js

@@ -0,0 +1,247 @@
+{	
+	'interfaces': [{'method':'POST', 'url=':'/exportmmtomd'}],
+	'csworker':
+		function(resp, method, uri, reqData, wcontext) {
+			var actions = [__wHttpReq('GET', '/current.model?wid=' + wcontext.__aswid)];
+			_do.chain(actions) (
+				function(asdata) {
+					var writeActions = [_fspp.mkdirs('./exported_to_md/')];
+					_do.chain(writeActions) (
+						function() {
+							var file_contents = '';
+							var as = _utils.jsonp(asdata['data']);
+							var edges = {};
+							var superclasses = {};
+							var superclasses_ids = {};
+							
+							// R: Replace $* by Node ($* is the wildcard class of AToMPM: metaDepth's Node)
+							// R: This is still not 100% safe since Node is no longer in the reservedWordsPattern, 
+							// so a class could be called Node in atompm and give a compilation error in metadepth
+							for (var key in as.nodes) {
+								var node = as.nodes[key];
+								if (node.name != null && node.name.value == '$*') {
+									node.name.value = 'Node';
+								}
+							}
+							
+							/* 
+							R: Start variable name fixing 
+							*/
+							var reservedWordsPattern = /(Sequence|Model|Edge|Link)/;
+							var escapes = [[/\//g, "\\\/"], [/\\/g, "\\\\"]];
+							var nonWordCharPattern = /\W/g; // A word character is a character from a-z, A-Z, 0-9, including the _ (underscore) character.		
+							function fixName(name) {
+								name = name.replace(nonWordCharPattern, '_');
+								var matchArr = name.match(reservedWordsPattern);
+								if (matchArr != null) {
+									name = name.replace(matchArr[0], matchArr[0] + '0');
+								}
+								return name;
+							}
+							function escapeString(str) {
+								for (i in escapes) {
+									str = str.replace(escapes[i][0], escapes[i][1]);
+								}
+								return str;
+							}
+							
+							for (var key in as.nodes) {
+								// All names of Nodes
+								// console.log(as);
+								var node = as.nodes[key];
+								if (node.name != null) {
+									node.name.value = fixName(node.name.value);
+									// console.log(node.name);
+									// console.log(node.attributes);
+									if (node.attributes != null) {
+										for (var prop in node.attributes['value']) {
+											// All names of attributes and (default) values
+											node.attributes['value'][prop].name = fixName(node.attributes['value'][prop].name);
+											if (node.attributes['value'][prop].type == 'string' | node.attributes['value'][prop].type == 'code')
+												node.attributes['value'][prop]['default'] = escapeString(node.attributes['value'][prop]['default']);
+										}
+									}
+								}
+							}
+							/* 
+							R: End variable name fixing
+							*/
+							
+							extract_md_type = function(mm) {
+								mm_parts = mm.split('/');
+								return fixName(mm_parts[mm_parts.length - 1]); // R: Add fixName() here to apply it to types as well
+							};
+							
+							for (var i = 0; i < as.edges.length; i += 2) {
+								if (as.edges[i].dest != as.edges[i + 1].src) console.error('The source and destination of the edge are different!');
+								if (extract_md_type(as.nodes[as.edges[i].dest]['$type']) == 'Inheritance') {
+									if (!(as.edges[i].src in superclasses)) {
+										superclasses[as.edges[i].src] = [];
+										superclasses_ids[as.edges[i].src] = [];
+									}
+									superclasses[as.edges[i].src].push(as.nodes[as.edges[i + 1].dest]['name']['value']);
+									superclasses_ids[as.edges[i].src].push(as.edges[i + 1].dest);
+								} else {
+									edges[as.edges[i].dest] = ([as.edges[i].src, as.edges[i + 1].dest]);
+								}
+							};
+							// Add superclass Link to all Edges (this is class is not present in AToMPM thus not contained in as.nodes)
+							for (var key in as.nodes) {
+								// console.log(key);
+								var node = as.nodes[key];
+								if (key in edges) {
+									superclasses[key] = ['Link'];
+								}
+							}
+							
+							file_contents += 'Model ' + reqData['name'] + ' {\n'
+							
+							var sorted_nodes = [];
+							var sorted_edges = [];
+							var nodes_no_superclasses = [];
+							var c_to_superclass = {}
+							// copy superclasses dictionary
+							for (var key in superclasses_ids) {
+								c_to_superclass[key] = superclasses_ids[key].slice(0);
+							}
+							// create reverse of superclasses: mapping of class to its subclasses
+							var c_to_subclasses = {};
+							for (var key in superclasses_ids) {
+								// console.error(superclasses_ids[key]);
+								for (var i in superclasses_ids[key]) {
+									var sc = superclasses_ids[key][i];
+									if (!(sc in c_to_subclasses)) {
+										c_to_subclasses[sc] = [];
+									}
+									c_to_subclasses[sc].push(key);
+								}
+							}
+							// get all nodes without any superclasses
+							for (var key in as.nodes) {
+								if (!(key in superclasses_ids)) {
+									nodes_no_superclasses.push(key)
+								}
+							}
+							// topological sort
+							while (nodes_no_superclasses.length > 0) {
+								var n = nodes_no_superclasses.pop();
+								if (n in edges) {
+									sorted_edges.push(n);
+								} else {
+									sorted_nodes.push(n);
+								}
+								for (var i in c_to_subclasses[n]) {
+									sc = c_to_subclasses[n][i];
+									// console.error(c_to_superclass[sc]);
+									c_to_superclass[sc].splice(c_to_superclass[sc].indexOf(n), 1);
+									// console.error(c_to_superclass[sc]);
+									if (c_to_superclass[sc].length == 0) {
+										nodes_no_superclasses.push(sc);
+									}
+								}
+							}
+							
+							sorted_nodes = sorted_nodes.concat(sorted_edges);
+							// console.log('as.nodes:');
+							// console.log(as.nodes);
+							// console.log('as.edges:');
+							// console.log(as.edges);
+							// console.log('edges:');
+							// console.log(edges);
+							
+							// If there is at least an edge in the model, add the Link superclass since all edges will extend it
+							// console.log(edges);
+							if (edges !== {}) { // BUG: This check is currently not working.
+								file_contents += 
+								'Node Link {\n' +
+								'src : Node;\n' +
+								'dst : Node;\n' +
+								'}\n';
+							}
+							while (sorted_nodes.length > 0) {
+								key = sorted_nodes.shift();
+								var node = as.nodes[key];
+							
+								if (!(node["$type"].search('GlobalConstraint') >= 0 || node["$type"].search('GlobalAction') >= 0 || node["$type"].search('Inheritance') >= 0|| node.name.value == "Node")) {
+									// if (key in edges) {
+										/*
+										var incoming, outgoing;
+										for (var e in edges) {
+											if (edges[e][0] == key) {
+												outgoing = edges[e][1];
+											} else if (edges[e][1] == key) {
+												incoming = edges[e][0];
+											}
+										}
+										*/
+									// var incoming = [];
+									// var outgoing = [];
+									// for (var e in edges) {
+										// if (edges[e][0] == key) {
+											// outgoing.push(e);
+										// } 
+										// if (edges[e][1] == key) {
+											// incoming.push(e);
+										// }
+									// }
+									// No abstract classes in pattern metamodel (RAMification)
+									file_contents += 	'Node ' 
+														+ node.name.value
+														+ (key in superclasses ? ': ' + superclasses[key].join(', ') : ' ')
+														+ '{\n';
+									// if (incoming.length) {
+									// file_contents += 	                    
+														// incoming.map(function(i) {return 'in' + as.nodes[i].name.value + 
+														// ': ' + as.nodes[edges[i][0]]['name']['value'] + '[*];'}).join('\n')
+														// + '\n';
+									// }
+									// if (outgoing.length) {
+									// file_contents += 	                    
+														// outgoing.map(function(i) {return 'out' + as.nodes[i].name.value + 
+														// ': ' + as.nodes[edges[i][1]]['name']['value'] + '[*];'}).join('\n')
+														// + '\n';
+									// }
+									var typemapping = {
+									'bool': 'boolean',
+									'string': 'String',
+									'list<string>': 'String[*]',
+									'list<bool>': 'boolean[*]',
+									'list<int>': 'int[*]',
+									'list<float>': 'double[*]',
+									'list<double>': 'double[*]',
+									'list<real>': 'double[*]',
+									'code': 'String'
+									}
+									
+									// DEPRECATED: No longer needed after adding the Link Node
+									// if (key in edges) {
+										// file_contents += 'in : ' + as.nodes[edges[key][0]]['name']['value'] +';\n';
+										// file_contents += 'out : ' + as.nodes[edges[key][1]]['name']['value'] +';\n';
+									// }
+									
+									for (var prop in node.attributes['value']) {
+										t = node.attributes['value'][prop].type;
+										file_contents += node.attributes['value'][prop].name + ':' + (t in typemapping ? typemapping[t] : t) + (node.attributes['value'][prop]['default'] != '' ?  ' = ' + (t.search('list') >= 0 ? '[' : '') + node.attributes['value'][prop]['default'] + (t.search('list') >= 0 ? ']' : '') : '') + ';\n';
+									}
+									file_contents += '}\n';	
+								};
+							};
+							file_contents += '}\n';
+							_fs.writeFileSync('./exported_to_md/' + reqData['name'] + '.mdepth', file_contents);
+							__postMessage({	'statusCode': 200,
+											'respIndex': resp});
+						},
+						function(writeErr) {__postInternalErrorMsg(resp, writeErr);}
+					);					
+				},
+				function(err) {__postInternalErrorMsg(resp, err);}
+			)
+		},
+	'asworker':
+		function(resp, method, uri, reqData, wcontext)
+		{
+			__postMessage(
+				{'statusCode': 200,
+					 'respIndex': resp});	
+		}
+}

plugins/exportmtomd.js

@@ -0,0 +1,190 @@
+{
+	
+	'interfaces': [{'method':'POST', 'url=':'/exportmtomd'}],
+	'csworker':
+		function(resp, method, uri, reqData, wcontext) {
+			var actions = [__wHttpReq('GET', '/current.model?wid=' + wcontext.__aswid)];
+			_do.chain(actions) (
+				function(asdata) {
+					var writeActions = [_fspp.mkdirs('./exported_to_md/')];
+					_do.chain(writeActions) (
+						function() {
+							var file_contents = '';
+							var as = _utils.jsonp(asdata['data']);
+							var mms = as['metamodels'];
+
+							/*
+							R: If a pattern metamodel is found: add the original metamodel to the imports list (if not already present)
+							e.g. rpg.pattern --> rpg
+							*/
+							var mmsToAdd = [];
+							for (var i in mms) {
+								var mm = mms[i];
+								var pos = mm.search(".pattern");
+								if (pos != -1) {
+									var mmToAdd = mm.replace(".pattern", "");
+									if (mms.indexOf(mmToAdd) == -1) {
+										mms.push(mmToAdd);
+									}
+								}
+							}
+							
+							/* 
+							R: Start variable name fixing 
+							*/
+							var reservedWordsPattern = /(Sequence|Model|)/g;
+							var stringEscapingPattern = /\\/g;
+							// A word character is a character from a-z, A-Z, 0-9, including the _ (underscore) character.
+							var nonWordCharPattern = /\W/g;
+							var reservedWordsPattern = /(Sequence|Model|Edge|Node)/;
+							var escapes = [[/\//g, "\\\/"], [/\\/g, "\\\\"], [/\"/g, "\\\""]];
+							var nonWordCharPattern = /\W/g; // A word character is a character from a-z, A-Z, 0-9, including the _ (underscore) character.		
+							function fixName(name) {
+								name = name.replace(nonWordCharPattern, '_');
+								var matchArr = name.match(reservedWordsPattern);
+								if (matchArr != null) {
+									name = name.replace(matchArr[0], matchArr[0] + '0');
+								}
+								return name;
+							}
+							function escapeString(str) {
+								for (i in escapes) {
+									str = str.replace(escapes[i][0], escapes[i][1]);
+								}
+								return str;
+							}
+							for (var key in as.nodes) {
+								// All names of Nodes
+								var node = as.nodes[key];
+								// console.log(node.$type);
+								// console.log(node);
+								if (node['$type'] != null) { // Fix node name
+									parts = node['$type'].split('/');
+									node['$type'] = parts.join('/').replace(parts[parts.length - 1], fixName(parts[parts.length - 1]));
+								}
+								for (var prop in node) {
+									if (prop != '$type') {
+										// All names and values of properties
+										if (node[prop]['type'] == 'string' | node[prop]['type'] == 'code')
+											node[prop]['value'] = escapeString(node[prop]['value']);
+									}
+								}
+							}
+							/* 
+							R: End variable name fixing
+							*/
+							
+							extract_md_type = function(mm) {
+								mm_parts = mm.split('/');
+								return fixName(mm_parts[mm_parts.length - 1]); // R: Add fixName() here to apply it to types as well
+							};
+							// Import extra metamodels
+							for (var i = mms.length - 1; i >= 0; i--) {
+								file_contents += 'load "' + extract_md_type(mms[i]) + '"\n';
+							};
+							// FIX: Define an auxiliary metamodel which imports all other metamodels and is then instantiated by the main model
+							var mm = extract_md_type(mms[0]);
+							var modelName = reqData['name'];
+							mm = 'Metamodel';
+							file_contents += '\nModel ' + mm + ' imports ';
+							for (var i = 0; i < mms.length - 1; i++) {
+								file_contents += extract_md_type(mms[i]) + ', ';
+							};
+							file_contents += extract_md_type(mms[mms.length - 1])
+							file_contents += ' {} \n\n';
+							var edges = {};
+							for (var i = 0; i < as.edges.length; i += 2) {
+								if (as.edges[i].dest != as.edges[i + 1].src) console.error('The source and destination of the edge are different!');
+								edges[as.edges[i].dest] = ([as.edges[i].src, as.edges[i + 1].dest]);
+							};
+							// Model definition
+							file_contents += mm + ' ' + modelName + ' {\n'
+							// console.log('------------');
+							// console.log(as.nodes);
+							// console.log('------------');
+							// console.log(as.edges);
+							// console.log('------------');
+							for (var key in as.nodes) {
+									var node = as.nodes[key];
+									// console.log('-----start-----');
+									// console.log(node);
+									var node_type = extract_md_type(node['$type']);
+									file_contents += node_type + ' ' + node_type + '_' + key;
+									file_contents += ' {\n';
+
+									if (key in edges) {
+										file_contents += 'src = ' + extract_md_type(as.nodes[edges[key][0]]['$type']) + '_' + edges[key][0] +';\n';
+										file_contents += 'dst = ' + extract_md_type(as.nodes[edges[key][1]]['$type']) + '_' + edges[key][1] +';\n';
+									}
+									// var incoming = [];
+									// var outgoing = [];
+									// for (var e in edges) {
+										// if (edges[e][0] == key) {
+											// outgoing.push(e);
+										// } 
+										// if (edges[e][1] == key) {
+											// incoming.push(e);
+										// }
+									// }
+
+									// if (incoming.length) {
+										// file_contents += 
+											// incoming.map(function(key) {
+												// var edge = edges[key];
+												// var srcKey = edge[0];
+												// var attr = 'in' + extract_md_type(as.nodes[key]['$type']);
+												// var type = extract_md_type(as.nodes[srcKey]['$type']);
+												// var name = type + '_' + srcKey;
+												// return attr + ' = ' + name + ';';
+											// }).join('\n') + '\n'
+										// ;
+									// }
+									// if (outgoing.length) {
+										// file_contents += 
+											// outgoing.map(function(key) {
+												// var edge = edges[key];
+												// var destKey = edge[1];
+												// var attr = 'out' + extract_md_type(as.nodes[key]['$type']);
+												// var type = extract_md_type(as.nodes[destKey]['$type']);
+												// var name = type + '_' + destKey;
+												// return attr + ' = ' + name + ';';
+											// }).join('\n') + '\n'
+										// ;
+									// }
+									for (var prop in node) {
+										if (prop != '$type') {
+											var pre = '';
+											var post = '';
+											if (node[prop]['type'] == 'string' | node[prop]['type'] == 'code') {
+												pre = '"';
+												post = '"';
+											} else if (node[prop]['type'].search('list') >= 0) {
+												pre = '[';
+												post = ']';
+											}
+											// fixName should be extracted from here and done at the start
+											file_contents += fixName(prop) + ' = ' + pre + node[prop]['value'] + post + ';\n';
+										}
+									}
+									file_contents += '}\n';
+								// }
+							};
+							file_contents += '}\n'
+							_fs.writeFileSync('./exported_to_md/' + reqData['name'] + '.mdepth', file_contents);
+							__postMessage({	'statusCode': 200,
+											'respIndex': resp});
+						},
+						function(writeErr) {__postInternalErrorMsg(resp, writeErr);}
+					);					
+				},
+				function(err) {__postInternalErrorMsg(resp, err);}
+			)
+		},
+	'asworker':
+		function(resp, method, uri, reqData, wcontext)
+		{
+			__postMessage(
+				{'statusCode': 200,
+					 'respIndex': resp});	
+		}
+}

plugins/exporttoppdevs.js

@@ -0,0 +1,302 @@
+{
+	
+	'interfaces': [{'method':'POST', 'url=':'/exportmtoppdevs'}],
+	'csworker':
+		function(resp, method, uri, reqData, wcontext) {
+			var actions = [__wHttpReq('GET', '/current.model?wid=' + wcontext.__aswid)];
+			_do.chain(actions) (
+				function(asdata) {
+					var writeActions = [_fspp.mkdirs('./exported_to_pypdevs/')];
+					_do.chain(writeActions) (
+						function() {
+							var file_contents = '',
+								as = _utils.jsonp(asdata['data']),
+								type_map = {},
+								type_map_keys = {},
+								incoming = {},
+								outgoing = {};
+							
+							file_contents += 'import sys\n'
+							file_contents += 'sys.path.append("../../pypdevs/src/")\n\n'
+							file_contents += 'from DEVS import *\n'
+							file_contents += 'from infinity import INFINITY\n'
+							file_contents += 'from util import *\n\n'
+							
+							for (var key in as.nodes) {
+								var node = as.nodes[key];
+								if (!(node['$type'] in type_map)) {
+									type_map[node['$type']] = [];
+									type_map_keys[node['$type']] = [];
+								}
+								type_map[node['$type']].push(node);
+								type_map_keys[node['$type']].push(key);
+								node['$key'] = key;
+							}
+							
+							function safe_add(l, el) {
+								if (l.indexOf(el) == -1) {
+									l.push(el);
+								}
+							}
+							
+							function calc_in_out_rel(rel_type) {
+								for (var idx in type_map_keys[rel_type]) {
+									key = type_map_keys[rel_type][idx];
+									incoming[key] = [];
+									outgoing[key] = [];
+									for (var e_key in as.edges) {
+										var e = as.edges[e_key];
+										if (e['dest'] == key) {
+											safe_add(incoming[key], e['src'])
+											if (!(e['src'] in outgoing)) {
+												outgoing[e['src']] = [];
+											}
+											safe_add(outgoing[e['src']], key);
+										}
+										if (e['src'] == key) {
+											safe_add(outgoing[key], e['dest'])
+											if (!(e['dest'] in incoming)) {
+												incoming[e['dest']] = [];
+											}
+											safe_add(incoming[e['dest']], key);
+										}
+									}
+								}
+							}
+							
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/states');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/ports');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/channel');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/statedef');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/submodels');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/ExternalTransition');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/InternalTransition');
+							calc_in_out_rel('/Formalisms/ParallelDEVS/ParallelDEVS/ConfluentTransition');
+							
+							for (var key in type_map['/Formalisms/ParallelDEVS/ParallelDEVS/StateDefinition']) {
+								var node = type_map['/Formalisms/ParallelDEVS/ParallelDEVS/StateDefinition'][key],
+									list_of_params = ['name=""'].concat(node['parameters']['value'].map(function(el) {return el['name'] + '=None'})),
+									list_of_param_names = ['name'].concat(node['parameters']['value'].map(function(el) {return el['name']})),
+									list_of_attrs = [['name', '']].concat(node['attributes']['value'].map(function(el) {return [el['name'], el['default']]}));
+								file_contents += 'class ' + node['name']['value'] + ':\n';
+								file_contents += '\tdef __init__(self, ' + list_of_params.join(', ') + '):\n';
+                                file_contents += list_of_attrs.map(function(el) {return '\t\tself.' + el[0] + ' = ' + (list_of_param_names.indexOf(el[0]) != -1 ? el[0] : el[1])}).join('\n') + "\n";
+                                file_contents += node['__init__']['value'].split('\n').map(function(line) {return '\t\t' + line}).join('\n');
+								file_contents += '\n\n';
+							}
+							
+							for (var key in type_map['/Formalisms/ParallelDEVS/ParallelDEVS/Event']) {
+								var node = type_map['/Formalisms/ParallelDEVS/ParallelDEVS/Event'][key],
+									list_of_params = (node['parameters']['value'].map(function(el) {return el['name'] + '=None'})),
+									list_of_param_names = (node['parameters']['value'].map(function(el) {return el['name']})),
+									list_of_attrs = (node['attributes']['value'].map(function(el) {return [el['name'], el['default']]}));
+								file_contents += 'class ' + node['name']['value'] + ':\n';
+								file_contents += '\tdef __init__(self, ' + list_of_params.join(', ') + '):\n';
+								file_contents += list_of_attrs.map(function(el) {return '\t\tself.' + el[0] + ' = ' + (list_of_param_names.indexOf(el[0]) != -1 ? el[0] : el[1])}).join('\n') + "\n";
+                                file_contents += node['__init__']['value'].split('\n').map(function(line) {return '\t\t' + line}).join('\n');
+								file_contents += '\n\n';
+								file_contents += '\tdef __str__(self):\n';
+								file_contents += '\t\treturn "' + node['name']['value'] + '(" + ' + list_of_attrs.map(function(el) {return 'str(self.' + el[0] + ')'}).join(' + ", " + ') + ' + ")"';
+								file_contents += '\n\n';
+							}
+							
+							for (var idx in type_map['/Formalisms/ParallelDEVS/ParallelDEVS/AtomicDEVS']) {
+								var node = type_map['/Formalisms/ParallelDEVS/ParallelDEVS/AtomicDEVS'][idx],
+									list_of_params = (node['parameters']['value'].map(function(el) {return el['name'] + '=None'})),
+									list_of_param_names = (node['parameters']['value'].map(function(el) {return el['name']})),
+									list_of_attrs = (node['attributes']['value'].map(function(el) {return [el['name'], el['default']]}));
+								file_contents += 'class ' + node['name']['value'] + '(AtomicDEVS):\n';
+								file_contents += '\tdef __init__(' + (['self', 'name="' + node['name']['value'] + '"'].concat(list_of_params).join(', ')) + '):\n';
+								file_contents += '\t\tAtomicDEVS.__init__(self, name)\n';
+								file_contents += list_of_attrs.map(function(el) {return '\t\tself.' + el[0] + ' = ' + (list_of_param_names.indexOf(el[0]) != -1 ? el[0] + ' if ' + el[0] + ' is not None else ' + el[1] : el[1])}).join('\n');
+								file_contents += '\n';
+								key = type_map_keys['/Formalisms/ParallelDEVS/ParallelDEVS/AtomicDEVS'][idx];
+								statedef = as.nodes[outgoing[outgoing[key].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/statedef'})[0]][0]];
+								states = outgoing[key].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/states'}).map(function(statesid) {return outgoing[statesid][0]}).map(function(sid) {return as.nodes[sid]});
+								defstate = states.filter(function(el) {return el['initial']['value']})[0]
+								list_of_assigns = ['name="' + defstate['name']['value'] + '"'].concat(statedef['initial_binding']['value'].map(function(el) {return el['name'] + '=' + el['val']}))
+								file_contents += '\t\tself.state = ' + statedef['name']['value'] + '(' + list_of_assigns.join(', ') + ')\n';
+                                file_contents += node['__init__']['value'].split('\n').map(function(line) {return '\t\t' + line}).join('\n') + "\n";
+								ports = outgoing[key].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/ports'}).map(function(portsid) {return outgoing[portsid][0]}).map(function(pid) {return as.nodes[pid]});
+								file_contents += '\t\tself.my_ports = {' + ports.map(function(el) {return '"' + el['name']['value'] + '": ' + (el['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/OutputPort' ? 'self.addOutPort("' : 'self.addInPort("') + el['name']['value'] + '")'}).join(', ') + '}\n\n'
+								file_contents += '\tdef timeAdvance(self):\n'
+								file_contents += states.map(function(s) {return '\t\tif self.state.name == "' + s['name']['value'] + '":\n' + s['time_advance']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n')}).join('\n')
+								file_contents += '\n\n';
+								file_contents += '\tdef outputFnc(self):\n'
+                                file_contents += '\t\tdef subfunc(self):\n'
+                                file_contents += states.map(function(s) {return '\t\t\tif self.state.name == "' + s['name']['value'] + '":\n' + (s['output']['value'] == '' ? ['\t\t\t\treturn {}'] : s['output']['value'].split('\n').map(function(line) {return '\t\t\t\t' + line}).join('\n'))}).join('\n') + "\n";
+                                file_contents += '\t\treturn {self.my_ports[k]: v for k, v in subfunc(self).iteritems()}\n';
+								file_contents += '\n\n';
+								file_contents += '\tdef intTransition(self):\n'
+								var content = false;
+								for (var sidx in states) {
+									s = states[sidx];
+									if (outgoing[s['$key']]) {
+										internals = outgoing[s['$key']].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/InternalTransition'}).map(function(tid) {return as.nodes[tid]});
+										for (var iidx in internals) {
+											content = true;
+											internal = internals[iidx];
+											var target = as.nodes[outgoing[internal['$key']][0]],
+												cond_name = 'cond_int_' + s['name']['value'] + '_to_' + target['name']['value'],
+												action_name = 'action_int_' + s['name']['value'] + '_to_' + target['name']['value'];
+											file_contents += '\t\t\def ' + cond_name + '():\n';
+											file_contents += internal['condition']['value'] == '' ? '\t\t\treturn True' : internal['condition']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+											file_contents += '\n\t\t\def ' + action_name + '():\n';
+											file_contents += internal['action']['value'] == '' ? '\t\t\treturn {}' : internal['action']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+											file_contents += '\n\t\tif self.state.name == "' + s['name']['value'] + '" and ' + cond_name + '():\n';
+											file_contents += '\t\t\treturn ' + statedef['name']['value'] + '(name="' + target['name']['value'] + '", **' + action_name + '())\n\n';
+										}
+									}
+								}
+								if (!content) {
+									file_contents += '\t\treturn AtomicDEVS.intTransition(self)\n';
+								} else {
+									file_contents += '\t\telse:\n';
+									file_contents += '\t\t\treturn AtomicDEVS.intTransition(self)\n';
+								}
+								file_contents += '\n';
+								file_contents += '\tdef extTransition(self, my_inputs):\n'
+								file_contents += '\t\tinputs = {k.getPortName(): v for k, v in my_inputs.iteritems()}\n'
+								content = false;
+								for (var sidx in states) {
+									s = states[sidx];
+									if (outgoing[s['$key']]) {
+										externals = outgoing[s['$key']].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/ExternalTransition'}).map(function(tid) {return as.nodes[tid]});
+										for (var iidx in externals) {
+											content  = true;
+											external = externals[iidx];
+											var target = as.nodes[outgoing[external['$key']][0]],
+												cond_name = 'cond_ext_' + s['name']['value'] + '_to_' + target['name']['value'],
+												action_name = 'action_ext_' + s['name']['value'] + '_to_' + target['name']['value'];
+											file_contents += '\t\t\def ' + cond_name + '():\n';
+											file_contents += external['condition']['value'] == '' ? '\t\t\treturn True' : external['condition']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+											file_contents += '\n\t\t\def ' + action_name + '():\n';
+											file_contents += external['action']['value'] == '' ? '\t\t\treturn {}' : external['action']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+											file_contents += '\n\t\tif self.state.name == "' + s['name']['value'] + '" and ' + cond_name + '():\n';
+											file_contents += '\t\t\treturn ' + statedef['name']['value'] + '(name="' + target['name']['value'] + '", **' + action_name + '())\n\n';
+										}
+									}
+								}
+								if (!content) {
+									file_contents += '\t\treturn AtomicDEVS.extTransition(self, my_inputs)\n';
+								} else {
+									file_contents += '\t\telse:\n';
+									file_contents += '\t\t\treturn AtomicDEVS.extTransition(self, my_inputs)\n';
+								}
+								file_contents += '\n'
+								file_contents += '\tdef confTransition(self, my_inputs):\n'
+								file_contents += '\t\tinputs = {k.getPortName(): v for k, v in my_inputs.iteritems()}\n'
+								content = false;
+								for (var sidx in states) {
+									s = states[sidx];
+									confluents = outgoing[s['$key']].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/ConfluentTransition'}).map(function(tid) {return as.nodes[tid]});
+									for (var iidx in confluents) {
+										content  = true;
+										confluent = confluents[iidx];
+										var target = as.nodes[outgoing[confluent['$key']][0]],
+											cond_name = 'cond_conf_' + s['name']['value'] + '_to_' + target['name']['value'],
+											action_name = 'action_conf_' + s['name']['value'] + '_to_' + target['name']['value'];
+										file_contents += '\t\t\def ' + cond_name + '():\n';
+										file_contents += confluent['condition']['value'] == '' ? '\t\t\treturn True' : confluent['condition']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+										file_contents += '\n\t\t\def ' + action_name + '():\n';
+										file_contents += confluent['action']['value'] == '' ? '\t\t\treturn {}' : confluent['action']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+										file_contents += '\n\t\tif self.state.name == "' + s['name']['value'] + '" and ' + cond_name + '():\n';
+										file_contents += '\t\t\treturn ' + statedef['name']['value'] + '(name="' + target['name']['value'] + '", **' + action_name + '())\n\n';
+									}
+								}
+								if (!content) {
+									file_contents += '\t\treturn AtomicDEVS.confTransition(self, my_inputs)\n';
+								} else {
+									file_contents += '\t\telse:\n';
+									file_contents += '\t\t\treturn AtomicDEVS.confTransition(self, my_inputs)\n';
+								}
+								file_contents += '\n'
+							}
+							
+							for (var idx in type_map['/Formalisms/ParallelDEVS/ParallelDEVS/CoupledDEVS']) {
+								var node = type_map['/Formalisms/ParallelDEVS/ParallelDEVS/CoupledDEVS'][idx],
+									list_of_params = (node['parameters']['value'].map(function(el) {return el['name'] + '=None'})),
+									list_of_param_names = (node['parameters']['value'].map(function(el) {return el['name']})),
+									list_of_attrs = (node['attributes']['value'].map(function(el) {return [el['name'], el['default']]}));
+								file_contents += 'class ' + node['name']['value'] + '(CoupledDEVS):\n';
+								file_contents += '\tdef __init__(' + (['self', 'name="' + node['name']['value'] + '"'].concat(list_of_params).join(', ')) + '):\n';
+								file_contents += '\t\tCoupledDEVS.__init__(self, name)\n';
+								file_contents += list_of_attrs.map(function(el) {return '\t\tself.' + el[0] + ' = ' + (list_of_param_names.indexOf(el[0]) != -1 ? el[0] : el[1])}).join('\n') + "\n";
+                                file_contents += node['__init__']['value'].split('\n').map(function(line) {return '\t\t' + line}).join('\n') + "\n";
+								key = type_map_keys['/Formalisms/ParallelDEVS/ParallelDEVS/CoupledDEVS'][idx];
+								ports = outgoing[key].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/ports'}).map(function(portsid) {return outgoing[portsid][0]}).map(function(pid) {return as.nodes[pid]});
+								file_contents += '\t\tself.my_ports = {' + ports.map(function(el) {return '"' + el['name']['value'] + '": ' + (el['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/OutputPort' ? 'self.addOutPort("' : 'self.addInPort("') + el['name']['value'] + '")'}).join(', ') + '}\n'
+								file_contents += '\t\tself.submodels = {}\n';
+								submodels = outgoing[key].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/submodels'}).map(function(submodelsid) {return outgoing[submodelsid][0]}).map(function(mid) {return as.nodes[mid]});
+								file_contents += submodels.map(function(m) {return '\t\tself.submodels["' + m['name']['value'] + '"] = self.addSubModel(' + m['devs_type']['value'] + '(' + ['name="' + m['name']['value'] + '"'].concat(m['parameter_binding']['value'].map(function(pb) {return pb['name'] + '=' + pb['val']})).join(', ') + '))'}).join('\n');
+								file_contents += '\n\n';
+								myportkeys = ports.map(function(port) {return port['$key']});
+								port_to_m = {};
+								m_to_ports = {};
+								m_to_ports[key] = ports;
+								ports.forEach(function(p) {port_to_m[p['$key']] = node});
+								for (var skey in submodels) {
+									var m = submodels[skey];
+									m_to_ports[m['$key']] = [];
+									ports = outgoing[m['$key']].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/ports'}).map(function(portsid) {return outgoing[portsid][0]}).map(function(pid) {return as.nodes[pid]});
+									ports.forEach(function(p) {port_to_m[p['$key']] = m; m_to_ports[m['$key']].push(p);});
+								}
+								for (var mkey in m_to_ports) {
+									for (var pidx in m_to_ports[mkey]) {
+										var p = m_to_ports[mkey][pidx],
+											pkey = p['$key'];
+										if (pkey in outgoing) {
+											var conns = outgoing[pkey].filter(function(el) {return as.nodes[el]['$type'] == '/Formalisms/ParallelDEVS/ParallelDEVS/channel'}).map(function(channelid) {return as.nodes[channelid]})
+											for (var cidx in conns) {
+												var conn = conns[cidx],
+													target = as.nodes[outgoing[conn['$key']][0]],
+													transfname = 'transfer_' + as.nodes[mkey]['name']['value'] + '_' + as.nodes[pkey]['name']['value'] + '_to_' + target['name']['value'],
+													fromportstr = (mkey == key ? 'self' : 'self.submodels["' + as.nodes[mkey]['name']['value'] + '"]') + '.my_ports["' + as.nodes[pkey]['name']['value'] + '"]',
+													toportstr = (port_to_m[target['$key']]['$key'] == key ? 'self' : 'self.submodels["' + port_to_m[target['$key']]['name']['value'] + '"]') + '.my_ports["' + target['name']['value'] + '"]';
+												if (conn['transfer_function']['value'] != '') {
+													file_contents += '\t\tdef ' + transfname + '(event):\n';
+													file_contents += conn['transfer_function']['value'].split('\n').map(function(line) {return '\t\t\t' + line}).join('\n');
+													file_contents += '\n\n';
+													file_contents += '\t\tself.connectPorts(' + fromportstr + ', ' + toportstr + ', ' + transfname + ')\n\n';
+												} else {
+													file_contents += '\t\tself.connectPorts(' + fromportstr + ', ' + toportstr + ')\n';
+												}
+											}
+										}
+									}
+								}
+								file_contents += '\n';
+							}
+							
+							_fs.writeFileSync('./exported_to_pypdevs/model.py', file_contents);
+							
+							file_contents = 'import sys\n';
+							file_contents += 'sys.path.append("../../pypdevs/src/")\n\n';
+							file_contents += 'from DEVS import *\n';
+							file_contents += 'from model import *\n';
+							file_contents += 'from python_runtime.statecharts_core import Event\n';
+							file_contents += 'from sccd import Controller\n\n';
+
+							file_contents += 'def termination_condition(time, model, transitioned):\n';
+							file_contents += '\ttime = time[0]\n';
+							file_contents += type_map['/Formalisms/ParallelDEVS/ParallelDEVS/Simulation'][0]['end_condition']['value'].split('\n').map(function(line) {return '\t' + line}).join('\n') + '\n';
+							
+							_fs.writeFileSync('./exported_to_pypdevs/experiment.py', file_contents);
+							
+							__postMessage({'statusCode': 200,
+										   'respIndex': resp});
+						},
+						function(writeErr) {__postInternalErrorMsg(resp, writeErr);}
+					);
+				},
+				function(err) {__postInternalErrorMsg(resp, err);}
+			)
+		},
+	'asworker':
+		function(resp, method, uri, reqData, wcontext)
+		{
+			__postMessage(
+				{'statusCode': 200,
+					 'respIndex': resp});	
+		}
+}