CSY/reowolf Changeset - 3f236d37dad1 · Centrum Wiskunde & Informatica (CWI)

Changeset - 3f236d37dad1

Parent rev.

Child rev.

[Not reviewed]

0 7 1

Christopher Esterhuyse - 5 years ago 2020-06-18 17:47:26
christopher.esterhuyse@gmail.com

pulled out arena-id dependency in favour of custom (minimal) impl, and to finish making component states serializable with serde

8 files changed with 114 insertions and 35 deletions:

Cargo.toml

README.md

src/common.rs

src/protocol/arena.rs

src/protocol/ast.rs

src/protocol/eval.rs

src/protocol/mod.rs

src/runtime/mod.rs

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

@@ @@ -4,36 +4,37 @@ version = "0.1.3" @@
 authors = [
 	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",
 	"Hans-Dieter Hiep <hdh@cwi.nl>"
+]
 edition = "2018"
 [dependencies]
 # convenience macros
 maplit = "1.0.2"
 derive_more = "0.99.2"
 # runtime
 serde = { version = "1.0.112", features = ["derive"] }
 getrandom = "0.1.14" # tiny crate. used to guess controller-id
 take_mut = "0.2.2"
 indexmap = "1.3.0" # hashsets/hashmaps with efficient arbitrary element removal
 # network
 integer-encoding = "1.0.7"
 byteorder = "1.3.2"
 mio = "0.6.21" # migrate to mio v0.7.0 when it stabilizes
 mio-extras = "2.0.6"
 # protocol
 id-arena = "2.2.1"
+# id-arena = "2.2.1"
 backtrace = "0.3"
 [dev-dependencies]
 test-generator = "0.3.0"
 crossbeam-utils = "0.7.0"
 lazy_static = "1.4.0"
 [lib]
 # compile target: dynamically linked library using C ABI
 crate-type = ["cdylib"]
 [features]

README.md

➞

Show inline comments

 # Reowolf Implementation
+# Reowolf 1.0 Implementation
 ## Compilation instructions
 . Install the latest stable Rust toolchain using Rustup. See https://rustup.rs/ for further instructions.
 . Run `cargo build --release` to download source dependencies, and compile the library with release-level optimizations.
 	- The resulting dylib can be found in target/release/, to be used with the header file reowolf.h.
 	- Note: A list of immediate ancestor dependencies is visible in Cargo.toml.
 	- Note: Run `cargo test --release` to run unit tests with release-level optimizations.
 . Install the Rust toolchain, using Rustup. See https://rustup.rs/ for further instructions.
 . Run `cargo test` to download dependencies, compile the project, and run the tests.
 ## Structure
 - The user-facing API is visible in src/runtime/connector.rs

src/common.rs

➞

Show inline comments

@@ @@ -26,41 +26,53 @@ pub use Polarity::*; @@
 pub type ControllerId = u32;
 pub type ChannelIndex = u32;
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd)]
 pub struct PortId {
     pub(crate) controller_id: ControllerId,
     pub(crate) port_index: u32,
+}
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Payload(Arc<Vec<u8>>);
 impl serde::Serialize for Payload {
     fn serialize<S>(
         &self,
         serializer: S,
     ) -> std::result::Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
     where
         S: serde::Serializer,
+    {
         let inner: &Vec<u8> = &self.0;
         inner.serialize(serializer)
+    }
+}
 /// This is a unique identifier for a channel (i.e., port).
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 pub struct ChannelId {
     pub(crate) controller_id: ControllerId,
     pub(crate) channel_index: ChannelIndex,
+}
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
+}
 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone)]
+#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone, serde::Serialize)]
 #[repr(C)]
