feat: support all events in the binary format

runtime_tracing/src/capnptrace.rs

@@ -91,6 +91,56 @@ impl From<trace::TypeKind> for crate::TypeKind {
     }
 }
 
+impl From<trace::EventLogKind> for crate::EventLogKind {
+    fn from(value: trace::EventLogKind) -> Self {
+        match value {
+            trace::EventLogKind::Write => crate::EventLogKind::Write,
+            trace::EventLogKind::WriteFile => crate::EventLogKind::WriteFile,
+            trace::EventLogKind::WriteOther => crate::EventLogKind::WriteOther,
+            trace::EventLogKind::Read => crate::EventLogKind::Read,
+            trace::EventLogKind::ReadFile => crate::EventLogKind::ReadFile,
+            trace::EventLogKind::ReadOther => crate::EventLogKind::ReadOther,
+            trace::EventLogKind::ReadDir => crate::EventLogKind::ReadDir,
+            trace::EventLogKind::OpenDir => crate::EventLogKind::OpenDir,
+            trace::EventLogKind::CloseDir => crate::EventLogKind::CloseDir,
+            trace::EventLogKind::Socket => crate::EventLogKind::Socket,
+            trace::EventLogKind::Open => crate::EventLogKind::Open,
+            trace::EventLogKind::Error => crate::EventLogKind::Error,
+            trace::EventLogKind::TraceLogEvent => crate::EventLogKind::TraceLogEvent,
+        }
+    }
+}
+
+impl From<crate::EventLogKind> for trace::EventLogKind {
+    fn from(value: crate::EventLogKind) -> Self {
+        match value {
+            crate::EventLogKind::Write => trace::EventLogKind::Write,
+            crate::EventLogKind::WriteFile => trace::EventLogKind::WriteFile,
+            crate::EventLogKind::WriteOther => trace::EventLogKind::WriteOther,
+            crate::EventLogKind::Read => trace::EventLogKind::Read,
+            crate::EventLogKind::ReadFile => trace::EventLogKind::ReadFile,
+            crate::EventLogKind::ReadOther => trace::EventLogKind::ReadOther,
+            crate::EventLogKind::ReadDir => trace::EventLogKind::ReadDir,
+            crate::EventLogKind::OpenDir => trace::EventLogKind::OpenDir,
+            crate::EventLogKind::CloseDir => trace::EventLogKind::CloseDir,
+            crate::EventLogKind::Socket => trace::EventLogKind::Socket,
+            crate::EventLogKind::Open => trace::EventLogKind::Open,
+            crate::EventLogKind::Error => trace::EventLogKind::Error,
+            crate::EventLogKind::TraceLogEvent => trace::EventLogKind::TraceLogEvent,
+        }
+    }
+}
+
+impl From<crate::PassBy> for trace::PassBy {
+    fn from(value: crate::PassBy) -> Self {
+        match value {
+            crate::PassBy::Value => trace::PassBy::Value,
+            crate::PassBy::Reference => trace::PassBy::Reference,
+        }
+    }
+}
+
+
 fn conv_valuerecord(
     bldr: crate::trace_capnp::trace::value_record::Builder,
     vr: &crate::ValueRecord,
@@ -317,8 +367,97 @@ pub fn write_trace(q: &[crate::TraceLowLevelEvent], output: &mut impl std::io::W
                 let ret_value = ret.init_return_value();
                 conv_valuerecord(ret_value, &returnrecord.return_value);
             }
-            _ => {
-                eprintln!("Not yet implemented: {:?}", qq);
+            TraceLowLevelEvent::Event(recordevent) => {
+                let mut ret = event.init_event();
+                ret.set_metadata(&recordevent.metadata);
+                ret.set_content(&recordevent.content);
+                ret.set_kind(recordevent.kind.into());
+            }
+            TraceLowLevelEvent::Variable(str) => {
+                event.set_variable(str);
+            }
+            TraceLowLevelEvent::Asm(strs) => {
+                let mut ret = event.init_asm(strs.len().try_into().unwrap());
+                for i in 0..strs.len() {
+                    ret.set(i.try_into().unwrap(), &strs[i]);
+                }
+            }
+            TraceLowLevelEvent::BindVariable(bindvarrec) => {
+                let mut ret = event.init_bind_variable();
+                let mut ret_var_id = ret.reborrow().init_variable_id();
+                ret_var_id.set_i(bindvarrec.variable_id.0.try_into().unwrap());
+                let mut ret_place = ret.init_place();
+                ret_place.set_p(bindvarrec.place.0.try_into().unwrap());
+            }
+            TraceLowLevelEvent::Assignment(assrec) => {
+                let mut ret = event.init_assignment();
+                let mut ret_to = ret.reborrow().init_to();
+                ret_to.set_i(assrec.to.0.try_into().unwrap());
+                ret.set_pass_by(assrec.pass_by.clone().into());
+                let ret_from = ret.init_from();
+                match &assrec.from {
+                    crate::RValue::Simple(variable_id) => {
+                        let mut ret_from_simple = ret_from.init_simple();
+                        ret_from_simple.set_i(variable_id.0.try_into().unwrap());
+                    },
+                    crate::RValue::Compound(variable_ids) => {
+                        let mut ret_from_compound = ret_from.init_compound(variable_ids.len().try_into().unwrap());
+                        for i in 0..variable_ids.len() {
+                            let mut r = ret_from_compound.reborrow().get(i.try_into().unwrap());
+                            r.set_i(variable_ids[i].0.try_into().unwrap());
+                        }
+                    },
+                }
+            }
+            TraceLowLevelEvent::DropLastStep => {
+                event.set_drop_last_step(());
+            }
+            TraceLowLevelEvent::DropVariables(vars) => {
+                let mut ret_vars = event.init_drop_variables(vars.len().try_into().unwrap());
+                for i in 0..vars.len() {
+                    let mut q = ret_vars.reborrow().get(i.try_into().unwrap());
+                    q.set_i(vars[i].0.try_into().unwrap());
+                }
+            }
+            TraceLowLevelEvent::DropVariable(varid) => {
+                let mut ret = event.init_drop_variable();
+                ret.set_i(varid.0.try_into().unwrap());
+            }
+            TraceLowLevelEvent::CompoundValue(cvr) => {
+                let mut ret = event.init_compound_value();
+                let mut ret_place = ret.reborrow().init_place();
+                ret_place.set_p(cvr.place.0.try_into().unwrap());
+                let ret_value = ret.init_value();
+                conv_valuerecord(ret_value, &cvr.value);
+            }
+            TraceLowLevelEvent::CellValue(cvr) => {
+                let mut ret = event.init_cell_value();
+                let mut ret_place = ret.reborrow().init_place();
+                ret_place.set_p(cvr.place.0.try_into().unwrap());
+                let ret_value = ret.init_value();
+                conv_valuerecord(ret_value, &cvr.value);
+            }
+            TraceLowLevelEvent::AssignCell(acr) => {
+                let mut ret = event.init_assign_cell();
+                let mut ret_place = ret.reborrow().init_place();
+                ret_place.set_p(acr.place.0.try_into().unwrap());
+                let ret_new_value = ret.init_new_value();
+                conv_valuerecord(ret_new_value, &acr.new_value);
+            }
+            TraceLowLevelEvent::AssignCompoundItem(aci) => {
+                let mut ret = event.init_assign_compound_item();
+                let mut ret_place = ret.reborrow().init_place();
+                ret_place.set_p(aci.place.0.try_into().unwrap());
+                ret.set_index(aci.index.try_into().unwrap());
+                let mut ret_item_place = ret.init_item_place();
+                ret_item_place.set_p(aci.item_place.0.try_into().unwrap());
+            }
+            TraceLowLevelEvent::VariableCell(vcr) => {
+                let mut ret = event.init_variable_cell();
+                let mut ret_variable_id = ret.reborrow().init_variable_id();
+                ret_variable_id.set_i(vcr.variable_id.0.try_into().unwrap());
+                let mut ret_place = ret.init_place();
+                ret_place.set_p(vcr.place.0.try_into().unwrap());
             }
         }
     }
