CSY/reowolf Changeset - 3845071002b0 · Centrum Wiskunde & Informatica (CWI)

Changeset - 3845071002b0

Parent rev.

Child rev.

[Not reviewed]

0 9 2

mh - 4 years ago 2021-05-09 14:54:48
contact@maxhenger.nl

reorganization of evaluator, WIP on hooking up to old system

11 files changed with 996 insertions and 844 deletions:

src/common.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval/executor.rs

550

src/protocol/eval/mod.rs

708

src/protocol/eval/store.rs

172

src/protocol/eval/value.rs

133

src/protocol/mod.rs

src/protocol/parser/depth_visitor.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_validation_linking.rs

0 comments (0 inline, 0 general)

src/common.rs

➞

Show inline comments

@@ @@ -48,25 +48,25 @@ pub struct U32Stream { @@
 /// Identifier of a component in a session
 #[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(Id); // PUB because it can be returned by errors
 /// Identifier of a port in a session
 #[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 #[repr(transparent)]
 pub struct PortId(Id);
 /// A safely aliasable heap-allocated payload of message bytes
 #[derive(Default, Eq, PartialEq, Clone, Ord, PartialOrd)]
 pub struct Payload(Arc<Vec<u8>>);
+pub struct Payload(pub Arc<Vec<u8>>);
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 /// "Orientation" of a port, determining whether they can send or receive messages with `put` and `get` respectively.
 #[repr(C)]
 #[derive(serde::Serialize, serde::Deserialize)]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
+}
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 /// "Orientation" of a transport-layer network endpoint, dictating how it's connection procedure should

src/protocol/ast.rs

➞

Show inline comments

 define_aliased_ast_id!(ParserTypeId, Id<ParserType>, index(ParserType, parser_types), alloc(alloc_parser_type));
 define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables), alloc(alloc_variable));
 define_aliased_ast_id!(DefinitionId, Id<Definition>, index(Definition, definitions));
 define_new_ast_id!(StructDefinitionId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));
 define_new_ast_id!(EnumDefinitionId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));
 define_new_ast_id!(UnionDefinitionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));
 define_new_ast_id!(ComponentDefinitionId, DefinitionId, index(ComponentDefinition, Definition::Component, definitions), alloc(alloc_component_definition));
 define_new_ast_id!(FunctionDefinitionId, DefinitionId, index(FunctionDefinition, Definition::Function, definitions), alloc(alloc_function_definition));
 define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));
 define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));
 define_new_ast_id!(EndBlockStatementId, StatementId, index(EndBlockStatement, Statement::EndBlock, statements), alloc(alloc_end_block_statement));
 define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements), alloc(alloc_local_statement));
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));
 define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));
 define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));
 define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));
 define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));
 define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));
 define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));
 define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));
 define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));
@@ @@ -966,24 +967,25 @@ impl FunctionDefinition { @@
             builtin: false,
             span, identifier, poly_vars,
             return_types: Vec::new(),
             parameters: Vec::new(),
             body: BlockStatementId::new_invalid(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
@@ @@ -1153,30 +1155,31 @@ impl Statement { @@
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) => unreachable!(),
+            Statement::EndBlock(_) | Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(_) => todo!(),
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
@@ @@ -1187,30 +1190,31 @@ impl Statement { @@
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub is_implicit: bool,
     pub span: InputSpan, // of the complete block
     pub statements: Vec<StatementId>,
     pub end_block: EndBlockStatementId,
     // Phase 2: linker
     pub parent_scope: Scope,
     pub first_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub next_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub relative_pos_in_parent: u32,
-    pub locals: Vec<LocalId>,
+    pub locals: Vec<VariableId>,
     pub labels: Vec<LabeledStatementId>,
+}
 impl BlockStatement {
     pub fn parent_block(&self, h: &Heap) -> Option<BlockStatementId> {
         let parent = self.parent_scope.unwrap();
         match parent {
             Scope::Definition(_) => {
                 // If the parent scope is a definition, then there is no
                 // parent block.
                 None
+            }
@@ @@ -1219,28 +1223,33 @@ impl BlockStatement { @@
                 // the parent of a synchronous statement is a block statement:
                 // nested synchronous statements are flagged illegal,
                 // and that happens before resolving variables that
                 // creates the parent_scope references in the first place.
                 Some(h[parent].parent_scope.unwrap().to_block())
+            }
             Scope::Regular(parent) => {
                 // A variable scope is either a definition, sync, or block.
                 Some(parent)
+            }
+        }
+    }
     pub fn first(&self) -> StatementId {
         // It is an invariant (guaranteed by the lexer) that block statements have at least one stmt
         *self.statements.first().unwrap()
+    }
+}
 #[derive(Debug, Clone)]
 pub struct EndBlockStatement {
     pub this: EndBlockStatementId,
     // Parser
     pub start_block: BlockStatementId,
     // Validation/Linking
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
@@ @@ -1304,45 +1313,42 @@ pub struct LabeledStatement { @@
     pub relative_pos_in_block: u32,
     pub in_sync: Option<SynchronousStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "if" keyword
     pub test: ExpressionId,
     pub true_body: BlockStatementId,
     pub false_body: Option<BlockStatementId>,
     // Phase 2: linker
     pub end_if: Option<EndIfStatementId>,
     pub end_if: EndIfStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     pub start_if: IfStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "while" keyword
     pub test: ExpressionId,
     pub body: BlockStatementId,
     // Phase 2: linker
     pub end_while: Option<EndWhileStatementId>,
     pub end_while: EndWhileStatementId,
     pub in_sync: Option<SynchronousStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     pub start_while: WhileStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
@@ @@ -1363,25 +1369,25 @@ pub struct ContinueStatement { @@
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<WhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub body: BlockStatementId,
     // Phase 2: linker
-    pub end_sync: Option<EndSynchronousStatementId>,
     pub end_sync: EndSynchronousStatementId,
     pub parent_scope: Option<Scope>,
+}
 #[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     pub start_sync: SynchronousStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -13,24 +13,25 @@ const PREFIX_ROOT_ID: &'static str = "Root"; @@
 const PREFIX_PRAGMA_ID: &'static str = "Prag";
 const PREFIX_IMPORT_ID: &'static str = "Imp ";
 const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";
 const PREFIX_VARIABLE_ID: &'static str = "Var ";
 const PREFIX_DEFINITION_ID: &'static str = "Def ";
 const PREFIX_STRUCT_ID: &'static str = "DefS";
 const PREFIX_ENUM_ID: &'static str = "DefE";
 const PREFIX_UNION_ID: &'static str = "DefU";
 const PREFIX_COMPONENT_ID: &'static str = "DefC";
 const PREFIX_FUNCTION_ID: &'static str = "DefF";
 const PREFIX_STMT_ID: &'static str = "Stmt";
 const PREFIX_BLOCK_STMT_ID: &'static str = "SBl ";
 const PREFIX_ENDBLOCK_STMT_ID: &'static str = "SEBl";
 const PREFIX_LOCAL_STMT_ID: &'static str = "SLoc";
 const PREFIX_MEM_STMT_ID: &'static str = "SMem";
 const PREFIX_CHANNEL_STMT_ID: &'static str = "SCha";
 const PREFIX_SKIP_STMT_ID: &'static str = "SSki";
 const PREFIX_LABELED_STMT_ID: &'static str = "SLab";
 const PREFIX_IF_STMT_ID: &'static str = "SIf ";
 const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";
 const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";
 const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";
 const PREFIX_BREAK_STMT_ID: &'static str = "SBre";
 const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";
 const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";
@@ @@ -349,82 +350,78 @@ impl ASTWriter { @@
                 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("ReturnParserTypes");
                 for return_type in &def.return_types {
                     self.kv(indent3).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, return_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3);
                 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);
             },
             Definition::Component(def) => {
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("PolymorphicVariables");
                 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("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3)
                 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_parameter(&mut self, heap: &Heap, param_id: ParameterId, indent: usize) {
         let indent2 = indent + 1;
         let param = &heap[param_id];
         self.kv(indent).with_id(PREFIX_PARAMETER_ID, param_id.0.index)
             .with_s_key("Parameter");
         self.kv(indent2).with_s_key("Name").with_identifier_val(&param.identifier);
         self.kv(indent2).with_s_key("ParserType").with_custom_val(|w| write_parser_type(w, heap, &param.parser_type));
+    }
     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("FirstUniqueScopeID").with_disp_val(&stmt.first_unique_id_in_scope);
                 self.kv(indent2).with_s_key("NextUniqueScopeID").with_disp_val(&stmt.next_unique_id_in_scope);
                 self.kv(indent2).with_s_key("RelativePos").with_disp_val(&stmt.relative_pos_in_parent);
                 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_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));

src/protocol/eval/executor.rs

➞

Show inline comments

@@ new file 100644 @@
 use std::collections::VecDeque;
 use super::value::*;
 use super::store::*;
 use crate::protocol::*;
 use crate::protocol::ast::*;
 enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 struct Frame {
     definition: DefinitionId,
     position: StatementId,
     expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: DefinitionId) -> Self {
         let definition = &heap[definition_id];
         let first_statement = match definition {
             Definition::Component(definition) => definition.body,
             Definition::Function(definition) => definition.body,
             _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),
         };
         Frame{
             definition: definition_id,
             position: first_statement.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
+        }
+    }
     /// 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) => {
                 todo!("implement binding expression");
             },
             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) => {
                         for field in &literal.fields {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, field.value);
+                        }
                     },
                     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);
