CSY/reowolf Changeset - 98726afd4a84 · Centrum Wiskunde & Informatica (CWI)

Changeset - 98726afd4a84

Parent rev.

Child rev.

[Not reviewed]

feat-select-block-evaluation

0 6 0

MH - 3 years ago 2022-03-02 11:22:39
contact@maxhenger.nl

Initial implementation of block evaluation

6 files changed with 40 insertions and 28 deletions:

src/protocol/ast_printer.rs

src/protocol/eval/executor.rs

src/protocol/mod.rs

src/protocol/parser/pass_rewriting.rs

src/runtime2/component/component_pdl.rs

src/runtime2/tests/mod.rs

0 comments (0 inline, 0 general)

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -338,673 +338,682 @@ impl ASTWriter { @@
                         self.kv(indent4).with_s_key("Value").with_s_val("None");
                     } else {
                         self.kv(indent4).with_s_key("Values");
                         for embedded in &variant.value {
                             self.kv(indent4+1).with_s_key("Value")
                                 .with_custom_val(|v| write_parser_type(v, heap, embedded));
+                        }
+                    }
+                }
+            }
             Definition::Procedure(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Kind").with_debug_val(&def.kind);
                 if let Some(parser_type) = &def.return_type {
                     self.kv(indent2).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, parser_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
             },
+        }
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match stmt {
             Statement::Block(stmt) => {
                 self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Block");
                 self.kv(indent2).with_s_key("EndBlockID").with_disp_val(&stmt.end_block.0.index);
                 self.kv(indent2).with_s_key("ScopeID").with_disp_val(&stmt.scope.index);
                 self.kv(indent2).with_s_key("Statements");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent3);
+                }
             },
             Statement::EndBlock(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDBLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndBlock");
                 self.kv(indent2).with_s_key("StartBlockID").with_disp_val(&stmt.start_block.0.index);
+            }
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
                         self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalChannel");
                         self.kv(indent2).with_s_key("From");
                         self.write_variable(heap, stmt.from, indent3);
                         self.kv(indent2).with_s_key("To");
                         self.write_variable(heap, stmt.to, indent3);
                         self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
                     },
                     LocalStatement::Memory(stmt) => {
                         self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalMemory");
                         self.kv(indent2).with_s_key("Variable");
                         self.write_variable(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("InitialValue");
                         self.write_expr(heap, stmt.initial_expr.upcast(), indent3);
                         self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+                    }
+                }
             },
             Statement::Labeled(stmt) => {
                 self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)
                     .with_s_key("Labeled");
                 self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Statement");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::If(stmt) => {
                 self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf").with_disp_val(&stmt.end_if.0.index);
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("TrueBody");
                 self.write_stmt(heap, stmt.true_case.body, indent3);
                 if let Some(false_body) = stmt.false_case {
                     self.kv(indent2).with_s_key("FalseBody");
                     self.write_stmt(heap, false_body.body, indent3);
+                }
             },
             Statement::EndIf(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::While(stmt) => {
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile").with_disp_val(&stmt.end_while.0.index);
                 self.kv(indent2).with_s_key("InSync")
                     .with_disp_val(&stmt.in_sync.0.index);
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndWhile(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Break(stmt) => {
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_disp_val(&stmt.target.0.index);
             },
             Statement::Continue(stmt) => {
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_disp_val(&stmt.target.0.index);
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync").with_disp_val(&stmt.end_sync.0.index);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Fork(stmt) => {
                 self.kv(indent).with_id(PREFIX_FORK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Fork");
                 self.kv(indent2).with_s_key("EndFork").with_disp_val(&stmt.end_fork.0.index);
                 self.kv(indent2).with_s_key("LeftBody");
                 self.write_stmt(heap, stmt.left_body, indent3);
                 if let Some(right_body_id) = stmt.right_body {
                     self.kv(indent2).with_s_key("RightBody");
                     self.write_stmt(heap, right_body_id, indent3);
+                }
             },
             Statement::EndFork(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_FORK_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndFork");
                 self.kv(indent2).with_s_key("StartFork").with_disp_val(&stmt.start_fork.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Select(stmt) => {
                 self.kv(indent).with_id(PREFIX_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Select");
                 self.kv(indent2).with_s_key("EndSelect").with_disp_val(&stmt.end_select.0.index);
                 self.kv(indent2).with_s_key("Cases");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for case in &stmt.cases {
                     self.kv(indent3).with_s_key("Guard");
                     self.write_stmt(heap, case.guard, indent4);
                     self.kv(indent3).with_s_key("Block");
                     self.write_stmt(heap, case.body, indent4);
+                }
                 self.kv(indent2).with_s_key("Replacement");
                 self.write_stmt(heap, stmt.next, indent3);
             },
             Statement::EndSelect(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSelect");
                 self.kv(indent2).with_s_key("StartSelect").with_disp_val(&stmt.start_select.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+            }
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expressions");
                 for expr_id in &stmt.expressions {
                     self.write_expr(heap, *expr_id, indent3);
+                }
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Target")
                     .with_disp_val(&stmt.target.0.index);
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Expression(stmt) => {
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+            }
+        }
+    }
     fn write_expr(&mut self, heap: &Heap, expr_id: ExpressionId, indent: usize) {
         let expr = &heap[expr_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match expr {
             Expression::Assignment(expr) => {
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binding(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BindingExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("BindToExpression");
                 self.write_expr(heap, expr.bound_to, indent3);
                 self.kv(indent2).with_s_key("BindFromExpression");
                 self.write_expr(heap, expr.bound_from, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Conditional(expr) => {
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binary(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Unary(expr) => {
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Indexing(expr) => {
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Slicing(expr) => {
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.kind {
                     SelectKind::StructField(field_name) => {
                         self.kv(indent2).with_s_key("StructField").with_identifier_val(field_name);
                     },
                     SelectKind::TupleMember(member_index) => {
                         self.kv(indent2).with_s_key("TupleMember").with_disp_val(member_index);
                     },
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Literal(expr) => {
                 self.kv(indent).with_id(PREFIX_LITERAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("LiteralExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_disp_val(data); },
                     Literal::String(data) => {
                         // Stupid hack
                         let string = String::from(data.as_str());
                         val.with_disp_val(&string);
                     },
                     Literal::Integer(data) => { val.with_debug_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
                             self.kv(indent4).with_s_key("Name").with_identifier_val(&field.identifier);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
                             self.write_expr(heap, field.value, indent4 + 1);
+                        }
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
                     },
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
                     },
                     Literal::Tuple(data) => {
                         val.with_s_val("Tuple");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Cast(expr) => {
                 self.kv(indent).with_id(PREFIX_CAST_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("ToType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.to_type));
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 let definition = &heap[expr.procedure];
                 self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&false);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.kind);
                 self.kv(indent2).with_s_key("MethodName").with_identifier_val(&definition.identifier);
                 self.kv(indent2).with_s_key("ParserType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
                 self.kv(indent2).with_s_key("Method").with_debug_val(&expr.method);
                 if !expr.procedure.is_invalid() {
                     let definition = &heap[expr.procedure];
                     self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&definition.builtin);
                     self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.kind);
                     self.kv(indent2).with_s_key("MethodName").with_identifier_val(&definition.identifier);
                     self.kv(indent2).with_s_key("ParserType")
                         .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
+                }
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&expr.identifier);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
+        }
+    }
     fn write_variable(&mut self, heap: &Heap, variable_id: VariableId, indent: usize) {
         let var = &heap[variable_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_VARIABLE_ID, variable_id.index)
             .with_s_key("Variable");
         self.kv(indent2).with_s_key("Name").with_identifier_val(&var.identifier);
         self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);
         self.kv(indent2).with_s_key("ParserType")
             .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));
         self.kv(indent2).with_s_key("RelativePos").with_disp_val(&var.relative_pos_in_parent);
         self.kv(indent2).with_s_key("UniqueScopeID").with_disp_val(&var.unique_id_in_scope);
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn kv(&mut self, indent: usize) -> KV {
         KV::new(&mut self.buffer, &mut self.temp1, &mut self.temp2, indent)
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
         self.buffer.clear()
+    }
+}
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => target.push_str(&format!("Some({})", v)),
         None => target.push_str("None")
     };
+}
 fn write_parser_type(target: &mut String, heap: &Heap, t: &ParserType) {
     use ParserTypeVariant as PTV;
     if t.elements.is_empty() {
         target.push_str("no elements in ParserType (can happen due to compiler-inserted AST nodes)");
         return;
+    }
     fn write_element(target: &mut String, heap: &Heap, t: &ParserType, mut element_idx: usize) -> usize {
         let element = &t.elements[element_idx];
         match &element.variant {
             PTV::Void => target.push_str("void"),
             PTV::InputOrOutput => {
                 target.push_str("portlike<");
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::ArrayLike => {
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push_str("[???]");
             },
             PTV::IntegerLike => target.push_str("integerlike"),
             PTV::Message => { target.push_str(KW_TYPE_MESSAGE_STR); },
             PTV::Bool => { target.push_str(KW_TYPE_BOOL_STR); },
             PTV::UInt8 => { target.push_str(KW_TYPE_UINT8_STR); },
             PTV::UInt16 => { target.push_str(KW_TYPE_UINT16_STR); },
             PTV::UInt32 => { target.push_str(KW_TYPE_UINT32_STR); },
             PTV::UInt64 => { target.push_str(KW_TYPE_UINT64_STR); },
             PTV::SInt8 => { target.push_str(KW_TYPE_SINT8_STR); },
             PTV::SInt16 => { target.push_str(KW_TYPE_SINT16_STR); },
             PTV::SInt32 => { target.push_str(KW_TYPE_SINT32_STR); },
             PTV::SInt64 => { target.push_str(KW_TYPE_SINT64_STR); },
             PTV::Character => { target.push_str(KW_TYPE_CHAR_STR); },
             PTV::String => { target.push_str(KW_TYPE_STRING_STR); },
             PTV::IntegerLiteral => { target.push_str("int_literal"); },
             PTV::Inferred => { target.push_str(KW_TYPE_INFERRED_STR); },
             PTV::Array => {
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push_str("[]");
             },
             PTV::Input => {
                 target.push_str(KW_TYPE_IN_PORT_STR);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::Output => {
                 target.push_str(KW_TYPE_OUT_PORT_STR);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::Tuple(num_embedded) => {
                 target.push('(');
                 let num_embedded = *num_embedded;
                 for embedded_idx in 0..num_embedded {
                     if embedded_idx != 0 {
                         target.push(',');
+                    }
                     element_idx = write_element(target, heap, t, element_idx + 1);
+                }
                 target.push(')');
+            }
             PTV::PolymorphicArgument(definition_id, arg_idx) => {
                 let definition = &heap[*definition_id];
                 let poly_var = &definition.poly_vars()[*arg_idx as usize].value;
                 target.push_str(poly_var.as_str());
             },
             PTV::Definition(definition_id, num_embedded) => {
                 let definition = &heap[*definition_id];
                 let definition_ident = definition.identifier().value.as_str();
                 target.push_str(definition_ident);
                 let num_embedded = *num_embedded;
                 if num_embedded != 0 {
                     target.push('<');
                     for embedded_idx in 0..num_embedded {
                         if embedded_idx != 0 {
                             target.push(',');
+                        }
                         element_idx = write_element(target, heap, t, element_idx + 1);
+                    }
                     target.push('>');
+                }
+            }
+        }
         element_idx
+    }
     write_element(target, heap, t, 0);
+}
 fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {
     use ConcreteTypePart as CTP;
     fn write_concrete_part(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType, mut idx: usize) -> usize {
         if idx >= t.parts.len() {
             return idx;
+        }
         match &t.parts[idx] {
             CTP::Void => target.push_str("void"),
             CTP::Message => target.push_str("msg"),
             CTP::Bool => target.push_str(KW_TYPE_BOOL_STR),
             CTP::UInt8 => target.push_str(KW_TYPE_UINT8_STR),
             CTP::UInt16 => target.push_str(KW_TYPE_UINT16_STR),
             CTP::UInt32 => target.push_str(KW_TYPE_UINT32_STR),
             CTP::UInt64 => target.push_str(KW_TYPE_UINT64_STR),
             CTP::SInt8 => target.push_str(KW_TYPE_SINT8_STR),
             CTP::SInt16 => target.push_str(KW_TYPE_SINT16_STR),
             CTP::SInt32 => target.push_str(KW_TYPE_SINT32_STR),
             CTP::SInt64 => target.push_str(KW_TYPE_SINT64_STR),
             CTP::Character => target.push_str(KW_TYPE_CHAR_STR),
             CTP::String => target.push_str(KW_TYPE_STRING_STR),
             CTP::Pointer => target.push('*'),
             CTP::Array => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[]");
             },
             CTP::Slice => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[..]");
+            }
             CTP::Input => {
                 target.push_str("in<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str("out<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>')
             },
             CTP::Tuple(num_embedded) => {
                 target.push('(');
                 for idx_embedded in 0..*num_embedded {
                     if idx_embedded != 0 {
                         target.push_str(", ");
+                    }
                     idx = write_concrete_part(target, heap, def_id, t, idx + 1);
+                }
                 target.push(')');
             },
             CTP::Instance(definition_id, num_embedded) => {
                 let identifier = heap[*definition_id].identifier();
                 target.push_str(identifier.value.as_str());
                 target.push('<');
                 for idx_embedded in 0..*num_embedded {
                     if idx_embedded != 0 {
                         target.push_str(", ");
+                    }
                     idx = write_concrete_part(target, heap, def_id, t, idx + 1);
+                }
                 target.push('>');
             },
             CTP::Function(_, _) => todo!("AST printer for ConcreteTypePart::Function"),
             CTP::Component(_, _) => todo!("AST printer for ConcreteTypePart::Component"),
+        }
         idx + 1
+    }
     write_concrete_part(target, heap, def_id, t, 0);
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::Memory(id) => format!("MemStmt({})", id.0.0.index),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::New(id) => format!("NewStmt({})", id.0.index),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/eval/executor.rs

➞

Show inline comments

 use std::collections::VecDeque;
 use super::value::*;
 use super::store::*;
 use super::error::*;
 use crate::protocol::*;
 use crate::protocol::ast::*;
 use crate::protocol::type_table::*;
-macro_rules! debug_enabled { () => { true }; }
+macro_rules! debug_enabled { () => { false }; }
 macro_rules! debug_log {
     ($format:literal) => {
-        enabled_debug_print!(true, "exec", $format);
+        enabled_debug_print!(false, "exec", $format);
     };
     ($format:literal, $($args:expr),*) => {
-        enabled_debug_print!(true, "exec", $format, $($args),*);
+        enabled_debug_print!(false, "exec", $format, $($args),*);
     };
+}
 #[derive(Debug, Clone)]
 pub(crate) enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Frame {
     pub(crate) definition: ProcedureDefinitionId,
     pub(crate) monomorph_type_id: TypeId,
     pub(crate) monomorph_index: usize,
     pub(crate) position: StatementId,
     pub(crate) expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     pub(crate) expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
     pub(crate) max_stack_size: u32,
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: ProcedureDefinitionId, monomorph_type_id: TypeId, monomorph_index: u32) -> Self {
         let definition = &heap[definition_id];
         let outer_scope_id = definition.scope;
         let first_statement_id = definition.body;
         // Another not-so-pretty thing that has to be replaced somewhere in the
         // future...
         fn determine_max_stack_size(heap: &Heap, scope_id: ScopeId, max_size: &mut u32) {
             let scope = &heap[scope_id];
             // Check current block
             let cur_size = scope.next_unique_id_in_scope as u32;
             if cur_size > *max_size { *max_size = cur_size; }
             // And child blocks
             for child_scope in &scope.nested {
                 determine_max_stack_size(heap, *child_scope, max_size);
+            }
+        }
         let mut max_stack_size = 0;
         determine_max_stack_size(heap, outer_scope_id, &mut max_stack_size);
         Frame{
             definition: definition_id,
             monomorph_type_id,
             monomorph_index: monomorph_index as usize,
             position: first_statement_id.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
             max_stack_size,
+        }
+    }
     /// Prepares a single expression for execution. This involves walking the
     /// expression tree and putting them in the `expr_stack` such that
     /// continuously popping from its back will evaluate the expression. The
     /// results of each expression will be stored by pushing onto `expr_values`.
     pub fn prepare_single_expression(&mut self, heap: &Heap, expr_id: ExpressionId) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear(); // May not be empty if last expression result(s) were discarded
         self.serialize_expression(heap, expr_id);
+    }
     /// Prepares multiple expressions for execution (i.e. evaluating all
     /// function arguments or all elements of an array/union literal). Per
     /// expression this works the same as `prepare_single_expression`. However
     /// after each expression is evaluated we insert a `PushValToFront`
     /// instruction
     pub fn prepare_multiple_expressions(&mut self, heap: &Heap, expr_ids: &[ExpressionId]) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear();
         for expr_id in expr_ids {
             self.expr_stack.push_back(ExprInstruction::PushValToFront);
             self.serialize_expression(heap, *expr_id);
+        }
+    }
     /// Performs depth-first serialization of expression tree. Let's not care
     /// about performance for a temporary runtime implementation
     fn serialize_expression(&mut self, heap: &Heap, id: ExpressionId) {
         self.expr_stack.push_back(ExprInstruction::EvalExpr(id));
         match &heap[id] {
             Expression::Assignment(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Binding(expr) => {
                 self.serialize_expression(heap, expr.bound_to);
                 self.serialize_expression(heap, expr.bound_from);
             },
             Expression::Conditional(expr) => {
                 self.serialize_expression(heap, expr.test);
             },
             Expression::Binary(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Unary(expr) => {
                 self.serialize_expression(heap, expr.expression);
             },
             Expression::Indexing(expr) => {
                 self.serialize_expression(heap, expr.index);
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Slicing(expr) => {
                 self.serialize_expression(heap, expr.from_index);
                 self.serialize_expression(heap, expr.to_index);
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Select(expr) => {
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Literal(expr) => {
                 // Here we only care about literals that have subexpressions
                 match &expr.value {
                     Literal::Null | Literal::True | Literal::False |
                     Literal::Character(_) | Literal::String(_) |
                     Literal::Integer(_) | Literal::Enum(_) => {
                         // No subexpressions
                     },
                     Literal::Struct(literal) => {
                         // Note: fields expressions are evaluated in programmer-
                         // specified order. But struct construction expects them
                         // in type-defined order. I might want to come back to
                         // this.
                         let mut _num_pushed = 0;
                         for want_field_idx in 0..literal.fields.len() {
                             for field in &literal.fields {
                                 if field.field_idx == want_field_idx {
                                     _num_pushed += 1;
                                     self.expr_stack.push_back(ExprInstruction::PushValToFront);
                                     self.serialize_expression(heap, field.value);
+                                }
+                            }
+                        }
                         debug_assert_eq!(_num_pushed, literal.fields.len())
                     },
                     Literal::Union(literal) => {
                         for value_expr_id in &literal.values {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
                     },
                     Literal::Array(value_expr_ids) => {
                         for value_expr_id in value_expr_ids {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
                     },
                     Literal::Tuple(value_expr_ids) => {
                         for value_expr_id in value_expr_ids {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
+                    }
+                }
             },
             Expression::Cast(expr) => {
                 self.serialize_expression(heap, expr.subject);
+            }
             Expression::Call(expr) => {
                 for arg_expr_id in &expr.arguments {
                     self.expr_stack.push_back(ExprInstruction::PushValToFront);
                     self.serialize_expression(heap, *arg_expr_id);
+                }
             },
             Expression::Variable(_expr) => {
                 // No subexpressions
+            }
+        }
+    }
+}
 pub type EvalResult = Result<EvalContinuation, EvalError>;
 #[derive(Debug)]
 pub enum EvalContinuation {
     // Returned in both sync and non-sync modes
     Stepping,
     // Returned only in sync mode
     BranchInconsistent,
     SyncBlockEnd,
     NewFork,
     BlockFires(PortId),
     BlockGet(PortId),
     Put(PortId, ValueGroup),

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 pub(crate) mod eval;
 pub(crate) mod input_source;
 mod parser;
 #[cfg(test)] mod tests;
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 use std::sync::Mutex;
 use crate::collections::{StringPool, StringRef};
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 use crate::protocol::type_table::*;
 pub use parser::type_table::TypeId;
 /// A protocol description module
 pub struct Module {
     pub(crate) source: InputSource,
     pub(crate) root_id: RootId,
     pub(crate) name: Option<StringRef<'static>>,
+}
 /// Description of a protocol object, used to configure new connectors.
 #[repr(C)]
 pub struct ProtocolDescription {
     pub(crate) modules: Vec<Module>,
     pub(crate) heap: Heap,
     pub(crate) types: TypeTable,
     pub(crate) pool: Mutex<StringPool>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     pub(crate) prompt: Prompt,
+}
 #[derive(Debug)]
 pub enum ComponentCreationError {
     ModuleDoesntExist,
     DefinitionDoesntExist,
     DefinitionNotComponent,
     InvalidNumArguments,
     InvalidArgumentType(usize),
     UnownedPort,
     InSync,
+}
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         let source = InputSource::new(String::new(), Vec::from(buffer));
         let mut parser = Parser::new();
         parser.feed(source).expect("failed to feed source");
         parser.write_ast_to = Some(String::from("hello.txt"));
         if let Err(err) = parser.parse() {
             println!("ERROR:\n{}", err);
             return Err(format!("{}", err))
+        }
         debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");
         let modules: Vec<Module> = parser.modules.into_iter()
             .map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             })
             .collect();
         return Ok(ProtocolDescription {
             modules,
             heap: parser.heap,
             types: parser.type_table,
             pool: Mutex::new(parser.string_pool),
         });
+    }
     pub(crate) fn new_component(
         &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup
     ) -> Result<Prompt, ComponentCreationError> {
         // Find the module in which the definition can be found
         let module_root = self.lookup_module_root(module_name);
         if module_root.is_none() {
             return Err(ComponentCreationError::ModuleDoesntExist);
+        }
         let module_root = module_root.unwrap();
         let root = &self.heap[module_root];
         let definition_id = root.get_definition_ident(&self.heap, identifier);
         if definition_id.is_none() {
             return Err(ComponentCreationError::DefinitionDoesntExist);
+        }
         let definition_id = definition_id.unwrap();
         let ast_definition = &self.heap[definition_id];
         if !ast_definition.is_procedure() {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // Make sure that the types of the provided value group matches that of
         // the expected types.
         let ast_definition = ast_definition.as_procedure();
         if !ast_definition.poly_vars.is_empty() || ast_definition.kind == ProcedureKind::Function {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // - check number of arguments by retrieving the one instantiated
         //   monomorph
         let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(ast_definition.this, 0)] };
         let procedure_type_id = self.types.get_procedure_monomorph_type_id(&definition_id, &concrete_type.parts).unwrap();
         let procedure_monomorph_index = self.types.get_monomorph(procedure_type_id).variant.as_procedure().monomorph_index;
         let monomorph_info = &ast_definition.monomorphs[procedure_monomorph_index as usize];
         if monomorph_info.argument_types.len() != arguments.values.len() {
             return Err(ComponentCreationError::InvalidNumArguments);
+        }
         // - for each argument try to make sure the types match
         for arg_idx in 0..arguments.values.len() {
             let expected_type_id = monomorph_info.argument_types[arg_idx];
             let expected_type = &self.types.get_monomorph(expected_type_id).concrete_type;
             let provided_value = &arguments.values[arg_idx];
             if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {
                 return Err(ComponentCreationError::InvalidArgumentType(arg_idx));
+            }
+        }
         // By now we're sure that all of the arguments are correct. So create
         // the connector.
         return Ok(Prompt::new(&self.types, &self.heap, ast_definition.this, procedure_type_id, arguments));
+    }
     fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {
         for module in self.modules.iter() {
             match &module.name {
                 Some(name) => if name.as_bytes() == module_name {
                     return Some(module.root_id);
                 },
                 None => if module_name.is_empty() {
                     return Some(module.root_id);
+                }
+            }
+        }
         return None;
+    }
     fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {
         use ConcreteTypePart as CTP;
         match &expected.parts[expected_idx] {
             CTP::Void | CTP::Message | CTP::Slice | CTP::Pointer | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),
             CTP::Bool => if let Value::Bool(_) = argument { true } else { false },
             CTP::UInt8 => if let Value::UInt8(_) = argument { true } else { false },
             CTP::UInt16 => if let Value::UInt16(_) = argument { true } else { false },
             CTP::UInt32 => if let Value::UInt32(_) = argument { true } else { false },
             CTP::UInt64 => if let Value::UInt64(_) = argument { true } else { false },
             CTP::SInt8 => if let Value::SInt8(_) = argument { true } else { false },
             CTP::SInt16 => if let Value::SInt16(_) = argument { true } else { false },
             CTP::SInt32 => if let Value::SInt32(_) = argument { true } else { false },
             CTP::SInt64 => if let Value::SInt64(_) = argument { true } else { false },
             CTP::Character => if let Value::Char(_) = argument { true } else { false },
             CTP::String => {
                 // Match outer string type and embedded character types
                 if let Value::String(heap_pos) = argument {
                     for element in &arguments.regions[*heap_pos as usize] {
                         if let Value::Char(_) = element {} else {
                             return false;
+                        }
+                    }
                 } else {
                     return false;
+                }
                 return true;
             },
             CTP::Array => {
                 if let Value::Array(heap_pos) = argument {
                     let heap_pos = *heap_pos;
                     for element in &arguments.regions[heap_pos as usize] {
                         if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {
                             return false;
+                        }
+                    }
                     return true;
                 } else {
                     return false;
+                }
             },
             CTP::Input => if let Value::Input(_) = argument { true } else { false },
             CTP::Output => if let Value::Output(_) = argument { true } else { false },
             CTP::Tuple(_) => todo!("implement full type checking on user-supplied arguments"),
             CTP::Instance(definition_id, _num_embedded) => {
                 let definition = self.types.get_base_definition(definition_id).unwrap();
                 match &definition.definition {
                     DefinedTypeVariant::Enum(definition) => {
                         if let Value::Enum(variant_value) = argument {
                             let is_valid = definition.variants.iter()
                                 .any(|v| v.value == *variant_value);
                             return is_valid;
+                        }
                     },
                     _ => todo!("implement full type checking on user-supplied arguments"),
+                }
                 return false;
             },
+        }
+    }
+}
 pub trait RunContext {
     fn performed_put(&mut self, port: PortId) -> bool;
     fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message
     fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched
     fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked
     fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared
     fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker
+}
 pub struct ProtocolDescriptionBuilder {
     parser: Parser,
+}
 impl ProtocolDescriptionBuilder {
     pub fn new() -> Self {
         return Self{
             parser: Parser::new(),
+        }
+    }
     pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {
         let input = InputSource::new(filename, buffer);
         self.parser.feed(input)?;
         return Ok(())
+    }
     pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {
         self.parser.parse()?;
         let modules: Vec<Module> = self.parser.modules.into_iter()
             .map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             })
             .collect();

src/protocol/parser/pass_rewriting.rs

➞

Show inline comments

@@ @@ -117,384 +117,390 @@ impl Visitor for PassRewriting { @@
             select_var_id: VariableId, select_var_type_id: TypeIdReference
         ) -> (IfStatementId, EndIfStatementId, ScopeId) {
             // Retrieve statement IDs associated with case
             let case = &ctx.heap[select_id].cases[case_index];
             let case_guard_id = case.guard;
             let case_body_id = case.body;
             let case_scope_id = case.scope;
             // Create the if-statement for the result of the select statement
             let compare_expr_id = create_ast_equality_comparison_expr(ctx, containing_procedure_id, select_var_id, select_var_type_id, case_index as u64);
             let true_case = IfStatementCase{
                 body: case_guard_id, // which is linked up to the body
                 scope: case_scope_id,
             };
             let (if_stmt_id, end_if_stmt_id) = create_ast_if_stmt(ctx, compare_expr_id.upcast(), true_case, None);
             // Link up body statement to end-if
             set_ast_statement_next(ctx, case_body_id, end_if_stmt_id.upcast());
             return (if_stmt_id, end_if_stmt_id, case_scope_id);
+        }
         // Precreate the block that will end up containing all of the
         // transformed statements. Also precreate the scope associated with it
         let (outer_block_id, outer_end_block_id, outer_scope_id) =
             create_ast_block_stmt(ctx, Vec::new());
         // The "select" and the "end select" statement will act like trampolines
         // that jump to the replacement block. So set the child/parent
         // relationship already.
         // --- for the statements
         let select_stmt = &mut ctx.heap[id];
         select_stmt.next = outer_block_id.upcast();
         let end_select_stmt_id = select_stmt.end_select;
         let select_stmt_relative_pos = select_stmt.relative_pos_in_parent;
         let outer_end_block_stmt = &mut ctx.heap[outer_end_block_id];
         outer_end_block_stmt.next = end_select_stmt_id.upcast();
         // --- for the scopes
         link_new_child_to_existing_parent_scope(ctx, &mut self.scope_buffer, self.current_scope, outer_scope_id, select_stmt_relative_pos);
         // Create statements that will create temporary variables for all of the
         // ports passed to the "get" calls in the select case guards.
         let select_stmt = &ctx.heap[id];
         let total_num_cases = select_stmt.cases.len();
         let mut total_num_ports = 0;
         let end_select_stmt_id = select_stmt.end_select;
         let _end_select = &ctx.heap[end_select_stmt_id];
         // Put heap IDs into temporary buffers to handle borrowing rules
         let mut call_id_section = self.call_expr_buffer.start_section();
         let mut expr_id_section = self.expression_buffer.start_section();
         for case in select_stmt.cases.iter() {
             total_num_ports += case.involved_ports.len();
             for (call_id, expr_id) in case.involved_ports.iter().copied() {
                 call_id_section.push(call_id);
                 expr_id_section.push(expr_id);
+            }
+        }
         // Transform all of the call expressions by takings its argument (the
         // port from which we `get`) and turning it into a temporary variable.
         let mut transformed_stmts = Vec::with_capacity(total_num_ports); // TODO: Recompute this preallocated length, put assert at the end
         let mut locals = Vec::with_capacity(total_num_ports);
         for port_var_idx in 0..call_id_section.len() {
             let get_call_expr_id = call_id_section[port_var_idx];
             let port_expr_id = expr_id_section[port_var_idx];
             let port_type_index = ctx.heap[port_expr_id].type_index();
             let port_type_ref = TypeIdReference::IndirectSameAsExpr(port_type_index);
             // Move the port expression such that it gets assigned to a temporary variable
             let variable_id = create_ast_variable(ctx, outer_scope_id);
             let variable_decl_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, variable_id, port_type_ref, port_expr_id);
             // Replace the original port expression in the call with a reference
             // to the replacement variable
             let variable_expr_id = create_ast_variable_expr(ctx, self.current_procedure_id, variable_id, port_type_ref);
             let call_expr = &mut ctx.heap[get_call_expr_id];
             call_expr.arguments[0] = variable_expr_id.upcast();
             transformed_stmts.push(variable_decl_stmt_id.upcast().upcast());
             locals.push((variable_id, port_type_ref));
+        }
         // Insert runtime calls that facilitate the semantics of the select
         // block.
         // Create the call that indicates the start of the select block
+        {
             let num_cases_expression_id = create_ast_literal_integer_expr(ctx, self.current_procedure_id, total_num_cases as u64, ctx.arch.uint32_type_id);
             let num_ports_expression_id = create_ast_literal_integer_expr(ctx, self.current_procedure_id, total_num_ports as u64, ctx.arch.uint32_type_id);
             let arguments = vec![
                 num_cases_expression_id.upcast(),
                 num_ports_expression_id.upcast()
             ];
             let call_expression_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectStart, &mut self.expression_buffer, arguments);
             let call_statement_id = create_ast_expression_stmt(ctx, call_expression_id.upcast());
             transformed_stmts.push(call_statement_id.upcast());
+        }
         // Create calls for each select case that will register the ports that
         // we are waiting on at the runtime.
+        {
             let mut total_port_index = 0;
             for case_index in 0..total_num_cases {
                 let case = &ctx.heap[id].cases[case_index];
                 let case_num_ports = case.involved_ports.len();
                 for case_port_index in 0..case_num_ports {
                     // Arguments to runtime call
                     let (port_variable_id, port_variable_type) = locals[total_port_index]; // so far this variable contains the temporary variables for the port expressions
                     let case_index_expr_id = create_ast_literal_integer_expr(ctx, self.current_procedure_id, case_index as u64, ctx.arch.uint32_type_id);
                     let port_index_expr_id = create_ast_literal_integer_expr(ctx, self.current_procedure_id, case_port_index as u64, ctx.arch.uint32_type_id);
                     let port_variable_expr_id = create_ast_variable_expr(ctx, self.current_procedure_id, port_variable_id, port_variable_type);
                     let runtime_call_arguments = vec![
                         case_index_expr_id.upcast(),
                         port_index_expr_id.upcast(),
                         port_variable_expr_id.upcast()
                     ];
                     // Create runtime call, then store it
                     let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectRegisterCasePort, &mut self.expression_buffer, runtime_call_arguments);
                     let runtime_call_stmt_id = create_ast_expression_stmt(ctx, runtime_call_expr_id.upcast());
                     transformed_stmts.push(runtime_call_stmt_id.upcast());
                     total_port_index += 1;
+                }
+            }
+        }
         // Create the variable that will hold the result of a completed select
         // block. Then create the runtime call that will produce this result
         let select_variable_id = create_ast_variable(ctx, outer_scope_id);
         let select_variable_type = TypeIdReference::DirectTypeId(ctx.arch.uint32_type_id);
         locals.push((select_variable_id, select_variable_type));
+        {
             let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectWait, &mut self.expression_buffer, Vec::new());
             let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, select_variable_id, select_variable_type, runtime_call_expr_id.upcast());
             transformed_stmts.push(variable_stmt_id.upcast().upcast());
+        }
         call_id_section.forget();
         expr_id_section.forget();
         // Now we transform each of the select block case's guard and code into
         // a chained if-else statement.
         let mut relative_pos = transformed_stmts.len() as i32;
         if total_num_cases > 0 {
             let (if_stmt_id, end_if_stmt_id, scope_id) = transform_select_case_code(ctx, self.current_procedure_id, id, 0, select_variable_id, select_variable_type);
             link_existing_child_to_new_parent_scope(ctx, &mut self.scope_buffer, outer_scope_id, scope_id, relative_pos);
             let first_end_if_stmt = &mut ctx.heap[end_if_stmt_id];
             first_end_if_stmt.next = outer_end_block_id.upcast();
             let mut last_if_stmt_id = if_stmt_id;
             let mut last_end_if_stmt_id = end_if_stmt_id;
             let mut last_parent_scope_id = outer_scope_id;
             let mut last_relative_pos = transformed_stmts.len() as i32 + 1;
             transformed_stmts.push(last_if_stmt_id.upcast());
             for case_index in 1..total_num_cases {
                 let (if_stmt_id, end_if_stmt_id, scope_id) = transform_select_case_code(ctx, self.current_procedure_id, id, case_index, select_variable_id, select_variable_type);
                 let false_case_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(last_if_stmt_id, false)));
                 link_existing_child_to_new_parent_scope(ctx, &mut self.scope_buffer, false_case_scope_id, scope_id, 0);
                 link_new_child_to_existing_parent_scope(ctx, &mut self.scope_buffer, last_parent_scope_id, false_case_scope_id, last_relative_pos);
                 set_ast_if_statement_false_body(ctx, last_if_stmt_id, last_end_if_stmt_id, IfStatementCase{ body: if_stmt_id.upcast(), scope: false_case_scope_id });
                 let end_if_stmt = &mut ctx.heap[end_if_stmt_id];
                 end_if_stmt.next = last_end_if_stmt_id.upcast();
                 last_if_stmt_id = if_stmt_id;
                 last_end_if_stmt_id = end_if_stmt_id;
                 last_parent_scope_id = false_case_scope_id;
                 last_relative_pos = 0;
+            }
+        }
         // Final steps: set the statements of the replacement block statement,
         // link all of those statements together, and update the scopes.
         let first_stmt_id = transformed_stmts[0];
         let mut last_stmt_id = transformed_stmts[0];
         for stmt_id in transformed_stmts.iter().skip(1).copied() {
             set_ast_statement_next(ctx, last_stmt_id, stmt_id);
             last_stmt_id = stmt_id;
+        }
         if total_num_cases == 0 {
             // If we don't have any cases, then we didn't connect the statements
             // up to the end of the outer block, so do that here
             set_ast_statement_next(ctx, last_stmt_id, outer_end_block_id.upcast());
+        }
         let outer_block_stmt = &mut ctx.heap[outer_block_id];
         outer_block_stmt.next = first_stmt_id;
         outer_block_stmt.statements = transformed_stmts;
         return Ok(())
+    }
+}
 // -----------------------------------------------------------------------------
 // Utilities to create compiler-generated AST nodes
 // -----------------------------------------------------------------------------
 #[derive(Clone, Copy)]
 enum TypeIdReference {
     DirectTypeId(TypeId),
     IndirectSameAsExpr(i32), // by type index
+}
 fn create_ast_variable(ctx: &mut Ctx, scope_id: ScopeId) -> VariableId {
     let variable_id = ctx.heap.alloc_variable(|this| Variable{
         this,
         kind: VariableKind::Local,
         parser_type: ParserType{
             elements: Vec::new(),
             full_span: InputSpan::new(),
         },
         identifier: Identifier::new_empty(InputSpan::new()),
         relative_pos_in_parent: -1,
         unique_id_in_scope: -1,
     });
     let scope = &mut ctx.heap[scope_id];
     scope.variables.push(variable_id);
     return variable_id;
+}
 fn create_ast_variable_expr(ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId, variable_id: VariableId, variable_type_id: TypeIdReference) -> VariableExpressionId {
     let variable_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, variable_type_id);
     return ctx.heap.alloc_variable_expression(|this| VariableExpression{
         this,
         identifier: Identifier::new_empty(InputSpan::new()),
         declaration: Some(variable_id),
         used_as_binding_target: false,
         parent: ExpressionParent::None,
         type_index: variable_type_index,
     });
+}
 fn create_ast_call_expr(ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId, method: Method, buffer: &mut ScopedBuffer<ExpressionId>, arguments: Vec<ExpressionId>) -> CallExpressionId {
     let call_type_id = match method {
         Method::SelectStart => ctx.arch.void_type_id,
         Method::SelectRegisterCasePort => ctx.arch.void_type_id,
         Method::SelectWait => ctx.arch.uint32_type_id, // TODO: Not pretty, this. Pretty error prone
         _ => unreachable!(), // if this goes of, add the appropriate method here.
     };
     let expression_ids = buffer.start_section_initialized(&arguments);
     let call_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(call_type_id));
     let call_expression_id = ctx.heap.alloc_call_expression(|this| CallExpression{
         func_span: InputSpan::new(),
         this,
         full_span: InputSpan::new(),
         parser_type: ParserType{
             elements: Vec::new(),
             full_span: InputSpan::new(),
         },
         method,
         arguments,
         procedure: ProcedureDefinitionId::new_invalid(),
         parent: ExpressionParent::None,
         type_index: call_type_index,
     });
     for argument_index in 0..expression_ids.len() {
         let argument_id = expression_ids[argument_index];
         let argument_expr = &mut ctx.heap[argument_id];
         *argument_expr.parent_mut() = ExpressionParent::Expression(call_expression_id.upcast(), argument_index as u32);
+    }
     return call_expression_id;
+}
 fn create_ast_literal_integer_expr(ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId, unsigned_value: u64, type_id: TypeId) -> LiteralExpressionId {
     let literal_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(type_id));
     return ctx.heap.alloc_literal_expression(|this| LiteralExpression{
         this,
         span: InputSpan::new(),
         value: Literal::Integer(LiteralInteger{
             unsigned_value,
             negated: false,
         }),
         parent: ExpressionParent::None,
         type_index: literal_type_index,
     });
+}
 fn create_ast_equality_comparison_expr(
     ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,
     variable_id: VariableId, variable_type: TypeIdReference, value: u64
 ) -> BinaryExpressionId {
     let var_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);
     let int_expr_id = create_ast_literal_integer_expr(ctx, containing_procedure_id, value, ctx.arch.uint32_type_id);
     let cmp_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(ctx.arch.bool_type_id));
     let cmp_expr_id = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
         this,
         operator_span: InputSpan::new(),
         full_span: InputSpan::new(),
         left: var_expr_id.upcast(),
         operation: BinaryOperator::Equality,
         right: int_expr_id.upcast(),
         parent: ExpressionParent::None,
         type_index: cmp_type_index,
     });
     let var_expr = &mut ctx.heap[var_expr_id];
     var_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 0);
     let int_expr = &mut ctx.heap[int_expr_id];
     int_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 1);
     return cmp_expr_id;
