rsspice 0.1.0

Pure Rust port of the SPICE Toolkit for space geometry
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

//
// GENERATED FILE
//

use super::*;
use f2rust_std::*;

struct SaveVars {
    BEGIN: i32,
    LAST: i32,
    J: i32,
    K: i32,
    ERROR: Vec<u8>,
    MINVAL: f64,
    MAXVAL: f64,
}

impl SaveInit for SaveVars {
    fn new() -> Self {
        let mut BEGIN: i32 = 0;
        let mut LAST: i32 = 0;
        let mut J: i32 = 0;
        let mut K: i32 = 0;
        let mut ERROR = vec![b' '; 80];
        let mut MINVAL: f64 = 0.0;
        let mut MAXVAL: f64 = 0.0;

        Self {
            BEGIN,
            LAST,
            J,
            K,
            ERROR,
            MINVAL,
            MAXVAL,
        }
    }
}

//$Procedure      M2NTEM ( Parse the numeric template of a @number )
pub fn M2NTEM(
    STRING: &[u8],
    BASE: &[u8],
    BEG: &mut i32,
    END: i32,
    A: &mut f64,
    B: &mut f64,
    ctx: &mut Context,
) {
    let save = ctx.get_vars::<SaveVars>();
    let save = &mut *save.borrow_mut();

    //
    // SPICELIB functions
    //

    //
    // Local variables
    //

    save.LAST = (END - 1);
    save.BEGIN = (*BEG + 1);

    //
    // First get the min and max's for this kind of word.
    //
    if fstr::eq(BASE, b"@int") {
        save.MINVAL = (spicelib::INTMIN() as f64);
        save.MAXVAL = (spicelib::INTMAX() as f64);
    } else {
        save.MINVAL = spicelib::DPMIN();
        save.MAXVAL = spicelib::DPMAX();
    }

    //
    // parse the restriction template
    //
    if fstr::eq(fstr::substr(STRING, save.BEGIN..=save.BEGIN), b":") {
        *A = save.MINVAL;
        spicelib::NPARSD(
            fstr::substr(STRING, (save.BEGIN + 1)..=save.LAST),
            B,
            &mut save.ERROR,
            &mut save.J,
            ctx,
        );

        if fstr::ne(&save.ERROR, b" ") {
            *B = save.MAXVAL;
        }
    } else if fstr::eq(fstr::substr(STRING, save.LAST..=save.LAST), b":") {
        spicelib::NPARSD(
            fstr::substr(STRING, save.BEGIN..=(save.LAST - 1)),
            A,
            &mut save.ERROR,
            &mut save.J,
            ctx,
        );

        if fstr::ne(&save.ERROR, b" ") {
            *A = save.MINVAL;
        }

        *B = save.MAXVAL;
    } else {
        save.J = (intrinsics::INDEX(fstr::substr(STRING, save.BEGIN..=save.LAST), b":") + *BEG);

        spicelib::NPARSD(
            fstr::substr(STRING, save.BEGIN..=(save.J - 1)),
            A,
            &mut save.ERROR,
            &mut save.K,
            ctx,
        );

        if fstr::ne(&save.ERROR, b" ") {
            *A = save.MINVAL;
        }

        spicelib::NPARSD(
            fstr::substr(STRING, (save.J + 1)..=save.LAST),
            B,
            &mut save.ERROR,
            &mut save.K,
            ctx,
        );

        if fstr::ne(&save.ERROR, b" ") {
            *B = save.MAXVAL;
        }
    }

    *BEG = (END + 1);
}