+                        }
+                    }
+                }
             },
             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
+            }
+        }
+    }
+}
 type EvalResult = Result<(), EvalContinuation>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, ValueGroup),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 pub struct Prompt {
     pub(crate) frames: Vec<Frame>,
     pub(crate) store: Store,
+}
 impl Prompt {
     pub fn new(heap: &Heap, def: DefinitionId, args: ValueGroup) -> Self {
         let mut prompt = Self{
             frames: Vec::new(),
             store: Store::new(),
         };
         prompt.frames.push(Frame::new(heap, def));
         args.into_store(&mut prompt.store);
         prompt
+    }
     pub fn step(&mut self, heap: &Heap, ctx: &mut EvalContext) -> EvalResult {
         let cur_frame = self.frames.last_mut().unwrap();
         if cur_frame.position.is_invalid() {
             if heap[cur_frame.definition].is_function() {
                 todo!("End of function without return, return an evaluation error");
+            }
             return Err(EvalContinuation::Terminal);
+        }
         while !cur_frame.expr_stack.is_empty() {
             let next = cur_frame.expr_stack.pop_back().unwrap();
             match next {
                 ExprInstruction::PushValToFront => {
                     cur_frame.expr_values.rotate_right(1);
                 },
                 ExprInstruction::EvalExpr(expr_id) => {
                     let expr = &heap[expr_id];
                     match expr {
                         Expression::Assignment(expr) => {
                             let to = cur_frame.expr_values.pop_back().unwrap().as_ref();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             apply_assignment_operator(&mut self.store, to, expr.operation, rhs);
                             cur_frame.expr_values.push_back(self.store.read_copy(to));
                             self.store.drop_value(&rhs);
                         },
                         Expression::Binding(_expr) => {
                             todo!("Binding expression");
                         },
                         Expression::Conditional(expr) => {
                             // Evaluate testing expression, then extend the
                             // expression stack with the appropriate expression
                             let test_result = cur_frame.expr_values.pop_back().unwrap().as_bool();
                             if test_result {
                                 cur_frame.serialize_expression(heap, expr.true_expression);
                             } else {
                                 cur_frame.serialize_expression(heap, expr.false_expression);
+                            }
                         },
                         Expression::Binary(expr) => {
                             let lhs = cur_frame.expr_values.pop_back().unwrap();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_binary_operator(&mut self.store, &lhs, expr.operation, &rhs);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(&lhs);
                             self.store.drop_value(&rhs);
                         },
                         Expression::Unary(expr) => {
                             let val = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_unary_operator(&mut self.store, expr.operation, &val);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(&val);
                         },
                         Expression::Indexing(expr) => {
                             // TODO: Out of bounds checking
                             // Evaluate index. Never heap allocated so we do
                             // not have to drop it.
                             let index = cur_frame.expr_values.pop_back().unwrap();
                             let index = match &index {
                                 Value::Ref(value_ref) => self.store.read_ref(*value_ref),
                                 index => index,
                             };
                             debug_assert!(index.is_integer());
                             let index = if index.is_signed_integer() {
                                 index.as_signed_integer() as u32
                             } else {
                                 index.as_unsigned_integer() as u32
                             };
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let heap_pos = match subject {
                                 Value::Ref(value_ref) => self.store.read_ref(value_ref).as_array(),
                                 val => val.as_array(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, index)));
                             self.store.drop_value(&subject);
                         },
                         Expression::Slicing(expr) => {
                             // TODO: Out of bounds checking
                             todo!("implement slicing")
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let heap_pos = match &subject {
                                 Value::Ref(value_ref) => self.store.read_ref(*value_ref).as_struct(),
                                 subject => subject.as_struct(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, expr.field.as_symbolic().field_idx as u32)));
                             self.store.drop_value(&subject);
                         },
                         Expression::Literal(expr) => {
                             let value = match &expr.value {
                                 Literal::Null => Value::Null,
                                 Literal::True => Value::Bool(true),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     let value = lit_value.as_str();
                                     debug_assert!(values.is_empty());
                                     values.reserve(value.len());
                                     for character in value.as_bytes() {
                                         debug_assert!(character.is_ascii());
                                         values.push(Value::Char(*character as char));
+                                    }
                                     Value::String(heap_pos)
+                                }
                                 Literal::Integer(lit_value) => {
                                     use ConcreteTypePart as CTP;
                                     debug_assert_eq!(expr.concrete_type.parts.len(), 1);
                                     match expr.concrete_type.parts[0] {
                                         CTP::UInt8  => Value::UInt8(lit_value.unsigned_value as u8),
                                         CTP::UInt16 => Value::UInt16(lit_value.unsigned_value as u16),
                                         CTP::UInt32 => Value::UInt32(lit_value.unsigned_value as u32),
                                         CTP::UInt64 => Value::UInt64(lit_value.unsigned_value as u64),
                                         CTP::SInt8  => Value::SInt8(lit_value.unsigned_value as i8),
                                         CTP::SInt16 => Value::SInt16(lit_value.unsigned_value as i16),
                                         CTP::SInt32 => Value::SInt32(lit_value.unsigned_value as i32),
                                         CTP::SInt64 => Value::SInt64(lit_value.unsigned_value as i64),
                                         _ => unreachable!(),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_fields = lit_value.fields.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_fields);
                                     for _ in 0..num_fields {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     Value::Struct(heap_pos)
+                                }
                                 Literal::Enum(lit_value) => {
                                     Value::Enum(lit_value.variant_idx as i64);
+                                }
                                 Literal::Union(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.values.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     Value::Union(lit_value.variant_idx as i64, heap_pos)
+                                }
                                 Literal::Array(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap())
+                                    }
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Call(expr) => {
                             // Push a new frame. Note that all expressions have
                             // been pushed to the front, so they're in the order
                             // of the definition.
                             let num_args = expr.arguments.len();
                             // Prepare stack for a new frame
                             let cur_stack_boundary = self.store.cur_stack_boundary;
                             self.store.cur_stack_boundary = self.store.stack.len();
                             self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));
                             for _ in 0..num_args {
                                 self.store.stack.push(cur_frame.expr_values.pop_front().unwrap());
+                            }
                             // Push the new frame
                             self.frames.push(Frame::new(heap, expr.definition));
                             // To simplify the logic a little bit we will now
                             // return and ask our caller to call us again
                             return Err(EvalContinuation::Stepping);
                         },
                         Expression::Variable(expr) => {
                             let variable = &heap[expr.declaration.unwrap()];
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos)));
+                        }
+                    }
+                }
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {
             Statement::Block(stmt) => {
                 // Reserve space on stack, but also make sure excess stack space
                 // is cleared
                 self.store.clear_stack(stmt.first_unique_id_in_scope as usize);
                 self.store.reserve_stack(stmt.next_unique_id_in_scope as usize);
                 cur_frame.position = stmt.statements[0];
                 Ok(())
             },
             Statement::EndBlock(stmt) => {
                 let block = &heap[stmt.start_block];
                 self.store.clear_stack(stmt.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(())
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.position = stmt.next;
                     },
                     LocalStatement::Channel(stmt) => {
                         let [from_value, to_value] = ctx.new_channel();
                         self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), from_value);
                         self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), to_value);
                         cur_frame.position = stmt.next;
