OKeilidh

OKeilidh requires your Jabber ID before rolling

Server:
JID:
Password:

Get a Jabber ID here

/~eXtended Lightweight Coordination Calculus (XLCC) Interpreter ~/

[*
/*
* WebLCC: Browser-based LCC debugging environment
* Copyright (C) 2009-2012 by Xi Bai
* 
* Author: Xi Bai
* Usage:  General variables, constants and defines
*
* THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. 
* THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE 
* EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY 
* DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED 
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
	var constraints = {};
	emitter.removeAllListeners("okcs loaded");
	emitter.removeAllListeners("gotMessageFromXMPPServer");
	emitter.on("gotMessageFromXMPPServer", onMessageArrival);
	emitter.on("msgReceived", receiveMSG);
	var v_names = new Array();
	var v_values = new Array();
	var okcs = new Array();
//	var clauses = new Array();
	var role_heads = new Array();
	var role_bodies = new Array();
	var init = undefined;
	
	var currentBackTrack = undefined;
	var currentBracketBackTrack = undefined;
	var currentMessageNode = undefined;
	var currentRoleNode = undefined;
	var currentConstraintsNode = undefined;
	var currentNextThenNode = undefined;
	var currentNextOrNode = undefined;
	var currentNextBracketNode = undefined;
	var currentNextBracketOrNode = undefined;
	var peerID = undefined;
	var iid = undefined;
	var webStorageSupported = window["localStorage"]? true : false;
	if(!webStorageSupported){
		alert("Your browser does not support local storage. Click 'OK' and keep going ...");
	}
	var niob_counter = 0;
	var niob_contexts = new Array();	
	function NiobContext() {
		this.id = undefined;
		this.msgs = [];
		this.currentMessageNode = undefined;
		this.currentRoleNode = undefined;
		this.currentConstraintsNode = undefined;
		this.currentNextThenNode = undefined;
		this.currentNextOrNode = undefined;
		this.currentNextBracketNode = undefined;
		this.currentNextBracketOrNode = undefined;
		this.currentBackTrack = undefined;
		this.currentBracketBackTrack = undefined;
	}
	var niob_default_context = new NiobContext();
	niob_default_context.id = 0;
	niob_contexts.push(niob_default_context);
	
	function getNiobContextByMsgName(msgName) {
		for(var i = 0; i < niob_contexts.length; i++){
			for(var j = 0; j < niob_contexts[i].msgs.length; j++){
//				alert(niob_contexts[i].msgs[j] + ":" + msgName);
				if(niob_contexts[i].msgs[j] == msgName){
					return niob_contexts[i]; 
				}
			}
		}
		return undefined;
	}
	
	function updateNiobContext(niob_context){
		var index = undefined;
		for(var i = 0; i < niob_contexts.length; i++){
			if(niob_context.id == niob_contexts[i].id){
				index = i;
				break;
			}
		}
		if(index != undefined)
			niob_contexts.slice(index, 1, niob_context);
		else
			niob_contexts.push(niob_context);
	}
	
	
	var NODE_OP			= 1;
	var NODE_VAR 		= 2;
	var NODE_CONST		= 3;
	var NODE_ARR		= 4;
	var NODE_STR		= 5;
	
	var OP_ENTRY		= -2;
	var OP_NONE 		= -1;
	var OP_SEND 		= 0;
	var OP_RECEIVE		= 1;
	var OP_THEN			= 2;
	var OP_OR			= 3;
	var OP_LIST 		= 4;
	var OP_ROLE			= 5;
	var OP_ROLE_DEF		= 6;
	var OP_SEND 		= 7;
	var OP_RECEIVE		= 8;
	var OP_ROLE_TYPE    = 9;
	var OP_SET_VAR      = 10;
	var OP_CONSTRAINT	= 11;
	var OP_NEGATE		= 12;
	var OP_LOGAND		= 13;
	var OP_LOGOR		= 14;
	var OP_NO_MSG		= 15;
	var OP_TERMS		= 16;
	var OP_FACTOR		= 17;
	var OP_MESSAGE		= 18;
	var OP_HEADBODY		= 19;
	var OP_ROLE_CHANGE  = 20;
	var OP_PAR			= 21;
	var OP_KNOWS		= 22;
	var OP_PLAYS		= 23;
	var OP_IID			= 24;
	var OP_CLAUSE		= 25;
	var OP_NIOB			= 26;
	var OP_BRACKET		= 27;
	var OP_BRACKET_OR	= 28;
	var OP_EQU			= 29;
	var OP_NEQ			= 30;
	var OP_GRT			= 31;
	var OP_LOT			= 32;
	var OP_GRE			= 33;
	var OP_LOE			= 34;
	var OP_ASSIGN		= 35;
	
	function Node(){
		var type;
		var value;
		var children;
	} 
		
	function createNode(type, value, childs){
		var n = new Node();
		n.type = type;
		n.value = value;
		n.children = new Array();
		
		for(var i = 2; i < arguments.length; i++){
			n.children.push(arguments[i]);
		}
		return n;
	}
	
	function setValue(vname, vvalue){
		var found = false;
		for(var i = 0; i < v_names.length; i++){
			if(v_names[i].toString() == vname.toString()){
				v_values[i] = (arguments.length == 1)? undefined : vvalue.toString(); //The type is now checked here.
				found = true;
				break;
			}
		}
		if(!found){
			v_names.push(vname);
			v_values.push((arguments.length == 1)? undefined : vvalue.toString());
		}
	}
	
	function getValue(vname){
		for(var i = 0; i < v_names.length; i++){
			if(v_names[i].toString() == vname.toString()){
				return v_values[i];
			}
		}
		return undefined;
	}
	
	function readValue(factors){
		if(factors.length != 0){
			for(var i = 0; i < factors.length; i++){
				if(factors[i].name && factors[i].name.charAt(0) === factors[i].name.charAt(0).toUpperCase()){
					if(!factors[i].value || factors[i].value == undefined || factors[i].value == "undefined" ){
						var fvalue = prompt("Please assign a new value to variable '" + factors[i].name + "':", factors[i].value);
						factors[i].value = fvalue;
						setValue(factors[i].name, fvalue);
					}
				}
				if(factors[i].params && factors[i].params.length != 0){
					readValue(factors[i].params);
				}
			}
		}
	}
	
	function display_okc_hook(factors, peerHelper){
		peerHelper.displayValue(factors);
		return true;
	}
	
	function inspect_okc_hook(factors, peerHelper){
		peerHelper.inspectValue(factors);
		return true;
	}
	
	function read_okc_hook(factors, peerHelper){
		peerHelper.readValue(factors);
		return true;
	}

/*  this can not block the thread as prompt() can	
	function submitValue(factors, msgDiv){
		alert("submit");
		var temp;
		if(arguments.length == 1){
			temp = $("<div></div>");
		}
		else{
			temp = arguments[1];
		}
		if(factors.length != 0){
			for(var i = 0; i < factors.length; i++){
				if(factors[i].name && factors[i].name.charAt(0) === factors[i].name.charAt(0).toUpperCase()){
					if(!factors[i].value || factors[i].value == undefined || factors[i].value == "undefined" ){
						var inputTemp =  $("<input></input>").attr({"name": factors[i].name, "size": "5"});
						inputTemp.type = "text";
						temp.append($("<span></span>").text("Please give values to the variable(s):").append($("<label></label>").attr("for", factors[i].name).text(factors[i].name + ":")).append(inputTemp));						
					}
				}
				if(factors[i].params && factors[i].params.length != 0){
					submitValue(factors[i].params, temp);
				}
			}
			temp.append($("<button></button>").attr({"name": "submit", "value": "submit"}).click(function() {
				temp.find("input").each(function() {
					setValue($(this).attr("name"), $(this).val());
					$(this).attr("disabled", "disabled");
				});
				temp.find("button").remove();
				return false;
			}));
			$("#messages").append(temp);
		}			
	}
*/
	
	function serialiseValue(factors, delimiter){
		var content = "";
		for(var i = 0; i < factors.length; i++){
//			alert(factors[i].name.charAt(0).toString() + " : " + factors[i].name.charAt(0).toString().toUpperCase());
			if(factors[i].name && factors[i].name.charAt(0).toString() == factors[i].name.charAt(0).toString().toUpperCase()){
				if(factors[i].value == undefined){
//					alert("here again");
				}
				else{
//					alert(JSON.stringify(factors[i]));
//					alert("detect factors " + factors[i].name + " " + factors[i].value);
					content += factors[i].name + " : " + factors[i].value + delimiter;
					
				}
			}
			if(factors[i].name == "list"){
				content += factors[i].name + " : " + factors[i].value.toString() + delimiter;
			}
			if(factors[i].name == "string"){
				content += factors[i].name + " : " + factors[i].value + delimiter;
			}
			if(factors[i].params && factors[i].params.length != 0){
				content += serialiseValue(factors[i].params, delimiter);
			}
		}
		return content;
	}
	
	function serialiseValueWithoutName(factors, delimiter){
		var content = "";
		for(var i = 0; i < factors.length; i++){
			if(factors[i].name && factors[i].name.charAt(0).toString() == factors[i].name.charAt(0).toString().toUpperCase()){
				if(factors[i].value == undefined){
//					alert("here again");
				}
				else{
					content += factors[i].value + delimiter;
					
				}
			}
			if(factors[i].name == "list"){
				content += factors[i].value.toString() + delimiter;
			}
			if(factors[i].name == "string"){
				content += factors[i].value + delimiter;
			}
			if(factors[i].params && factors[i].params.length != 0){
				content += serialiseValueWithoutName(factors[i].params, delimiter);
			}
		}
		return content;
	}
	
	function displayValue(factors){
		alert(serialiseValue(factors, "\r\n"));
	}
	
	function displayValueWithoutName(factors){
		alert(serialiseValueWithoutName(factors, "\r\n"));
	}
	
	function renderValues(factors){
		var time = new Date();
		$("#messages").append($("<div></div>").html("[" + time.getHours() + ":" + time.getMinutes() + ":" + time.getSeconds() + "]<br/>" + serialiseValue(factors, "<br/>")));
	}
	
	var peerHelper = { 
		"setValue" : setValue, 
		"getValue" : getValue,
		"readValue" : readValue,
		"displayValue" : displayValueWithoutName,
		"inspectValue" : displayValue,
//		"submitValue" : submitValue,
		"renderValues" : renderValues
	}
	
	function resetLCCEnvironment(){
		v_names = new Array();
		v_values = new Array();
		currentBackTrack = undefined;
		currentBracketBackTrack = undefined;
		okcs = new Array();
//		clauses = new Array();
		role_heads = new Array();
		role_bodies = new Array();
		init = undefined;
		currentMessageNode = undefined;
		currentRoleNode = undefined;
		currentConstraintsNode = undefined;
		currentNextThenNode = undefined;
		currentNextOrNode = undefined;
		currentNextBracketNode = undefined;
		currentNextBracketOrNode = undefined;
		peerID = undefined;
		finished = undefined;
		niob_counter = 0;
		niob_contexts = new Array();
		niob_contexts.push(niob_default_context);
		offline_msg = undefined;
		triggered = false;
		xmpp_resource = undefined;
		emitter.removeAllListeners("okcs loaded");
		emitter.removeAllListeners("gotMessageFromXMPPServer");
		emitter.on("gotMessageFromXMPPServer", onMessageArrival);
		emitter.on("msgReceived", receiveMSG);
	}
	
	function saveSnapShot(iid){
		var funcStrs = new Array();
		for(var func in window){
			if(window.hasOwnProperty(func) && typeof window[func] === "function" && window[func].toString().indexOf("\[native code\]") == -1){
				funcStrs.push(func.toString());
			}
		}
		var snapShot = {
			"v_names" : v_names,
			"v_values" : v_values, 
			"currentBackTrack" : currentBackTrack,
			"currentBracketBackTrack" : currentBracketBackTrack,
			"okcs" : okcs,
//			"clauses" : clauses,
			"role_heads" : role_heads,
			"role_bodies" : role_bodies,
			"init" : init,
			"currentMessageNode" : currentMessageNode,
			"currentRoleNode" : currentRoleNode,
			"currentConstraintsNode" : currentConstraintsNode,
			"currentNextThenNode" : currentNextThenNode,
			"currentNextOrNode" : currentNextOrNode,
			"currentNextBracketNode" : currentNextBracketNode,
			"currentNextBracketOrNode" : currentNextBracketOrNode,
			"peerID" : peerID,
			"finished" : finished,
			"emitter" : emitter,
			"offline_msg" : offline_msg,
			"triggered" : triggered,
			"xmpp_resource" : xmpp_resource,
			"functions" : funcStrs,
			"niob_counter" : niob_counter,
			"niob_contexts" : niob_contexts
		};
		if(window["localStorage"]){
			window["localStorage"].setItem(iid, JSON.stringify(snapShot));
		}
		else{
//			throw webStorageNotSupportedException();
		}
		return snapShot;
	}
	
	function loadSnapShot(iid){
		var snapshot;
		if(window["localStorage"]){
			snapshot = JSON.parse(window["localStorage"].getItem(iid));
			for(var variable in snapshot){
				if(variable.toString() != "functions"){
					window[variable] = snapshot[variable];
				}
				else{
					for(var funcStr in snapshot[variable]){
						eval.call(null, funcStr);
					}
				}
			}
		}
		else{
//			throw webStorageNotSupportedException();
		}
	}
	
	function removeSnapShot(iid){
		if(window["localStorage"] && window["localStorage"].getItem(iid)){
			window["localStorage"].removeItem(iid);
		}
	}
	
	function removeQuotes(str){
		if(str.charAt(0) == '\'' || str.charAt(0) == '\"')
			return str.substring(1, str.length - 1);
		else
			return str;
	}
	
	function isIdenticalRole(tnode1, tnode2, recursion_counter){ //TODO need testing
//		alert(recursion_counter + " : "+ JSON.stringify(tnode1) + " " + JSON.stringify(tnode2));
		if(typeof(tnode1) == "string" && typeof(tnode2) == "string"){
			if(recursion_counter < 4){
				if(tnode1 == tnode2){
					return true;
				}
				else{
					return false;
				}
			}
			else{
				return true;
			}	
		}
		else if(typeof(tnode1) == "string" && typeof(tnode2) != "string" || typeof(tnode1) != "string" && typeof(tnode2) == "string"){
			return false;
		}
		else{
			recursion_counter++;
			if((tnode1.type == 1 && tnode1.type.toString() == tnode2.type.toString() && tnode1.value.toString() == tnode2.value.toString())
			|| (tnode1.type != 1 && tnode1.type.toString() == tnode2.type.toString())){
				if(tnode1.children.length == 0 && tnode2.children.length == 0){
					return true;
				}
				else if(tnode1.children.length == tnode2.children.length){
					for(var i = 0; i < tnode1.children.length; i++){
						if(isIdenticalRole(tnode1.children[i], tnode2.children[i], recursion_counter)){
							continue;
						}
						else{
//							alert("detect false here");
							return false;
						}
					}
					return true;
				}
				else{
//					alert("different children lengths");
					return false;
				}
			}
			else{
//				alert("different types or values");
				return false;
			}
		}
	}
	
	function updateVariableValueInNode(src_role_head, dest_role_head){
		if(typeof(src_role_head) == "string" && typeof(dest_role_head) == "string"){
			if(getValue(src_role_head)){
				setValue(dest_role_head, removeQuotes(getValue(src_role_head)));
			}
			else{
				setValue(dest_role_head, removeQuotes(src_role_head));
			}
		}
		else{
			for(var i = 0; i < src_role_head.children.length; i++){
				updateVariableValueInNode(src_role_head.children[i], dest_role_head.children[i]);
			}
		}
	}
	
	function getRoleBodyByRoleHead(role_head){
		var role_body = null;
		alert(role_head + " ::::: " + role_heads);
		for(var i = 0; i < role_heads.length; i++){
			if(isIdenticalRole(role_head, role_heads[i], 0)){
				role_body = role_bodies[i];
				break;
			}
		}
		if(role_body == null){
			throw roleDefinitionNotFoundException(JSON.stringify(role_head));
		}
		else{
//			alert("find the role definition!");
		}
		return role_body;
	}
	
	function getRoleBodyByRoleHeadAfterRoleChanging(role_head){
		var role_body = null;
//		alert(JSON.stringify(role_head) + " ::::: " + JSON.stringify(role_heads));
//		alert("number of pairs of heads and bodies: " + role_heads.length);
		for(var i = 0; i < role_heads.length; i++){
//			alert(JSON.stringify(role_head) + "================" + JSON.stringify(role_heads[i]));
			if(isIdenticalRole(role_head, role_heads[i], 0)){
//				alert("find identical roles");
				updateVariableValueInNode(role_head, role_heads[i]);
				role_body = role_bodies[i];
				break;
			}
		}
		if(role_body == null){
			throw roleDefinitionNotFoundException(JSON.stringify(role_head));
		}
		else{
//			alert("find the role definition!");
		}
		return role_body;
	}
	
	function getRoleNameByRoleHeadNode(role_head){
		return role_head.children[0].children[0].toString();
	}
	
	function retrieveOKCs(okcs, headElem, count, length, node){
		if(okcs.length == 0){
			emitter.emit("okcs loaded", node, niob_contexts[0]);
		}
		else{
			var okcElem = document.createElement("script");
			headElem.appendChild(okcElem);
			okcElem.type = "text/javascript";
			okcElem.src =  okcs[count];
			okcElem.onload = function () {
				alert("OKC [" + okcs[count] + "] loaded!");
				count++;
				if(count == length){
					alert("OKCs loading finished!");
	//				alert(JSON.stringify(node));
					emitter.emit("okcs loaded", node, niob_contexts[0]);
				}
				else{
					retrieveOKCs(okcs, headElem, count, length, node);
				}
			};
		}
	}
	
	function initialize(clauses, builtIns){
		window.top.onbeforeunload = function() {
//			alert("finished " + finished);
			if(!finished){
				saveSnapShot(iid);
				return confirm("Closing before finished may cause data lost! Are you sure?");
			}
			else
				return "Bye!";
		}
		init = new Array();
		okcs = new Array();
		niob_counter = 0;
		execute(builtIns, niob_contexts[0]);
		finished = false;
		peerID = document.getElementById("jid").value;		//based on user's inputs
//		alert("Start interpreting the codes");
		emitter.on("okcs loaded", execute);
//		alert(init[0].jid.toString());
		for(var i = 0; i < init.length; i++){
			if(init[i].iid){
				OKBuzzer.resource = init[i].iid.toString();
				iid = init[i].iid.toString();
				alert("Interaction ID is " + OKBuzzer.resource);
			}
			if(init[i].okcs){
				for(var j = 0; j < init[i].okcs.length; j++){
					okcs.push(init[i].okcs[j]);
	//				alert(init[i].okcs[j]);
				}
			}
		}
		var count = 0;
		var length = okcs.length;
		var headElem = document.getElementsByTagName("head")[0];
/* Web storage		
		if(webStorageSupported && window["localStorage"].getItem(iid) != undefined){
			if(confirm("You have an unfinished interaction. Do you want to rusume it?")){
				alert("about to resume the unfinished interaction ...");
//				loadSnapShot(iid);
				retrieveOKCs(okcs, headElem, count, length, clauses); //for debug only
			}
			else{
				retrieveOKCs(okcs, headElem, count, length, clauses);
			}
		}
		else{
			retrieveOKCs(okcs, headElem, count, length, clauses);
		}
*/
		retrieveOKCs(okcs, headElem, count, length, clauses);	/* delete this when uncomment Web storage */
	}
	
	function initializeByHeader(jsonStr, clauses, builtIns){
		niob_counter = 0;
		window.top.onbeforeunload = function() {
//			alert("finished " + finished);
			if(!finished){
				saveSnapShot(iid);
				return confirm("Closing before finished may cause data lost! Are you sure?");
			}
			else
				return "Bye!";
		}
		peerID = document.getElementById("jid").value;		//based on user's inputs
//		alert("Start interpreting the codes");
		emitter.on("okcs loaded", execute);
		finished = false;
//		alert("node " + JSON.stringify(clauses, null, "\t"));
		init = eval('(' + jsonStr + ')');
//		alert(init[0].jid.toString());
		for(var i = 0; i < init.length; i++){
			if(init[i].iid){
				OKBuzzer.resource = init[i].iid.toString();
				iid = init[i].iid.toString();
				alert("Interaction ID is " + OKBuzzer.resource);
			}
			for(var j = 0; j < init[i].okcs.length; j++){
				okcs.push(init[i].okcs[j]);
//				alert(init[i].okcs[j]);
			}
		}
		if(arguments.length == 3){
			execute(builtIns, niob_contexts[0]);
		}
		var count = 0;
		var length = okcs.length;
		var headElem = document.getElementsByTagName("head")[0];
/* Web storage
		if(webStorageSupported && window["localStorage"].getItem(iid) != undefined){
			if(confirm("You have an unfinished interaction. Do you want to rusume it?")){
				alert("about to resume the unfinished interaction ...");
				loadSnapShot(iid);
			}
			else{
				retrieveOKCs(okcs, headElem, count, length, clauses);
			}
		}
		else{
			retrieveOKCs(okcs, headElem, count, length, clauses);
		}
*/
		retrieveOKCs(okcs, headElem, count, length, clauses); /* delete this when uncomment Web storage */
	}
	
//	function sendtext(){
//		var fullJID = 
//		OKBuzzer.connection.send($msg({ "to" : "bob@okbook.inf.ed.ac.uk", "type" : "chat"}).c("body").t("send"));
//		setTimeout('sendtext();', 3000);
//	}
	
	function sendMSG(message, recepientJID){
		var success;
		var fullJID = recepientJID + "/" + OKBuzzer.resource; //TODO: this needs to be passed from the XLCC codes
		alert("Sending message " + message + " to " + fullJID);
		OKBuzzer.connection.send($msg({ "to" : fullJID, "type" : "chat"}).c("body").t(message));
//		sendtext();
		success = true;
		return success;
	}
	
	function updateVariableValueInJSON(src_msg, dest_msg){
		dest_msg.value = src_msg.value;
		setValue(dest_msg.name, dest_msg.value);
		if(dest_msg.params.length != 0 && dest_msg.params.length != 0){
			for(var i = 0; i < src_msg.params.length; i++){
				updateVariableValueInJSON(src_msg.params[i], dest_msg.params[i]);
			}
		}
	}
	
	function executeNextThenOrOrBranch(solved, niob_context){
//		alert("niob counter: " + niob_counter);
		if(solved){
			if(emitter.listeners("nextThenDEF_" + niob_context.id) != undefined && emitter.listeners("nextThenDEF_" + niob_context.id).length != 0){
//				alert("nextThenDEF is not empty! --- " + emitter.listeners("nextThenDEF_" + niob_context.id).length);
				emitter.emit("nextThenDEF_" + niob_context.id, niob_context.currentNextThenNode, niob_context, "nextThenDEF");
			}
			else if(emitter.listeners("nextBracketDEF_" + niob_context.id) != undefined && emitter.listeners("nextBracketDEF_" + niob_context.id).length != 0){
				emitter.emit("nextBracketDEF_" + niob_context.id, niob_context.currentNextBracketNode, niob_context, "nextBracketDEF");
			}
			else{
				if(niob_counter == -1){
					alert("Interaction finished successfully!");
					triggered = false;
					finished = true;
					removeSnapShot(iid);	
				}
				else{
					niob_counter--;
					if(niob_counter == -1){
						alert("Interaction finished successfully!");
						triggered = false;
						finished = true;
						removeSnapShot(iid);
					}
					else{
						alert("Start waiting for another niob context!");
					}
				}
			}
		}
		else{
			if(emitter.listeners("nextOrDEF_" + niob_context.id) != undefined && emitter.listeners("nextOrDEF_" + niob_context.id).length != 0){
				v_names = niob_context.currentBackTrack.v_names;
				v_values = niob_context.currentBackTrack.v_values;
//				alert("track back after OR");
				emitter.emit("nextOrDEF_" + niob_context.id, niob_context.currentNextOrNode, niob_context, "nextOrDEF");
			}
			else if(emitter.listeners("nextBracketOrDEF_" + niob_context.id) != undefined && emitter.listeners("nextBracketOrDEF_" + niob_context.id).length != 0){
				v_names = niob_context.currentBracketBackTrack.v_names;
				v_values = niob_context.currentBracketBackTrack.v_values;
//				alert("track back after next OR");
				emitter.emit("nextBracketOrDEF_" + niob_context.id, niob_context.currentNextBracketOrNode, niob_context, "nextBracketOrDEF");
			} 
			else{
				throw constraitsSolvingFailedException();
			}
		}
	}
	
	function onMessageArrival(msg) {
//		alert("A new message came : " + msg.body); 
		var senderJID = msg.from.toString();
		var receiverJID = msg.to.toString();
		offline_msg = undefined;
		if(receiverJID.indexOf("/") != -1 && receiverJID.split("/")[1] == OKBuzzer.resource){
			//TODO the sender id and the resource need to be checked here.
			var msgBody = JSON.parse(msg.body);
	//		alert("body : " + JSON.stringify(msgBody));
			var niob_context = getNiobContextByMsgName(msgBody.name);
//			alert("context after receiving msg: " + JSON.stringify(niob_context));
//			alert("msg name: " + msgBody.name);
	//update variables here
			//when receive message
			
			if(niob_context.currentConstraintsNode != undefined){
				emitter.emit("msgReceived", msgBody, execute(niob_context.currentMessageNode, niob_context), execute(niob_context.currentRoleNode, niob_context), niob_context, niob_context.currentConstraintsNode);
			}
			else{
				emitter.emit("msgReceived", msgBody, execute(niob_context.currentMessageNode, niob_context), execute(niob_context.currentRoleNode, niob_context), niob_context);
			}
		}
	}
	
	function receiveMSG(msgBody, msgJSONStr, roleNode, niob_context){
		msgJSON = eval("(" + msgJSONStr + ")");
		updateVariableValueInJSON(msgBody, msgJSON);
//		alert("after update: " + JSON.stringify(msgBody) + "============" + JSON.stringify(msgJSON));
		if(arguments[4]){
			var solved = execute(niob_context.currentConstraintsNode, niob_context);
			niob_context.currentConstraintsNode = undefined;
			updateNiobContext(niob_context);
			executeNextThenOrOrBranch(solved, niob_context);
		}
		else{
			executeNextThenOrOrBranch(true, niob_context);
		}
	}
	
	function execute(node, niob_context, removeListeners){
//		alert(niob_context.id);
//		alert("execute: " + JSON.stringify(niob_context));
		if(arguments.length == 3){
			if(removeListeners == "nextThenDEF"){
				emitter.removeAllListeners("nextThenDEF_" + niob_context.id);
//				alert("after remove we got : " + emitter.listeners("nextThenDEF_" + niob_context.id));	
			}
			else if(removeListeners == "nextOrDEF"){
				emitter.removeAllListeners("nextOrDEF_" + niob_context.id);
//				emitter.removeAllListeners("nextThenDEF_" + niob_context.id);	//problematic
				emitter.removeAllListeners("nextBracketDEF_" + niob_context.id);
//				alert("after remove we got : " + emitter.listeners("nextOrDEF_" + niob_context.id));	
			}
			else if(removeListeners == "nextBracketDEF"){
				emitter.removeAllListeners("nextBracketDEF_" + niob_context.id);
			}
			else if(removeListeners == "nextBracketOrDEF"){
				emitter.removeAllListeners("nextBracketOrDEF_" + niob_context.id);
//				emitter.removeAllListeners("nextThenDEF_" + niob_context.id);	//problematic
				emitter.removeAllListeners("nextBracketDEF_" + niob_context.id);
			}
		}
//		alert("executing " + JSON.stringify(node));
		var ret = 0;
		if(!node)
			return 0;
		switch(node.type){
			case NODE_OP: 
				switch(node.value){
					case OP_ENTRY:
//						alert("hit entry");
						if(node.children[0]){
//							alert(JSON.stringify(clauses));
							execute(getRoleBodyByRoleHeadAfterRoleChanging(node.children[0]), niob_context);
						}
						break;
					case OP_NONE:
//						alert("hit none");
						if(node.children[0]){
							execute(node.children[0], niob_context);
						}
						break;
					case OP_CLAUSE:
//						alert("hit clause");
						if(node.children[0]){
//							clauses.push(node.children[0]);
							execute(node.children[0], niob_context);
						}
						if(node.children[1]){
							execute(node.children[1], niob_context);
						}
						break;
					case OP_HEADBODY:
//						alert("hit headbody");
						if(node.children[0]){
							role_heads.push(node.children[0]);
//							execute(node.children[0], niob_context);
						}
						if(node.children[1]){
							role_bodies.push(node.children[1]);
//							execute(node.children[1], niob_context);
						}
						break;
					case OP_ROLE_CHANGE:
//						alert("hit role_change");
						if(node.children[1]){
							if(execute(node.children[1], niob_context) && node.children[1]){
								alert("Role change now!");
								execute(getRoleBodyByRoleHeadAfterRoleChanging(node.children[0]), niob_context);
							}
							else{
								throw constraitsSolvingFailedException();
							}
						}
						else if(node.children[0]){
							alert("Role change now!");
							execute(getRoleBodyByRoleHeadAfterRoleChanging(node.children[0]), niob_context);						
						}
						break;
					case OP_ROLE:
//							alert("hit role");
							var roleID = node.children[1].value.toString();
							if(getValue(roleID) != null && getValue(roleID) != undefined){
								ret = getValue(roleID);
								break;
							}
							else{
//								alert("role parse: " + JSON.stringify(execute(node.children[0], niob_context)));
								var temp = eval("[(" + execute(node.children[0], niob_context) + ")]");
								readValue(temp);
//								submitValue(temp);		// this can not block the thread as prompt() can
								var roleType = temp[0];
								var roleName = roleType.name;
								var roleFoundInInit = true;
								var roleJID = "";
								for(var i = 0; i < init.length; i++){
//									alert(roleName.toString().toLowerCase() + " : " + init[i].role.toString().toLowerCase());
									if(roleName.toString().toLowerCase() == init[i].role.toString().toLowerCase()){
										setValue(roleID, init[i].jid.toString());
//										alert(roleID + " " + init[i].jid.toString());
										roleJID = init[i].jid.toString();
										roleFoundInInit = true;
										break;
									}
									roleFoundInInit = false;
								}
								if(roleFoundInInit){
									ret = roleJID; 
									break;
								}
								else{
//									alert(roleID + " : " + getValue(roleID));
									throw CommunicationIDNotFoundException(roleName);
								}
							}	
					case OP_KNOWS:
//						alert("hit knows");
						if(node.children[0])
							okcs.push(removeQuotes(node.children[0].toString()));
						break;
					case OP_PLAYS:
//						alert("hit plays");
						if(node.children[0] && node.children[1]){
							var info = {};
							info["jid"] = removeQuotes(node.children[0].toString());
							info["role"] = node.children[1].toString();
							init.push(info);						
						}
						break;
					case OP_IID:
//						alert("hit iid");
						if(node.children[0]){
							OKBuzzer.resource = removeQuotes(node.children[0].toString());
							iid = removeQuotes(node.children[0].toString());
						}
//						alert("in OP_IID " + OKBuzzer.resource);
						break;
					case OP_ROLE_TYPE:
//						alert("hit role_type");
						var ret = execute(node.children[0], niob_context);
						break;
					case OP_TERMS:
//						alert("hit terms");
						if(node.children[1]){
							ret = execute(node.children[0], niob_context) + ", " + execute(node.children[1], niob_context);
						}
						else{
							ret = execute(node.children[0], niob_context);
						}
						break;
					case OP_FACTOR:
//						alert("hit factor");
						if(node.children[1])
							ret = '{ "name" : "' + node.children[0] + '", "value" : "' + getValue(node.children[0]) + '", "params" : [' + execute(node.children[1], niob_context) + ']}';
						else{
//							alert(node.children[0].toString());
							if(node.children[0].toString().charAt(0) == "[" && node.children[0].toString().charAt(node.children[0].toString().length - 1) == "]"){
								ret = '{ "name" : "list", "value" : [' + eval(node.children[0]).toString() + '], "params" : []}';
							}
							else if(node.children[0].toString().charAt(0) == "'" && node.children[0].toString().charAt(node.children[0].toString().length - 1) == "'"){
								ret = '{ "name" : "string", "value" : "' + removeQuotes(node.children[0].toString()) + '", "params" : []}';
							}
							else if(node.children[0].toString().charAt(0) == "\"" && node.children[0].toString().charAt(node.children[0].toString().length - 1) == "\""){
								ret = '{ "name" : "string", "value" : "' + removeQuotes(node.children[0].toString()) + '", "params" : []}';
							}
							else{
								ret = '{ "name" : "' + node.children[0] + '", "value" : "' + getValue(node.children[0]) + '", "params" : []}';
							}
						}
						break;
					case OP_CONSTRAINT://TODO need check the Variables and which of them are inputs and wich of them are outputs (callback?).
//						alert("hit constraint");
						var constraintName = node.children[0];
						if(node.children[1]){
//							alert(execute(node.children[1], niob_context));
				//			alert(eval("JSON.parse(\"" + execute(node.children[1], niob_context) + "\");"));
							ret = eval(constraintName + "_okc_hook" + "(eval(\'([\' + \'" + execute(node.children[1], niob_context) + "\' + \'])\'), peerHelper);"); //according to "Conventions over configurations"
						}
						else{
							ret = eval(constraintName + "_okc_hook" + "(eval(\'([\' + \'])\'), peerHelper);");
						}
						if(ret == null || ret == undefined)
							throw invalidOKCException(funcName);
						break;
					case OP_NEGATE:
//						alert("hit negate");
						ret = !execute(node.children[0], niob_context);	
						break;
					case OP_LOGAND:
//						alert("hit logand");
						ret = execute(node.children[0], niob_context) && execute(node.children[1], niob_context);
						break;
					case OP_LOGOR:
//						alert("hit logor");
						niob_context.currentBackTrack = {};
						niob_context.currentBackTrack.v_names = v_names;
						niob_context.currentBackTrack.v_values = v_values;
						if(execute(node.children[0], niob_context)){
							ret = ture;
						}
						else{
//							alert("trackback after ||");
							v_names = niob_context.currentBackTrack.v_names;
							v_values = niob_context.currentBackTrack.v_values;
							ret = execute(node.children[1], niob_context);
						}
						break;
					case OP_LIST:
//						alert("hit list");
						var list = execute(node.children[0], niob_context);
						var listHead = execute(node.children[1], niob_context);
						var listTail = execute(node.children[2], niob_context);
						if(listHead != undefined && listTail != undefined && listTail.length){
							setValue(node.children[0].value.toString(), listTail.unshift(listHead));
							ret = true;
						}
						else if(list != undefined && list.length){
							if(list.length == 0){
								setValue(node.children[1].value.toString(), new Array());
								setValue(node.children[2].value.toString(), new Array());
							}
							else{
								setValue(node.children[1].value.toString(), list[0]);
								list.shift();
								setValue(node.children[2].value.toString(), list);
							}
							ret = true;
						}	
						else{
							throw listDefinitionNotSupportedException();
						}					
						break;
					case OP_THEN:
//						alert("hit 'then'");
						emitter.removeAllListeners("nextThenDEF_" + niob_context.id);
//						alert("after remove we got : " + emitter.listeners("nextThenDEF_" + niob_context.id));
						niob_context.currentNextThenNode = node.children[1];
//						thens.unshift(niob_context.currentNextThenNode);
						emitter.on("nextThenDEF_" + niob_context.id, execute);
//						alert("the next then will be: " +JSON.stringify(niob_context.currentNextThenNode) + "  : nextThenDefLength: " + emitter.listeners("nextThenDEF_" + niob_context.id).length);
						execute(node.children[0], niob_context);
						break;
					case OP_OR:
						alert("hit 'or'");
						emitter.removeAllListeners("nextOrDEF_" + niob_context.id);
//						alert("after remove we got : " + emitter.listeners("nextThenDEF_" + niob_context.id));
						niob_context.currentNextOrNode = node.children[1];
						niob_context.currentBackTrack = {};
						niob_context.currentBackTrack.v_names = v_names;
						niob_context.currentBackTrack.v_values = v_values;
						emitter.on("nextOrDEF_" + niob_context.id, execute);
						execute(node.children[0], niob_context);
						break;
					case OP_NIOB:
						alert("hit 'niob'");
						execute(node.children[0], niob_context);
						niob_counter++;
						alert("niob counter: " + niob_counter);
						var nextNiobContext = new NiobContext();
						nextNiobContext.id = niob_counter;
						execute(node.children[1], nextNiobContext);// need to change
						break;
					case OP_BRACKET:
						alert("hit 'bracket then'");
						emitter.removeAllListeners("nextBracketDEF_" + niob_context.id);
						niob_context.currentNextBracketNode = node.children[1];
						emitter.on("nextBracketDEF_" + niob_context.id, execute);
						execute(node.children[0], niob_context);
						break;
					case OP_BRACKET_OR:
						alert("hit 'bracket or'");
						emitter.removeAllListeners("nextBracketOrDEF_" + niob_context.id);
						niob_context.currentNextBracketOrNode = node.children[1];
						niob_context.currentBracketBackTrack = {};
						niob_context.currentBracketBackTrack.v_names = v_names;
						niob_context.currentBracketBackTrack.v_values = v_values;
						emitter.on("nextBracketOrDEF_" + niob_context.id, execute);
						execute(node.children[0], niob_context);
						breakl
/*					case OP_PAR:
						alert("hit par");
						break;
*/						
					case OP_SEND:
//						alert("hit send");
//						alert("message : " + JSON.stringify(node.children[0]));
//						alert("receipient : " + execute(node.children[1], niob_context));
						var msgNode = node.children[0];
						var roleNode = node.children[1];
						var solved = true;
						var message = undefined;
						var recepientJID = undefined;
						if(node.children[2]){
							solved = execute(node.children[2], niob_context);
//							alert("solved : " + solved);
							if(solved){
								message = execute(msgNode, niob_context);
								recepientJID = execute(roleNode, niob_context);
								sendMSG(message, recepientJID);
								alert("Message sent!");
							}
							executeNextThenOrOrBranch(solved, niob_context);
						}
						else{
							message = execute(msgNode, niob_context);
							recepientJID = execute(roleNode, niob_context);
							sendMSG(message, recepientJID);
							alert("Message sent!");
							alert("Message sent!");
//							alert("next then DEF: " + emitter.listeners("nextThenDEF_" + niob_context.id));
							executeNextThenOrOrBranch(true, niob_context);
						}
						break;
					case OP_RECEIVE: 
//						alert("hit receive");
//						emitter.removeAllListeners("receive");
						niob_context.currentMessageNode = node.children[0];
						niob_context.currentRoleNode = node.children[1];
//						alert("message name: " + JSON.parse(execute(node.children[0], niob_context)).name);
						niob_context.msgs.push(JSON.parse(execute(node.children[0], niob_context)).name);
//						alert("current niob context: " + JSON.stringify(niob_context));
						if(node.children[2]){
							niob_context.currentConstraintsNode = node.children[2];
						}
						else{
							niob_context.currentConstriantsNode = null;
						}
//						alert("offline_msg " + offline_msg);
//						emitter.on("msgReceived", receiveMSG);
						if(offline_msg != undefined){
//							alert("got offline msg");
							emitter.emit("gotMessageFromXMPPServer", offline_msg);
						}
						else{
							alert("Start waiting for a new message");
						}
						break;
					case OP_MESSAGE:
//						alert("hit message");
						ret = '{ "name" : "' + node.children[0] + '", "value" : "' + getValue(node.children[0]) + '", "params" : [' + execute(node.children[1], niob_context) + ']}';
//						alert("return message : " + ret);
						break;
					case OP_NO_MSG:
//						alert("hit no_msg");
						ret = execute(node.children[0], niob_context);
						executeNextThenOrOrBranch(ret, niob_context);
						break;
					case OP_EQU:
						ret = execute(node.children[0], niob_context) == execute(node.children[1], niob_context);
						break;
					case OP_NEQ:
						ret = execute(node.children[0], niob_context) != execute(node.children[1], niob_context);
						break;
					case OP_GRT:
						ret = execute(node.children[0], niob_context) > execute(node.children[1], niob_context);
						break;
					case OP_LOT:
						ret = execute(node.children[0], niob_context) < execute(node.children[1], niob_context);
						break;
					case OP_GRE:
						ret = execute(node.children[0], niob_context) >= execute(node.children[1], niob_context);
						break;
					case OP_LOE:
						ret = execute(node.children[0], niob_context) <= execute(node.children[1], niob_context);
						break;					
					case OP_ASSIGN:
						setValue(node.children[0].toString(), execute(node.children[1], niob_context));
						ret = true;
						break;
				}
				break;
			case NODE_VAR:
				if(getValue(node.value))
					ret = getValue(node.value);
				else
					ret = node.value;
				break;
			case NODE_CONST:
				ret = node.value;
				break;
			case NODE_ARR:
				ret = eval(node.value);
				break;
			case NODE_STR:
				ret = removeQuotes(node.value.toString());
				break;
		}
		updateNiobContext(niob_context);
//		alert("after update the contexts:" + JSON.stringify(niob_contexts));
		return ret;
	}
	
	function invalidOKCException(okcName){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "OKC " + "'" + okcName + "()' has not been loaded.";
		alert(message);
		return message; 
	}
	
	function roleDefinitionNotFoundException(roleName){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "Role " + "'" + roleName + "' has not been defined in this interaction model.";
		alert(message);
		return message;
	}
	
	function constraitsSolvingFailedException(){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "Constraints can not be solved. Interaction terminated without completion!";
		alert(message);
		return message;
	}
	
	function webStorageNotSupportedException(){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "Web storage is not supported by this browser and your states may be lost after you close the current window.";
		alert(message);
		return message;
	}

function listDefinitionNotSupportedException(){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "This usage of the constraint list is not supported or correct.";
		alert(message);
		return message;
	}
	
	function CommunicationIDNotFoundException(roleName){
		resetLCCEnvironment();
		if(iid) removeSnapShot(iid);
		var message = "Cannot find the communication ID (Jabber ID) of the message receiver with the role name: " + roleName;
		alert(message);
		return message;
	}
	
*]

