par-term-config 0.14.2

Configuration system for par-term terminal emulator
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
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

//! Controls that attach to `uniform int`.
//!
//! `int`, `select` and `channel` are grouped because all three are counted
//! against `MAX_SHADER_INT_CONTROLS` -- they compete for the same 16 slots.

use super::parse_helpers::{
    ControlDirective, parse_channel_options, parse_required_i32, parse_select_options,
};
use super::{ShaderControlKind, ShaderControlWarning};

/// Parse a `// control int ...` directive.
///
/// Returns `None` when the control must be dropped; the caller skips to the
/// next line without recording a duplicate, a capacity slot, or a group.
pub(super) fn parse_int(
    directive: &ControlDirective<'_>,
    warnings: &mut Vec<ShaderControlWarning>,
) -> Option<ShaderControlKind> {
    directive.warn_unknown_fields(warnings, &["min", "max", "step", "label", "group"]);

    if !directive.require_uniform_type(
        warnings,
        "int",
        format!(
            "Int control for `{}` must attach to `uniform int`",
            directive.uniform_name
        ),
    ) {
        return None;
    }

    let min = match parse_required_i32(directive.key_values, "min") {
        Ok(value) => value,
        Err(error) => {
            directive.warn(
                warnings,
                format!("Int `{}` {}", directive.uniform_name, error),
            );
            return None;
        }
    };
    let max = match parse_required_i32(directive.key_values, "max") {
        Ok(value) => value,
        Err(error) => {
            directive.warn(
                warnings,
                format!("Int `{}` {}", directive.uniform_name, error),
            );
            return None;
        }
    };
    // `step` is the one optional numeric field; absent means 1, present but
    // unparseable is an error rather than a fallback.
    let step = match directive.key_values.get("step") {
        Some(_) => match parse_required_i32(directive.key_values, "step") {
            Ok(value) => value,
            Err(error) => {
                directive.warn(
                    warnings,
                    format!("Int `{}` {}", directive.uniform_name, error),
                );
                return None;
            }
        },
        None => 1,
    };

    if max < min || step <= 0 {
        directive.warn(
            warnings,
            format!(
                "Int `{}` must have max >= min and step > 0",
                directive.uniform_name
            ),
        );
        return None;
    }

    let label = directive.label(warnings, "Int");

    Some(ShaderControlKind::Int {
        min,
        max,
        step,
        label,
    })
}

/// Parse a `// control select ...` directive.
pub(super) fn parse_select(
    directive: &ControlDirective<'_>,
    warnings: &mut Vec<ShaderControlWarning>,
) -> Option<ShaderControlKind> {
    directive.warn_unknown_fields(warnings, &["options", "label", "group"]);

    if !directive.require_uniform_type(
        warnings,
        "int",
        format!(
            "Select control for `{}` must attach to `uniform int`",
            directive.uniform_name
        ),
    ) {
        return None;
    }

    let options = match parse_select_options(directive.key_values.get("options")) {
        Ok(options) => options,
        Err(error) => {
            directive.warn(
                warnings,
                format!("Select `{}` {}", directive.uniform_name, error),
            );
            return None;
        }
    };

    let label = directive.label(warnings, "Select");

    Some(ShaderControlKind::Select { options, label })
}

/// Parse a `// control channel ...` directive.
pub(super) fn parse_channel(
    directive: &ControlDirective<'_>,
    warnings: &mut Vec<ShaderControlWarning>,
) -> Option<ShaderControlKind> {
    directive.warn_unknown_fields(warnings, &["options", "label", "group"]);

    if !directive.require_uniform_type(
        warnings,
        "int",
        format!(
            "Channel control for `{}` must attach to `uniform int`",
            directive.uniform_name
        ),
    ) {
        return None;
    }

    let options = match parse_channel_options(directive.key_values.get("options")) {
        Ok(options) => options,
        Err(error) => {
            directive.warn(
                warnings,
                format!("Channel `{}` {}", directive.uniform_name, error),
            );
            return None;
        }
    };

    let label = directive.label(warnings, "Channel");

    Some(ShaderControlKind::Channel { options, label })
}