+                    }
+                }
                 Ok(())
             },
             Statement::Labeled(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(())
             },
             Statement::If(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for if statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.true_body.upcast();
                 } else if let Some(false_body) = stmt.false_body {
                     cur_frame.position = false_body.upcast();
                 } else {
                     // Not true, and no false body
                     cur_frame.position = stmt.end_if.unwrap().upcast();
+                }
                 Ok(())
             },
             Statement::EndIf(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(())
             },
             Statement::While(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for while statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.body.upcast();
                 } else {
                     cur_frame.position = stmt.end_while.unwrap().upcast();
+                }
                 Ok(())
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(())
             },
             Statement::Break(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::Continue(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body.upcast();
                 Err(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 Err(EvalContinuation::SyncBlockEnd)
             },
             Statement::Return(stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // Clear any values in the current stack frame
                 self.store.clear_stack(0);
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 let prev_stack_idx = self.store.stack[self.store.cur_stack_boundary].as_stack_boundary();
                 debug_assert!(prev_stack_idx >= 0);
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 self.frames.pop();
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // Immediately return, we don't care about the current frame
                 // anymore and there is nothing left to evaluate
                 return Ok(());
             },
             Statement::Goto(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 // Note that due to expression value evaluation they exist in
                 // reverse order on the stack.
                 // TODO: Revise this code, keep it as is to be compatible with current runtime
                 let mut args = Vec::new();
                 while let Some(value) = cur_frame.expr_values.pop_front() {
                     args.push(value);
+                }
                 cur_frame.position = stmt.next;
                 todo!("Make sure this is handled correctly, transfer 'heap' values to another Prompt");
                 Err(EvalContinuation::NewComponent(call_expr.definition, args))
             },
             Statement::Expression(stmt) => {
                 // The expression has just been completely evaluated. Some
                 // values might have remained on the expression value stack.
                 cur_frame.expr_values.clear();
                 cur_frame.position = stmt.next;
                 Ok(())
             },
         };
         // If the next statement requires evaluating expressions then we push
         // these onto the expression stack. This way we will evaluate this
         // stack in the next loop, then evaluate the statement using the result
         // from the expression evaluation.
         if !cur_frame.position.is_invalid() {
             let stmt = &heap[cur_frame.position];
             match stmt {
                 Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::Return(stmt) => {
                     debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues
                     cur_frame.prepare_single_expression(heap, stmt.expressions[0]);
                 },
                 Statement::New(stmt) => {
                     // Note that we will end up not evaluating the call itself.
                     // Rather we will evaluate its expressions and then
                     // instantiate the component upon reaching the "new" stmt.
                     let call_expr = &heap[stmt.expression];
                     cur_frame.prepare_multiple_expressions(heap, &call_expr.arguments);
                 },
                 Statement::Expression(stmt) => {
                     cur_frame.prepare_single_expression(heap, stmt.expression);
+                }
                 _ => {},
+            }
+        }
         return_value
+    }
+}
@@ \ No newline at end of file @@

src/protocol/eval/mod.rs

➞

Show inline comments

@@ @@ -7,726 +7,23 @@ @@
 ///
 /// Code is always executed within a "frame". For Reowolf the first frame is
 /// usually an executed component. All subsequent frames are function calls.
 /// Simple values live on the "stack". Each variable/parameter has a place on
 /// the stack where its values are stored. If the value is not a primitive, then
 /// its value will be stored in the "heap". Expressions are treated differently
 /// and use a separate "stack" for their evaluation.
 ///
 /// Since this is a value-based language, most values are copied. One has to be
 /// careful with values that reside in the "heap" and make sure that copies are
 /// properly removed from the heap..
 ///
 /// Just to reiterate: this is a temporary implementation. A proper
+/// Just to reiterate: this is a temporary wasteful implementation. A proper
 /// implementation would fully fill out the type table with alignment/size/
 /// offset information and lay out bytecode.
 mod value;
 mod store;
 mod executor;
 use std::collections::VecDeque;
 pub use value::{Value, ValueGroup};
 pub use executor::{EvalContinuation, Prompt};
 use super::value::*;
 use crate::PortId;
 use crate::protocol::ast::*;
 use crate::protocol::*;
 struct HeapAllocation {
     values: Vec<Value>,
+}
 struct Store {
     // The stack where variables/parameters are stored. Note that this is a
     // non-shrinking stack. So it may be filled with garbage.
     stack: Vec<Value>,
     // Represents the place in the stack where we find the `PrevStackBoundary`
     // value containing the previous stack boundary. This is so we can pop from
     // the stack after function calls.
     cur_stack_boundary: usize,
     // A rather ridiculous simulated heap, but this allows us to "allocate"
     // things that occupy more then one stack slot.
     heap_regions: Vec<HeapAllocation>,
     free_regions: VecDeque<HeapPos>,
+}
 impl Store {
     fn new() -> Self {
         let mut store = Self{
             stack: Vec::with_capacity(64),
             cur_stack_boundary: 0,
             heap_regions: Vec::new(),
             free_regions: VecDeque::new(),
         };
         store.stack.push(Value::PrevStackBoundary(-1));
         store
+    }
     /// Resizes(!) the stack to fit the required number of values. Any
     /// unallocated slots are initialized to `Unassigned`. The specified stack
     /// index is exclusive.
     fn reserve_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         if new_size > self.stack.len() {
             self.stack.resize(new_size, Value::Unassigned);
+        }
+    }
     /// Clears values on the stack and removes their heap allocations when
     /// applicable. The specified index itself will also be cleared (so if you
     /// specify 0 all values in the frame will be destroyed)
     fn clear_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         for idx in new_size..self.stack.len() {
             self.drop_value(&self.stack[idx]);
             self.stack[idx] = Value::Unassigned;
+        }
+    }
     /// Reads a value from a specific address. The value is always copied, hence
     /// if the value ends up not being written, one should call `drop_value` on
     /// it.
     fn read_copy(&mut self, address: ValueId) -> Value {
         match value {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return self.clone_value(&self.stack[cur_pos]);
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return self.clone_value(&self.heap_regions[heap_pos as usize].values[region_idx as usize])
+            }
+        }
+    }
     /// Returns an immutable reference to the value pointed to by an address
     fn read_ref(&mut self, address: ValueId) -> &Value {
         match value {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Returns a mutable reference to the value pointed to by an address
     fn read_mut_ref(&mut self, address: ValueId) -> &mut Value {
         match value {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &mut self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &mut self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Writes a value
     fn write(&mut self, address: ValueId, value: Value) {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 self.drop_value(&self.stack[cur_pos]);
                 self.stack[cur_pos] = value;
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 let heap_pos = heap_pos as usize;
                 let region_idx = region_idx as usize;
                 self.drop_value(&self.heap_regions[heap_pos].values[region_idx]);
                 self.heap_regions[heap_pos].values[region_idx] = value
+            }
+        }
+    }
     fn clone_value(&mut self, value: &Value) -> Value {
         // Quickly check if the value is not on the heap
         let source_heap_pos = value.get_heap_pos();
         if source_heap_pos.is_none() {
             // We can do a trivial copy
             return value.clone();
+        }
         // Value does live on heap, copy it
         let source_heap_pos = source_heap_pos.unwrap() as usize;
         let target_heap_pos = self.alloc_heap();
         let target_heap_pos_usize = target_heap_pos as usize;
         let num_values = self.heap_regions[source_heap_pos].values.len();
         for value_idx in 0..num_values {
             let cloned = self.clone_value(&self.heap_regions[source_heap_pos].values[value_idx]);
             self.heap_regions[target_heap_pos_usize].values.push(cloned);
+        }
         match value {
             Value::Message(_) => Value::Message(target_heap_pos),
             Value::Array(_) => Value::Array(target_heap_pos),
             Value::Union(tag, _) => Value::Union(*tag, target_heap_pos),
             Value::Struct(_) => Value::Struct(target_heap_pos),
             _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),
+        }
+    }
     fn drop_value(&mut self, value: &Value) {
         if let Some(heap_pos) = value.get_heap_pos() {
             self.drop_heap_pos(heap_pos);
+        }
+    }
     fn drop_heap_pos(&mut self, heap_pos: HeapPos) {
         let num_values = self.heap_regions[heap_pos as usize].values.len();
         for value_idx in 0..num_values {
             if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {
                 self.drop_heap_pos(other_heap_pos);
+            }
+        }
         self.heap_regions[heap_pos as usize].values.clear();
         self.free_regions.push_back(heap_pos);
+    }
     fn alloc_heap(&mut self) -> HeapPos {
         if self.free_regions.is_empty() {
             let idx = self.heap_regions.len() as HeapPos;
             self.heap_regions.push(HeapAllocation{ values: Vec::new() });
             return idx;
         } else {
             let idx = self.free_regions.pop_back().unwrap();
             return idx;
+        }
+    }
+}
 enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 struct Frame {
     definition: DefinitionId,
     position: StatementId,
     expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: DefinitionId) -> Self {
         let definition = &heap[definition_id];
         let first_statement = match definition {
             Definition::Component(definition) => definition.body,
             Definition::Function(definition) => definition.body,
             _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),
         };
         Frame{
             definition: definition_id,
             position: first_statement.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
+        }
+    }
     /// 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) => {
                 todo!("implement binding expression");
             },
             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) => {
                         for field in &literal.fields {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, field.value);
+                        }
                     },
                     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);
+                        }
+                    }
+                }
             },
             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