-pub struct Port(pub usize); // ports are COPY
+pub struct Port(pub u32); // ports are COPY
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
 pub enum MainComponentErr {
     NoSuchComponent,
     NonPortTypeParameters,
     CannotMovePort(Port),
     WrongNumberOfParamaters { expected: usize },
     UnknownPort(Port),
     WrongPortPolarity { param_index: usize, port: Port },
     DuplicateMovedPort(Port),
+}
 pub trait ProtocolDescription: Sized {
@@ @@ -148,25 +160,25 @@ impl std::iter::FromIterator<u8> for Payload { @@
+}
 impl From<Vec<u8>> for Payload {
     fn from(s: Vec<u8>) -> Self {
         Self(s.into())
+    }
+}
 impl Debug for Port {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(f, "Port({})", self.0)
+    }
+}
 impl Port {
-    pub fn from_raw(raw: usize) -> Self {
+    pub fn from_raw(raw: u32) -> Self {
         Self(raw)
+    }
-    pub fn to_raw(self) -> usize {
+    pub fn to_raw(self) -> u32 {
         self.0
+    }
     pub fn to_token(self) -> mio::Token {
         mio::Token(self.0.try_into().unwrap())
+    }
     pub fn from_token(t: mio::Token) -> Self {
         Self(t.0.try_into().unwrap())
+    }
+}

src/protocol/arena.rs

➞

Show inline comments

@@ new file 100644 @@
 use core::hash::Hash;
 use core::marker::PhantomData;
 #[derive(Debug, serde::Serialize)]
 pub struct Id<T> {
     index: u32,
     _phantom: PhantomData<T>,
+}
 impl<T> Clone for Id<T> {
     fn clone(&self) -> Self {
         *self
+    }
+}
 impl<T> Copy for Id<T> {}
 impl<T> PartialEq for Id<T> {
     fn eq(&self, other: &Self) -> bool {
         self.index.eq(&other.index)
+    }
+}
 impl<T> Eq for Id<T> {}
 impl<T> Hash for Id<T> {
     fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
         self.index.hash(h);
+    }
+}
 pub struct Arena<T> {
     store: Vec<T>,
+}
 impl<T> Arena<T> {
     pub fn new() -> Self {
         Self { store: vec![] }
+    }
     pub fn alloc_with_id(&mut self, f: impl FnOnce(Id<T>) -> T) -> Id<T> {
         use std::convert::TryFrom;
         let id = Id {
             index: u32::try_from(self.store.len()).expect("Out of capacity!"),
             _phantom: Default::default(),
         };
         self.store.push(f(id));
         id
+    }
     pub fn iter(&self) -> impl Iterator<Item = (Id<T>, &T)> {
         (0..).map(|index| Id { index, _phantom: Default::default() }).zip(self.store.iter())
+    }
+}
 impl<T> core::ops::Index<Id<T>> for Arena<T> {
     type Output = T;
     fn index(&self, id: Id<T>) -> &Self::Output {
         self.store.index(id.index as usize)
+    }
+}
 impl<T> core::ops::IndexMut<Id<T>> for Arena<T> {
     fn index_mut(&mut self, id: Id<T>) -> &mut Self::Output {
         self.store.index_mut(id.index as usize)
+    }
+}

src/protocol/ast.rs

➞

Show inline comments

 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
-use id_arena::{Arena, Id};
+use super::arena::{Arena, Id};
 use crate::protocol::inputsource::*;
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct RootId(Id<Root>);
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PragmaId(Id<Pragma>);
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ImportId(Id<Import>);
@@ @@ -30,46 +30,46 @@ impl SourceIdentifierId { @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ExternalIdentifierId(IdentifierId);
 impl ExternalIdentifierId {
     pub fn upcast(self) -> IdentifierId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TypeAnnotationId(Id<TypeAnnotation>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 pub struct VariableId(Id<Variable>);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ParameterId(VariableId);
 impl ParameterId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct LocalId(VariableId);
 impl LocalId {
     pub fn upcast(self) -> VariableId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct DefinitionId(Id<Definition>);
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ComponentId(DefinitionId);
 impl ComponentId {
     pub fn upcast(self) -> DefinitionId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ @@ -90,25 +90,25 @@ impl CompositeId { @@
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PrimitiveId(ComponentId);
 impl PrimitiveId {
     pub fn upcast(self) -> ComponentId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 pub struct StatementId(Id<Statement>);
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct BlockStatementId(StatementId);
 impl BlockStatementId {
     pub fn upcast(self) -> StatementId {
         self.0
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq)]

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -19,25 +19,25 @@ const SHORT_MAX: i64 = i16::MAX as i64; @@
 const INT_MIN: i64 = i32::MIN as i64;
 const INT_MAX: i64 = i32::MAX as i64;
 const MESSAGE_MAX_LENGTH: i64 = SHORT_MAX;
 const ONE: Value = Value::Byte(ByteValue(1));
 trait ValueImpl {
     fn exact_type(&self) -> Type;
     fn is_type_compatible(&self, t: &Type) -> bool;
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub enum Value {
     Input(InputValue),
     Output(OutputValue),
     Message(MessageValue),
     Boolean(BooleanValue),
     Byte(ByteValue),
     Short(ShortValue),
     Int(IntValue),
     Long(LongValue),
     InputArray(InputArrayValue),
     OutputArray(OutputArrayValue),
     MessageArray(MessageArrayValue),
@@ @@ -876,75 +876,75 @@ impl Display for Value { @@
             Value::OutputArray(val) => disp = val,
             Value::MessageArray(val) => disp = val,
             Value::BooleanArray(val) => disp = val,
             Value::ByteArray(val) => disp = val,
             Value::ShortArray(val) => disp = val,
             Value::IntArray(val) => disp = val,
             Value::LongArray(val) => disp = val,
+        }
         disp.fmt(f)
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct InputValue(pub Port);
 impl Display for InputValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#in")
+    }
+}
 impl ValueImpl for InputValue {
     fn exact_type(&self) -> Type {
         Type::INPUT
+    }
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Input => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct OutputValue(pub Port);
 impl Display for OutputValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#out")
+    }
+}
 impl ValueImpl for OutputValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT
+    }
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Output => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct MessageValue(pub Option<Payload>);
 impl Display for MessageValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.0 {
             None => write!(f, "null"),
             Some(payload) => {
                 // format print up to 10 bytes
                 let mut slice = payload.as_slice();
                 if slice.len() > 10 {
                     slice = &slice[..10];
+                }
@@ @@ -961,25 +961,25 @@ impl ValueImpl for MessageValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Message => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct BooleanValue(bool);
 impl Display for BooleanValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for BooleanValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN
+    }
@@ @@ -990,25 +990,25 @@ impl ValueImpl for BooleanValue { @@
+        }
         match primitive {
             PrimitiveType::Boolean => true,
             PrimitiveType::Byte => true,
             PrimitiveType::Short => true,
             PrimitiveType::Int => true,
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ByteValue(i8);
 impl Display for ByteValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ByteValue {
     fn exact_type(&self) -> Type {
         Type::BYTE
+    }
@@ @@ -1018,25 +1018,25 @@ impl ValueImpl for ByteValue { @@
             return false;
+        }
         match primitive {
             PrimitiveType::Byte => true,
             PrimitiveType::Short => true,
             PrimitiveType::Int => true,
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ShortValue(i16);
 impl Display for ShortValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ShortValue {
     fn exact_type(&self) -> Type {
         Type::SHORT
+    }
@@ @@ -1045,25 +1045,25 @@ impl ValueImpl for ShortValue { @@
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Short => true,
             PrimitiveType::Int => true,
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct IntValue(i32);
 impl Display for IntValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for IntValue {
     fn exact_type(&self) -> Type {
         Type::INT
+    }
@@ @@ -1071,50 +1071,50 @@ impl ValueImpl for IntValue { @@
         let Type { primitive, array } = t;
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Int => true,
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct LongValue(i64);
 impl Display for LongValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for LongValue {
     fn exact_type(&self) -> Type {
         Type::LONG
+    }
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if *array {
             return false;
+        }
         match primitive {
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct InputArrayValue(Vec<InputValue>);
 impl Display for InputArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1130,25 +1130,25 @@ impl ValueImpl for InputArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Input => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct OutputArrayValue(Vec<OutputValue>);
 impl Display for OutputArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1164,25 +1164,25 @@ impl ValueImpl for OutputArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Output => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct MessageArrayValue(Vec<MessageValue>);
 impl Display for MessageArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1198,25 +1198,25 @@ impl ValueImpl for MessageArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Message => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct BooleanArrayValue(Vec<BooleanValue>);
 impl Display for BooleanArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1232,25 +1232,25 @@ impl ValueImpl for BooleanArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Boolean => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ByteArrayValue(Vec<ByteValue>);
 impl Display for ByteArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1266,25 +1266,25 @@ impl ValueImpl for ByteArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Byte => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ShortArrayValue(Vec<ShortValue>);
 impl Display for ShortArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1300,25 +1300,25 @@ impl ValueImpl for ShortArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Short => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct IntArrayValue(Vec<IntValue>);
 impl Display for IntArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1334,25 +1334,25 @@ impl ValueImpl for IntArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Int => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct LongArrayValue(Vec<LongValue>);
 impl Display for LongArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
@@ @@ -1368,25 +1368,25 @@ impl ValueImpl for LongArrayValue { @@
     fn is_type_compatible(&self, t: &Type) -> bool {
         let Type { primitive, array } = t;
         if !*array {
             return false;
+        }
         match primitive {
             PrimitiveType::Long => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 struct Store {
     map: HashMap<VariableId, Value>,
+}
 impl Store {
     fn new() -> Self {
         Store { map: HashMap::new() }
+    }
     fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {
         // Ensure value is compatible with type of variable
         let the_type = h[var].the_type(h);
         assert!(value.is_type_compatible(the_type));
         // Overwrite mapping
@@ @@ -1601,25 +1601,25 @@ type EvalResult = Result<Value, EvalContinuation>; @@
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DeclarationId, Vec<Value>),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Prompt {
     definition: DefinitionId,
     store: Store,
     position: Option<StatementId>,
+}
 impl Prompt {
     pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {
         let mut prompt =
             Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };
         prompt.set_arguments(h, args);
         prompt

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 mod ast;
 mod eval;
 pub mod inputsource;
 mod lexer;
 mod library;
 mod parser;
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
@@ @@ -86,25 +87,25 @@ impl ProtocolDescription for ProtocolDescriptionImpl { @@
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
         ComponentStateImpl { prompt: Prompt::new(h, def, &args) }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct ComponentStateImpl {
     prompt: Prompt,
+}
 impl ComponentState for ComponentStateImpl {
     type D = ProtocolDescriptionImpl;
     fn pre_sync_run<C: MonoContext<D = ProtocolDescriptionImpl, S = Self>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> MonoBlocker {
         let mut context = EvalContext::Mono(context);

src/runtime/mod.rs

➞

Show inline comments

@@ @@ -52,24 +52,27 @@ pub struct Unconfigured { @@
 pub struct Configured {
     controller_id: ControllerId,
     polarities: Vec<Polarity>,
     bindings: HashMap<usize, PortBinding>,
     protocol_description: Arc<ProtocolD>,
     main_component: Vec<u8>,
     logger: String,
+}
 #[derive(Debug)]
 pub struct Connected {
     native_interface: Vec<(Port, Polarity)>,
     sync_batches: Vec<SyncBatch>,
     // controller is cooperatively scheduled with the native application
     // (except for transport layer behind Endpoints, which are managed by the OS)
     // control flow is passed to the controller during methods on Connector (primarily, connect and sync).
     controller: Controller,
+}
 #[derive(Debug, Copy, Clone)]
 pub enum PortBinding {
     Native,
     Active(SocketAddr),
     Passive(SocketAddr),
+}
 #[derive(Debug)]
 struct Arena<T> {
@@ @@ -292,43 +295,44 @@ impl From<MessengerRecvErr> for ConnectErr { @@
     fn from(e: MessengerRecvErr) -> ConnectErr {
         ConnectErr::MessengerRecvErr(e)
+    }
+}
 impl<T> Default for Arena<T> {
     fn default() -> Self {
         Self { storage: vec![] }
+    }
+}
 impl<T> Arena<T> {
     pub fn alloc(&mut self, t: T) -> Port {
         self.storage.push(t);
         Port::from_raw(self.storage.len() - 1)
         let l: u32 = self.storage.len().try_into().unwrap();
         Port::from_raw(l - 1u32)
+    }
     pub fn get(&self, key: Port) -> Option<&T> {
         self.storage.get(key.to_raw() as usize)
+    }
     pub fn get_mut(&mut self, key: Port) -> Option<&mut T> {
         self.storage.get_mut(key.to_raw() as usize)
+    }
     pub fn type_convert<X>(self, f: impl FnMut((Port, T)) -> X) -> Arena<X> {
         Arena { storage: self.keyspace().zip(self.storage.into_iter()).map(f).collect() }
+    }
     pub fn iter(&self) -> impl Iterator<Item = (Port, &T)> {
         self.keyspace().zip(self.storage.iter())
+    }
     pub fn len(&self) -> usize {
         self.storage.len()
+    }
     pub fn keyspace(&self) -> impl Iterator<Item = Port> {
-        (0..self.storage.len()).map(Port::from_raw)
+        (0u32..self.storage.len().try_into().unwrap()).map(Port::from_raw)
+    }
+}
 impl ChannelIdStream {
     fn new(controller_id: ControllerId) -> Self {
         Self { controller_id, next_channel_index: 0 }
+    }
     fn next(&mut self) -> ChannelId {
         self.next_channel_index += 1;
         ChannelId { controller_id: self.controller_id, channel_index: self.next_channel_index - 1 }
+    }
+}

0 comments (0 inline, 0 general)