@@ -538,27 +677,7 @@ pub fn read_trace(input: &mut impl std::io::BufRead) -> ::capnp::Result<Vec<crat
             Ok(trace::trace_low_level_event::Which::Event(record_event)) => {
                 let record_event = record_event?;
                 TraceLowLevelEvent::Event(crate::RecordEvent {
-                    kind: match record_event.get_kind()? {
-                        trace::EventLogKind::Write => crate::EventLogKind::Write,
-                        trace::EventLogKind::WriteFile => {
-                            crate::EventLogKind::WriteFile
-                        }
-                        trace::EventLogKind::Read => crate::EventLogKind::Read,
-                        trace::EventLogKind::ReadFile => {
-                            crate::EventLogKind::ReadFile
-                        }
-                        trace::EventLogKind::ReadDir => crate::EventLogKind::ReadDir,
-                        trace::EventLogKind::OpenDir => crate::EventLogKind::OpenDir,
-                        trace::EventLogKind::CloseDir => {
-                            crate::EventLogKind::CloseDir
-                        }
-                        trace::EventLogKind::Socket => crate::EventLogKind::Socket,
-                        trace::EventLogKind::Open => crate::EventLogKind::Open,
-                        trace::EventLogKind::Error => crate::EventLogKind::Error,
-                        trace::EventLogKind::TraceLogEvent => {
-                            crate::EventLogKind::TraceLogEvent
-                        }
-                    },
+                    kind: record_event.get_kind()?.into(),
                     metadata: record_event.get_metadata()?.to_string()?,
                     content: record_event.get_content()?.to_string()?,
                 })

runtime_tracing/src/trace.capnp

@@ -292,8 +292,10 @@ struct Trace {
     enum EventLogKind {
         write @0;
         writeFile @1;
+        writeOther @11;
         read @2;
         readFile @3;
+        readOther @12;
         readDir @4;
         openDir @5;
         closeDir @6;