+}
 fn create_ast_expression_stmt(ctx: &mut Ctx, expression_id: ExpressionId) -> ExpressionStatementId {
     let statement_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
         this,
         span: InputSpan::new(),
         expression: expression_id,
         next: StatementId::new_invalid(),
     });
     let expression = &mut ctx.heap[expression_id];
     *expression.parent_mut() = ExpressionParent::ExpressionStmt(statement_id);
     return statement_id;
+}
 fn create_ast_variable_declaration_stmt(
     ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,
     variable_id: VariableId, variable_type: TypeIdReference, initial_value_expr_id: ExpressionId
 ) -> MemoryStatementId {
     // Create the assignment expression, assigning the initial value to the variable
     let variable_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);
     let void_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(ctx.arch.void_type_id));
     let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
         this,
         operator_span: InputSpan::new(),
         full_span: InputSpan::new(),
         left: variable_expr_id.upcast(),
         operation: AssignmentOperator::Set,
         right: initial_value_expr_id,
         parent: ExpressionParent::None,
         type_index: void_type_index,
     });
     // Create the memory statement
     let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
         this,
         span: InputSpan::new(),
         variable: variable_id,
         initial_expr: assignment_expr_id,
         next: StatementId::new_invalid(),
     });
     // Set all parents which we can access
     let variable_expr = &mut ctx.heap[variable_expr_id];
     variable_expr.parent = ExpressionParent::Expression(assignment_expr_id.upcast(), 0);
     let value_expr = &mut ctx.heap[initial_value_expr_id];
     *value_expr.parent_mut() = ExpressionParent::Expression(assignment_expr_id.upcast(), 1);
     let assignment_expr = &mut ctx.heap[assignment_expr_id];
     assignment_expr.parent = ExpressionParent::Memory(memory_stmt_id);
     return memory_stmt_id;