/~ Lightweight Coordination Calculus (LCC) Interpreter ~/

/~ Tokens to be ignored ~/
!	' |\r|\n|\t|//[^\n]*\n '
        ;

/~ Grammar tokens ~/
	'head'
	'a'
/~	'okc' ~/
	'or'
	'then'
	'niob'
/~  'par' ~/
	'knows'
	'plays'
	'iid'
	'list'
	'null'
	'not'									/~ logical "NOT" ~/
/~	'msg' ~/
/~	'text' ~/
/~	'input' ~/
/~	'initiakl' ~/
	'::'
	','
	'\.'
	'$'
	'$'
	'\['
	'\]'
	'\{'
	'\}'
	'=='
	'!='
	'>'
	'<'
	'>='
	'=<'
	'=>'
	'<='
	'->'
	'<-'
	'='
	'_'
	'\|'                             
	'([A-Z][A-Za-z0-9_]*)'	Variable
/~	'(([\'\"])?[a-z][A-Za-z0-9_@\.:-//]*([\'\"])?)|(([\'\"])?([0-9-])+([\'\"])?)'		Constant	~/
	'([a-z][A-Za-z0-9_@\.:-//]*)|(([0-9\.])+)'											Constant
	'\[[^\|]*\{[^\|]+\}[^\|]*\]'													JSONLIST
	'\[[^\{\}><=!]*\]'																LIST 