+            }
+        }
+    }
+}
 type EvalResult = Result<(), EvalContinuation>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, Vec<Value>),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 pub struct Prompt {
     frames: Vec<Frame>,
     store: Store,
+}
 impl Prompt {
     pub fn new(heap: &Heap, def: DefinitionId) -> Self {
         let mut prompt = Self{
             frames: Vec::new(),
             store: Store::new(),
         };
         prompt.frames.push(Frame::new(heap, def));
         prompt
+    }
     pub fn step(&mut self, heap: &Heap, ctx: &mut EvalContext) -> EvalResult {
         let cur_frame = self.frames.last_mut().unwrap();
         if cur_frame.position.is_invalid() {
             if heap[cur_frame.definition].is_function() {
                 todo!("End of function without return, return an evaluation error");
+            }
             return Err(EvalContinuation::Terminal);
+        }
         while !cur_frame.expr_stack.is_empty() {
             let next = cur_frame.expr_stack.pop_back().unwrap();
             match next {
                 ExprInstruction::PushValToFront => {
                     cur_frame.expr_values.rotate_right(1);
                 },
                 ExprInstruction::EvalExpr(expr_id) => {
                     let expr = &heap[expr_id];
                     match expr {
                         Expression::Assignment(expr) => {
                             let to = cur_frame.expr_values.pop_back().unwrap().as_ref();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             apply_assignment_operator(&mut self.store, to, expr.operation, rhs);
                             cur_frame.expr_values.push_back(self.store.read_copy(to));
                             self.store.drop_value(&rhs);
                         },
                         Expression::Binding(_expr) => {
                             todo!("Binding expression");
                         },
                         Expression::Conditional(expr) => {
                             // Evaluate testing expression, then extend the
                             // expression stack with the appropriate expression
                             let test_result = cur_frame.expr_values.pop_back().unwrap().as_bool();
                             if test_result {
                                 cur_frame.serialize_expression(heap, expr.true_expression);
                             } else {
                                 cur_frame.serialize_expression(heap, expr.false_expression);
+                            }
                         },
                         Expression::Binary(expr) => {
                             let lhs = cur_frame.expr_values.pop_back().unwrap();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_binary_operator(&mut self.store, &lhs, expr.operation, &rhs);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(&lhs);
                             self.store.drop_value(&rhs);
                         },
                         Expression::Unary(expr) => {
                             let val = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_unary_operator(&mut self.store, expr.operation, &val);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(&val);
                         },
                         Expression::Indexing(expr) => {
                             // TODO: Out of bounds checking
                             // Evaluate index. Never heap allocated so we do
                             // not have to drop it.
                             let index = cur_frame.expr_values.pop_back().unwrap();
                             let index = match &index {
                                 Value::Ref(value_ref) => self.store.read_ref(*value_ref),
                                 index => index,
                             };
                             debug_assert!(deref.is_integer());
                             let index = if index.is_signed_integer() {
                                 index.as_signed_integer() as u32
                             } else {
                                 index.as_unsigned_integer() as u32
                             };
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let heap_pos = match val {
                                 Value::Ref(value_ref) => self.store.read_ref(value_ref).as_array(),
                                 val => val.as_array(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, index)));
                             self.store.drop_value(&subject);
                         },
                         Expression::Slicing(expr) => {
                             // TODO: Out of bounds checking
                             todo!("implement slicing")
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let heap_pos = match &subject {
                                 Value::Ref(value_ref) => self.store.read_ref(*value_ref).as_struct(),
                                 subject => subject.as_struct(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, expr.field.as_symbolic().field_idx as u32)));
                             self.store.drop_value(&subject);
                         },
                         Expression::Literal(expr) => {
                             let value = match &expr.value {
                                 Literal::Null => Value::Null,
                                 Literal::True => Value::Bool(true),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     let value = lit_value.as_str();
                                     debug_assert!(values.is_empty());
                                     values.reserve(value.len());
                                     for character in value.as_bytes() {
                                         debug_assert!(character.is_ascii());
                                         values.push(Value::Char(*character as char));
+                                    }
                                     Value::String(heap_pos)
+                                }
                                 Literal::Integer(lit_value) => {
                                     use ConcreteTypePart as CTP;
                                     debug_assert_eq!(expr.concrete_type.parts.len(), 1);
                                     match expr.concrete_type.parts[0] {
                                         CTP::UInt8  => Value::UInt8(lit_value.unsigned_value as u8),
                                         CTP::UInt16 => Value::UInt16(lit_value.unsigned_value as u16),
                                         CTP::UInt32 => Value::UInt32(lit_value.unsigned_value as u32),
                                         CTP::UInt64 => Value::UInt64(lit_value.unsigned_value as u64),
                                         CTP::SInt8  => Value::SInt8(lit_value.unsigned_value as i8),
                                         CTP::SInt16 => Value::SInt16(lit_value.unsigned_value as i16),
                                         CTP::SInt32 => Value::SInt32(lit_value.unsigned_value as i32),
                                         CTP::SInt64 => Value::SInt64(lit_value.unsigned_value as i64),
                                         _ => unreachable!(),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_fields = lit_value.fields.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_fields);
                                     for _ in 0..num_fields {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     Value::Struct(heap_pos)
+                                }
                                 Literal::Enum(lit_value) => {
                                     Value::Enum(lit_value.variant_idx as i64);
+                                }
                                 Literal::Union(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.values.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     Value::Union(lit_value.variant_idx as i64, heap_pos)
+                                }
                                 Literal::Array(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap())
+                                    }
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Call(expr) => {
                             // Push a new frame. Note that all expressions have
                             // been pushed to the front, so they're in the order
                             // of the definition.
                             let num_args = expr.arguments.len();
                             // Prepare stack for a new frame
                             let cur_stack_boundary = self.store.cur_stack_boundary;
                             self.store.cur_stack_boundary = self.store.stack.len();
                             self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));
                             for _ in 0..num_args {
                                 self.store.stack.push(cur_frame.expr_values.pop_front().unwrap());
+                            }
                             // Push the new frame
                             self.frames.push(Frame::new(heap, expr.definition));
                             // To simplify the logic a little bit we will now
                             // return and ask our caller to call us again
                             return Err(EvalContinuation::Stepping);
                         },
                         Expression::Variable(expr) => {
                             let variable = &heap[expr.declaration.unwrap()];
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos)));
+                        }
+                    }
+                }
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {
             Statement::Block(stmt) => {
                 // Reserve space on stack, but also make sure excess stack space
                 // is cleared
                 self.store.clear_stack(stmt.first_unique_id_in_scope as usize);
                 self.store.reserve_stack(stmt.next_unique_id_in_scope as usize);
                 cur_frame.position = stmt.statements[0];
                 Ok(())
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.position = stmt.next;
                     },
                     LocalStatement::Channel(stmt) => {
                         let [from_value, to_value] = ctx.new_channel();
                         self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), from_value);
                         self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), to_value);
                         cur_frame.position = stmt.next;
+                    }
+                }
                 Ok(())
             },
             Statement::Labeled(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(())
             },
             Statement::If(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for if statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.true_body.upcast();
                 } else if let Some(false_body) = stmt.false_body {
                     cur_frame.position = false_body.upcast();
                 } else {
                     // Not true, and no false body
                     cur_frame.position = stmt.end_if.unwrap().upcast();
+                }
                 Ok(())
             },
             Statement::EndIf(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(())
             },
             Statement::While(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for while statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.body.upcast();
                 } else {
                     cur_frame.position = stmt.end_while.unwrap().upcast();
+                }
                 Ok(())
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(())
             },
             Statement::Break(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::Continue(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body.upcast();
                 Err(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 Err(EvalContinuation::SyncBlockEnd)
             },
             Statement::Return(stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // Clear any values in the current stack frame
                 self.store.clear_stack(0);
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 let prev_stack_idx = self.store.stack[self.store.cur_stack_boundary].as_stack_boundary();
                 debug_assert!(prev_stack_idx >= 0);
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 self.frames.pop();
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // Immediately return, we don't care about the current frame
                 // anymore and there is nothing left to evaluate
                 return Ok(());
             },
             Statement::Goto(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(())
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 // Note that due to expression value evaluation they exist in
                 // reverse order on the stack.
                 // TODO: Revise this code, keep it as is to be compatible with current runtime
                 let mut args = Vec::new();
                 while let Some(value) = cur_frame.expr_values.pop_front() {
                     args.push(value);
+                }
                 cur_frame.position = stmt.next;
                 todo!("Make sure this is handled correctly, transfer 'heap' values to another Prompt");
                 Err(EvalContinuation::NewComponent(call_expr.definition, args))
             },
             Statement::Expression(stmt) => {
                 // The expression has just been completely evaluated. Some
                 // values might have remained on the expression value stack.
                 cur_frame.expr_values.clear();
                 cur_frame.position = stmt.next;
                 Ok(())
             },
         };
         // If the next statement requires evaluating expressions then we push
         // these onto the expression stack. This way we will evaluate this
         // stack in the next loop, then evaluate the statement using the result
         // from the expression evaluation.
         if !cur_frame.position.is_invalid() {
             let stmt = &heap[cur_frame.position];
             match stmt {
                 Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::Return(stmt) => {
                     debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues
                     cur_frame.prepare_single_expression(heap, stmt.expressions[0]);
                 },
                 Statement::New(stmt) => {
                     // Note that we will end up not evaluating the call itself.
                     // Rather we will evaluate its expressions and then
                     // instantiate the component upon reaching the "new" stmt.
                     let call_expr = &heap[stmt.expression];
                     cur_frame.prepare_multiple_expressions(heap, &call_expr.arguments);
                 },
                 Statement::Expression(stmt) => {
                     cur_frame.prepare_single_expression(heap, stmt.expression);
+                }
                 _ => {},
+            }
+        }
         return_value
+    }
+}
@@ \ No newline at end of file @@

