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

//
// GENERATED FILE
//

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

pub const LBCELL: i32 = -5;

//$Procedure       SYPTRC ( Symbol table, fetch pointers, generic )
pub fn SYPTRC(
    NAME: &[u8],
    SYMNAM: CharArray,
    SYMPTR: &[i32],
    SYMVAL: CharArrayMut,
    PTR: &mut i32,
    N: &mut i32,
    FOUND: &mut bool,
    ctx: &mut Context,
) -> f2rust_std::Result<()> {
    let SYMNAM = DummyCharArray::new(SYMNAM, None, LBCELL..);
    let SYMPTR = DummyArray::new(SYMPTR, LBCELL..);
    let mut SYMVAL = DummyCharArrayMut::new(SYMVAL, None, LBCELL..);
    let mut LOC: i32 = 0;
    let mut NUMBER: i32 = 0;

    if spicelib::RETURN(ctx) {
        return Ok(());
    } else {
        spicelib::CHKIN(b"SYPTRC", ctx)?;
    }
    //
    // We don't use the values of the symbol table in this routine
    // but it is passed for the sake of uniformity in the symbol
    // table routine calling sequences.  However, some compilers
    // generate warnings if a variable isn't used.  So we touch
    // the values cell to fake out the compiler.
    //
    spicelib::TOUCHC(
        &SYMVAL[LBCELL].to_vec(),
        fstr::substr_mut(&mut SYMVAL[LBCELL], 1..=1),
    );

    //
    // Now for the real work of this routine.
    //
    NUMBER = spicelib::CARDC(SYMNAM.as_arg(), ctx)?;
    LOC = spicelib::BSRCHC(NAME, NUMBER, SYMNAM.subarray(1));

    if (LOC == 0) {
        *FOUND = false;
        *PTR = 0;
        *N = 0;
        spicelib::CHKOUT(b"SYPTRC", ctx)?;
        return Ok(());
    }

    *PTR = (spicelib::SUMAI(SYMPTR.subarray(1), (LOC - 1)) + 1);
    *N = SYMPTR[LOC];
    *FOUND = true;

    spicelib::CHKOUT(b"SYPTRC", ctx)?;

    Ok(())
}