vize_l3 0.429.2

L3 - the Davinci reactivity IR (codename Impeto): flat scheduled ops with explicit state and effect edges
Documentation 
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

//! Owned value page paired with the graph-only `L3Page` view.
//! JSON tuples keep arbitrary authored strings line-atomic without inventing
//! another quoting grammar. Tuple equality is document equality only.

use alloc::vec::Vec;
use core::fmt;
use vize_davinci::dump::value::DumpValue;
use vize_davinci::dump::{Dump, Error as DumpError};
use vize_l0::{Span, String, cstr};

use crate::op::Program;
use crate::operand::{OperandRole, OperandValue, ValueKind};

/// op, role, target, region, attribute name, kind, text, qualifier, start, end.
pub type OperandRow = (
    u32,
    String,
    Option<u32>,
    Option<u32>,
    Option<String>,
    String,
    String,
    String,
    u32,
    u32,
);

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Operand(pub OperandRow);

#[derive(Debug, Clone, Default, PartialEq, Eq, Dump)]
#[dump(name = "s3-values-folio")]
pub struct Page {
    pub operands: Vec<Operand>,
}

impl Page {
    #[must_use]
    pub fn of(program: &Program<'_>) -> Self {
        Self {
            operands: program
                .operands
                .iter()
                .map(|operand| {
                    Operand((
                        operand.op.index(),
                        String::from(operand.role.as_str()),
                        operand.target.map(|id| id.index()),
                        operand.region.map(|id| id.index()),
                        operand.name.map(String::from),
                        String::from(operand.value.kind.as_str()),
                        String::from(operand.value.text),
                        String::from(operand.value.qualifier),
                        operand.value.span.start,
                        operand.value.span.end,
                    ))
                })
                .collect(),
        }
    }
}

impl DumpValue for Operand {
    fn print_value<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
        let text = serde_json::to_string(&self.0).map_err(|_| fmt::Error)?;
        w.write_str("operand=")?;
        w.write_str(&text)
    }

    fn parse_value(text: &str, line: usize) -> Result<Self, DumpError> {
        let text = text
            .strip_prefix("operand=")
            .ok_or_else(|| DumpError::new(line, cstr!("L3 value row must start with operand=")))?;
        let row: OperandRow = serde_json::from_str(text)
            .map_err(|error| DumpError::new(line, cstr!("invalid L3 operand: {error}")))?;
        let role = OperandRole::parse(&row.1)
            .ok_or_else(|| DumpError::new(line, cstr!("unknown L3 operand role")))?;
        let kind = ValueKind::parse(&row.5)
            .ok_or_else(|| DumpError::new(line, cstr!("unknown L3 value kind")))?;
        let value = OperandValue {
            kind,
            text: &row.6,
            qualifier: &row.7,
            span: Span::new(row.8, row.9),
        };
        if !value.is_well_formed() {
            return Err(DumpError::new(line, cstr!("malformed L3 operand value")));
        }
        if !role.accepts_target(row.2.is_some())
            || row.4.is_some()
                != matches!(role, OperandRole::Attribute | OperandRole::ModelAttribute)
            || row.3.is_some() != (role == OperandRole::Condition)
            || (row.3.is_some() && row.2.is_some())
        {
            return Err(DumpError::new(
                line,
                cstr!("malformed L3 operand references"),
            ));
        }
        Ok(Self(row))
    }
}