src/protocol/eval/store.rs

➞

Show inline comments

@@ new file 100644 @@
 use std::collections::VecDeque;
 use super::value::{Value, ValueId, HeapPos};
 pub(crate) struct HeapAllocation {
     pub values: Vec<Value>,
+}
 pub(crate) struct Store {
     // The stack where variables/parameters are stored. Note that this is a
     // non-shrinking stack. So it may be filled with garbage.
     pub(crate) stack: Vec<Value>,
     // Represents the place in the stack where we find the `PrevStackBoundary`
     // value containing the previous stack boundary. This is so we can pop from
     // the stack after function calls.
     pub(crate) cur_stack_boundary: usize,
     // A rather ridiculous simulated heap, but this allows us to "allocate"
     // things that occupy more then one stack slot.
     pub(crate) heap_regions: Vec<HeapAllocation>,
     pub(crate) free_regions: VecDeque<HeapPos>,
+}
 impl Store {
     pub(crate) fn new() -> Self {
         let mut store = Self{
             stack: Vec::with_capacity(64),
             cur_stack_boundary: 0,
             heap_regions: Vec::new(),
             free_regions: VecDeque::new(),
         };
         store.stack.push(Value::PrevStackBoundary(-1));
         store
+    }
     /// Resizes(!) the stack to fit the required number of values. Any
     /// unallocated slots are initialized to `Unassigned`. The specified stack
     /// index is exclusive.
     pub(crate) fn reserve_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         if new_size > self.stack.len() {
             self.stack.resize(new_size, Value::Unassigned);
+        }
+    }
     /// Clears values on the stack and removes their heap allocations when
     /// applicable. The specified index itself will also be cleared (so if you
     /// specify 0 all values in the frame will be destroyed)
     pub(crate) fn clear_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         for idx in new_size..self.stack.len() {
             self.drop_value(&self.stack[idx]);
             self.stack[idx] = Value::Unassigned;
+        }
+    }
     /// Reads a value from a specific address. The value is always copied, hence
     /// if the value ends up not being written, one should call `drop_value` on
     /// it.
     pub(crate) fn read_copy(&mut self, address: ValueId) -> Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return self.clone_value(&self.stack[cur_pos]);
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return self.clone_value(&self.heap_regions[heap_pos as usize].values[region_idx as usize])
+            }
+        }
+    }
     /// Returns an immutable reference to the value pointed to by an address
     pub(crate) fn read_ref(&mut self, address: ValueId) -> &Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Returns a mutable reference to the value pointed to by an address
     pub(crate) fn read_mut_ref(&mut self, address: ValueId) -> &mut Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &mut self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &mut self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Writes a value
     pub(crate) fn write(&mut self, address: ValueId, value: Value) {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 self.drop_value(&self.stack[cur_pos]);
                 self.stack[cur_pos] = value;
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 let heap_pos = heap_pos as usize;
                 let region_idx = region_idx as usize;
                 self.drop_value(&self.heap_regions[heap_pos].values[region_idx]);
                 self.heap_regions[heap_pos].values[region_idx] = value
+            }
+        }
+    }
     fn clone_value(&mut self, value: &Value) -> Value {
         // Quickly check if the value is not on the heap
         let source_heap_pos = value.get_heap_pos();
         if source_heap_pos.is_none() {
             // We can do a trivial copy
             return value.clone();
+        }
         // Value does live on heap, copy it
         let source_heap_pos = source_heap_pos.unwrap() as usize;
         let target_heap_pos = self.alloc_heap();
         let target_heap_pos_usize = target_heap_pos as usize;
         let num_values = self.heap_regions[source_heap_pos].values.len();
         for value_idx in 0..num_values {
             let cloned = self.clone_value(&self.heap_regions[source_heap_pos].values[value_idx]);
             self.heap_regions[target_heap_pos_usize].values.push(cloned);
+        }
         match value {
             Value::Message(_) => Value::Message(target_heap_pos),
             Value::Array(_) => Value::Array(target_heap_pos),
             Value::Union(tag, _) => Value::Union(*tag, target_heap_pos),
             Value::Struct(_) => Value::Struct(target_heap_pos),
             _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),
+        }
+    }
     pub(crate) fn drop_value(&mut self, value: &Value) {
         if let Some(heap_pos) = value.get_heap_pos() {
             self.drop_heap_pos(heap_pos);
+        }
+    }
     pub(crate) fn drop_heap_pos(&mut self, heap_pos: HeapPos) {
         let num_values = self.heap_regions[heap_pos as usize].values.len();
         for value_idx in 0..num_values {
             if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {
                 self.drop_heap_pos(other_heap_pos);
+            }
+        }
         self.heap_regions[heap_pos as usize].values.clear();
         self.free_regions.push_back(heap_pos);
+    }
     pub(crate) fn alloc_heap(&mut self) -> HeapPos {
         if self.free_regions.is_empty() {
             let idx = self.heap_regions.len() as HeapPos;
             self.heap_regions.push(HeapAllocation{ values: Vec::new() });
             return idx;
         } else {
             let idx = self.free_regions.pop_back().unwrap();
             return idx;
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/eval/value.rs

➞

Show inline comments

 use super::store::*;
 use crate::PortId;
 use crate::protocol::ast::{
     AssignmentOperator,
     BinaryOperator,
     UnaryOperator,
 };
 use crate::protocol::eval::Store;
 pub type StackPos = u32;
 pub type HeapPos = u32;
 #[derive(Copy, Clone)]
 pub enum ValueId {
     Stack(StackPos), // place on stack
     Heap(HeapPos, u32), // allocated region + values within that region
+}
 /// Represents a value stored on the stack or on the heap. Some values contain
 /// a `HeapPos`, implying that they're stored in the store's `Heap`. Clearing
 /// a `Value` with a `HeapPos` from a stack must also clear the associated
 /// region from the `Heap`.
 #[derive(Debug, Clone)]
 pub enum Value {
     // Special types, never encountered during evaluation if the compiler works correctly
     Unassigned,                 // Marker when variables are first declared, immediately followed by assignment
     PrevStackBoundary(isize),   // Marker for stack frame beginning, so we can pop stack values
     Ref(ValueId),               // Reference to a value, used by expressions producing references
     // Builtin types
     Input(PortId),
     Output(PortId),
     Message(HeapPos),
     Null,
     Bool(bool),
@@ @@ -132,49 +136,158 @@ impl Value { @@
     /// doesn't store anything in the heap then we return `None`.
     pub(crate) fn get_heap_pos(&self) -> Option<HeapPos> {
         match self {
             Value::Message(v) => Some(*v),
             Value::Array(v) => Some(*v),
             Value::Union(_, v) => Some(*v),
             Value::Struct(v) => Some(*v),
             _ => None
+        }
+    }
+}
 /// Applies the assignment operator. If a heap position is returned then that
 /// heap position should be cleared
 pub(crate) fn apply_assignment_operator(store: &mut Store, lhs: ValueRef, op: AssignmentOperator, rhs: Value) {
 /// When providing arguments to a new component, or when transferring values
 /// from one component's store to a newly instantiated component, one has to
 /// transfer stack and heap values. This `ValueGroup` represents such a
 /// temporary group of values with potential heap allocations.
 ///
 /// Constructing such a ValueGroup manually requires some extra care to make
 /// sure all elements of `values` point to valid elements of `regions`.
 ///
 /// Again: this is a temporary thing, hopefully removed once we move to a
 /// bytecode interpreter.
 pub struct ValueGroup {
     pub(crate) values: Vec<Value>,
     pub(crate) regions: Vec<Vec<Value>>
+}
 impl ValueGroup {
     pub(crate) fn new_stack(values: Vec<Value>) -> Self {
         debug_assert!(values.iter().all(|v| v.get_heap_pos().is_none()));
         Self{
             values,
             regions: Vec::new(),
+        }
+    }
     pub(crate) fn from_store(store: &Store, values: &[Value]) -> Self {
         let mut group = ValueGroup{
             values: Vec::with_capacity(values.len()),
             regions: Vec::with_capacity(values.len()), // estimation
         };
         for value in values {
             let transferred = group.retrieve_value(value, store);
             group.values.push(transferred);
+        }
         group
+    }
     /// Transfers a provided value from a store into a local value with its
     /// heap allocations (if any) stored in the ValueGroup. Calling this
     /// function will not store the returned value in the `values` member.
     fn retrieve_value(&mut self, value: &Value, from_store: &Store) -> Value {
         if let Some(heap_pos) = value.get_heap_pos() {
             // Value points to a heap allocation, so transfer the heap values
             // internally.
             let from_region = &from_store.heap_regions[heap_pos as usize].values;
             let mut new_region = Vec::with_capacity(from_region.len());
             for value in from_region {
                 let transferred = self.transfer_value(value, from_store);
                 new_region.push(transferred);
+            }
             // Region is constructed, store internally and return the new value.
             let new_region_idx = self.regions.len() as HeapPos;
             self.regions.push(new_region);
             return match value {
                 Value::Message(_)    => Value::Message(new_region_idx),
                 Value::String(_)     => Value::String(new_region_idx),
                 Value::Array(_)      => Value::Array(new_region_idx),
                 Value::Union(tag, _) => Value::Union(*tag, new_region_idx),
                 Value::Struct(_)     => Value::Struct(new_region_idx),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
     /// Transfers the heap values and the stack values into the store. Stack
     /// values are pushed onto the Store's stack in the order in which they
     /// appear in the value group.
     pub fn into_store(self, store: &mut Store) {
         for value in &self.values {
             let transferred = self.provide_value(value, store);
             store.stack.push(transferred);
+        }
+    }
     fn provide_value(&self, value: &Value, to_store: &mut Store) -> Value {
         if let Some(from_heap_pos) = value.get_heap_pos() {
             let from_heap_pos = from_heap_pos as usize;
             let to_heap_pos = to_store.alloc_heap();
             let to_heap_pos_usize = to_heap_pos as usize;
             to_store.heap_regions[to_heap_pos_usize].values.reserve(self.regions[from_heap_pos].len());
             for value in &self.regions[from_heap_pos as usize] {
                 let transferred = self.provide_value(value, to_store);
                 to_store.heap_regions[to_heap_pos_usize].values.push(transferred);
+            }
             return match value {
                 Value::Message(_)    => Value::Message(to_heap_pos),
                 Value::String(_)     => Value::String(to_heap_pos),
                 Value::Array(_)      => Value::Array(to_heap_pos),
                 Value::Union(tag, _) => Value::Union(*tag, to_heap_pos),
                 Value::Struct(_)     => Value::Struct(to_heap_pos),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
+}
 impl Default for ValueGroup {
     /// Returns an empty ValueGroup
     fn default() -> Self {
         Self { values: Vec::new(), regions: Vec::new() }
+    }
+}
 pub(crate) fn apply_assignment_operator(store: &mut Store, lhs: ValueId, op: AssignmentOperator, rhs: Value) {
     use AssignmentOperator as AO;
     macro_rules! apply_int_op {
         ($lhs:ident, $assignment_tokens:tt, $operator:ident, $rhs:ident) => {
             match $lhs {
                 Value::UInt8(v)  => { *v $assignment_tokens $rhs.as_uint8();  },
                 Value::UInt16(v) => { *v $assignment_tokens $rhs.as_uint16(); },
                 Value::UInt32(v) => { *v $assignment_tokens $rhs.as_uint32(); },
                 Value::UInt64(v) => { *v $assignment_tokens $rhs.as_uint64(); },
                 Value::SInt8(v)  => { *v $assignment_tokens $rhs.as_sint8();  },
                 Value::SInt16(v) => { *v $assignment_tokens $rhs.as_sint16(); },
                 Value::SInt32(v) => { *v $assignment_tokens $rhs.as_sint32(); },
                 Value::SInt64(v) => { *v $assignment_tokens $rhs.as_sint64(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs),
+            }
+        }
+    }
     let lhs = store.read_mut_ref(lhs);
     let mut to_dealloc = None;
-    match AO {
+    match op {
         AO::Set => {
             match lhs {
                 Value::Unassigned => { *lhs = rhs; },
                 Value::Input(v)  => { *v = rhs.as_input(); },
                 Value::Output(v) => { *v = rhs.as_output(); },
                 Value::Message(v)  => { to_dealloc = Some(*v); *v = rhs.as_message(); },
                 Value::Bool(v)    => { *v = rhs.as_bool(); },
                 Value::Char(v) => { *v = rhs.as_char(); },
                 Value::String(v) => { *v = rhs.as_string().clone(); },
                 Value::UInt8(v) => { *v = rhs.as_uint8(); },
                 Value::UInt16(v) => { *v = rhs.as_uint16(); },
                 Value::UInt32(v) => { *v = rhs.as_uint32(); },
         BO::Add              => { apply_int_op_and_return!(lhs, +,  op, rhs); },
         BO::Subtract         => { apply_int_op_and_return!(lhs, -,  op, rhs); },
         BO::Multiply         => { apply_int_op_and_return!(lhs, *,  op, rhs); },
         BO::Divide           => { apply_int_op_and_return!(lhs, /,  op, rhs); },
         BO::Remainder        => { apply_int_op_and_return!(lhs, %,  op, rhs); }
+    }
+}
 pub(crate) fn apply_unary_operator(store: &mut Store, op: UnaryOperator, value: &Value) -> Value {
     use UnaryOperator as UO;
     macro_rules! apply_int_expr_and_return {
-        ($value:ident, $apply:expr, $op:ident) => {
+        ($value:ident, $apply:tt, $op:ident) => {
             return match $value {
                 Value::UInt8(v)  => Value::UInt8($apply),
                 Value::UInt16(v) => Value::UInt16($apply),
                 Value::UInt32(v) => Value::UInt32($apply),
                 Value::UInt64(v) => Value::UInt64($apply),
                 Value::SInt8(v)  => Value::SInt8($apply),
                 Value::SInt16(v) => Value::SInt16($apply),
                 Value::SInt32(v) => Value::SInt32($apply),
                 Value::SInt64(v) => Value::SInt64($apply),
                 Value::UInt8(v)  => Value::UInt8($apply *v),
                 Value::UInt16(v) => Value::UInt16($apply *v),
                 Value::UInt32(v) => Value::UInt32($apply *v),
                 Value::UInt64(v) => Value::UInt64($apply *v),
                 Value::SInt8(v)  => Value::SInt8($apply *v),
                 Value::SInt16(v) => Value::SInt16($apply *v),
                 Value::SInt32(v) => Value::SInt32($apply *v),
                 Value::SInt64(v) => Value::SInt64($apply *v),
                 _ => unreachable!("apply_unary_operator {:?} on value {:?}", $op, $value),
             };
+        }
+    }
     match op {
         UO::Positive   => { apply_int_expr_and_return!(value, *v, op) },
         UO::Negative   => { apply_int_expr_and_return!(value, *v, op) },
         UO::BitwiseNot => { apply_int_expr_and_return!(value, *v, op)},
         UO::Positive   => {
             debug_assert!(value.is_integer());
             return value.clone();
         },
         UO::Negative   => { apply_int_expr_and_return!(value, -, op) },
         UO::BitwiseNot => { apply_int_expr_and_return!(value, !, op)},
         UO::LogicalNot => { return Value::Bool(!value.as_bool()); },
         UO::PreIncrement => { todo!("implement") },
         UO::PreDecrement => { todo!("implement") },
         UO::PostIncrement => { todo!("implement") },
         UO::PostDecrement => { todo!("implement") },
+    }
+}
@@ \ No newline at end of file @@

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -11,25 +11,25 @@ use crate::common::*; @@
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 /// Description of a protocol object, used to configure new connectors.
 #[repr(C)]
 pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}
 #[derive(Debug, Clone)]
+// #[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
+}
 pub(crate) enum EvalContext<'a> {
     Nonsync(&'a mut NonsyncProtoContext<'a>),
     Sync(&'a mut SyncProtoContext<'a>),
     // None,
+}
 //////////////////////////////////////////////
 impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ @@ -93,58 +93,79 @@ impl ProtocolDescription { @@
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
     pub(crate) fn new_component(&self, identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
                 Polarity::Getter => args.push(Value::Input(x)),
                 Polarity::Putter => args.push(Value::Output(x)),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
-        ComponentState { prompt: Prompt::new(h, def, &args) }
+        ComponentState { prompt: Prompt::new(h, def, ValueGroup::new_stack(args)) }
+    }
+}
 impl ComponentState {
     pub(crate) fn nonsync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut NonsyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> NonsyncBlocker {
         let mut context = EvalContext::Nonsync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
                     EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(definition_id, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let mut moved_ports = HashSet::new();
                         for arg in args.values.iter() {
                             match arg {
                                 Value::Output(port) => {
                                     moved_ports.insert(*port);
+                                }
                                 Value::Input(port) => {
                                     moved_ports.insert(*port);
+                                }
                                 _ => {}
+                            }
+                        }
                         for region in args.regions.iter() {
                             for arg in region {
                                 match arg {
                                     Value::Output(port) => { moved_ports.insert(*port); },
                                     Value::Input(port) => { moved_ports.insert(*port); },
                                     _ => {},
+                                }
+                            }
+                        }
                         let h = &pd.heap;
                         let init_state = ComponentState { prompt: Prompt::new(h, definition_id, &args) };
                         context.new_component(&args, init_state);
                         let init_state = ComponentState { prompt: Prompt::new(h, definition_id, args) };
                         context.new_component(moved_ports, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(_) => unreachable!(),
                     EvalContinuation::BlockGet(_) => unreachable!(),
                     EvalContinuation::Put(_, _) => unreachable!(),
                 },
+            }
+        }
+    }
@@ @@ -161,139 +182,132 @@ impl ComponentState { @@
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
                     EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
-                        Value::Output(OutputValue(port)) => {
                         Value::Output(port) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
-                        Value::Input(InputValue(port)) => {
                         Value::Input(port) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
-                        Value::Output(OutputValue(port)) => {
                         Value::Output(port) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
-                        Value::Input(InputValue(port)) => {
                         Value::Input(port) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let value;
                         match port {
-                            Value::Output(OutputValue(port_value)) => {
                             Value::Output(port_value) => {
                                 value = port_value;
+                            }
-                            Value::Input(InputValue(port_value)) => {
                             Value::Input(port_value) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
                             Value::Null => {
                                 return SyncBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                             },
                             Value::Message(heap_pos) => {
                                 // Create a copy of the payload
                                 payload = buffer;
                                 let values = &self.prompt.store.heap_regions[heap_pos as usize].values;
                                 let mut bytes = Vec::with_capacity(values.len());
                                 for value in values {
                                     bytes.push(value.as_uint8());
+                                }
                                 payload = Payload(Arc::new(bytes));
+                            }
                             _ => unreachable!(),
+                        }
                         return SyncBlocker::PutMsg(value, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         // EvalContext::None => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
-    fn new_component(&mut self, args: &[Value], init_state: ComponentState) -> () {
+    fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: ComponentState) -> () {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let mut moved_ports = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         Value::Input(InputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_ports, init_state)
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let [from, to] = context.new_port_pair();
                 let from = Value::Output(OutputValue(from));
                 let to = Value::Input(InputValue(to));
                 let from = Value::Output(from);
                 let to = Value::Input(to);
                 return [from, to];
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => context.is_firing(port).map(Value::from),
                 Value::Input(InputValue(port)) => context.is_firing(port).map(Value::from),
                 Value::Output(port) => context.is_firing(port).map(Value::Bool),
                 Value::Input(port) => context.is_firing(port).map(Value::Bool),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
                 Value::Output(port) => {
                     debug_assert!(false, "Getting from an output port? Am I mad?");
                     context.read_msg(port).map(Value::receive_message)
+                }
-                Value::Input(InputValue(port)) => {
                 Value::Input(port) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 _ => unreachable!(),
             },
+        }
+    }
     fn did_put(&mut self, port: Value) -> bool {
         match self {
             EvalContext::Nonsync(_) => unreachable!("did_put in nonsync context"),
             EvalContext::Sync(context) => match port {
-                Value::Output(OutputValue(port)) => {
                 Value::Output(port) => {
                     context.did_put_or_get(port)
                 },
                 Value::Input(_) => unreachable!("did_put on input port"),
                 _ => unreachable!("did_put on non-port value")
+            }
+        }
+    }
+}

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

@@ @@ -34,52 +34,48 @@ pub(crate) trait Visitor: Sized { @@
+    }
     fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         recursive_composite_definition(self, h, def)
+    }
     fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentDefinitionId) -> VisitorResult {
         recursive_primitive_definition(self, h, def)
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionDefinitionId) -> VisitorResult {
         recursive_function_definition(self, h, def)
+    }
     fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_parameter_declaration(&mut self, _h: &mut Heap, _decl: ParameterId) -> VisitorResult {
         Ok(())
+    }
     fn visit_local_declaration(&mut self, _h: &mut Heap, _decl: LocalId) -> VisitorResult {
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         recursive_local_statement(self, h, stmt)
+    }
     fn visit_memory_statement(&mut self, _h: &mut Heap, _stmt: MemoryStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_channel_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ChannelStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         recursive_block_statement(self, h, stmt)
+    }
     fn visit_end_block_statement(&mut self, h: &mut Heap, stmt: EndBlockStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         recursive_if_statement(self, h, stmt)
+    }
     fn visit_end_if_statement(&mut self, _h: &mut Heap, _stmt: EndIfStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         recursive_while_statement(self, h, stmt)
+    }
@@ @@ -180,41 +176,24 @@ pub(crate) trait Visitor: Sized { @@
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         _h: &mut Heap,
         _expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 // Bubble-up helpers
 fn recursive_parameter_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     param: ParameterId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, param.upcast())
+}
 fn recursive_local_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     local: LocalId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, local.upcast())
+}
 fn recursive_call_expression_as_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     call: CallExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, call.upcast())
+}
 // Recursive procedures
 fn recursive_protocol_description<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
@@ @@ -257,89 +236,79 @@ fn recursive_component_definition<T: Visitor>( @@
     match component_variant {
         ComponentVariant::Primitive => this.visit_primitive_definition(h, def),
         ComponentVariant::Composite => this.visit_composite_definition(h, def),
+    }
+}
 fn recursive_composite_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
-        recursive_parameter_as_variable(this, h, param)?;
+        this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_primitive_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
-        recursive_parameter_as_variable(this, h, param)?;
+        this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: FunctionDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
-        recursive_parameter_as_variable(this, h, param)?;
+        this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_variable_declaration<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     decl: VariableId,
 ) -> VisitorResult {
     match h[decl].clone() {
         Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),
         Variable::Local(decl) => this.visit_local_declaration(h, decl.this),
+    }
+}
 fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {
     match h[stmt].clone() {
         Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),
         Statement::EndBlock(stmt) => this.visit_end_block_statement(h, stmt.this),
         Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),
         Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),
         Statement::If(stmt) => this.visit_if_statement(h, stmt.this),
         Statement::While(stmt) => this.visit_while_statement(h, stmt.this),
         Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),
         Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),
         Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),
         Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),
         Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),
         Statement::New(stmt) => this.visit_new_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(stmt) => this.visit_end_synchronous_statement(h, stmt.this),
         Statement::EndWhile(stmt) => this.visit_end_while_statement(h, stmt.this),
         Statement::EndIf(stmt) => this.visit_end_if_statement(h, stmt.this),
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     block: BlockStatementId,
 ) -> VisitorResult {
     for &local in h[block].locals.clone().iter() {
-        recursive_local_as_variable(this, h, local)?;
+        this.visit_variable_declaration(h, local)?;
+    }
     for &stmt in h[block].statements.clone().iter() {
         this.visit_statement(h, stmt)?;
+    }
     Ok(())
+}
 fn recursive_local_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LocalStatementId,
 ) -> VisitorResult {
@@ @@ -540,24 +509,36 @@ impl Visitor for LinkStatements { @@
         assert!(self.prev.is_none());
         recursive_symbol_definition(self, h, def)?;
         // Clear out last statement
         self.prev = None;
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         if let Some(prev) = self.prev.take() {
             h[prev.0].link_next(stmt.upcast());
+        }
         let end_block = h[stmt].end_block;
         recursive_block_statement(self, h, stmt)?;
         if let Some(prev) = self.prev.take() {
             h[prev.0].link_next(end_block.upcast());
+        }
         self.prev = Some(UniqueStatementId(end_block.upcast()));
         Ok(())
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // Link the two branches to the corresponding EndIf pseudo-statement
         let end_if_id = h[stmt].end_if;
         assert!(end_if_id.is_some());
         let end_if_id = end_if_id.unwrap();

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -6,39 +6,39 @@ use super::token_parsing::*; @@
 use crate::protocol::input_source::{InputSource as InputSource, InputPosition as InputPosition, InputSpan, ParseError};
 use crate::collections::*;
 /// Parses all the tokenized definitions into actual AST nodes.
 pub(crate) struct PassDefinitions {
     // State
     cur_definition: DefinitionId,
     // Temporary buffers of various kinds
     buffer: String,
     struct_fields: ScopedBuffer<StructFieldDefinition>,
     enum_variants: ScopedBuffer<EnumVariantDefinition>,
     union_variants: ScopedBuffer<UnionVariantDefinition>,
-    parameters: ScopedBuffer<ParameterId>,
+    variables: ScopedBuffer<VariableId>,
     expressions: ScopedBuffer<ExpressionId>,
     statements: ScopedBuffer<StatementId>,
     parser_types: ScopedBuffer<ParserType>,
+}
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             buffer: String::with_capacity(128),
             struct_fields: ScopedBuffer::new_reserved(128),
             enum_variants: ScopedBuffer::new_reserved(128),
             union_variants: ScopedBuffer::new_reserved(128),
-            parameters: ScopedBuffer::new_reserved(128),
+            variables: ScopedBuffer::new_reserved(128),
             expressions: ScopedBuffer::new_reserved(128),
             statements: ScopedBuffer::new_reserved(128),
             parser_types: ScopedBuffer::new_reserved(128),
+        }
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let module_range = &module.tokens.ranges[0];
         debug_assert_eq!(module.phase, ModuleCompilationPhase::ImportsResolved);
         debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);
@@ @@ -250,25 +250,25 @@ impl PassDefinitions { @@
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
-        let mut parameter_section = self.parameters.start_section();
+        let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let mut return_types = self.parser_types.start_section();
         let mut open_curly_pos = iter.last_valid_pos(); // bogus value
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
@@ @@ -305,25 +305,25 @@ impl PassDefinitions { @@
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated definition
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse component's argument list
-        let mut parameter_section = self.parameters.start_section();
+        let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume block
         let body = self.consume_block_statement(module, iter, ctx)?;
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_component_mut();
         component.parameters = parameters;
         component.body = body;
@@ @@ -341,36 +341,46 @@ impl PassDefinitions { @@
             // This is a block statement
             self.consume_block_statement(module, iter, ctx)
         } else {
             // Not a block statement, so wrap it in one
             let mut statements = self.statements.start_section();
             let wrap_begin_pos = iter.last_valid_pos();
             self.consume_statement(module, iter, ctx, &mut statements)?;
             let wrap_end_pos = iter.last_valid_pos();
             debug_assert_eq!(statements.len(), 1);
             let statements = statements.into_vec();
-            Ok(ctx.heap.alloc_block_statement(|this| BlockStatement{
+            let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
                 this,
                 is_implicit: true,
                 span: InputSpan::from_positions(wrap_begin_pos, wrap_end_pos), // TODO: @Span
                 statements,
                 end_block: EndBlockStatementId::new_invalid(),
                 parent_scope: Scope::Definition(DefinitionId::new_invalid()),
                 first_unique_id_in_scope: -1,
                 next_unique_id_in_scope: -1,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new()
             }))
             });
             let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
                 this, start_block: id, next: StatementId::new_invalid()
             });
             let block_stmt = &mut ctx.heap[id];
             block_stmt.end_block = end_block;
             Ok(id)
+        }
+    }
     /// Consumes a statement and returns a boolean indicating whether it was a
     /// block or not.
     fn consume_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let next = iter.next().expect("consume_statement has a next token");
         if next == TokenKind::OpenCurly {
             let id = self.consume_block_statement(module, iter, ctx)?;
@@ @@ -380,52 +390,52 @@ impl PassDefinitions { @@
             if ident == KW_STMT_IF {
                 // Consume if statement and place end-if statement directly
                 // after it.
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
                     this, start_if: id, next: StatementId::new_invalid()
                 });
                 section.push(id.upcast());
                 let if_stmt = &mut ctx.heap[id];
-                if_stmt.end_if = Some(end_if);
                 if_stmt.end_if = end_if;
             } else if ident == KW_STMT_WHILE {
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{
                     this, start_while: id, next: StatementId::new_invalid()
                 });
                 section.push(id.upcast());
                 let while_stmt = &mut ctx.heap[id];
