CSY/reowolf Changeset - 644bbf1ed134 · Centrum Wiskunde & Informatica (CWI)

Changeset - 644bbf1ed134

Parent rev.

Child rev.

[Not reviewed]

0 9 0

MH - 3 years ago 2022-04-07 17:42:38
contact@maxhenger.nl

WIP on TCP component implementation, changes to interface

9 files changed with 252 insertions and 76 deletions:

src/protocol/ast.rs

src/protocol/mod.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/type_table.rs

src/protocol/tests/utils.rs

src/runtime2/component/component.rs

src/runtime2/component/component_internet.rs

157

src/runtime2/stdlib/internet.rs

std/std.internet.pdl

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

 define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));
 define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));
 define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));
 define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));
 define_new_ast_id!(SlicingExpressionId, ExpressionId, index(SlicingExpression, Expression::Slicing, expressions), alloc(alloc_slicing_expression));
 define_new_ast_id!(SelectExpressionId, ExpressionId, index(SelectExpression, Expression::Select, expressions), alloc(alloc_select_expression));
 define_new_ast_id!(LiteralExpressionId, ExpressionId, index(LiteralExpression, Expression::Literal, expressions), alloc(alloc_literal_expression));
 define_new_ast_id!(CastExpressionId, ExpressionId, index(CastExpression, Expression::Cast, expressions), alloc(alloc_cast_expression));
 define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Expression::Call, expressions), alloc(alloc_call_expression));
 define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));
 define_aliased_ast_id!(ScopeId, Id<Scope>, index(Scope, scopes), alloc(alloc_scope));
 #[derive(Debug)]
 pub struct Heap {
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     pub(crate) protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
     pub(crate) scopes: Arena<Scope>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
             scopes: Arena::new(),
+        }
+    }
     pub fn alloc_memory_statement(
         &mut self,
         f: impl FnOnce(MemoryStatementId) -> MemoryStatement,
     ) -> MemoryStatementId {
         MemoryStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Memory(
                 f(MemoryStatementId(LocalStatementId(id)))
             ))
         })))