/~	'\'([^\']|\'\')*\'' 															String	~/
	'(\'([^\']|\'\')*\')|(\"([^\"]|\"\")*\")'										String
	;
	
	
/~ associativity ~/
> 	"niob"
	;
	
>	"or"							
	;

>	"then"
	;

>       '<='
        '=>'
        ;

>       '<-'
        '->'
        ;

>	'\|\|'									/~ logical "OR" ~/
	;
	
>	'&&'									/~ logical "AND" ~/
	;	
	
> 	'=='
	'!='
	'>'
	'<'
	'>='
	'=<'
	'='
	;

IM:		Clause_List	BuiltIn_List						[* initialize(%1, %2); *]
		| BuiltIn_List Clause_List						[* initialize(%2, %1); *]
		| head '(' JSONLIST ')' '.' Clause_List 			[* initializeByHeader(%3, %6); *]
		| Clause_List head '(' JSONLIST ')' '.'				[* initializeByHeader(%4, %1); *]
		| head '(' JSONLIST ')' '.' Clause_List BuiltIn_List			[* initializeByHeader(%3, %6, %7); *]
		| head '(' JSONLIST ')' '.' BuiltIn_List Clause_List 			[* initializeByHeader(%3, %7, %6); *]
		;

Clause_List:	Clause									[* %% = createNode(NODE_OP, OP_CLAUSE, %1); *]
                | Clause Clause_List					[* %% = createNode(NODE_OP, OP_CLAUSE, %1, %2); *]
	        ;