-                while_stmt.end_while = Some(end_while);
                 while_stmt.end_while = end_while;
             } else if ident == KW_STMT_BREAK {
                 let id = self.consume_break_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CONTINUE {
                 let id = self.consume_continue_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_SYNC {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                     this, start_sync: id, next: StatementId::new_invalid()
                 });
                 let sync_stmt = &mut ctx.heap[id];
-                sync_stmt.end_sync = Some(end_sync);
                 sync_stmt.end_sync = end_sync;
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_GOTO {
                 let id = self.consume_goto_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_NEW {
                 let id = self.consume_new_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CHANNEL {
                 let id = self.consume_channel_statement(module, iter, ctx)?;
                 section.push(id.upcast().upcast());
@@ @@ -465,36 +475,46 @@ impl PassDefinitions { @@
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected a statement or '}'"
                 ));
+            }
             self.consume_statement(module, iter, ctx, &mut stmt_section)?;
             next = iter.next();
+        }
         let statements = stmt_section.into_vec();
         let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         block_span.begin = open_curly_pos;
-        Ok(ctx.heap.alloc_block_statement(|this| BlockStatement{
+        let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             is_implicit: false,
             span: block_span,
             statements,
             end_block: EndBlockStatementId::new_invalid(),
             parent_scope: Scope::Definition(DefinitionId::new_invalid()),
             first_unique_id_in_scope: -1,
             next_unique_id_in_scope: -1,
             relative_pos_in_parent: 0,
             locals: Vec::new(),
             labels: Vec::new(),
         }))
         });
         let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
             this, start_block: id, next: StatementId::new_invalid()
         });
         let block_stmt = &mut ctx.heap[id];
         block_stmt.end_block = end_block;
         Ok(id)