+    }
     pub fn alloc_channel_statement(
         &mut self,
         f: impl FnOnce(ChannelStatementId) -> ChannelStatement,
     ) -> ChannelStatementId {
         ChannelStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Channel(
                 f(ChannelStatementId(LocalStatementId(id)))
             ))
         })))
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
         match &self.statements[index.0.0] {
             Statement::Local(LocalStatement::Memory(v)) => v,
             _ => unreachable!(),
+        }
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
         match &self.statements[index.0.0] {
             Statement::Local(LocalStatement::Channel(v)) => v,
             _ => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
     // pub position: InputPosition,
     pub pragmas: Vec<PragmaId>,
     pub imports: Vec<ImportId>,
     pub definitions: Vec<DefinitionId>,
+}
 impl Root {
-    pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {
+    pub fn get_definition_by_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {
         for &def in self.definitions.iter() {
             if h[def].identifier().value.as_bytes() == id {
                 return Some(def);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Pragma {
     Version(PragmaVersion),
     Module(PragmaModule),
+}
 impl Pragma {
     pub(crate) fn as_module(&self) -> &PragmaModule {
         match self {
             Pragma::Module(pragma) => pragma,
             _ => unreachable!("Tried to obtain {:?} as PragmaModule", self),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct PragmaVersion {
     pub this: PragmaId,
     // Phase 1: parser
     pub span: InputSpan, // of full pragma
     pub version: u64,
+}
 #[derive(Debug, Clone)]
 pub struct PragmaModule {
     pub this: PragmaId,
     // Phase 1: parser
     pub span: InputSpan, // of full pragma
     pub value: Identifier,
+}
 #[derive(Debug, Clone)]
 pub enum Import {
     Module(ImportModule),
     Symbols(ImportSymbols)
+}
 impl Import {
     pub(crate) fn span(&self) -> InputSpan {
         match self {
             Import::Module(v) => v.span,
             Import::Symbols(v) => v.span,
+        }
+    }
     pub(crate) fn as_module(&self) -> &ImportModule {
         match self {
             Import::Module(m) => m,
             _ => unreachable!("Unable to cast 'Import' to 'ImportModule'")
+        }
+    }
     pub(crate) fn as_symbols(&self) -> &ImportSymbols {
         match self {
             Import::Symbols(m) => m,
             _ => unreachable!("Unable to cast 'Import' to 'ImportSymbols'")
+        }
+    }
     pub(crate) fn as_symbols_mut(&mut self) -> &mut ImportSymbols {
         match self {
             Import::Symbols(m) => m,
             _ => unreachable!("Unable to cast 'Import' to 'ImportSymbols'")
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ImportModule {
     pub this: ImportId,
     // Phase 1: parser
     pub span: InputSpan,
     pub module: Identifier,
     pub alias: Identifier,
     pub module_id: RootId,
+}
 #[derive(Debug, Clone)]
 pub struct AliasedSymbol {
     pub name: Identifier,
     pub alias: Option<Identifier>,
     pub definition_id: DefinitionId,
+}
 #[derive(Debug, Clone)]
 pub struct ImportSymbols {
     pub this: ImportId,
     // Phase 1: parser
     pub span: InputSpan,

src/protocol/mod.rs

➞

Show inline comments

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

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -1975,193 +1975,193 @@ impl PassTyping { @@
+                }
+            }
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn poly_data_type_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference_poly_args: &Vec<InferenceType>,
             first_concrete_part: ConcreteTypePart,
         ) -> Result<ConcreteType, ParseError> {
             // Prepare storage vector
             let mut num_inference_parts = 0;
             for inference_type in inference_poly_args {
                 num_inference_parts += inference_type.parts.len();
+            }
             let mut concrete_type = ConcreteType{
                 parts: Vec::with_capacity(1 + num_inference_parts),
             };
             concrete_type.parts.push(first_concrete_part);
             // Go through all polymorphic arguments and add them to the concrete
             // types.
             for (poly_idx, poly_type) in inference_poly_args.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.procedure.upcast(),
                         Expression::Literal(expr) => match &expr.value {
                             Literal::Enum(lit) => lit.definition,
                             Literal::Union(lit) => lit.definition,
                             Literal::Struct(lit) => lit.definition,
                             _ => unreachable!()
                         },
                         _ => unreachable!(),
                     };
                     let poly_vars = ctx.heap[definition].poly_vars();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, expr.operation_span(), format!(
                             "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",
                             poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
                 poly_type.write_concrete_type(&mut concrete_type);
+            }
             Ok(concrete_type)
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the AST. If this is the first time we're
         // visiting this procedure then we assign expression indices as well.
         let procedure = &ctx.heap[self.procedure_id];
         let num_infer_nodes = self.infer_nodes.len();
         let mut monomorph = ProcedureDefinitionMonomorph{
             argument_types: Vec::with_capacity(procedure.parameters.len()),
             expr_info: Vec::with_capacity(num_infer_nodes),
         };
         // For all of the expressions look up the TypeId (or create a new one).
         // For function calls and component instantiations figure out if they
         // need to be typechecked
         for infer_node in self.infer_nodes.iter_mut() {
             // Determine type ID
             let expr = &ctx.heap[infer_node.expr_id];
             // TODO: Maybe optimize? Split insertion up into lookup, then clone
             //  if needed?
             let mut concrete_type = ConcreteType::default();
             infer_node.expr_type.write_concrete_type(&mut concrete_type);
             let info_type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete_type)?;
             // Determine procedure type ID, i.e. a called/instantiated
             // procedure's signature.
             let info_variant = if let Expression::Call(expr) = expr {
                 // Construct full function type. If not yet typechecked then
                 // queue it for typechecking.
                 let poly_data = &self.poly_data[infer_node.poly_data_index as usize];
                 debug_assert!(expr.method.is_user_defined() || expr.method.is_public_builtin());
                 let procedure_id = expr.procedure;
                 let num_poly_vars = poly_data.poly_vars.len() as u32;
                 let first_part = match expr.method {
                     Method::UserFunction => ConcreteTypePart::Function(procedure_id, num_poly_vars),
                     Method::UserComponent => ConcreteTypePart::Component(procedure_id, num_poly_vars),
                     _ => ConcreteTypePart::Function(procedure_id, num_poly_vars),
                 };
                 let definition_id = procedure_id.upcast();
                 let signature_type = poly_data_type_to_concrete_type(
                     ctx, infer_node.expr_id, &poly_data.poly_vars, first_part
                 )?;
-                let (type_id, monomorph_index) = if let Some(type_id) = ctx.types.get_procedure_monomorph_type_id(&definition_id, &signature_type.parts) {
+                let (type_id, monomorph_index) = if let Some(type_id) = ctx.types.get_monomorph_type_id(&definition_id, &signature_type.parts) {
                     // Procedure is already typechecked
                     let monomorph_index = ctx.types.get_monomorph(type_id).variant.as_procedure().monomorph_index;
                     (type_id, monomorph_index)
                 } else {
                     // Procedure is not yet typechecked, reserve a TypeID and a monomorph index
                     let procedure_to_check = &mut ctx.heap[procedure_id];
                     let monomorph_index = procedure_to_check.monomorphs.len() as u32;
                     procedure_to_check.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());
                     let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, signature_type, monomorph_index);
                     if !procedure_to_check.source.is_builtin() {
                         // Only perform typechecking on the user-defined
                         // procedures
                         queue.push_back(ResolveQueueElement{
                             root_id: ctx.heap[definition_id].defined_in(),
                             definition_id,
                             reserved_type_id: type_id,
                             reserved_monomorph_index: monomorph_index,
                         });
+                    }
                     (type_id, monomorph_index)
                 };
                 ExpressionInfoVariant::Procedure(type_id, monomorph_index)
             } else if let Expression::Select(_expr) = expr {
                 ExpressionInfoVariant::Select(infer_node.field_index)
             } else {
                 ExpressionInfoVariant::Generic
             };
             infer_node.info_type_id = info_type_id;
             infer_node.info_variant = info_variant;
+        }
         // Write the types of the arguments
         let procedure = &ctx.heap[self.procedure_id];
         for parameter_id in procedure.parameters.iter().copied() {
             let mut concrete = ConcreteType::default();
             let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();
             var_data.var_type.write_concrete_type(&mut concrete);
             let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;
             monomorph.argument_types.push(type_id)
+        }
         // Determine if we have already assigned type indices to the expressions
         // before (the indices that, for a monomorph, can retrieve the type of
         // the expression).
         let has_type_indices = self.reserved_monomorph_index > 0;
         if has_type_indices {
             // already have indices, so resize and then index into it
             debug_assert!(monomorph.expr_info.is_empty());
             monomorph.expr_info.resize(num_infer_nodes, ExpressionInfo::new_invalid());
             for infer_node in self.infer_nodes.iter() {
                 let type_index = ctx.heap[infer_node.expr_id].type_index();
                 monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();
+            }
         } else {
             // no indices yet, need to be assigned in AST
             for infer_node in self.infer_nodes.iter() {
                 let type_index = monomorph.expr_info.len();
                 monomorph.expr_info.push(infer_node.as_expression_info());
                 *ctx.heap[infer_node.expr_id].type_index_mut() = type_index as i32;
+            }
+        }
         // Push the information into the AST
         let procedure = &mut ctx.heap[self.procedure_id];
         procedure.monomorphs[self.reserved_monomorph_index as usize] = monomorph;
         Ok(())
+    }
     fn progress_inference_rule(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         use InferenceRule as IR;
         let node = &self.infer_nodes[node_index];
         match &node.inference_rule {
             IR::Noop =>
                 unreachable!(),
             IR::MonoTemplate(_) =>
                 self.progress_inference_rule_mono_template(ctx, node_index),
             IR::BiEqual(_) =>
                 self.progress_inference_rule_bi_equal(ctx, node_index),
             IR::TriEqualArgs(_) =>
                 self.progress_inference_rule_tri_equal_args(ctx, node_index),
             IR::TriEqualAll(_) =>
                 self.progress_inference_rule_tri_equal_all(ctx, node_index),
             IR::Concatenate(_) =>
                 self.progress_inference_rule_concatenate(ctx, node_index),
             IR::IndexingExpr(_) =>
                 self.progress_inference_rule_indexing_expr(ctx, node_index),
             IR::SlicingExpr(_) =>
                 self.progress_inference_rule_slicing_expr(ctx, node_index),
             IR::SelectStructField(_) =>
                 self.progress_inference_rule_select_struct_field(ctx, node_index),

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -590,196 +590,196 @@ pub struct TypeTable { @@
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             definition_lookup: HashMap::with_capacity(128),
             mono_type_lookup: HashMap::with_capacity(128),
             mono_types: Vec::with_capacity(128),
             mono_search_key: MonoSearchKey::with_capacity(32),
             type_loop_breadcrumbs: Vec::with_capacity(32),
             type_loops: Vec::with_capacity(8),
             encountered_types: Vec::with_capacity(32),
             memory_layout_breadcrumbs: Vec::with_capacity(32),
             size_alignment_stack: Vec::with_capacity(64),
+        }
+    }
     /// Iterates over all defined types (polymorphic and non-polymorphic) and
     /// add their types in two passes. In the first pass we will just add the
     /// base types (we will not consider monomorphs, and we will not compute
     /// byte sizes). In the second pass we will compute byte sizes of
     /// non-polymorphic types, and potentially the monomorphs that are embedded
     /// in those types.
     pub(crate) fn build_base_types(&mut self, modules: &mut [Module], ctx: &mut PassCtx) -> Result<(), ParseError> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));
         debug_assert!(self.definition_lookup.is_empty());
         dbg_code!({
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
         });
         // Use context to guess hashmap size of the base types
         let reserve_size = ctx.heap.definitions.len();
         self.definition_lookup.reserve(reserve_size);
         // Resolve all base types
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let definition = &ctx.heap[definition_id];
             match definition {
                 Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,
                 Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,
                 Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,
                 Definition::Procedure(_) => self.build_base_procedure_definition(modules, ctx, definition_id)?,
+            }
+        }
         debug_assert_eq!(self.definition_lookup.len(), reserve_size, "mismatch in reserved size of type table");
         for module in modules.iter_mut() {
             module.phase = ModuleCompilationPhase::TypesAddedToTable;
+        }
         // Go through all types again, lay out all types that are not
         // polymorphic. This might cause us to lay out monomorphized polymorphs
         // if these were member types of non-polymorphic types.
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.definition_lookup.get(&definition_id).unwrap();
             if !poly_type.definition.is_data_type() || !poly_type.poly_vars.is_empty() {
                 continue;
+            }
             // If here then the type is a data type without polymorphic
             // variables, but we might have instantiated it already, so:
             let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];
             self.mono_search_key.set(&concrete_parts, &[]);
             let type_id = self.mono_type_lookup.get(&self.mono_search_key);
             if type_id.is_none() {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx.heap, ctx.arch,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 self.lay_out_memory_for_encountered_types(ctx.arch);
+            }
+        }
         Ok(())
+    }
     /// Retrieves base definition from type table. We must be able to retrieve
     /// it as we resolve all base types upon type table construction (for now).
     /// However, in the future we might do on-demand type resolving, so return
     /// an option anyway
     #[inline]
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.definition_lookup.get(&definition_id)
+    }
-    /// Returns the index into the monomorph type array if the procedure type
+    /// Returns the index into the monomorph type array if the provided type
     /// already has a (reserved) monomorph.
     #[inline]
-    pub(crate) fn get_procedure_monomorph_type_id(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<TypeId> {
+    pub(crate) fn get_monomorph_type_id(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<TypeId> {
         // Cannot use internal search key due to mutability issues. But this
         // method should end up being deprecated at some point anyway.
         debug_assert_eq!(get_concrete_type_definition(type_parts).unwrap(), *definition_id);
         let base_type = self.definition_lookup.get(definition_id).unwrap();
         let mut search_key = MonoSearchKey::with_capacity(type_parts.len());
         search_key.set(type_parts, &base_type.poly_vars);
         return self.mono_type_lookup.get(&search_key).copied();
+    }
     #[inline]
     pub(crate) fn get_monomorph(&self, type_id: TypeId) -> &MonoType {
         return &self.mono_types[type_id.0 as usize];
+    }
     /// Reserves space for a monomorph of a polymorphic procedure. The index
     /// will point into a (reserved) slot of the array of expression types. The
     /// monomorph may NOT exist yet (because the reservation implies that we're
     /// going to be performing typechecking on it, and we don't want to
     /// check the same monomorph twice)
     pub(crate) fn reserve_procedure_monomorph_type_id(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType, monomorph_index: u32) -> TypeId {
         debug_assert_eq!(get_concrete_type_definition(&concrete_type.parts).unwrap(), *definition_id);
         let type_id = TypeId(self.mono_types.len() as i64);
         let base_type = self.definition_lookup.get_mut(definition_id).unwrap();
         self.mono_search_key.set(&concrete_type.parts, &base_type.poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Procedure(ProcedureMonomorph{
             monomorph_index,
             builtin: false,
         })));
         return type_id;
+    }
     /// Adds a builtin type to the type table. As this is only called by the
     /// compiler during setup we assume it cannot fail.
     pub(crate) fn add_builtin_data_type(&mut self, concrete_type: ConcreteType, poly_vars: &[PolymorphicVariable], size: usize, alignment: usize) -> TypeId {
         self.mono_search_key.set(&concrete_type.parts, poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         debug_assert_ne!(alignment, 0);
         let type_id = TypeId(self.mono_types.len() as i64);
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType{
             type_id,
             concrete_type,
             size,
             alignment,
             variant: MonoTypeVariant::Builtin,
         });
         return type_id;
+    }
     /// Adds a builtin procedure to the type table.
     pub(crate) fn add_builtin_procedure_type(&mut self, concrete_type: ConcreteType, poly_vars: &[PolymorphicVariable]) -> TypeId {
         self.mono_search_key.set(&concrete_type.parts, poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         let type_id = TypeId(self.mono_types.len() as i64);
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType{
             type_id,
             concrete_type,
             size: 0,
             alignment: 0,
             variant: MonoTypeVariant::Procedure(ProcedureMonomorph{
                 monomorph_index: u32::MAX,
                 builtin: true,
             })
         });
         return type_id;
+    }
     /// Adds a monomorphed type to the type table. If it already exists then the
     /// previous entry will be used.
     pub(crate) fn add_monomorphed_type(
         &mut self, modules: &[Module], heap: &Heap, arch: &TargetArch, concrete_type: ConcreteType
     ) -> Result<TypeId, ParseError> {
         // Check if the concrete type was already added
         Self::set_search_key_to_type(&mut self.mono_search_key, &self.definition_lookup, &concrete_type.parts);
         if let Some(type_id) = self.mono_type_lookup.get(&self.mono_search_key) {
             return Ok(*type_id);
+        }
         // Concrete type needs to be added
         self.detect_and_resolve_type_loops_for(modules, heap, arch, concrete_type)?;
         let type_id = self.encountered_types[0].type_id;
         self.lay_out_memory_for_encountered_types(arch);
         return Ok(type_id);
+    }
     //--------------------------------------------------------------------------
     // Building base types

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -610,309 +610,309 @@ impl<'a> FunctionTester<'a> { @@
+        }
         assert!(
             outer_match_idx < module.source.input.len(),
             "[{}] Failed to find '{}' within the source that contains {}",
             self.ctx.test_name, outer_match, self.assert_postfix()
         );
         let inner_match_idx = outer_match_idx + outer_match.find(inner_match).unwrap();
         // Use the inner match index to find the expression
         let expr_id = seek_expr_in_stmt(
             &self.ctx.heap, self.def.body.upcast(),
             &|expr| expr.operation_span().begin.offset as usize == inner_match_idx
         );
         assert!(
             expr_id.is_some(),
             "[{}] Failed to find '{}' within the source that contains {} \
             (note: expression was found, but not within the specified function",
             self.ctx.test_name, outer_match, self.assert_postfix()
         );
         let expr_id = expr_id.unwrap();
         // We have the expression, call the testing function
         let tester = ExpressionTester::new(
             self.ctx, self.def.this.upcast(), &self.ctx.heap[expr_id]
         );
         f(tester);
         self
+    }
     pub(crate) fn call_ok(self, expected_result: Option<Value>) -> Self {
         use crate::protocol::*;
         let (prompt, result) = self.eval_until_end();
         match result {
             Ok(_) => {
                 assert!(
                     prompt.store.stack.len() > 0, // note: stack never shrinks
                     "[{}] No value on stack after calling function for {}",
                     self.ctx.test_name, self.assert_postfix()
                 );
             },
             Err(err) => {
                 println!("DEBUG: Formatted evaluation error:\n{}", err);
                 assert!(
                     false,
                     "[{}] Expected call to succeed, but got {:?} for {}",
                     self.ctx.test_name, err, self.assert_postfix()
+                )
+            }
+        }
         if let Some(expected_result) = expected_result {
             debug_assert!(expected_result.get_heap_pos().is_none(), "comparing against heap thingamajigs is not yet implemented");
             assert!(
                 value::apply_equality_operator(&prompt.store, &prompt.store.stack[0], &expected_result),
                 "[{}] Result from call was {:?}, but expected {:?} for {}",
                 self.ctx.test_name, &prompt.store.stack[0], &expected_result, self.assert_postfix()
+            )
+        }
         self
+    }
     // Keeping this simple for now, will likely change
     pub(crate) fn call_err(self, expected_result: &str) -> Self {
         let (_, result) = self.eval_until_end();
         match result {
             Ok(_) => {
                 assert!(
                     false,
                     "[{}] Expected an error, but evaluation finished successfully for {}",
                     self.ctx.test_name, self.assert_postfix()
                 );
             },
             Err(err) => {
                 println!("DEBUG: Formatted evaluation error:\n{}", err);
                 debug_assert_eq!(err.statements.len(), 1);
                 assert!(
                     err.statements[0].message.contains(&expected_result),
                     "[{}] Expected error message to contain '{}', but it was '{}' for {}",
                     self.ctx.test_name, expected_result, err.statements[0].message, self.assert_postfix()
                 );
+            }
+        }
         self
+    }
     fn eval_until_end(&self) -> (Prompt, Result<EvalContinuation, EvalError>) {
         use crate::protocol::*;
         // Assuming the function is not polymorphic
         let definition_id = self.def.this;
         let func_type = [ConcreteTypePart::Function(definition_id, 0)];
-        let mono_index = self.ctx.types.get_procedure_monomorph_type_id(&definition_id.upcast(), &func_type).unwrap();
+        let mono_index = self.ctx.types.get_monomorph_type_id(&definition_id.upcast(), &func_type).unwrap();
         let mut prompt = Prompt::new(&self.ctx.types, &self.ctx.heap, definition_id, mono_index, ValueGroup::new_stack(Vec::new()));
         let mut call_context = FakeRunContext{};
         loop {
             let result = prompt.step(&self.ctx.types, &self.ctx.heap, &self.ctx.modules, &mut call_context);
             match result {
                 Ok(EvalContinuation::Stepping) => {},
                 _ => return (prompt, result),
+            }
+        }
+    }
     fn assert_postfix(&self) -> String {
         format!("Function{{ name: {} }}", self.def.identifier.value.as_str())
+    }
+}
 pub(crate) struct VariableTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId,
     variable: &'a Variable,
     var_expr: &'a VariableExpression,
+}
 impl<'a> VariableTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, variable: &'a Variable, var_expr: &'a VariableExpression
     ) -> Self {
         Self{ ctx, definition_id, variable, var_expr }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected parser type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         // Lookup concrete type in type table
         let mono_proc = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let mono_index = mono_proc.monomorph_index;
         let mono_data = &self.ctx.heap[self.definition_id].as_procedure().monomorphs[mono_index as usize];
         let expr_info = &mono_data.expr_info[self.var_expr.type_index as usize];
         let concrete_type = &self.ctx.types.get_monomorph(expr_info.type_id).concrete_type;
         // Serialize and check
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!("Variable{{ name: {} }}", self.variable.identifier.value.as_str())
+    }
+}
 pub(crate) struct ExpressionTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId, // of the enclosing function/component
     expr: &'a Expression