Clause:	Role '::' Def '.'								[* %% = createNode(NODE_OP, OP_HEADBODY, %1, %3); *]		
		| Role '.'										[* %% = createNode(NODE_OP, OP_ENTRY, %1); *]
		;	
		
BuiltIn_List: 	BuiltIn									[* %% = createNode(NODE_OP, OP_CLAUSE, %1); *]
				| BuiltIn BuiltIn_List					[* %% = createNode(NODE_OP, OP_CLAUSE, %1, %2); *]
				;
		
BuiltIn:	plays '(' String ',' Constant ')'	'.'						[* %% = createNode(NODE_OP, OP_PLAYS, %3, %5); *]
		 	| knows '(' String ')' '.'								[* %% = createNode(NODE_OP, OP_KNOWS, %3); *] 
		 	| iid '(' String ')' '.'									[* %% = createNode(NODE_OP, OP_IID, %3); *]
		 	;

Role:	a '(' Type ',' Id ')'                           [* %% = createNode(NODE_OP, OP_ROLE, %3, %5); *]
		;

Type:	Term                                                [* %% = createNode(NODE_OP, OP_ROLE_TYPE, %1); *]
		;
	
Def:	Interaction												  /~ [* %% = %1; *] ~/
		| Def then Def                                            [* %% = createNode(NODE_OP, OP_THEN, %1, %3); *]
		| Def or Def                                              [* %% = createNode(NODE_OP, OP_OR, %1, %3); *]
		| Def niob Def											  [* %% = createNode(NODE_OP, OP_NIOB, %1, %3); *]
		| '{' Def '}'											  [* %% = %2; *]
