Files
@ ce77f83608df
Branch filter:
Location: CSY/reowolf/src/protocol/mod.rs - annotation
ce77f83608df
14.7 KiB
application/rls-services+xml
Integrate with old runtime, pending some tiny fixes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 | 3f236d37dad1 06f259bf8031 012b61623f5a 06f259bf8031 aaeaf5986496 06f259bf8031 814be01095d9 729feec4d37a 6c04a99de862 b69f417a9972 b69f417a9972 b69f417a9972 06f259bf8031 06f259bf8031 a226385adc2d 012b61623f5a 06f259bf8031 ef37386d0c6f 06f259bf8031 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 d3835a56401d d600dd299dde 44a98be4e4b4 b69f417a9972 06f259bf8031 ef37386d0c6f b69f417a9972 06f259bf8031 9b32fa307ceb 4c9116f4253b 44a98be4e4b4 44a98be4e4b4 4c9116f4253b cecf94fdb875 cecf94fdb875 9b32fa307ceb 44a98be4e4b4 44a98be4e4b4 06f259bf8031 44a98be4e4b4 06f259bf8031 d23010006486 06f259bf8031 06f259bf8031 44a98be4e4b4 9774ef9fe888 44a98be4e4b4 33ea10021de4 33ea10021de4 012b61623f5a 33ea10021de4 012b61623f5a 9774ef9fe888 9774ef9fe888 9774ef9fe888 9774ef9fe888 06f259bf8031 9774ef9fe888 9774ef9fe888 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 ef37386d0c6f b69f417a9972 b69f417a9972 06f259bf8031 4c9116f4253b 44a98be4e4b4 b69f417a9972 44a98be4e4b4 44a98be4e4b4 44a98be4e4b4 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 935120e93ef1 44a98be4e4b4 935120e93ef1 b69f417a9972 b69f417a9972 935120e93ef1 44a98be4e4b4 935120e93ef1 b69f417a9972 3af8b6eaec1b b69f417a9972 012b61623f5a fdaf709bf0ca 012b61623f5a 012b61623f5a 3af8b6eaec1b 44a98be4e4b4 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b b69f417a9972 3af8b6eaec1b 3af8b6eaec1b b69f417a9972 012b61623f5a fdaf709bf0ca 012b61623f5a 3af8b6eaec1b 012b61623f5a 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b 3af8b6eaec1b 4776bcc45b33 b69f417a9972 06f259bf8031 b69f417a9972 3af8b6eaec1b 3845071002b0 3845071002b0 06f259bf8031 06f259bf8031 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 ef37386d0c6f b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 06f259bf8031 06f259bf8031 44a98be4e4b4 4c9116f4253b 44a98be4e4b4 cecf94fdb875 44a98be4e4b4 44a98be4e4b4 44a98be4e4b4 06f259bf8031 ef37386d0c6f 06f259bf8031 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 9b32fa307ceb 06f259bf8031 44a98be4e4b4 44a98be4e4b4 44a98be4e4b4 06f259bf8031 06f259bf8031 ef37386d0c6f 5e11ebce9bc0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 ef37386d0c6f 3845071002b0 5e11ebce9bc0 a226385adc2d 06f259bf8031 06f259bf8031 ac7f49602455 ac7f49602455 ac7f49602455 a226385adc2d 06f259bf8031 06f259bf8031 06f259bf8031 06f259bf8031 4c9116f4253b 44a98be4e4b4 cecf94fdb875 44a98be4e4b4 44a98be4e4b4 44a98be4e4b4 06f259bf8031 ef37386d0c6f 06f259bf8031 b69f417a9972 b69f417a9972 b69f417a9972 b69f417a9972 9b32fa307ceb 06f259bf8031 44a98be4e4b4 06f259bf8031 06f259bf8031 06f259bf8031 06f259bf8031 44a98be4e4b4 06f259bf8031 ef37386d0c6f a226385adc2d 3845071002b0 44a98be4e4b4 06f259bf8031 3845071002b0 44a98be4e4b4 06f259bf8031 a226385adc2d a226385adc2d a226385adc2d 3845071002b0 44a98be4e4b4 a226385adc2d 3845071002b0 44a98be4e4b4 a226385adc2d a226385adc2d a226385adc2d 06f259bf8031 dedf89df1602 06f259bf8031 3845071002b0 dedf89df1602 06f259bf8031 3845071002b0 dedf89df1602 06f259bf8031 a226385adc2d 06f259bf8031 06f259bf8031 06f259bf8031 3845071002b0 44a98be4e4b4 3845071002b0 3845071002b0 06f259bf8031 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 3845071002b0 06f259bf8031 a226385adc2d 06f259bf8031 44a98be4e4b4 06f259bf8031 a226385adc2d 06f259bf8031 06f259bf8031 06f259bf8031 06f259bf8031 06f259bf8031 dedf89df1602 dedf89df1602 175721d796d7 44a98be4e4b4 44a98be4e4b4 dedf89df1602 dedf89df1602 3845071002b0 06f259bf8031 9b32fa307ceb 44a98be4e4b4 dedf89df1602 5e11ebce9bc0 44a98be4e4b4 5e11ebce9bc0 5e11ebce9bc0 5e11ebce9bc0 5e11ebce9bc0 9b32fa307ceb 44a98be4e4b4 8642f7a7bf01 3845071002b0 3845071002b0 5e11ebce9bc0 5e11ebce9bc0 44a98be4e4b4 06f259bf8031 06f259bf8031 06f259bf8031 06f259bf8031 9b32fa307ceb 44a98be4e4b4 44a98be4e4b4 3845071002b0 3845071002b0 a226385adc2d a226385adc2d 06f259bf8031 06f259bf8031 9b32fa307ceb 06f259bf8031 9b32fa307ceb 44a98be4e4b4 44a98be4e4b4 3845071002b0 3845071002b0 9b32fa307ceb dedf89df1602 3845071002b0 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb ce77f83608df ce77f83608df 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb 9b32fa307ceb 06f259bf8031 a226385adc2d 06f259bf8031 06f259bf8031 06f259bf8031 6938bcacc41e 6938bcacc41e 9b32fa307ceb 6938bcacc41e 6938bcacc41e 3845071002b0 6ec2e0261a03 6938bcacc41e 6938bcacc41e 6938bcacc41e 6938bcacc41e 6938bcacc41e 6938bcacc41e a226385adc2d | mod arena;
mod eval;
pub(crate) mod input_source;
mod parser;
#[cfg(test)] mod tests;
pub(crate) mod ast;
pub(crate) mod ast_printer;
use std::sync::Mutex;
use crate::collections::{StringPool, StringRef};
use crate::common::*;
use crate::protocol::ast::*;
use crate::protocol::eval::*;
use crate::protocol::input_source::*;
use crate::protocol::parser::*;
use crate::protocol::type_table::*;
/// 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 {
modules: Vec<Module>,
heap: Heap,
types: TypeTable,
pool: Mutex<StringPool>,
}
#[derive(Debug, Clone)]
pub(crate) struct ComponentState {
prompt: Prompt,
}
pub(crate) enum EvalContext<'a> {
Nonsync(&'a mut NonsyncProtoContext<'a>),
Sync(&'a mut SyncProtoContext<'a>),
None,
}
//////////////////////////////////////////////
impl std::fmt::Debug for ProtocolDescription {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "(An opaque protocol description)")
}
}
impl ProtocolDescription {
// TODO: Allow for multi-file compilation
pub fn parse(buffer: &[u8]) -> Result<Self, String> {
// TODO: @fixme, keep code compilable, but needs support for multiple
// input files.
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))
}
debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");
let modules: Vec<Module> = parser.modules.into_iter()
.map(|module| Module{
source: module.source,
root_id: module.root_id,
name: module.name.map(|(_, name)| name)
})
.collect();
return Ok(ProtocolDescription {
modules,
heap: parser.heap,
types: parser.type_table,
pool: Mutex::new(parser.string_pool),
});
}
pub(crate) fn component_polarities(
&self,
module_name: &[u8],
identifier: &[u8],
) -> Result<Vec<Polarity>, AddComponentError> {
use AddComponentError::*;
let module_root = self.lookup_module_root(module_name);
if module_root.is_none() {
return Err(AddComponentError::NoSuchModule);
}
let module_root = module_root.unwrap();
let root = &self.heap[module_root];
let def = root.get_definition_ident(&self.heap, identifier);
if def.is_none() {
return Err(NoSuchComponent);
}
let def = &self.heap[def.unwrap()];
if !def.is_component() {
return Err(NoSuchComponent);
}
for ¶m in def.parameters().iter() {
let param = &self.heap[param];
let first_element = ¶m.parser_type.elements[0];
match first_element.variant {
ParserTypeVariant::Input | ParserTypeVariant::Output => continue,
_ => {
return Err(NonPortTypeParameters);
}
}
}
let mut result = Vec::new();
for ¶m in def.parameters().iter() {
let param = &self.heap[param];
let first_element = ¶m.parser_type.elements[0];
if first_element.variant == ParserTypeVariant::Input {
result.push(Polarity::Getter)
} else if first_element.variant == ParserTypeVariant::Output {
result.push(Polarity::Putter)
} else {
unreachable!()
}
}
Ok(result)
}
// expects port polarities to be correct
pub(crate) fn new_component(&self, module_name: &[u8], identifier: &[u8], ports: &[PortId]) -> ComponentState {
let mut args = Vec::new();
for (&x, y) in ports.iter().zip(self.component_polarities(module_name, identifier).unwrap()) {
match y {
Polarity::Getter => args.push(Value::Input(x)),
Polarity::Putter => args.push(Value::Output(x)),
}
}
let module_root = self.lookup_module_root(module_name).unwrap();
let root = &self.heap[module_root];
let def = root.get_definition_ident(&self.heap, identifier).unwrap();
ComponentState { prompt: Prompt::new(&self.types, &self.heap, def, 0, ValueGroup::new_stack(args)) }
}
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;
}
}
impl ComponentState {
pub(crate) fn nonsync_run<'a: 'b, 'b>(
&'a mut self,
context: &'b mut NonsyncProtoContext<'b>,
pd: &'a ProtocolDescription,
) -> NonsyncBlocker {
let mut context = EvalContext::Nonsync(context);
loop {
let result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, &mut context);
match result {
Err(err) => {
println!("Evaluation error:\n{}", err);
panic!("proper error handling when component fails");
},
Ok(cont) => match cont {
EvalContinuation::Stepping => continue,
EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
// Not possible to end sync block if never entered one
EvalContinuation::SyncBlockEnd => unreachable!(),
EvalContinuation::NewComponent(definition_id, monomorph_idx, args) => {
// Look up definition (TODO for now, assume it is a definition)
let mut moved_ports = HashSet::new();
for arg in args.values.iter() {
match arg {
Value::Output(port) => {
moved_ports.insert(*port);
}
Value::Input(port) => {
moved_ports.insert(*port);
}
_ => {}
}
}
for region in args.regions.iter() {
for arg in region {
match arg {
Value::Output(port) => { moved_ports.insert(*port); },
Value::Input(port) => { moved_ports.insert(*port); },
_ => {},
}
}
}
let init_state = ComponentState { prompt: Prompt::new(&pd.types, &pd.heap, definition_id, monomorph_idx, args) };
context.new_component(moved_ports, init_state);
// Continue stepping
continue;
}
// Outside synchronous blocks, no fires/get/put happens
EvalContinuation::BlockFires(_) => unreachable!(),
EvalContinuation::BlockGet(_) => unreachable!(),
EvalContinuation::Put(_, _) => unreachable!(),
},
}
}
}
pub(crate) fn sync_run<'a: 'b, 'b>(
&'a mut self,
context: &'b mut SyncProtoContext<'b>,
pd: &'a ProtocolDescription,
) -> SyncBlocker {
let mut context = EvalContext::Sync(context);
loop {
let result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, &mut context);
match result {
Err(err) => {
println!("Evaluation error:\n{}", err);
panic!("proper error handling when component fails");
},
Ok(cont) => match cont {
EvalContinuation::Stepping => continue,
EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
// First need to exit synchronous block before definition may end
EvalContinuation::Terminal => unreachable!(),
// No nested synchronous blocks
EvalContinuation::SyncBlockStart => unreachable!(),
EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
// Not possible to create component in sync block
EvalContinuation::NewComponent(_, _, _) => unreachable!(),
EvalContinuation::BlockFires(port) => match port {
Value::Output(port) => {
return SyncBlocker::CouldntCheckFiring(port);
}
Value::Input(port) => {
return SyncBlocker::CouldntCheckFiring(port);
}
_ => unreachable!(),
},
EvalContinuation::BlockGet(port) => match port {
Value::Output(port) => {
return SyncBlocker::CouldntReadMsg(port);
}
Value::Input(port) => {
return SyncBlocker::CouldntReadMsg(port);
}
_ => unreachable!(),
},
EvalContinuation::Put(port, message) => {
let value;
match port {
Value::Output(port_value) => {
value = port_value;
}
Value::Input(port_value) => {
value = port_value;
}
_ => unreachable!(),
}
let payload;
match message {
Value::Null => {
return SyncBlocker::Inconsistent;
},
Value::Message(heap_pos) => {
// Create a copy of the payload
let values = &self.prompt.store.heap_regions[heap_pos as usize].values;
let mut bytes = Vec::with_capacity(values.len());
for value in values {
bytes.push(value.as_uint8());
}
payload = Payload(Arc::new(bytes));
}
_ => unreachable!(),
}
return SyncBlocker::PutMsg(value, payload);
}
},
}
}
}
}
impl EvalContext<'_> {
// fn random(&mut self) -> LongValue {
// match self {
// // EvalContext::None => unreachable!(),
// EvalContext::Nonsync(_context) => todo!(),
// EvalContext::Sync(_) => unreachable!(),
// }
// }
fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: ComponentState) -> () {
match self {
EvalContext::None => unreachable!(),
EvalContext::Nonsync(context) => {
context.new_component(moved_ports, init_state)
}
EvalContext::Sync(_) => unreachable!(),
}
}
fn new_channel(&mut self) -> [Value; 2] {
match self {
EvalContext::None => unreachable!(),
EvalContext::Nonsync(context) => {
let [from, to] = context.new_port_pair();
let from = Value::Output(from);
let to = Value::Input(to);
return [from, to];
}
EvalContext::Sync(_) => unreachable!(),
}
}
fn fires(&mut self, port: Value) -> Option<Value> {
match self {
EvalContext::None => unreachable!(),
EvalContext::Nonsync(_) => unreachable!(),
EvalContext::Sync(context) => match port {
Value::Output(port) => context.is_firing(port).map(Value::Bool),
Value::Input(port) => context.is_firing(port).map(Value::Bool),
_ => unreachable!(),
},
}
}
fn get(&mut self, port: Value, store: &mut Store) -> Option<Value> {
match self {
EvalContext::None => unreachable!(),
EvalContext::Nonsync(_) => unreachable!(),
EvalContext::Sync(context) => match port {
Value::Output(port) => {
debug_assert!(false, "Getting from an output port? Am I mad?");
unreachable!();
}
Value::Input(port) => {
let payload = context.read_msg(port);
if payload.is_none() { return None; }
let heap_pos = store.alloc_heap();
let heap_pos_usize = heap_pos as usize;
let payload = payload.unwrap();
store.heap_regions[heap_pos_usize].values.reserve(payload.0.len());
for value in payload.0.iter() {
store.heap_regions[heap_pos_usize].values.push(Value::UInt8(*value));
}
return Some(Value::Message(heap_pos));
}
_ => unreachable!(),
},
}
}
fn did_put(&mut self, port: Value) -> bool {
match self {
EvalContext::None => unreachable!("did_put in None context"),
EvalContext::Nonsync(_) => unreachable!("did_put in nonsync context"),
EvalContext::Sync(context) => match port {
Value::Output(port) => {
context.did_put_or_get(port)
},
Value::Input(_) => unreachable!("did_put on input port"),
_ => unreachable!("did_put on non-port value")
}
}
}
}
|