+}
 impl<'a> ExpressionTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, expr: &'a Expression
     ) -> Self {
         Self{ ctx, definition_id, expr }
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         // Lookup concrete type
         let mono_proc = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let mono_index = mono_proc.monomorph_index;
         let mono_data = &self.ctx.heap[self.definition_id].as_procedure().monomorphs[mono_index as usize];
         let expr_info = &mono_data.expr_info[self.expr.type_index() as usize];
         let concrete_type = &self.ctx.types.get_monomorph(expr_info.type_id).concrete_type;
         // Serialize and check type
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!(
             "Expression{{ debug: {:?} }}",
             self.expr
+        )
+    }
+}
 fn get_procedure_monomorph<'a>(heap: &Heap, types: &'a TypeTable, definition_id: DefinitionId) -> &'a ProcedureMonomorph {
     let ast_definition = heap[definition_id].as_procedure();
     let func_type = if ast_definition.kind == ProcedureKind::Function {
         [ConcreteTypePart::Function(ast_definition.this, 0)]
     } else {
         [ConcreteTypePart::Component(ast_definition.this, 0)]
     };
-    let mono_index = types.get_procedure_monomorph_type_id(&definition_id, &func_type).unwrap();
+    let mono_index = types.get_monomorph_type_id(&definition_id, &func_type).unwrap();
     let mono_data = types.get_monomorph(mono_index).variant.as_procedure();
     mono_data