/~		| Def par Def                                             [* %% = createNode(NODE_OP, OP_PAR, %1, %3); *] ~/
		;

Interaction:	Message '=>' Role                                 [* %% = createNode(NODE_OP, OP_SEND, %1, %3); *]
				| Message '=>' Role '<-' Constraint               [* %% = createNode(NODE_OP, OP_SEND, %1, %3, %5); *]
				| Message '<=' Role                               [* %% = createNode(NODE_OP, OP_RECEIVE, %1, %3); *]
				| Constraint '<-' Message '<=' Role               [* %% = createNode(NODE_OP, OP_RECEIVE, %3, %5, %1); *]
				| null '<-' Constraint                            [* %% = createNode(NODE_OP, OP_NO_MSG, %3); *]   /~ not in the original BNF declaration on the openk website ~/
				| Role											  [* %% = createNode(NODE_OP, OP_ROLE_CHANGE, %1 );*]
	      		| Role '<-' Constraint							  [* %% = createNode(NODE_OP, OP_ROLE_CHANGE, %1, %3) *]			
				;

Constraint:	Constant  											[* %% = true; *]
			| Constant '(' ')'                            		[* %% = createNode(NODE_OP, OP_CONSTRAINT, %1); *]
			| Constant '(' Terms ')'                            [* %% = createNode(NODE_OP, OP_CONSTRAINT, %1, %3); *]
			| not '(' Constraint ')'                            [* %% = createNode(NODE_OP, OP_NEGATE, %3); *]
			| Id '==' Id										[* %% = createNode(NODE_OP, OP_EQU, %1, %3); *]
			| Id '!=' Id										[* %% = createNode(NODE_OP, OP_NEQ, %1, %3); *]
			| Id '>' Id											[* %% = createNode(NODE_OP, OP_GRT, %1, %3); *]
			| Id '<' Id											[* %% = createNode(NODE_OP, OP_LOT, %1, %3); *]
			| Id '>=' Id										[* %% = createNode(NODE_OP, OP_GRE, %1, %3); *]
			| Id '=<' Id										[* %% = createNode(NODE_OP, OP_LOE, %1, %3); *]
			| Variable '=' Id									[* %% = createNode(NODE_OP, OP_ASSIGN, %1, %3); *]
			| Constraint '&&' Constraint                        [* %% = createNode(NODE_OP, OP_LOGAND, %1, %3); *]
			| Constraint '\|\|' Constraint                      [* %% = createNode(NODE_OP, OP_LOGOR, %1, %3); *] 
			| list '(' Id ',' Id ',' Id ')' 					[* %% = createNode(NODE_OP, OP_LIST, %3, %5, %7); *]
			;
	
