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

//
// GENERATED FILE
//

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

const LBCELL: i32 = -5;

//
// Detect path mismatch.
//
pub fn T_PTHCMP(PATH: CharArray, EXPPTH: CharArray, ctx: &mut Context) -> f2rust_std::Result<()> {
    let PATH = DummyCharArray::new(PATH, None, LBCELL..);
    let EXPPTH = DummyCharArray::new(EXPPTH, None, LBCELL..);
    let mut CP: i32 = 0;
    let mut CX: i32 = 0;
    let mut I: i32 = 0;
    let mut N: i32 = 0;
    let mut NM: i32 = 0;

    spicelib::CHKIN(b"T_PTHCMP", ctx)?;

    CP = spicelib::CARDC(PATH.as_arg(), ctx)?;
    CX = spicelib::CARDC(EXPPTH.as_arg(), ctx)?;

    NM = intrinsics::MIN0(&[CP, CX]);

    N = 0;

    {
        let m1__: i32 = 1;
        let m2__: i32 = NM;
        let m3__: i32 = 1;
        I = m1__;
        for _ in 0..((m2__ - m1__ + m3__) / m3__) as i32 {
            if fstr::eq(PATH.get(I), EXPPTH.get(I)) {
                N = (N + 1);
            }

            I += m3__;
        }
    }

    if (CP != CX) {
        spicelib::SETMSG(b"Path was expected to have length # but had length #. Last element of actual path was <#>. Last element common to both paths was <#>.", ctx);
        spicelib::ERRINT(b"#", CX, ctx);
        spicelib::ERRINT(b"#", CP, ctx);

        if (CP > 0) {
            spicelib::ERRCH(b"#", &PATH[CP], ctx);
        } else {
            spicelib::ERRCH(b"#", b"<empty>", ctx);
        }

        if (N > 0) {
            spicelib::ERRCH(b"#", &EXPPTH[N], ctx);
        } else {
            spicelib::ERRCH(b"#", b"<empty>", ctx);
        }

        spicelib::SIGERR(b"SPICE(BADPATHLENGTH)", ctx)?;
        spicelib::CHKOUT(b"T_PTHCMP", ctx)?;
        return Ok(());
    }

    I = 1;

    while (I <= spicelib::CARDC(EXPPTH.as_arg(), ctx)?) {
        if fstr::ne(PATH.get(I), EXPPTH.get(I)) {
            spicelib::SETMSG(b"Path element # was expected to be <#> but was <#>.", ctx);
            spicelib::ERRINT(b"#", I, ctx);
            spicelib::ERRCH(b"#", &EXPPTH[I], ctx);
            spicelib::ERRCH(b"#", &PATH[I], ctx);
            spicelib::SIGERR(b"SPICE(BADPATH)", ctx)?;
            spicelib::CHKOUT(b"T_PTHCMP", ctx)?;
            return Ok(());
        }

        I = (I + 1);
    }

    spicelib::CHKOUT(b"T_PTHCMP", ctx)?;
    Ok(())
}

//
// Display path.
//
pub fn T_PTHDSP(PATH: CharArray, ctx: &mut Context) -> f2rust_std::Result<()> {
    let PATH = DummyCharArray::new(PATH, None, LBCELL..);
    let mut I: i32 = 0;

    spicelib::CHKIN(b"T_PTHDSP", ctx)?;

    {
        let m1__: i32 = 1;
        let m2__: i32 = spicelib::CARDC(PATH.as_arg(), ctx)?;
        let m3__: i32 = 1;
        I = m1__;
        for _ in 0..((m2__ - m1__ + m3__) / m3__) as i32 {
            spicelib::TOSTDO(&PATH[I], ctx)?;
            I += m3__;
        }
    }

    spicelib::CHKOUT(b"T_PTHDSP", ctx)?;
    Ok(())
}