+}
 //------------------------------------------------------------------------------
 // Interface for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstErrTester {
     test_name: String,
     error: ParseError,
+}
 impl AstErrTester {
     fn new(test_name: String, error: ParseError) -> Self {
         Self{ test_name, error }
+    }
     pub(crate) fn error<F: Fn(ErrorTester)>(&self, f: F) {
         // Maybe multiple errors will be supported in the future
         let tester = ErrorTester{ test_name: &self.test_name, error: &self.error };
         f(tester)
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct ErrorTester<'a> {
     test_name: &'a str,
     error: &'a ParseError,
+}
 impl<'a> ErrorTester<'a> {
     pub(crate) fn assert_num(self, num: usize) -> Self {
         assert_eq!(
             num, self.error.statements.len(),
             "[{}] expected error to consist of '{}' parts, but encountered '{}' for {}",
             self.test_name, num, self.error.statements.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].context.contains(msg),
             "[{}] expected error statement {}'s context to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].message.contains(msg),
             "[{}] expected error statement {}'s message to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     /// Seeks the index of the pattern in the context message, then checks if
     /// the input position corresponds to that index.
     pub (crate) fn assert_occurs_at(self, idx: usize, pattern: &str) -> Self {
         let pos = self.error.statements[idx].context.find(pattern);
         assert!(
             pos.is_some(),
             "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",
             self.test_name, pattern, self.assert_postfix()
         );
         let pos = pos.unwrap();
         let col = self.error.statements[idx].start_column as usize;
         assert_eq!(
             pos + 1, col,
             "[{}] Expected error to occur at column {}, but found it at {} for {}",
             self.test_name, pos + 1, col, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("error: [");
         for (idx, stmt) in self.error.statements.iter().enumerate() {
             if idx != 0 {
                 v.push_str(", ");
+            }
             v.push_str(&format!("{{ context: {}, message: {} }}", &stmt.context, stmt.message));
+        }

src/runtime2/component/component.rs

➞

Show inline comments

 use crate::protocol::eval::{Prompt, EvalError, ValueGroup, PortId as EvalPortId};
 use crate::protocol::*;
 use crate::runtime2::*;
 use crate::runtime2::communication::*;
 use super::{CompCtx, CompPDL};
 use super::component_context::*;
 use super::component_random::*;
 use super::control_layer::*;
 use super::consensus::*;
 pub enum CompScheduling {
     Immediate,
     Requeue,
     Sleep,
     Exit,
+}
 /// Generic representation of a component (as viewed by a scheduler).
 pub(crate) trait Component {
     /// Called upon the creation of the component.
     fn on_creation(&mut self, sched_ctx: &SchedulerCtx);
     /// Called if the component is created by another component and the messages
     /// are being transferred between the two.
     fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage);
     /// Called if the component receives a new message. The component is
     /// responsible for deciding where that messages goes.
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message);
     /// Called if the component's routine should be executed. The return value
     /// can be used to indicate when the routine should be run again.
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError>;
+}
 /// Representation of the generic operating mode of a component.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) enum CompMode {
     NonSync, // not in sync mode
     Sync, // in sync mode, can interact with other components
     SyncEnd, // awaiting a solution, i.e. encountered the end of the sync block
     BlockedGet, // blocked because we need to receive a message on a particular port
     BlockedPut, // component is blocked because the port is blocked
     BlockedSelect, // waiting on message to complete the select statement
     StartExit, // temporary state: if encountered then we start the shutdown process
     BusyExit, // temporary state: waiting for Acks for all the closed ports
     Exit, // exiting: shutdown process started, now waiting until the reference count drops to 0
+}
 impl CompMode {
     pub(crate) fn is_in_sync_block(&self) -> bool {
         use CompMode::*;
         match self {
             Sync | SyncEnd | BlockedGet | BlockedPut | BlockedSelect => true,
             NonSync | StartExit | BusyExit | Exit => false,
+        }
+    }
+}
 /// Component execution state: the execution mode along with some descriptive
 /// fields. Fields are public for ergonomic reasons, use member functions when
 /// appropriate.
 pub(crate) struct CompExecState {
     pub mode: CompMode,
     pub mode_port: PortId, // valid if blocked on a port (put/get)
     pub mode_value: ValueGroup, // valid if blocked on a put
+}
 impl CompExecState {
     pub(crate) fn new() -> Self {
         return Self{
             mode: CompMode::NonSync,
             mode_port: PortId::new_invalid(),
             mode_value: ValueGroup::default(),
+        }
+    }
     pub(crate) fn set_as_blocked_get(&mut self, port: PortId) {
         self.mode = CompMode::BlockedGet;
         self.mode_port = port;
         debug_assert!(self.mode_value.values.is_empty());
+    }
     pub(crate) fn is_blocked_on_get(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedGet &&
             self.mode_port == port;
+    }
     pub(crate) fn set_as_blocked_put(&mut self, port: PortId, value: ValueGroup) {
         self.mode = CompMode::BlockedPut;
         self.mode_port = port;
         self.mode_value = value;
+    }
     pub(crate) fn is_blocked_on_put(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedPut &&
             self.mode_port == port;
+    }
+}
 /// Creates a new component based on its definition. Meaning that if it is a
 /// user-defined component then we set up the PDL code state. Otherwise we
 /// construct a custom component. This does NOT take care of port and message
 /// management.
 pub(crate) fn create_component(
     protocol: &ProtocolDescription,
     definition_id: ProcedureDefinitionId, type_id: TypeId,
     arguments: ValueGroup, num_ports: usize
 ) -> Box<dyn Component> {
     let definition = &protocol.heap[definition_id];
     debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite);
     if definition.source.is_builtin() {
         // Builtin component
         let component = match definition.source {

src/runtime2/component/component_internet.rs

➞

Show inline comments

 use crate::protocol::eval::{ValueGroup, Value, EvalError};
 use crate::runtime2::*;
 use crate::runtime2::component::CompCtx;
 use crate::runtime2::stdlib::internet::*;
 use super::component::{self, *};
 use super::control_layer::*;
 use super::consensus::*;
 use std::io::ErrorKind as IoErrorKind;
 enum SocketState {
     Connected(SocketTcpClient),
     Error,
+}
 impl SocketState {
     fn get_socket(&self) -> &SocketTcpClient {
         match self {
             SocketState::Connected(v) => v,
             SocketState::Error => unreachable!(),
+        }
+    }
+}
 /// States from the point of view of the component that is connecting to this
 /// TCP component (i.e. from the point of view of attempting to interface with
 /// a socket).
 enum SyncState {
     AwaitingCmd,
     Getting,
     Putting
+}
 pub struct ComponentTcpClient {
     // Properties for the tcp socket
     socket_state: SocketState,
     sync_state: SyncState,
     pending_recv: Vec<DataMessage>, // on the input port
     pdl_input_port_id: PortId, // input from PDL, so transmitted over socket
     pdl_output_port_id: PortId, // output towards PDL, so received over socket
     input_union_send_tag_value: i64,
     input_union_receive_tag_value: i64,
     input_union_finish_tag_value: i64,
     // Generic component state
     exec_state: CompExecState,
     control: ControlLayer,
     consensus: Consensus,
     // Temporary variables
     byte_buffer: Vec<u8>,
+}
 impl Component for ComponentTcpClient {
     fn on_creation(&mut self, sched_ctx: &SchedulerCtx) {
         let pd = &sched_ctx.runtime.protocol;
         let cmd_type = pd.find_type(b"std.internet", b"Cmd")
             .expect("'Cmd' type in the 'std.internet' module")
             .as_union();
         self.input_union_send_tag_value = cmd_type.get_variant_tag_value(b"Send").unwrap();
         self.input_union_receive_tag_value = cmd_type.get_variant_tag_value(b"Receive").unwrap();
         self.input_union_finish_tag_value = cmd_type.get_variant_tag_value(b"Finish").unwrap();
+    }
     fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, message: DataMessage) {
         self.handle_incoming_data_message(message);
+    }
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message) {
         match mesage {
             Message::Data(message) => {
                 self.handle_incoming_data_message(message);
             },
             Message::Sync(message) => {
                 let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);
                 component::default_handle_sync_decision(&mut self.exec_state, decision, &mut self.consensus);
             },
             Message::Control(message) => {
                 component::default_handle_control_message(
                     &mut self.exec_state, &mut self.control, &mut self.consensus,
                     message, sched_ctx, comp_ctx
                 );
+            }
+        }
+    }
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError> {
         sched_ctx.log(&format!("Running component ComponentTcpClient (mode: {:?}", self.exec_state.mode));
         match self.exec_state.mode {
             CompMode::BlockedGet | CompMode::BlockedSelect => {
                 // impossible for this component. We always accept the input
                 // values, and we never perform an explicit select.
             CompMode::BlockedSelect => {
                 // Not possible: we never enter this state
                 unreachable!();
             },
             CompMode::NonSync => {
                 // When in non-sync mode
                 match &mut self.socket_state {
                     SocketState::Connected(socket) => {
                         if self.pending_tx
                     SocketState::Connected(_socket) => {
                         // Always move into the sync-state
                         self.sync_state = SyncState::AwaitingCmd;
                         self.consensus.notify_sync_start(comp_ctx);
                         self.exec_state.mode = CompMode::Sync;
                     },
                     SocketState::Error => {
                         // Could potentially send an error message to the
                         // connected component.
                         self.exec_state.mode = CompMode::StartExit;
                         return Ok(CompScheduling::Immediate);
+                    }
+                }
             },
             CompMode::Sync => {
                 // When in sync mode: wait for a command to come in
                 match self.sync_state {
                     SyncState::AwaitingCmd => {
                         if let Some(message) = self.pending_recv.pop() {
                             if self.consensus.try_receive_data_message(sched_ctx, comp_ctx, &message) {
                                 // Check which command we're supposed to execute.
                                 let (tag_value, embedded_heap_pos) = message.content.values[0].as_union();
                                 if tag_value == self.input_union_send_tag_value {
                                     // Retrieve bytes from the message
                                     self.byte_buffer.clear();
                                     let union_content = &message.content.regions[embedded_heap_pos as usize];
                                     debug_assert_eq!(union_content.len(), 1);
                                     let array_heap_pos = union_content[0].as_array();
                                     let array_values = &message.content.regions[array_heap_pos as usize];
                                     self.byte_buffer.reserve(array_values.len());
                                     for value in array_values {
                                         self.byte_buffer.push(value.as_uint8());
+                                    }
                                     self.sync_state = SyncState::Putting;
                                     return Ok(CompScheduling::Immediate);
                                 } else if tag_value == self.input_union_receive_tag_value {
                                     // Component requires a `recv`
                                     self.sync_state = SyncState::Getting;
                                     return Ok(CompScheduling::Immediate);
                                 } else if tag_value == self.input_union_finish_tag_value {
                                     // Component requires us to end the sync round
                                     let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
                                     component::default_handle_sync_decision(&mut self.exec_state, decision, &mut self.consensus);
+                                }
                             } else {
                                 todo!("handle sync failure due to message deadlock");
                                 return Ok(CompScheduling::Sleep);
+                            }
                         } else {
                             self.exec_state.set_as_blocked_get(self.pdl_input_port_id);
                             return Ok(CompScheduling::Sleep);
+                        }
                     },
                     SyncState::Putting => {
                         // We're supposed to send a user-supplied message fully
                         // over the socket. But we might end up blocking. In
                         // that case the component goes to sleep until it is
                         // polled.
                         let socket = self.socket_state.get_socket();
                         while !self.byte_buffer.is_empty() {
                             match socket.send(&self.byte_buffer) {
                                 Ok(bytes_sent) => {
                                     self.byte_buffer.drain(..bytes_sent);
                                 },
                                 Err(err) => {
                                     if err.kind() == IoErrorKind::WouldBlock {
                                         return Ok(CompScheduling::Sleep); // wait until notified
                                     } else {
                                         todo!("handle socket.send error {:?}", err)
+                                    }
+                                }
+                            }
+                        }
                         // If here then we're done putting the data, we can
                         // finish the sync round
                         let decision = self.consensus.notify_sync_end(sched_ctx, comp_ctx);
                         component::default_handle_sync_decision(&mut self.exec_state, decision, &mut self.consensus);
                     },
                     SyncState::Getting => {
                         // We're going to try and receive a single message. If
                         // this causes us to end up blocking the component
                         // goes to sleep until it is polled.
                         const BUFFER_SIZE: usize = 1024; // TODO: Move to config
                         let socket = self.socket_state.get_socket();
                         debug_assert!(self.byte_buffer.is_empty());
                         self.byte_buffer.resize(BUFFER_SIZE, 0);
                         match socket.receive(&mut self.byte_buffer) {
                             Ok(num_received) => {
                                 self.byte_buffer.resize(num_received);
                                 let message_content = self.bytes_to_data_message_content(&self.byte_buffer);
                                 let port_handle = comp_ctx.get_port_handle(self.pdl_output_port_id);
                                 let port_info = comp_ctx.get_port(port_handle);
                                 let message = self.consensus.annotate_data_message(comp_ctx, port_info, message_content);
                             },
                             Err(err) => {
                                 if err.kind() == IoErrorKind::WouldBlock {
                                     return Ok(CompScheduling::Sleep); // wait until polled
                                 } else {
                                     todo!("handle socket.receive error {:?}", err);
+                                }
+                            }
+                        }
                     },
+                }
             },
             CompMode::BlockedGet => {
                 // Entered when awaiting a new command
                 debug_assert_eq!(self.sync_state, SyncState::AwaitingCmd);
                 if self.
             },
             CompMode::SyncEnd | CompMode::BlockedPut =>
                 return Ok(CompScheduling::Sleep),
             CompMode::StartExit =>
                 return Ok(component::default_handle_start_exit(&mut self.exec_state, &mut self.control, sched_ctx, comp_ctx)),
             CompMode::BusyExit =>
                 return Ok(component::default_handle_busy_exit(&mut self.exec_state, &mut self.control, sched_ctx)),
             CompMode::Exit =>
                 return Ok(component::default_handle_exit(&self.exec_state)),
+        }
         return Ok(CompScheduling::Immediate);
+    }
+}
 impl ComponentTcpClient {
     pub(crate) fn new(arguments: ValueGroup) -> Self {
         use std::net::{IpAddr, Ipv4Addr};
         debug_assert_eq!(arguments.values.len(), 4);
         // Parsing arguments
         let ip_heap_pos = arguments.values[0].as_array();
         let ip_elements = &arguments.regions[ip_heap_pos as usize];
         if ip_elements.len() != 4 {
             todo!("friendly error reporting: ip contains 4 octects");
+        }
         let ip_address = IpAddr::V4(Ipv4Addr::new(
             ip_elements[0].as_uint8(), ip_elements[1].as_uint8(),
             ip_elements[2].as_uint8(), ip_elements[3].as_uint8()
         ));
         let port = arguments.values[1].as_uint16();
         let input_port = component::port_id_from_eval(arguments.values[2].as_input());
         let output_port = component::port_id_from_eval(arguments.values[3].as_output());
         let socket = SocketTcpClient::new(ip_address, port);
         if let Err(socket) = socket {
             todo!("friendly error reporting: failed to open socket {:?}", socket);
+        }
         return Self{
             socket_state: SocketState::Connected(socket.unwrap()),
             pending_tx: Vec::new(),
             input_union_send_tag_value: -1,
             input_union_receive_tag_value: -1,
             input_union_finish_tag_value: -1,
             pdl_input_port_id: input_port,
             pdl_output_port_id: output_port,
             exec_state: CompExecState::new(),
             control: ControlLayer::default(),
             consensus: Consensus::new(),
+        }
+    }
     // Handles incoming data from the PDL side (hence, going into the socket)
     fn handle_incoming_data_message(&mut self, message: DataMessage) {
         // Input message is an array of bytes (u8)
         self.pending_recv.push(message);
+    }
     fn data_message_to_bytes(&self, message: DataMessage, bytes: &mut Vec<u8>) {
         debug_assert_eq!(message.data_header.target_port, self.pdl_input_port_id);
         debug_assert_eq!(message.content.values.len(), 1);
         if let Value::Array(array_pos) = message.content.values[0] {
             let region = &message.content.regions[array_pos as usize];
             bytes.reserve(region.len());
             for value in region {
                 bytes.push(value.as_uint8());
+            }
         } else {
             unreachable!();
+        }
+    }
     fn bytes_to_data_message_content(&self, buffer: &[u8]) -> ValueGroup {
         // Turn bytes into silly executor-style array
         let mut values = Vec::with_capacity(buffer.len());
         for byte in buffer.iter().copied() {
             values.push(Value::UInt8(byte));
+        }
         // Put in a value group
         let mut value_group = ValueGroup::default();
         value_group.regions.push(values);
         value_group.values.push(Value::Array(0));
         return value_group;
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/stdlib/internet.rs

➞

Show inline comments

 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::mem::size_of;
 use std::io::{Error as IoError, ErrorKind as IoErrorKind};
 use libc::{
     c_int,
     sockaddr_in, sockaddr_in6, in_addr, in6_addr,
     socket, bind, listen, accept, connect, close,
 };
 use mio::{event, Interest, Registry, Token};
 #[derive(Debug)]
 pub enum SocketError {
     Opening,
     Modifying,
     Binding,
     Listening,
     Connecting,
     Accepted,
     Accepting,
+}
 enum SocketState {
     Opened,
     Listening,
+}
 /// TCP connection
 pub struct SocketTcpClient {
     socket_handle: libc::c_int,
     is_blocking: bool,
+}
 impl SocketTcpClient {
     pub fn new(ip: IpAddr, port: u16) -> Result<Self, SocketError> {
         const BLOCKING: bool = false;
         let socket_handle = create_and_connect_socket(
             libc::SOCK_STREAM, libc::IPPROTO_TCP, ip, port
         )?;
         if !set_socket_blocking(socket_handle, BLOCKING) {
             unsafe{ libc::close(socket_handle); }
             return Err(SocketError::Modifying);
+        }
         return Ok(SocketTcpClient{
             socket_handle,
             is_blocking: BLOCKING,
         })
+    }
-    pub fn send(&self, message: &[u8]) -> Result<usize, ()> {
+    pub fn send(&self, message: &[u8]) -> Result<usize, IoError> {
         let result = unsafe{
             let message_pointer = message.as_ptr().cast();
             libc::send(self.socket_handle, message_pointer, message.len() as libc::size_t, 0)
         };
         if result < 0 {
             return Err(())
+            return Err(IoError::last_os_error());
+        }
         return Ok(result as usize);
+    }
     /// Receives data from the TCP socket. Returns the number of bytes received.
     /// More bytes may be present even thought `used < buffer.len()`.
     pub fn receive(&self, buffer: &mut [u8]) -> Result<usize, IoError> {
         if self.is_blocking {
             return self.receive_blocking(buffer);
         } else {
             return self.receive_nonblocking(buffer);
+        }
+    }
     #[inline]
     fn receive_blocking(&self, buffer: &mut [u8]) -> Result<usize, IoError> {
         let result = unsafe {
             let message_pointer = buffer.as_mut_ptr().cast();
             libc::recv(self.socket_handle, message_pointer, buffer.len(), 0)
         };
         if result < 0 {
             return Err(IoError::last_os_error());
+        }
         return Ok(result as usize);
+    }
     #[inline]
     fn receive_nonblocking(&self, buffer: &mut [u8]) -> Result<usize, IoError> {
         unsafe {
             let mut message_pointer = buffer.as_mut_ptr().cast();
             let mut remaining = buffer.len();
             loop {
                 // Receive more data
                 let result = libc::recv(self.socket_handle, message_pointer, remaining, 0);
                 if result < 0 {
                     // Check reason
                     let os_error = IoError::last_os_error();
                     if os_error.kind() == IoErrorKind::WouldBlock {
                         return Ok(buffer.len() - remaining);
                     } else {
                         return Err(os_error);
+                    }
+                }
                 // Modify pointer and remaining bytes
                 let received = result as usize;
                 message_pointer = message_pointer.add(received);
                 remaining -= received;
                 if remaining == 0 {
                     return Ok(buffer.len());
+                }
+            }
+        }
+    }
+}
 impl Drop for SocketTcpClient {
     fn drop(&mut self) {
         debug_assert!(self.socket_handle >= 0);
         unsafe{ close(self.socket_handle) };
+    }
+}
 /// Raw socket receiver. Essentially a listener that accepts a single connection
 struct SocketRawRx {
     listen_handle: c_int,
     accepted_handle: c_int,
+}
 impl SocketRawRx {
     pub fn new(ip: Option<Ipv4Addr>, port: u16) -> Result<Self, SocketError> {
         let ip = ip.unwrap_or(Ipv4Addr::UNSPECIFIED); // unspecified is the same as INADDR_ANY
         let address = unsafe{ in_addr{
             s_addr: std::mem::transmute(ip.octets()),
         }};
         let socket_address = sockaddr_in{
             sin_family: libc::AF_INET as libc::sa_family_t,
             sin_port: htons(port),
             sin_addr: address,
             sin_zero: [0; 8],
         };
         unsafe {
             let socket_handle = create_and_bind_socket(libc::SOCK_RAW, 0, IpAddr::V4(ip), port)?;
             let result = listen(socket_handle, 3);
             if result < 0 { return Err(SocketError::Listening); }
             return Ok(SocketRawRx{
                 listen_handle: socket_handle,
                 accepted_handle: -1,
             });
+        }
+    }
     // pub fn try_accept(&mut self, timeout_ms: u32) -> Result<(), SocketError> {
     //     if self.accepted_handle >= 0 {
     //         // Already accepted a connection
     //         return Err(SocketError::Accepted);
     //     }
     //
     //     let mut socket_address = sockaddr_in{
     //         sin_family: 0,
     //         sin_port: 0,
     //         sin_addr: in_addr{ s_addr: 0 },
     //         sin_zero: [0; 8]
     //     };
     //     let mut size = size_of::<sockaddr_in>() as u32;
     //     unsafe {
     //         let result = accept(self.listen_handle, &mut socket_address as *mut _, &mut size as *mut _);
     //         if result < 0 {
     //             return Err(SocketError::Accepting);
     //         }
     //     }
     //
     //     return Ok(());
     // }
+}
 impl Drop for SocketRawRx {
     fn drop(&mut self) {
         if self.accepted_handle >= 0 {
             unsafe {
                 close(self.accepted_handle);
+            }
+        }
         if self.listen_handle >= 0 {
             unsafe {
                 close(self.listen_handle);
+            }
+        }
+    }
+}
 // The following is essentially stolen from `mio`'s io_source.rs file.
 #[cfg(unix)]
 trait AsRawFileDescriptor {
     fn as_raw_file_descriptor(&self) -> c_int;
+}
 impl AsRawFileDescriptor for SocketTcpClient {
     fn as_raw_file_descriptor(&self) -> c_int {
         return self.socket_handle;
+    }
+}
 /// Performs the `socket` and `bind` calls.
 fn create_and_bind_socket(socket_type: libc::c_int, protocol: libc::c_int, ip: IpAddr, port: u16) -> Result<libc::c_int, SocketError> {
     let family = socket_family_from_ip(ip);
         if result < 0 {
             close(socket_handle);
             return Err(SocketError::Connecting);
+        }
         return Ok(socket_handle);
+    }
+}
 #[inline]
 fn create_sockaddr_in_v4(ip: Ipv4Addr, port: u16) -> (sockaddr_in, libc::socklen_t) {
     let address = unsafe{
         in_addr{
             s_addr: std::mem::transmute(ip.octets())
+        }
     };
     let socket_address = sockaddr_in{
         sin_family: libc::AF_INET as libc::sa_family_t,
         sin_port: htons(port),
         sin_addr: address,
         sin_zero: [0; 8]
     };
     let address_size = size_of::<sockaddr_in>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn create_sockaddr_in_v6(ip: Ipv6Addr, port: u16) -> (sockaddr_in6, libc::socklen_t) {
     // flow label is advised to be, according to RFC6437 a (somewhat
     // secure) random number taken from a uniform distribution
     let flow_info = rand::random();
     let address = unsafe{
         in6_addr{
             s6_addr: ip.octets()
+        }
     };
     let socket_address = sockaddr_in6{
         sin6_family: libc::AF_INET6 as libc::sa_family_t,
         sin6_port: htons(port),
         sin6_flowinfo: flow_info,
         sin6_addr: address,
         sin6_scope_id: 0, // incorrect in case of loopback address
     };
     let address_size = size_of::<sockaddr_in6>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn set_socket_blocking(handle: libc::c_int, blocking: bool) -> bool {
     if handle < 0 {
         return false;
+    }
     unsafe{
         let mut flags = libc::fcntl(handle, libc::F_GETFL, 0);
         if flags < 0 {
             return false;
+        }
         if blocking {
             flags &= !libc::O_NONBLOCK;
         } else {
             flags |= libc::O_NONBLOCK;
+        }
         let result = libc::fcntl(handle, libc::F_SETFL, flags);
         if result < 0 {
             return false;
+        }
+    }
     return true;
+}
 #[inline]
 fn socket_family_from_ip(ip: IpAddr) -> libc::c_int {
     return match ip {
         IpAddr::V4(_) => libc::AF_INET,
         IpAddr::V6(_) => libc::AF_INET6,
     };
+}
 #[inline]
 fn htons(port: u16) -> u16 {
     return port.to_be();
+}
 mod tests {
     use std::net::*;
     use super::*;
     #[test]
     fn test_inet_thingo() {
         const SIZE: usize = 1024;
         let s = SocketTcpClient::new(IpAddr::V4(Ipv4Addr::new(142, 250, 179, 163)), 80).expect("connect");
         s.send(b"GET / HTTP/1.1\r\n\r\n").expect("sending");
         let mut total = Vec::<u8>::new();
         let mut buffer = [0; SIZE];
         let mut received = SIZE;
         while received > 0 {
             received = s.receive(&mut buffer).expect("receiving");
             println!("DEBUG: Received {} bytes", received);
             total.extend_from_slice(&buffer[..received]);
+        }
         let as_str = String::from_utf8_lossy(total.as_slice());
         println!("Yay! Got {} bytes:\n{}", as_str.len(), as_str);
+    }
     // #[test] @nocommit Remove this
     // fn test_inet_thingo() {
     //     const SIZE: usize = 1024;
     //
     //     let s = SocketTcpClient::new(IpAddr::V4(Ipv4Addr::new(142, 250, 179, 163)), 80).expect("connect");
     //     s.send(b"GET / HTTP/1.1\r\n\r\n").expect("sending");
     //     let mut total = Vec::<u8>::new();
     //     let mut buffer = [0; SIZE];
     //     let mut received = SIZE;
     //
     //     while received > 0 {
     //         received = s.receive(&mut buffer).expect("receiving");
     //         println!("DEBUG: Received {} bytes", received);
     //         total.extend_from_slice(&buffer[..received]);
     //     }
     //     let as_str = String::from_utf8_lossy(total.as_slice());
     //     println!("Yay! Got {} bytes:\n{}", as_str.len(), as_str);
     // }
+}
@@ \ No newline at end of file @@

std/std.internet.pdl

➞

Show inline comments

 #module std.internet
 primitive tcp_client(u8[] ip, u16 port, in<u8[]> tx, out<u8[]> rx) {
 union Cmd {
     Send(u8[]),
     Receive,
     Finish,
+}
 primitive tcp_client(u8[] ip, u16 port, in<Cmd> cmds, out<u8[]> rx) {
     #builtin
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)