Simplified the model to only include parts necessary for initial protocol notation. Fixed some issues with running sub-protocol, parsing and projection.

Author: Gary Brown

modules/org.scribble.protocol.conformance/src/main/java/org/scribble/protocol/conformance/impl/BehaviourList.java

@@ -62,7 +62,7 @@ protected BehaviourList(Block defn) {
 	 * @param defn The block
 	 * @param include The model inclusion construct
 	 */
-	protected BehaviourList(Block defn, org.scribble.protocol.model.ModelInclude include) {
+	protected BehaviourList(Block defn, org.scribble.protocol.model.Run include) {
 		m_block = defn;
 		m_include = include;
 
@@ -173,12 +173,12 @@ public java.util.List<Behaviour> getBehaviourList() {
 	}
 
 	/**
-	 * This method returns the optional model include
+	 * This method returns the optional run activity
 	 * associated with the contained behaviour activities.
 	 * 
-	 * @return The optional model include
+	 * @return The optional run activity
 	 */
-	public ModelInclude getModelInclude() {
+	public Run getRun() {
 		return(m_include);
 	}
 
@@ -228,7 +228,7 @@ public void visit(Visitor visitor) {
 	}
 
 	private Block m_block=null;
-	private ModelInclude m_include=null;
+	private Run m_include=null;
 	private java.util.Map<String,String> m_nameMap=null;
 	private java.util.List<Behaviour> m_list=new java.util.Vector<Behaviour>();
 
@@ -320,7 +320,7 @@ public void visitInteraction(Interaction elem) {
 
 		public void visitRun(Run run) {
 			Protocol defn=
-				((ModelInclude)run).getProtocol();
+				((Run)run).getProtocol();
 
 			if (defn != null) {
 				BehaviourList list=null;
@@ -366,133 +366,5 @@ public void visitRun(Run run) {
 				}
 			}			
 		}
-
-		/*
-		public boolean visit(ModelObject obj) {
-			boolean ret=false;
-			
-			if (obj instanceof MultiPathBehaviour) {
-				MultiPathBehaviour paths=
-						(MultiPathBehaviour)obj;
-				java.util.List<BehaviourList> bllist=
-						new java.util.Vector<BehaviourList>();
-				
-				for (int i=0; i < paths.getPaths().size(); i++) {
-					Block block=paths.getPaths().get(i);
-					
-					BehaviourList bl=new BehaviourList(block);
-					
-					//bl.derivedFrom(block);
-					
-					bl.setNameMap(m_nameMap);
-					
-					//block.visit(bl);
-					
-					bllist.add(bl);
-				}
-				
-				BehaviourListPaths blpaths=new BehaviourListPaths((Behaviour)obj,
-										bllist);
-				
-				if (blpaths.isVisible()) {
-					addToList(blpaths);
-				}
-
-			} else if (obj instanceof SinglePathBehaviour) {
-				SinglePathBehaviour path=
-						(SinglePathBehaviour)obj;
-				java.util.List<BehaviourList> bllist=
-						new java.util.Vector<BehaviourList>();
-				
-				BehaviourList bl=new BehaviourList(path.getBlock());
-					
-				//bl.derivedFrom(path.getBlock());
-					
-				bl.setNameMap(m_nameMap);
-					
-				//path.getBlock().visit(bl);
-					
-				bllist.add(bl);
-				
-				BehaviourListPaths blpaths=new BehaviourListPaths((Behaviour)obj,
-										bllist);
-				
-				if (blpaths.isVisible()) {
-					addToList(blpaths);
-				}
-
-			} else if (obj instanceof ModelInclude) {
-				ModelInclude include=
-						(ModelInclude)obj;
-				Protocol defn=
-						((ModelInclude)obj).getProtocol();
-				
-				if (defn != null) {
-					BehaviourList list=null;
-					
-					// Check if external model - if so, then
-					// need to supply reference to list, so can be
-					// used in error reporting
-					if (include.getReference() != null &&
-								include.getReference().isInner() == false) {
-						list = new BehaviourList(defn.getBlock(), include);
-					} else {
-						list = new BehaviourList(defn.getBlock());
-					}
-					
-					list.setNameMap(getNameMap(include.getBindings()));
-					
-//					list.derivedFrom(include);
-					
-//					defn.visit(list);
-				
-					// Add list, if async (to identify existence of
-					// async composed conversation), or if the list
-					// has elements
-					if (include.isAsynchronous()) {
-						
-						// If async, then need to add 'behaviour
-						// list path' to isolate the behaviour
-						// list, to ensure it does not get merged
-						// into the outer list (as with the
-						// sync run)
-						java.util.List<BehaviourList> bllist=
-							new java.util.Vector<BehaviourList>();
-					
-						bllist.add(list);
-					
-						BehaviourListPaths blpaths=new BehaviourListPaths((Behaviour)obj,
-											bllist);
-					
-						addToList(blpaths);
-						
-					} else if (list.getBehaviourList().size() > 0) {
-						addToList(list);					
-					}
-				}
-				
-			} else if (obj instanceof Block) {
-				
-				// Iterate through each activity checking its a behaviour
-				ret = true;
-				
-			} else if (obj instanceof Behaviour) {
-				addToList((Behaviour)obj);
-			
-				// Only recursively check for behaviours
-				// inside other behaviours. This will ensure
-				// inner protocols will not be indirectly
-				// processed - only if invoked as part of
-				// a run statement.
-				ret = true;
-				
-			} else if (obj == m_block) {
-				// Visiting the main definition, so visit contents
-				ret = true;
-			}
-			
-			return(ret);
-		}
-		*/
 	}
 }

modules/org.scribble.protocol.conformance/src/main/java/org/scribble/protocol/conformance/impl/BehaviourListIterator.java

@@ -17,8 +17,8 @@
 package org.scribble.protocol.conformance.impl;
 
 import org.scribble.protocol.model.Behaviour;
-import org.scribble.protocol.model.ModelInclude;
 import org.scribble.protocol.model.ModelReference;
+import org.scribble.protocol.model.Run;
 
 /**
  * This class provides an iterator implementation over a behaviour list.
@@ -90,18 +90,18 @@ public ModelReference getComposedSource() {
 
 		if (m_subList != null) {
 			ret = m_subList.getComposedSource();
-		} else if (m_list.getModelInclude() != null) {
-			ret = m_list.getModelInclude().getReference();
+		} else if (m_list.getRun() != null) {
+			ret = m_list.getRun().getReference();
 		}
 
 		return(ret);
 	}
 
-	public ModelInclude getModelInclude() {
-		ModelInclude ret=m_list.getModelInclude();
+	public Run getRun() {
+		Run ret=m_list.getRun();
 
 		if (ret == null && m_subList != null) {
-			ret = m_subList.getModelInclude();
+			ret = m_subList.getRun();
 		}
 
 		return(ret);

modules/org.scribble.protocol.parser/src/Copy of ScribbleProtocol.g

@@ -0,0 +1,163 @@
+grammar ScribbleProtocol;
+
+options {
+	output=AST;
+}
+
+tokens {
+	INTERACTION = 'interaction' ;
+	PLUS 	= '+' ;
+	MINUS	= '-' ;
+	MULT	= '*' ;
+	DIV	= '/' ;
+	FULLSTOP = '.' ;
+}
+
+@header {
+package org.scribble.protocol.parser.antlr;
+}
+   
+@lexer::header {
+package org.scribble.protocol.parser.antlr;
+}
+   
+@members {
+	private org.scribble.common.logging.Journal m_journal=null;
+	
+	public static void main(String[] args) throws Exception {
+        ScribbleProtocolLexer lex = new ScribbleProtocolLexer(new ANTLRFileStream(args[0]));
+       	CommonTokenStream tokens = new CommonTokenStream(lex);
+
+		ScribbleProtocolParser parser = new ScribbleProtocolParser(tokens);
+
+		ProtocolTreeAdaptor adaptor=new ProtocolTreeAdaptor();
+		adaptor.setParser(parser);
+		
+		parser.setTreeAdaptor(adaptor);
+		
+        try {
+            ScribbleProtocolParser.description_return r=parser.description();
+            
+            //CommonTree t=(CommonTree)r.getTree();
+            
+            //Tree t=(Tree)r.getTree();
+            
+            //System.out.println(t.toStringTree());
+            
+        } catch (RecognitionException e)  {
+            e.printStackTrace();
+        }
+    }
+    
+    public void setJournal(org.scribble.common.logging.Journal journal) {
+    	m_journal = journal;
+    }
+    
+    public void emitErrorMessage(String mesg) {
+    	if (m_journal == null) {
+    		super.emitErrorMessage(mesg);
+    	} else {
+    		m_journal.error(mesg, null);
+    	}
+    }
+}
+
+/*------------------------------------------------------------------
+ * PARSER RULES
+ *------------------------------------------------------------------*/
+
+description: ( namespaceDeclaration )? ( importStatement )* protocolDef ;
+
+namespaceDeclaration: 'namespace'^ qualifiedName ';'! ;
+
+qualifiedName: ID ( '.' ID )* ;
+
+urlDef: URL ;
+
+importStatement: 'import'^ qualifiedName ( '@' urlDef )? ';'! ;
+
+protocolDef: 'protocol'^ locatedNameDef blockDef ;
+
+locatedNameDef: ID ( '@' participantName )? ;
+
+blockDef: sequenceDef ;
+
+sequenceDef: '{'! activityListDef '}'! ;
+
+activityListDef: ( activityDef )* ;
+
+activityDef: participantListDef | interactionDef | 
+			raiseDef  | choiceDef | parallelDef | optionalDef | repeatDef | runDef | 
+			tryEscapeDef | protocolDef ;
+
+participantListDef: 'participant'^ participantDef ( ','! participantDef )* ';'! ;
+
+participantDef: ID ;
+
+participantName: ID ;
+
+typeReferenceDef: qualifiedName ;
+
+interactionSignatureDef: ( typeReferenceDef | ID '('! typeReferenceDef ( ','! typeReferenceDef )* ')'! ) ;
+
+interactionDef: interactionSignatureDef ( 'from' participantName )? ( 'to' participantName )? ';'! ;
+
+choiceDef: 'choice'^ ( 'from' participantName )? ( 'to' participantName )? '{'! ( whenBlockDef )+ '}'! ;
+
+whenBlockDef: 'when'^ interactionSignatureDef sequenceDef ;
+
+repeatDef: 'repeat'^ ( '@' participantName ( ','! participantName )* )? blockDef ;
+
+optionalDef: 'optional'^ ( '@' participantName ( ','! participantName )* )? blockDef ;
+
+runDef: 'run'^ ( inlineProtocolDef | protocolRefDef ( '('! boundParameter ( ','! boundParameter )* ')'! )? ';'! ) ;
+
+protocolRefDef: ID ( '@' participantName )? ;
+
+inlineProtocolDef: 'protocol' ( '@' participantName )? ( '('! boundParameter ( ','! boundParameter )* ')'! )? blockDef ;
+
+declarationName: ID ;
+
+boundParameter: declarationName 'for' declarationName ;
+
+parallelDef: 'parallel'^ blockDef ( 'and' blockDef )* ;
+
+raiseDef: 'raise'^ '@' participantName ( ','! participantName )* typeReferenceDef ';'! ;
+
+tryEscapeDef: 'try'^ blockDef ( catchOrInterruptBlockDef )+ ;
+
+catchOrInterruptBlockDef: catchBlockDef | interruptBlockDef ;
+
+catchBlockDef: 'catch'^ ( '@' participantName ( ',' participantName )* )? typeReferenceDef sequenceDef ;
+
+interruptBlockDef: 'interrupt'^ ( '@' participantName ( ',' participantName )* )? sequenceDef ;
+
+
+/*-----------------------------------------------
+TO DO:
+Declaration (variables) possibly - but that may need
+lookahead to avoid conflict with interactions.
+-------------------------------------------------*/
+
+
+
+expr	: term ( ( PLUS | MINUS )  term )* ;
+
+term	: factor ( ( MULT | DIV ) factor )* ;
+
+factor	: NUMBER ;
+
+
+/*------------------------------------------------------------------
+ * LEXER RULES
+ *------------------------------------------------------------------*/
+
+ID : ('a'..'z'|'A'..'Z'|'_')('a'..'z'|'A'..'Z'|'0'..'9'|'_')* ;
+
+URL : (ID|':'|'?'|'/')+ ;
+
+NUMBER	: (DIGIT)+ ;
+
+WHITESPACE : ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+ 	{ $channel = HIDDEN; } ;
+
+fragment DIGIT	: '0'..'9' ;

modules/org.scribble.protocol.parser/src/main/antlr3/org/scribble/protocol/parser/antlr/ScribbleProtocol.g

@@ -110,13 +110,16 @@ repeatDef: 'repeat'^ ( '@' participantName ( ','! participantName )* )? blockDef
 
 optionalDef: 'optional'^ ( '@' participantName ( ','! participantName )* )? blockDef ;
 
-runDef: 'run'^ ( inlineProtocolDef | protocolRefDef ( '('! boundParameter ( ','! boundParameter )* ')'! )? ';'! ) ;
+runDef: 'run'^ ( ( ( '@' participantName )? '('! boundParameter ( ','! boundParameter )* ')'! )? inlineProtocolDef | 
+			protocolRefDef ( '('! boundParameter ( ','! boundParameter )* ')'! )? ';'! ) ;
 
 protocolRefDef: ID ( '@' participantName )? ;
 
-inlineProtocolDef: 'protocol' ( '('! boundParameter ( ','! boundParameter )* ')'! )? blockDef ;
+inlineProtocolDef: blockDef ;
 
-boundParameter: ID '='! ID ;
+declarationName: ID ;
+
+boundParameter: declarationName '=' declarationName ;
 
 parallelDef: 'parallel'^ blockDef ( 'and' blockDef )* ;