Terms:	Terms ',' Term                                          [* %% = createNode(NODE_OP, OP_TERMS, %1, %3); *] 
		| Term                                                  [* %% = createNode(NODE_OP, OP_TERMS, %1); *] 
		;
		
Term:	Constant                                              	[* %% = createNode(NODE_OP, OP_FACTOR, %1); *] 
		| Variable                                              [* %% = createNode(NODE_OP, OP_FACTOR, %1); *]  
		| LIST					 								[* %% = createNode(NODE_OP, OP_FACTOR, %1); *] 
		| Constant '(' Terms ')'                                [* %% = createNode(NODE_OP, OP_FACTOR, %1, %3); *]
		| String												[* %% = createNode(NODE_OP, OP_FACTOR, %1); *]
		| '_'
		;

Id:	Constant                                                    [* %% = createNode(NODE_CONST, %1); *] 
	| Variable                                                  [* %% = createNode(NODE_VAR, %1); *]  
	| LIST														[* %% = createNode(NODE_ARR, %1); *] 
	| String													[* %% = createNode(NODE_STR, %1); *]
	;

Message:	Constant '(' Terms ')'                              [* %% = createNode(NODE_OP, OP_MESSAGE, %1, %3); *]
			;

[*
	var str = document.getElementById("lcc_head").value + document.getElementById("lcc_body").value;
	var error_cnt 	= 0;
	var error_off	= new Array();
	var error_la	= new Array();
	
	if( ( error_cnt = __parse( str, error_off, error_la ) ) > 0 )
	{
		for( i = 0; i < error_cnt; i++ )
			alert( "Parse error near >" 
				+ str.substr( error_off[i], 30 ) + "<, expecting \"" + error_la[i].join() + "\"" );
	}
*]

IM	:=	Clause_List
Clauses_List	:=	Clause \| Clause_List
Clause	:=	Role :: Def . \| Role . \| plays ( String , Constant) . \| knows ( String ) . \| iid ( String ) .
Role	:=	a ( Type , Id )
Def	:=	Message \| Def then Def \| Def or Def \| Def niob Def
Message	:=	M => Role \| M => Role <- C \| M <= Role \| C <- M <= Role \| null <- C \| Role \| Role <- C
C	:=	Constant \| Constant ( Terms ) \| not ( C ) \| C && C \| C \|\| C \| C = C \| C Operator C \| list ( Variable, Variable, Terms)
Terms	:=	Term , Terms \| Term
Type	:=	Term
Id	:=	Constant \| Variable
M	:=	Constant ( Term )
Term	:=	Constant \| Variable \| Constant ( Terms ) \| _ )
Operator	:=	== \| != \| > \| < \| >= \| =<
Constant	:=	lower case character, sequence or number
Variable	:=	upper case character, sequence or number

Please input the bodyload an example

Configure the XMPP-HTTP endpoint:

Import external OKCs

Create OKCs on the fly

Edit peer subscription head

Please input the headload an example