shelly-shell 0.5.4

A Rust based Unix style shell with a typed and structured language syntax.
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


use std::{
    cell::RefCell,
    collections::HashSet,
    fmt::{self, Debug, Formatter},
    rc::Rc,
};

use crate::language::{
    bytecode::FunctionRef, data::value::Value, interpreter::CallFrame, text::location::Location,
};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FailureStatus
{
    Pending,
    Propagating,
    Acknowledged,
}

#[derive(Clone, Debug)]
pub struct RelatedFailure
{
    pub relation: String,
    pub snapshot: Value,
    pub origin: Location,
    pub native_origin: Option<Location>,
    pub frames: Vec<CallFrame>,
}

#[derive(Clone, Copy, Debug)]
pub enum ControlFailure
{
    Interrupted,
    CleanupAbort,
    CleanupTimeout,
}

#[derive(Clone)]
pub struct FailureOccurrence
{
    pub id: u64,
    pub owner: u64,
    pub control: Option<ControlFailure>,
    pub status: FailureStatus,
    pub origin: Location,
    pub native_origin: Option<Location>,
    pub frames: Vec<CallFrame>,
    pub propagation: Vec<Location>,
    pub related: Vec<RelatedFailure>,
    pub slots: HashSet<usize>,
    pub formatter: Option<FunctionRef>,
    pub rethrow_source: Option<u64>,
}

impl Debug for FailureOccurrence
{
    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result
    {
        formatter
            .debug_struct("FailureOccurrence")
            .field("id", &self.id)
            .field("status", &self.status)
            .finish()
    }
}

impl PartialEq for FailureOccurrence
{
    fn eq(&self, other: &Self) -> bool
    {
        self.id == other.id
    }
}

pub type FailureRef = Rc<RefCell<FailureOccurrence>>;

pub fn occurrence(value: &Value) -> Option<FailureRef>
{
    match value.underlying()
    {
        Value::Struct(item) => item.failure.clone(),
        _ => None,
    }
}

pub fn pending(value: &Value) -> Option<FailureRef>
{
    occurrence(value).filter(|item| item.borrow().status == FailureStatus::Pending)
}

pub fn marked(value: &Value) -> bool
{
    matches!(value.underlying(), Value::Struct(item) if item.definition.error)
}