+}
 fn create_ast_block_stmt(ctx: &mut Ctx, statements: Vec<StatementId>) -> (BlockStatementId, EndBlockStatementId, ScopeId) {
     let block_stmt_id = ctx.heap.alloc_block_statement(|this| BlockStatement{
         this,
         span: InputSpan::new(),
         statements,
         end_block: EndBlockStatementId::new_invalid(),
         scope: ScopeId::new_invalid(),
         next: StatementId::new_invalid(),
     });
     let end_block_stmt_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
         this,
         start_block: block_stmt_id,
         next: StatementId::new_invalid(),
     });
     let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_stmt_id)));
     let block_stmt = &mut ctx.heap[block_stmt_id];
     block_stmt.end_block = end_block_stmt_id;

src/runtime2/component/component_pdl.rs

➞

Show inline comments

@@ @@ -191,400 +191,397 @@ impl SelectState { @@
     /// Checks if a decision can be reached
     fn has_decision(&mut self, inbox: &InboxMain, comp_ctx: &CompCtx) -> SelectDecision {
         self.candidates_workspace.clear();
         if self.cases.is_empty() {
             // If there are no cases then we can immediately reach a "bogus
             // decision".
             return SelectDecision::Case(0);
+        }
         // Need to check for valid case
         'case_loop: for (case_index, case) in self.cases.iter().enumerate() {
             for port_handle in case.involved_ports.iter().copied() {
                 let port_index = comp_ctx.get_port_index(port_handle);
                 if inbox[port_index].is_none() {
                     // Condition not satisfied
                     continue 'case_loop;
+                }
+            }
             // If here then the case guard is satisfied
             self.candidates_workspace.push(case_index);
+        }
         if self.candidates_workspace.is_empty() {
             return SelectDecision::None;
         } else {
             let candidate_index = self.random.get_u64() as usize % self.candidates_workspace.len();
             return SelectDecision::Case(self.candidates_workspace[candidate_index] as u32);
+        }
+    }
+}
 pub(crate) struct CompPDL {
     pub mode: Mode,
     pub mode_port: PortId, // when blocked on a port
     pub mode_value: ValueGroup, // when blocked on a put
     select: SelectState,
     pub prompt: Prompt,
     pub control: ControlLayer,
     pub consensus: Consensus,
     pub sync_counter: u32,
     pub exec_ctx: ExecCtx,
     // TODO: Temporary field, simulates future plans of having one storage place
     //  reserved per port.
     // Should be same length as the number of ports. Corresponding indices imply
     // message is intended for that port.
     pub inbox_main: InboxMain,
     pub inbox_backup: Vec<DataMessage>,
+}
 impl CompPDL {
     pub(crate) fn new(initial_state: Prompt, num_ports: usize) -> Self {
         let mut inbox_main = Vec::new();
         inbox_main.reserve(num_ports);
         for _ in 0..num_ports {
             inbox_main.push(None);
+        }
         return Self{
             mode: Mode::NonSync,
             mode_port: PortId::new_invalid(),
             mode_value: ValueGroup::default(),
             select: SelectState::new(),
             prompt: initial_state,
             control: ControlLayer::default(),
             consensus: Consensus::new(),
             sync_counter: 0,
             exec_ctx: ExecCtx{
                 stmt: ExecStmt::None,
             },
             inbox_main,
             inbox_backup: Vec::new(),
+        }
+    }
     pub(crate) fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, mut message: Message) {
         sched_ctx.log(&format!("handling message: {:#?}", message));
         if let Some(new_target) = self.control.should_reroute(&mut message) {
             let mut target = sched_ctx.runtime.get_component_public(new_target);
             target.send_message(sched_ctx, message, false); // not waking up: we schedule once we've received all PortPeerChanged Acks
             let _should_remove = target.decrement_users();
             debug_assert!(_should_remove.is_none());
             return;
+        }
         match message {
             Message::Data(message) => {
                 self.handle_incoming_data_message(sched_ctx, comp_ctx, message);
             },
             Message::Control(message) => {
                 self.handle_incoming_control_message(sched_ctx, comp_ctx, message);
             },
             Message::Sync(message) => {
                 self.handle_incoming_sync_message(sched_ctx, comp_ctx, message);
+            }
+        }
+    }
     // -------------------------------------------------------------------------
     // Running component and handling changes in global component state
     // -------------------------------------------------------------------------
     pub(crate) fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {
         use EvalContinuation as EC;
         sched_ctx.log(&format!("Running component (mode: {:?})", self.mode));
         // Depending on the mode don't do anything at all, take some special
         // actions, or fall through and run the PDL code.
         match self.mode {
             Mode::NonSync | Mode::Sync | Mode::BlockedSelect => {
                 // continue and run PDL code
             },
             Mode::SyncEnd | Mode::BlockedGet | Mode::BlockedPut => {
                 return Ok(CompScheduling::Sleep);
+            }
             Mode::StartExit => {
                 self.handle_component_exit(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             Mode::BusyExit => {
                 if self.control.has_acks_remaining() {
                     return Ok(CompScheduling::Sleep);
                 } else {
                     self.mode = Mode::Exit;
                     return Ok(CompScheduling::Exit);
+                }
             },
             Mode::Exit => {
                 return Ok(CompScheduling::Exit);
+            }
+        }
         let run_result = self.execute_prompt(&sched_ctx)?;
         match run_result {
             EC::Stepping => unreachable!(), // execute_prompt runs until this is no longer returned
             EC::BranchInconsistent | EC::NewFork | EC::BlockFires(_) => todo!("remove these"),
             // Results that can be returned in sync mode
             EC::SyncBlockEnd => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 self.handle_sync_end(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::BlockGet(port_id) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 debug_assert!(self.exec_ctx.stmt.is_none());
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_index = comp_ctx.get_port_index(port_handle);
                 if let Some(message) = &self.inbox_main[port_index] {
                     // Check if we can actually receive the message
                     if self.consensus.try_receive_data_message(sched_ctx, comp_ctx, message) {
                         // Message was received. Make sure any blocked peers and
                         // pending messages are handled.
                         let message = self.inbox_main[port_index].take().unwrap();
                         self.handle_received_data_message(sched_ctx, comp_ctx, port_handle);
                         self.exec_ctx.stmt = ExecStmt::PerformedGet(message.content);
                         return Ok(CompScheduling::Immediate);
                     } else {
                         todo!("handle sync failure due to message deadlock");
                         return Ok(CompScheduling::Sleep);
+                    }
                 } else {
                     // We need to wait
                     self.mode = Mode::BlockedGet;
                     self.mode_port = port_id;
                     return Ok(CompScheduling::Sleep);
+                }
             },
             EC::Put(port_id, value) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 sched_ctx.log(&format!("Putting value {:?}", value));
                 let port_id = port_id_from_eval(port_id);
                 let port_handle = comp_ctx.get_port_handle(port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 if port_info.state.is_blocked() {
                     self.mode = Mode::BlockedPut;
                     self.mode_port = port_id;
                     self.mode_value = value;
                     self.exec_ctx.stmt = ExecStmt::PerformedPut; // prepare for when we become unblocked
                     return Ok(CompScheduling::Sleep);
                 } else {
                     self.send_data_message_and_wake_up(sched_ctx, comp_ctx, port_handle, value);
                     self.exec_ctx.stmt = ExecStmt::PerformedPut;
                     return Ok(CompScheduling::Immediate);
+                }
             },
             EC::SelectStart(num_cases, _num_ports) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 println!("DEBUG: AAAAAAAAAA");
                 self.select.handle_select_start(num_cases);
                 return Ok(CompScheduling::Requeue);
             },
             EC::SelectRegisterPort(case_index, port_index, port_id) => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 println!("DEBUG: BBBBBBBBBBB");
                 let port_id = port_id_from_eval(port_id);
                 if let Err(_err) = self.select.register_select_case_port(comp_ctx, case_index, port_index, port_id) {
                     todo!("handle registering a port multiple times");
+                }
                 return Ok(CompScheduling::Immediate);
             },
             EC::SelectWait => {
                 debug_assert_eq!(self.mode, Mode::Sync);
                 println!("DEBUG: CCCCCCCCCCC");
                 let select_decision = self.select.handle_select_waiting_point(&self.inbox_main, comp_ctx);
                 if let SelectDecision::Case(case_index) = select_decision {
                     // Reached a conclusion, so we can continue immediately
                     self.exec_ctx.stmt = ExecStmt::PerformedSelectWait(case_index);
                     self.mode = Mode::Sync;
                     return Ok(CompScheduling::Immediate);
                 } else {
                     // No decision yet
                     self.mode = Mode::BlockedSelect;
                     return Ok(CompScheduling::Sleep);
+                }
             },
             // Results that can be returned outside of sync mode
             EC::ComponentTerminated => {
                 self.mode = Mode::StartExit; // next call we'll take care of the exit
                 return Ok(CompScheduling::Immediate);
             },
             EC::SyncBlockStart => {
                 debug_assert_eq!(self.mode, Mode::NonSync);
                 self.handle_sync_start(sched_ctx, comp_ctx);
                 return Ok(CompScheduling::Immediate);
             },
             EC::NewComponent(definition_id, type_id, arguments) => {
                 debug_assert_eq!(self.mode, Mode::NonSync);
                 self.create_component_and_transfer_ports(
                     sched_ctx, comp_ctx,
                     definition_id, type_id, arguments
                 );
                 return Ok(CompScheduling::Requeue);
             },
             EC::NewChannel => {
                 debug_assert_eq!(self.mode, Mode::NonSync);
                 debug_assert!(self.exec_ctx.stmt.is_none());
                 let channel = comp_ctx.create_channel();
                 self.exec_ctx.stmt = ExecStmt::CreatedChannel((
                     Value::Output(port_id_to_eval(channel.putter_id)),
                     Value::Input(port_id_to_eval(channel.getter_id))
                 ));
                 self.inbox_main.push(None);
                 self.inbox_main.push(None);
                 return Ok(CompScheduling::Immediate);
+            }
+        }
+    }
     fn execute_prompt(&mut self, sched_ctx: &SchedulerCtx) -> EvalResult {
         let mut step_result = EvalContinuation::Stepping;
         while let EvalContinuation::Stepping = step_result {
             step_result = self.prompt.step(
                 &sched_ctx.runtime.protocol.types, &sched_ctx.runtime.protocol.heap,
                 &sched_ctx.runtime.protocol.modules, &mut self.exec_ctx,
             )?;
+        }
         return Ok(step_result)
+    }
     fn handle_sync_start(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component starting sync mode");
         self.consensus.notify_sync_start(comp_ctx);
         debug_assert_eq!(self.mode, Mode::NonSync);
         self.mode = Mode::Sync;
+    }
     /// Handles end of sync. The conclusion to the sync round might arise
     /// immediately (and be handled immediately), or might come later through
     /// messaging. In any case the component should be scheduled again
     /// immediately
     fn handle_sync_end(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component ending sync mode (now waiting for solution)");
         let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
         self.mode = Mode::SyncEnd;
         self.handle_sync_decision(sched_ctx, comp_ctx, decision);
+    }
     /// Handles decision from the consensus round. This will cause a change in
     /// the internal `Mode`, such that the next call to `run` can take the
     /// appropriate next steps.
     fn handle_sync_decision(&mut self, sched_ctx: &SchedulerCtx, _comp_ctx: &mut CompCtx, decision: SyncRoundDecision) {
         sched_ctx.log(&format!("Handling sync decision: {:?} (in mode {:?})", decision, self.mode));
         let is_success = match decision {
             SyncRoundDecision::None => {
                 // No decision yet
                 return;
             },
             SyncRoundDecision::Solution => true,
             SyncRoundDecision::Failure => false,
         };
         // If here then we've reached a decision
         debug_assert_eq!(self.mode, Mode::SyncEnd);
         if is_success {
             self.mode = Mode::NonSync;
             self.consensus.notify_sync_decision(decision);
         } else {
             self.mode = Mode::StartExit;
+        }
+    }
     fn handle_component_exit(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         sched_ctx.log("Component exiting");
         debug_assert_eq!(self.mode, Mode::StartExit);
         self.mode = Mode::BusyExit;
         // Doing this by index, then retrieving the handle is a bit rediculous,
         // but Rust is being Rust with its borrowing rules.
         for port_index in 0..comp_ctx.num_ports() {
             let port = comp_ctx.get_port_by_index_mut(port_index);
             if port.state == PortState::Closed {
                 // Already closed, or in the process of being closed
                 continue;
+            }
             // Mark as closed
             let port_id = port.self_id;
             port.state = PortState::Closed;
             // Notify peer of closing
             let port_handle = comp_ctx.get_port_handle(port_id);
             let (peer, message) = self.control.initiate_port_closing(port_handle, comp_ctx);
             let peer_info = comp_ctx.get_peer(peer);
             peer_info.handle.send_message(sched_ctx, Message::Control(message), true);
+        }
+    }
     // -------------------------------------------------------------------------
     // Handling messages
     // -------------------------------------------------------------------------
     fn send_data_message_and_wake_up(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, source_port_handle: LocalPortHandle, value: ValueGroup) {
         let port_info = comp_ctx.get_port(source_port_handle);
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         let annotated_message = self.consensus.annotate_data_message(comp_ctx, port_info, value);
         peer_info.handle.send_message(sched_ctx, Message::Data(annotated_message), true);
+    }
     /// Handles a message that came in through the public inbox. This function
     /// will handle putting it in the correct place, and potentially blocking
     /// the port in case too many messages are being received.
     fn handle_incoming_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: DataMessage) {
         // Check if we can insert it directly into the storage associated with
         // the port
         let target_port_id = message.data_header.target_port;
         let port_handle = comp_ctx.get_port_handle(target_port_id);
         let port_index = comp_ctx.get_port_index(port_handle);
         if self.inbox_main[port_index].is_none() {
             self.inbox_main[port_index] = Some(message);
             // After direct insertion, check if this component's execution is
             // blocked on receiving a message on that port
             debug_assert!(!comp_ctx.get_port(port_handle).state.is_blocked()); // because we could insert directly
             if self.mode == Mode::BlockedGet && self.mode_port == target_port_id {
                 // We were indeed blocked
                 self.mode = Mode::Sync;
                 self.mode_port = PortId::new_invalid();
             } else if self.mode == Mode::BlockedSelect {
                 let select_decision = self.select.handle_updated_inbox(&self.inbox_main, comp_ctx);
                 if let SelectDecision::Case(case_index) = select_decision {
                     self.exec_ctx.stmt = ExecStmt::PerformedSelectWait(case_index);
                     self.mode = Mode::Sync;
+                }
+            }
             return;
+        }
         // The direct inbox is full, so the port will become (or was already) blocked
         let port_info = comp_ctx.get_port_mut(port_handle);
         debug_assert!(port_info.state == PortState::Open || port_info.state.is_blocked());
         if port_info.state == PortState::Open {
             comp_ctx.set_port_state(port_handle, PortState::BlockedDueToFullBuffers);
             let (peer_handle, message) =
                 self.control.initiate_port_blocking(comp_ctx, port_handle);
             let peer = comp_ctx.get_peer(peer_handle);
             peer.handle.send_message(sched_ctx, Message::Control(message), true);
+        }
         // But we still need to remember the message, so:
         self.inbox_backup.push(message);
+    }
     /// Handles when a message has been handed off from the inbox to the PDL
     /// code. We check to see if there are more messages waiting and, if not,
     /// then we handle the case where the port might have been blocked
     /// previously.
     fn handle_received_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, port_handle: LocalPortHandle) {
         let port_index = comp_ctx.get_port_index(port_handle);
         debug_assert!(self.inbox_main[port_index].is_none()); // this function should be called after the message is taken out

src/runtime2/tests/mod.rs

➞

Show inline comments

 use crate::protocol::*;
 use crate::protocol::eval::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::component::{CompCtx, CompPDL};
 fn create_component(rt: &Runtime, module_name: &str, routine_name: &str, args: ValueGroup) {
     let prompt = rt.inner.protocol.new_component(
         module_name.as_bytes(), routine_name.as_bytes(), args
     ).expect("create prompt");
     let reserved = rt.inner.start_create_pdl_component();
     let ctx = CompCtx::new(&reserved);
     let (key, _) = rt.inner.finish_create_pdl_component(reserved, CompPDL::new(prompt, 0), ctx, false);
     rt.inner.enqueue_work(key);
+}
 fn no_args() -> ValueGroup { ValueGroup::new_stack(Vec::new()) }
 #[test]
 fn test_component_creation() {
     let pd = ProtocolDescription::parse(b"
     primitive nothing_at_all() {
         s32 a = 5;
         auto b = 5 + a;
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, true, pd);
     for _i in 0..20 {
         create_component(&rt, "", "nothing_at_all", no_args());
+    }
+}
 #[test]
 fn test_component_communication() {
     let pd = ProtocolDescription::parse(b"
     primitive sender(out<u32> o, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 put(o, inside_index);
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
     primitive receiver(in<u32> i, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 auto val = get(i);
                 while (val != inside_index) {} // infinite loop if incorrect value is received
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
     composite constructor() {
         channel o_orom -> i_orom;
         channel o_mrom -> i_mrom;
         channel o_ormm -> i_ormm;
         channel o_mrmm -> i_mrmm;
         // one round, one message per round
         new sender(o_orom, 1, 1);
         new receiver(i_orom, 1, 1);
         // multiple rounds, one message per round
         new sender(o_mrom, 5, 1);
         new receiver(i_mrom, 5, 1);
         // one round, multiple messages per round
         new sender(o_ormm, 1, 5);
         new receiver(i_ormm, 1, 5);
         // multiple rounds, multiple messages per round
         new sender(o_mrmm, 5, 5);
         new receiver(i_mrmm, 5, 5);
     }").expect("compilation");
     let rt = Runtime::new(3, true, pd);
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_simple_select() {
     let pd = ProtocolDescription::parse(b"
     func infinite_assert<T>(T val, T expected) -> () {
         while (val != expected) { print(\"nope!\"); }
         return ();
+    }
     primitive receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {
         auto num_from_a = 0;
         auto num_from_b = 0;
         while (num_from_a + num_from_b < 2 * num_sends) {
             sync select {
                 auto v = get(in_a) -> {
                     print(\"got something from A\");
                     auto _ = infinite_assert(v, num_from_a);
                     num_from_a += 1;
+                }
                 auto v = get(in_b) -> {
                     print(\"got something from B\");
                     auto _ = infinite_assert(v, num_from_b);
                     num_from_b += 1;
+                }
+            }
+        }
+    }
     primitive sender(out<u32> tx, u32 num_sends) {
         auto index = 0;
         while (index < num_sends) {
             sync {
                 put(tx, index);
                 index += 1;
+            }
+        }
+    }
     composite constructor() {
         auto num_sends = 15;
         channel tx_a -> rx_a;
         channel tx_b -> rx_b;
         new sender(tx_a, num_sends);
         new receiver(rx_a, rx_b, num_sends);
         new sender(tx_b, num_sends);
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, false, pd);
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
-fn test_empty_select() {
+fn test_unguarded_select() {
     let pd = ProtocolDescription::parse(b"
-    primitive constructor() {
+    primitive constructor_outside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> print(\"hello\"); }
             index += 1;
+        }
+    }
     primitive constructor_inside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> index += 1; }
+        }
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, false, pd);
     create_component(&rt, "", "constructor", no_args());
     create_component(&rt, "", "constructor_outside_select", no_args());
     create_component(&rt, "", "constructor_inside_select", no_args());
+}
 #[test]
-fn test_empty_select_should_not_work() {
+fn test_empty_select() {
     let pd = ProtocolDescription::parse(b"
     primitive constructor() {
         u32 index = 0;
         print(\"before while\");
         while (index < 5) {
             print(\"before sync\");
             sync {
                 print(\"before select\");
                 select { }
                 print(\"after select\");
+            }
             print(\"after sync\");
             sync select {}
             index += 1;
+        }
         print(\"after while\");
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, false, pd);
     create_component(&rt, "", "constructor", no_args());
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)