+    }
     fn consume_if_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<IfStatementId, ParseError> {
         let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let true_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         let false_body = if has_ident(&module.source, iter, KW_STMT_ELSE) {
@@ @@ -502,43 +522,43 @@ impl PassDefinitions { @@
             let false_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
             Some(false_body)
         } else {
             None
         };
         Ok(ctx.heap.alloc_if_statement(|this| IfStatement{
             this,
             span: if_span,
             test,
             true_body,
             false_body,
-            end_if: None,
+            end_if: EndIfStatementId::new_invalid(),
         }))
+    }
     fn consume_while_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<WhileStatementId, ParseError> {
         let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_while_statement(|this| WhileStatement{
             this,
             span: while_span,
             test,
             body,
-            end_while: None,
+            end_while: EndWhileStatementId::new_invalid(),
             in_sync: None,
         }))
+    }
     fn consume_break_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BreakStatementId, ParseError> {
         let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;
         let label = if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
@@ @@ -573,25 +593,25 @@ impl PassDefinitions { @@
+    }
     fn consume_synchronous_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SynchronousStatementId, ParseError> {
         let synchronous_span = consume_exact_ident(&module.source, iter, KW_STMT_SYNC)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{
             this,
             span: synchronous_span,
             body,
-            end_sync: None,
+            end_sync: EndSynchronousStatementId::new_invalid(),
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ReturnStatementId, ParseError> {
         let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;
         let mut scoped_section = self.expressions.start_section();
         consume_comma_separated_until(
             TokenKind::SemiColon, &module.source, iter, ctx,
         TokenKind::OpenAngle, TokenKind::CloseAngle, source, iter, _ctx,
         |source, iter, _ctx| {
             consume_ident(source, iter)?;
             Ok(())
         }, "a polymorphic variable"
     )?;
     Ok(())
+}
 /// Consumes the parameter list to functions/components
 fn consume_parameter_list(
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
-    target: &mut ScopedSection<ParameterId>, scope: SymbolScope, definition_id: DefinitionId
+    target: &mut ScopedSection<VariableId>, scope: SymbolScope, definition_id: DefinitionId
 ) -> Result<(), ParseError> {
     consume_comma_separated(
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
         |source, iter, ctx| {
             let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
             let parser_type = consume_parser_type(
                 source, iter, &ctx.symbols, &ctx.heap, poly_vars, scope,
                 definition_id, false, 0
             )?;
             let identifier = consume_ident_interned(source, iter, ctx)?;
             let parameter_id = ctx.heap.alloc_variable(|this| Variable{
                 this,

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -3,25 +3,24 @@ use crate::protocol::ast::*; @@
 use crate::protocol::input_source::*;
 use crate::protocol::parser::symbol_table::*;
 use crate::protocol::parser::type_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
 use crossbeam_utils::thread::scope;
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     Primitive(ComponentDefinitionId),
     Composite(ComponentDefinitionId),
     Function(FunctionDefinitionId)
+}
 impl DefinitionType {
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }

0 comments (0 inline, 0 general)