CSY/reowolf Changeset - 5e11ebce9bc0 · Centrum Wiskunde & Informatica (CWI)

Changeset - 5e11ebce9bc0

Parent rev.

Child rev.

[Not reviewed]

0 5 0

Hans-Dieter Hiep - 5 years ago 2020-02-10 11:57:19
hdh@cwi.nl

Evaluator new_component and new_channel implemented

5 files changed with 103 insertions and 23 deletions:

src/protocol/ast.rs

src/protocol/eval.rs

src/protocol/mod.rs

src/protocol/parser.rs

src/test/connector.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1308,97 +1308,97 @@ impl Identifier { @@
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(self.ident()))
+    }
+}
 impl PartialEq<Identifier> for Identifier {
     fn eq(&self, rhs: &Identifier) -> bool {
         self.ident() == rhs.ident()
+    }
+}
 impl PartialEq<SourceIdentifier> for Identifier {
     fn eq(&self, rhs: &SourceIdentifier) -> bool {
         self.ident() == rhs.ident()
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ExternalIdentifier {
     pub this: ExternalIdentifierId,
     // Phase 1: parser
     pub value: Vec<u8>,
+}
 impl ExternalIdentifier {
     fn ident(&self) -> &[u8] {
         &self.value
+    }
+}
 impl Display for ExternalIdentifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 #[derive(Debug, Clone)]
 pub struct SourceIdentifier {
     pub this: SourceIdentifierId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 impl SourceIdentifier {
     fn ident(&self) -> &[u8] {
+    pub fn ident(&self) -> &[u8] {
         &self.value
+    }
+}
 impl SyntaxElement for SourceIdentifier {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 impl Display for SourceIdentifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 impl PartialEq<Identifier> for SourceIdentifier {
     fn eq(&self, rhs: &Identifier) -> bool {
         self.ident() == rhs.ident()
+    }
+}
 impl PartialEq<SourceIdentifier> for SourceIdentifier {
     fn eq(&self, rhs: &SourceIdentifier) -> bool {
         self.ident() == rhs.ident()
+    }
+}
 type TypeData = Vec<u8>;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PrimitiveType {
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
     Symbolic(TypeData),
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
@@ @@ -1782,96 +1782,102 @@ pub struct Primitive { @@
     pub body: StatementId,
+}
 impl SyntaxElement for Primitive {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub return_type: TypeAnnotationId,
     pub identifier: SourceIdentifierId,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Function {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Declaration {
     Defined(DefinedDeclaration),
     Imported(ImportedDeclaration),
+}
 impl Declaration {
     pub fn signature(&self) -> &Signature {
         match self {
             Declaration::Defined(decl) => &decl.signature,
             Declaration::Imported(decl) => &decl.signature,
+        }
+    }
     pub fn identifier(&self) -> IdentifierId {
         self.signature().identifier()
+    }
     pub fn is_component(&self) -> bool {
         self.signature().is_component()
+    }
     pub fn is_function(&self) -> bool {
         self.signature().is_function()
+    }
     pub fn as_defined(&self) -> &DefinedDeclaration {
         match self {
             Declaration::Defined(result) => result,
             _ => panic!("Unable to cast `Declaration` to `DefinedDeclaration`"),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct DefinedDeclaration {
     pub this: DefinedDeclarationId,
     // Phase 2: linker
     pub definition: DefinitionId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone)]
 pub struct ImportedDeclaration {
     pub this: ImportedDeclarationId,
     // Phase 2: linker
     pub import: ImportId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone)]
 pub enum Signature {
     Component(ComponentSignature),
     Function(FunctionSignature),
+}
 impl Signature {
     pub fn from_definition(h: &Heap, def: DefinitionId) -> Signature {
         match &h[def] {
             Definition::Component(com) => Signature::Component(ComponentSignature {
                 identifier: com.identifier().0,
                 arity: Signature::convert_parameters(h, com.parameters()),
             }),
             Definition::Function(fun) => Signature::Function(FunctionSignature {
                 return_type: h[fun.return_type].the_type.clone(),
                 identifier: fun.identifier.0,
                 arity: Signature::convert_parameters(h, &fun.parameters),
             }),
+        }
+    }
     fn convert_parameters(h: &Heap, params: &Vec<ParameterId>) -> Vec<Type> {
         let mut result = Vec::new();
         for &param in params.iter() {
             result.push(h[h[param].type_annotation].the_type.clone());
+        }
         result
+    }
     fn identifier(&self) -> IdentifierId {
         match self {
             Signature::Component(com) => com.identifier,
@@ @@ -2133,96 +2139,97 @@ impl SyntaxElement for Statement { @@
             Statement::Synchronous(stmt) => stmt.position(),
             Statement::EndSynchronous(stmt) => stmt.position(),
             Statement::Return(stmt) => stmt.position(),
             Statement::Assert(stmt) => stmt.position(),
             Statement::Goto(stmt) => stmt.position(),
             Statement::New(stmt) => stmt.position(),
             Statement::Put(stmt) => stmt.position(),
             Statement::Expression(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub statements: Vec<StatementId>,
     // Phase 2: linker
     pub parent_scope: Option<Scope>,
     pub locals: Vec<LocalId>,
     pub labels: Vec<LabeledStatementId>,
+}
 impl BlockStatement {
     pub fn parent_block(&self, h: &Heap) -> Option<BlockStatementId> {
         let parent = self.parent_scope.unwrap();
         match parent {
             Scope::Definition(_) => {
                 // If the parent scope is a definition, then there is no
                 // parent block.
                 None
+            }
             Scope::Synchronous(parent) => {
                 // It is always the case that when this function is called,
                 // the parent of a synchronous statement is a block statement:
                 // nested synchronous statements are flagged illegal,
                 // and that happens before resolving variables that
                 // creates the parent_scope references in the first place.
                 Some(h[parent].parent_scope(h).unwrap().to_block())
+            }
             Scope::Block(parent) => {
                 // A variable scope is either a definition, sync, or block.
                 Some(parent)
+            }
+        }
+    }
     pub fn first(&self) -> StatementId {
         // It is an invariant (guaranteed by the lexer) that block statements have at least one stmt
         *self.statements.first().unwrap()
+    }
+}
 impl SyntaxElement for BlockStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 impl VariableScope for BlockStatement {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         self.parent_scope
+    }
     fn get_variable(&self, h: &Heap, id: SourceIdentifierId) -> Option<VariableId> {
         for &local in self.locals.iter() {
             if h[h[local].identifier] == h[id] {
                 return Some(local.0);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -1330,97 +1330,97 @@ impl Store { @@
     fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {
         // Ensure value is compatible with type of variable
         let the_type = h[var].the_type(h);
         assert!(value.is_type_compatible(the_type));
         // Overwrite mapping
         self.map.insert(var, value.clone());
+    }
     fn update(
         &mut self,
         h: &Heap,
         ctx: &mut EvalContext,
         lexpr: ExpressionId,
         value: Value,
     ) -> EvalResult {
         match &h[lexpr] {
             Expression::Variable(var) => {
                 let var = var.declaration.unwrap();
                 // Ensure value is compatible with type of variable
                 let the_type = h[var].the_type(h);
                 assert!(value.is_type_compatible(the_type));
                 // Overwrite mapping
                 self.map.insert(var, value.clone());
                 Ok(value)
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
                 let index = self.eval(h, ctx, indexing.index)?;
                 // Mutable reference to the subject
                 let subject;
                 match &h[indexing.subject] {
                     Expression::Variable(var) => {
                         let var = var.declaration.unwrap();
                         subject = self.map.get_mut(&var).unwrap();
+                    }
                     _ => unreachable!(),
+                }
                 match subject.set(&index, &value) {
                     Some(value) => Ok(value),
                     None => Err(EvalContinuation::Inconsistent),
+                }
+            }
             _ => unimplemented!("{:?}", h[lexpr]),
+        }
+    }
     fn get(&mut self, h: &Heap, rexpr: ExpressionId) -> EvalResult {
         match &h[rexpr] {
             Expression::Variable(var) => {
                 let var = var.declaration.unwrap();
-                let value = self.map.get(&var).unwrap();
+                let value = self.map.get(&var).expect(&format!("Uninitialized variable {:?}", h[h[var].identifier()]));
                 Ok(value.clone())
+            }
             _ => unimplemented!("{:?}", h[rexpr]),
+        }
+    }
     fn eval(&mut self, h: &Heap, ctx: &mut EvalContext, expr: ExpressionId) -> EvalResult {
         match &h[expr] {
             Expression::Assignment(expr) => {
                 let value = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     AssignmentOperator::Set => {
                         self.update(h, ctx, expr.left, value.clone());
+                    }
                     AssignmentOperator::Added => {
                         let old = self.get(h, expr.left)?;
                         self.update(h, ctx, expr.left, old.plus(&value));
+                    }
                     AssignmentOperator::Subtracted => {
                         let old = self.get(h, expr.left)?;
                         self.update(h, ctx, expr.left, old.minus(&value));
+                    }
                     _ => unimplemented!("{:?}", expr),
+                }
                 Ok(value)
+            }
             Expression::Conditional(expr) => {
                 let test = self.eval(h, ctx, expr.test)?;
                 if test.as_boolean().0 {
                     self.eval(h, ctx, expr.true_expression)
                 } else {
                     self.eval(h, ctx, expr.false_expression)
+                }
+            }
             Expression::Binary(expr) => {
                 let left = self.eval(h, ctx, expr.left)?;
                 let right = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     BinaryOperator::Equality => Ok(left.eq(&right)),
                     BinaryOperator::Inequality => Ok(left.neq(&right)),
                     BinaryOperator::LessThan => Ok(left.lt(&right)),
                     BinaryOperator::LessThanEqual => Ok(left.lte(&right)),
                     BinaryOperator::GreaterThan => Ok(left.gt(&right)),
                     BinaryOperator::GreaterThanEqual => Ok(left.gte(&right)),
                     BinaryOperator::Remainder => Ok(left.modulus(&right)),
                     _ => unimplemented!(),
+                }
+            }
             Expression::Unary(expr) => {
@@ @@ -1440,249 +1440,283 @@ impl Store { @@
                         value = value.minus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone());
+                    }
                     _ => unimplemented!(),
+                }
                 Ok(value)
+            }
             Expression::Indexing(expr) => self.get(h, expr.this.upcast()),
             Expression::Slicing(expr) => unimplemented!(),
             Expression::Select(expr) => self.get(h, expr.this.upcast()),
             Expression::Array(expr) => unimplemented!(),
             Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),
             Expression::Call(expr) => match expr.method {
                 Method::Create => {
                     assert_eq!(1, expr.arguments.len());
                     let length = self.eval(h, ctx, expr.arguments[0])?;
                     Ok(Value::create_message(length))
+                }
                 Method::Fires => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.fires(value.clone()) {
                         None => Err(EvalContinuation::BlockFires(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Get => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.get(value.clone()) {
                         None => Err(EvalContinuation::BlockGet(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Symbolic(symbol) => unimplemented!(),
             },
             Expression::Variable(expr) => self.get(h, expr.this.upcast()),
+        }
+    }
+}
 type EvalResult = Result<Value, EvalContinuation>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(Vec<Value>),
+    NewComponent(DeclarationId, Vec<Value>),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 #[derive(Debug, Clone)]
 pub struct Prompt {
     definition: DefinitionId,
     store: Store,
     position: Option<StatementId>,
+}
 impl Prompt {
     pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {
         let mut prompt =
             Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };
         prompt.set_arguments(h, args);
         prompt
+    }
     fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {
         let def = &h[self.definition];
         let params = def.parameters();
         assert_eq!(params.len(), args.len());
         for (param, value) in params.iter().zip(args.iter()) {
             let hparam = &h[*param];
             let type_annot = &h[hparam.type_annotation];
             assert!(value.is_type_compatible(&type_annot.the_type));
             self.store.initialize(h, param.upcast(), value.clone());
+        }
+    }
     pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {
         if let Some(stmt) = self.position {
             let stmt = &h[stmt];
             match stmt {
                 Statement::Block(stmt) => {
                     // Continue to first statement
                     self.position = Some(stmt.first());
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Local(stmt) => {
                     match stmt {
                         LocalStatement::Memory(stmt) => {
                             // Evaluate initial expression
                             let value = self.store.eval(h, ctx, stmt.initial)?;
                             // Update store
                             self.store.initialize(h, stmt.variable.upcast(), value);
+                        }
                         LocalStatement::Channel(stmt) => unimplemented!(),
                         LocalStatement::Channel(stmt) => {
                             let [from, to] = ctx.new_channel();
                             // Store the values in the declared variables
                             self.store.initialize(h, stmt.from.upcast(), from);
                             self.store.initialize(h, stmt.to.upcast(), to);
                         },
+                    }
                     // Continue to next statement
                     self.position = stmt.next();
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Skip(stmt) => {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Labeled(stmt) => {
                     // Continue to next statement
                     self.position = Some(stmt.body);
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::If(stmt) => {
                     // Evaluate test
                     let value = self.store.eval(h, ctx, stmt.test)?;
                     // Continue with either branch
                     if value.as_boolean().0 {
                         self.position = Some(stmt.true_body);
                     } else {
                         self.position = Some(stmt.false_body);
+                    }
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::EndIf(stmt) => {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::While(stmt) => {
                     // Evaluate test
                     let value = self.store.eval(h, ctx, stmt.test)?;
                     // Either continue with body, or go to next
                     if value.as_boolean().0 {
                         self.position = Some(stmt.body);
                     } else {
                         self.position = stmt.next.map(|x| x.upcast());
+                    }
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::EndWhile(stmt) => {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Synchronous(stmt) => {
                     // Continue to next statement, and signal upward
                     self.position = Some(stmt.body);
                     Err(EvalContinuation::SyncBlockStart)
+                }
                 Statement::EndSynchronous(stmt) => {
                     // Continue to next statement, and signal upward
                     self.position = stmt.next;
                     Err(EvalContinuation::SyncBlockEnd)
+                }
                 Statement::Break(stmt) => {
                     // Continue to end of while
                     self.position = stmt.target.map(EndWhileStatementId::upcast);
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Continue(stmt) => {
                     // Continue to beginning of while
                     self.position = stmt.target.map(WhileStatementId::upcast);
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::Assert(stmt) => {
                     // Evaluate expression
                     let value = self.store.eval(h, ctx, stmt.expression)?;
                     if value.as_boolean().0 {
                         // Continue to next statement
                         self.position = stmt.next;
                         Err(EvalContinuation::Stepping)
                     } else {
                         // Assertion failed: inconsistent
                         Err(EvalContinuation::Inconsistent)
+                    }
+                }
                 Statement::Return(stmt) => {
                     // Evaluate expression
                     let value = self.store.eval(h, ctx, stmt.expression)?;
                     // Done with evaluation
                     Ok(value)
+                }
                 Statement::Goto(stmt) => {
                     // Continue to target
                     self.position = stmt.target.map(|x| x.upcast());
                     Err(EvalContinuation::Stepping)
+                }
                 Statement::New(stmt) => todo!(),
                 Statement::New(stmt) => {
                     let expr = &h[stmt.expression];
                     let mut args = Vec::new();
                     for &arg in expr.arguments.iter() {
                         let value = self.store.eval(h, ctx, arg)?;
                         args.push(value);
+                    }
                     self.position = stmt.next;
                     Err(EvalContinuation::NewComponent(expr.declaration.unwrap(), args))
+                }
                 Statement::Put(stmt) => {
                     // Evaluate port and message
                     let port = self.store.eval(h, ctx, stmt.port)?;
                     let message = self.store.eval(h, ctx, stmt.message)?;
                     // Continue to next statement
                     self.position = stmt.next;
                     // Signal the put upwards
                     Err(EvalContinuation::Put(port, message))
+                }
                 Statement::Expression(stmt) => {
                     // Evaluate expression
                     let value = self.store.eval(h, ctx, stmt.expression)?;
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
+                }
                 _ => unimplemented!("{:?}", stmt),
+            }
         } else {
             Err(EvalContinuation::Terminal)
+        }
+    }
     fn compute_function(h: &Heap, fun: FunctionId, args: &Vec<Value>) -> Option<Value> {
         let mut prompt = Self::new(h, fun.upcast(), args);
         let mut context = EvalContext::None;
         loop {
             let result = prompt.step(h, &mut context);
             match result {
                 Ok(val) => return Some(val),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return None,
                     // Functions never terminate without returning
                     EvalContinuation::Terminal => unreachable!(),
                     // Functions never encounter any blocking behavior
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => unreachable!(),
-                    EvalContinuation::NewComponent(args) => unreachable!(),
+                    EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(val) => unreachable!(),
                     EvalContinuation::BlockGet(val) => unreachable!(),
                     EvalContinuation::Put(port, msg) => unreachable!(),
                 },
+            }
+        }
+    }
+}
 #[cfg(test)]
 mod tests {
     extern crate test_generator;
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use test_generator::test_resources;
     use super::*;
     #[test_resources("testdata/eval/positive/*.pdl")]
     fn batch1(resource: &str) {
         let path = Path::new(resource);
         let expect = path.with_extension("txt");
         let mut heap = Heap::new();
         let mut source = InputSource::from_file(&path).unwrap();
         let mut parser = Parser::new(&mut source);
         let pd = parser.parse(&mut heap).unwrap();
         let test = heap.get_external_identifier(b"test");
         let def = heap[pd].get_definition(&heap, test.upcast()).unwrap();
         let def = heap[pd].get_definition_ident(&heap, b"test").unwrap();
         let fun = heap[def].as_function().this;
         let args = Vec::new();
         let result = Prompt::compute_function(&heap, fun, &args).unwrap();
         let valstr: String = format!("{}", result);
         println!("{}", valstr);
         let mut cev: Vec<u8> = Vec::new();
         let mut f = File::open(expect).unwrap();
         f.read_to_end(&mut cev).unwrap();
         let lavstr = String::from_utf8_lossy(&cev);
         println!("{}", lavstr);
         assert_eq!(valstr, lavstr);
+    }
+}

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -76,176 +76,204 @@ impl ProtocolDescription for ProtocolDescriptionImpl { @@
             } else if ptype == &PrimitiveType::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     fn new_main_component(&self, identifier: &[u8], ports: &[Key]) -> ComponentStateImpl {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
         ComponentStateImpl { prompt: Prompt::new(h, def, &args) }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ComponentStateImpl {
     prompt: Prompt,
+}
 impl ComponentState for ComponentStateImpl {
     type D = ProtocolDescriptionImpl;
     fn pre_sync_run<C: MonoContext<D = ProtocolDescriptionImpl, S = Self>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> MonoBlocker {
         let mut context = EvalContext::Mono(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return MonoBlocker::Inconsistent,
                     EvalContinuation::Terminal => return MonoBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return MonoBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(args) => {
                         todo!();
                     EvalContinuation::NewComponent(decl, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let h = &pd.heap;
                         let def = h[decl].as_defined().definition;
                         println!("Create component: {}",  String::from_utf8_lossy(h[h[def].identifier()].ident()));
                         let init_state = ComponentStateImpl { prompt: Prompt::new(h, def, &args) };
                         context.new_component(&args, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(val) => unreachable!(),
                     EvalContinuation::BlockGet(val) => unreachable!(),
                     EvalContinuation::Put(port, msg) => unreachable!(),
                 },
+            }
+        }
+    }
     fn sync_run<C: PolyContext<D = ProtocolDescriptionImpl>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> PolyBlocker {
         let mut context = EvalContext::Poly(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // Inside synchronous blocks, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return PolyBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => return PolyBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
-                    EvalContinuation::NewComponent(args) => unreachable!(),
+                    EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
                         Value::Output(OutputValue(key)) => {
                             return PolyBlocker::CouldntCheckFiring(key);
+                        }
                         Value::Input(InputValue(key)) => {
                             return PolyBlocker::CouldntCheckFiring(key);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
                         Value::Output(OutputValue(key)) => {
                             return PolyBlocker::CouldntReadMsg(key);
+                        }
                         Value::Input(InputValue(key)) => {
                             return PolyBlocker::CouldntReadMsg(key);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let key;
                         match port {
                             Value::Output(OutputValue(the_key)) => {
                                 key = the_key;
+                            }
                             Value::Input(InputValue(the_key)) => {
                                 key = the_key;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
                                 return PolyBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                                 // Create a copy of the payload
                                 payload = buffer.clone();
+                            }
                             _ => unreachable!(),
+                        }
                         return PolyBlocker::PutMsg(key, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 pub enum EvalContext<'a> {
     Mono(&'a mut dyn MonoContext<D = ProtocolDescriptionImpl, S = ComponentStateImpl>),
     Poly(&'a mut dyn PolyContext<D = ProtocolDescriptionImpl>),
     None,
+}
 impl EvalContext<'_> {
     fn random(&mut self) -> LongValue {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Mono(context) => todo!(),
-            EvalContext::Poly(context) => unreachable!(),
+            EvalContext::Poly(_) => unreachable!(),
+        }
+    }
-    fn channel(&mut self) -> (Value, Value) {
+    fn new_component(&mut self, args: &[Value], init_state: ComponentStateImpl) -> () {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Mono(context) => unreachable!(),
             EvalContext::Poly(context) => todo!(),
             EvalContext::Mono(context) => {
                 let mut moved_keys = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(key)) => { moved_keys.insert(*key); }
                         Value::Input(InputValue(key)) => { moved_keys.insert(*key); }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_keys, init_state)
+            }
             EvalContext::Poly(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Mono(context) => {
                 let [from, to] = context.new_channel();
                 let from = Value::Output(OutputValue(from));
                 let to = Value::Input(InputValue(to));
                 return [from, to];
+            }
             EvalContext::Poly(_) => unreachable!()
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
-            EvalContext::Mono(context) => unreachable!(),
+            EvalContext::Mono(_) => unreachable!(),
             EvalContext::Poly(context) => match port {
                 Value::Output(OutputValue(key)) => context.is_firing(key).map(Value::from),
                 Value::Input(InputValue(key)) => context.is_firing(key).map(Value::from),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
-            EvalContext::Mono(context) => unreachable!(),
+            EvalContext::Mono(_) => unreachable!(),
             EvalContext::Poly(context) => match port {
                 Value::Output(OutputValue(key)) => {
                     context.read_msg(key).map(Value::receive_message)
+                }
                 Value::Input(InputValue(key)) => context.read_msg(key).map(Value::receive_message),
                 _ => unreachable!(),
             },
+        }
+    }
+}

src/protocol/parser.rs

➞

Show inline comments

@@ @@ -1037,125 +1037,125 @@ impl Visitor for ResolveVariables { @@
+        }
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         h: &mut Heap,
         expr: VariableExpressionId,
     ) -> VisitorResult {
         let var = self.get_variable(h, h[expr].identifier)?;
         h[expr].declaration = Some(var);
         Ok(())
+    }
+}
 struct UniqueStatementId(StatementId);
 struct LinkStatements {
     prev: Option<UniqueStatementId>,
+}
 impl LinkStatements {
     fn new() -> Self {
         LinkStatements { prev: None }
+    }
+}
 impl Visitor for LinkStatements {
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
-        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
+        if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, which combines both branches into one next statement
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_if_statement(|this| EndIfStatement { this, position, next: None }).upcast();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].true_body)?;
-        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
+        if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].false_body)?;
-        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
+        if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         // Use the pseudo-statement as the statement where to update the next pointer
         self.prev = Some(UniqueStatementId(pseudo));
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, to which the break statement finds its target
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_while_statement(|this| EndWhileStatement { this, position, next: None });
         // Update the while's next statement to point to the pseudo-statement
         h[stmt].next = Some(pseudo);
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement loops back to the while statement itself
         // Note: continue statements also loop back to the while statement itself
         if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
             h[prev].link_next(stmt.upcast());
+        }
         // Use the while statement as the statement where the next pointer is updated
         self.prev = Some(UniqueStatementId(pseudo.upcast()));
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command
         // that marks the end of the synchronous block. Every evaluation has to pause at this
         // point, only to resume later when the thread is selected as unique thread to continue.
         let position = h[stmt].position;
         let pseudo = h
             .alloc_end_synchronous_statement(|this| EndSynchronousStatement {
                 this,
                 position,
                 next: None,

src/test/connector.rs

➞

Show inline comments

@@ @@ -479,116 +479,127 @@ fn alternator_2() { @@
+                }
+            }
         },
         &|x| {
             // A
             x.configure(PDL, b"sync").unwrap();
             x.bind_port(0, Active(addrs[0])).unwrap();
             x.bind_port(1, Native).unwrap();
             x.connect(timeout).unwrap();
             for _ in 0..N {
                 // get msg round
                 x.get(0).unwrap();
                 assert_eq!(Ok(0), x.sync(timeout)); // GET ONE
                 assert_eq!(Ok(MSG), x.read_gotten(0));
                 // silent round
                 assert_eq!(Ok(0), x.sync(timeout)); // MISS ONE
                 assert_eq!(Err(ReadGottenErr::DidNotGet), x.read_gotten(0));
+            }
         },
         &|x| {
             // B
             x.configure(PDL, b"sync").unwrap();
             x.bind_port(0, Active(addrs[1])).unwrap();
             x.bind_port(1, Native).unwrap();
             x.connect(timeout).unwrap();
             for _ in 0..N {
                 // silent round
                 assert_eq!(Ok(0), x.sync(timeout)); // MISS ONE
                 assert_eq!(Err(ReadGottenErr::DidNotGet), x.read_gotten(0));
                 // get msg round
                 x.get(0).unwrap();
                 assert_eq!(Ok(0), x.sync(timeout)); // GET ONE
                 assert_eq!(Ok(MSG), x.read_gotten(0));
+            }
         },
     ]));
+}
 #[test]
 // PANIC TODO: eval::1536
 fn composite_chain() {
     // Check if composition works. Forward messages through long chains
     /*
     Alice -->sync-->sync-->A|P-->sync-->sync--> Bob
     */
     static PDL : &[u8] =
 b"primitive sync(in i, out o) {
     while(true) synchronous {
         if (fires(i)) put(o, get(i));
+    }
+}
 composite sync_2(in i, out o) {
     channel x -> y;
     new sync(i, x);
     new sync(y, o);
 }";
     let timeout = Duration::from_millis(1_500);
     let addrs = [next_addr(), next_addr()];
     const N: usize = 1;
-    static MSG: &[u8] = b"Hippity Hoppity";
+    static MSG: &[u8] = b"SSS";
     assert!(run_connector_set(&[
         //
         &|x| {
             // Alice
             x.configure(PDL, b"sync_2").unwrap();
             x.bind_port(0, Native).unwrap();
             x.bind_port(1, Active(addrs[0])).unwrap();
             x.connect(timeout).unwrap();
             for _ in 0..N {
                 x.put(0, MSG.to_vec()).unwrap();
                 assert_eq!(0, x.sync(timeout).unwrap());
+            }
         },
         &|x| {
             // Bob
-            x.configure(PDL, b"sync_2").unwrap();
+            x.configure(PDL, b"sync").unwrap();
             x.bind_port(0, Passive(addrs[0])).unwrap();
             x.bind_port(1, Native).unwrap();
             x.connect(timeout).unwrap();
             for _ in 0..N {
                 // get msg round
                 x.get(0).unwrap();
                 assert_eq!(Ok(0), x.sync(timeout));
                 assert_eq!(Ok(MSG), x.read_gotten(0));
+            }
         },
     ]));
+}
 #[test]
 // PANIC TODO: eval::1605
 fn exchange() {
     /*
         /-->forward-->P|A-->forward-->\
     Alice                             Bob
         \<--forward<--P|A<--forward<--/
     */
     let timeout = Duration::from_millis(1_500);
     let addrs = [next_addr(), next_addr()];
     const N: usize = 1;
     assert!(run_connector_set(&[
         //
         &|x| {
             // Alice
             x.configure(PDL, b"forward_pair").unwrap();
             x.bind_port(0, Native).unwrap(); // native in
             x.bind_port(1, Passive(addrs[0])).unwrap(); // peer out
             x.bind_port(2, Passive(addrs[1])).unwrap(); // peer in
             x.bind_port(3, Native).unwrap(); // native out
             x.connect(timeout).unwrap();
             for _ in 0..N {
                 x.put(0, b"A->B".to_vec()).unwrap();
                 x.get(1).unwrap();
                 assert_eq!(Ok(0), x.sync(timeout));
                 assert_eq!(Ok(b"B->A" as &[u8]), x.read_gotten(0));
+            }
         },
         &|x| {
             // Bob
             x.configure(PDL, b"forward_pair").unwrap();
             x.bind_port(0, Native).unwrap(); // native in
             x.bind_port(1, Active(addrs[1])).unwrap(); // peer out
             x.bind_port(2, Active(addrs[0])).unwrap(); // peer in
             x.bind_port(3, Native).unwrap(); // native out

0 comments (0 inline, 0 general)