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
135
136
137
138
139
140

//
// GENERATED FILE
//

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

const ENCSIZ: i32 = 5;
const CPSIZE: i32 = 1014;
const CFPIDX: i32 = (CPSIZE + 1);
const CLCIDX: i32 = (CFPIDX + ENCSIZ);
const DPSIZE: i32 = 126;
const DFPIDX: i32 = (DPSIZE + 1);
const DLCIDX: i32 = (DFPIDX + 1);
const IPSIZE: i32 = 254;
const IFPIDX: i32 = (IPSIZE + 1);
const ILCIDX: i32 = (IFPIDX + 1);
const SDSCSZ: i32 = 24;
const EKTIDX: i32 = 1;
const SNOIDX: i32 = (EKTIDX + 1);
const IMDIDX: i32 = (SNOIDX + 1);
const TNMIDX: i32 = (IMDIDX + 1);
const NCIDX: i32 = (TNMIDX + 1);
const NRIDX: i32 = (NCIDX + 1);
const RTIDX: i32 = (NRIDX + 1);
const CPTIDX: i32 = (RTIDX + 1);
const DPTIDX: i32 = (CPTIDX + 1);
const IPTIDX: i32 = (DPTIDX + 1);
const MFLIDX: i32 = (IPTIDX + 1);
const IFLIDX: i32 = (MFLIDX + 1);
const SHDIDX: i32 = (IFLIDX + 1);
const CFHIDX: i32 = (SHDIDX + 1);
const CSNIDX: i32 = (CFHIDX + 1);
const LCPIDX: i32 = (CSNIDX + 1);
const LDPIDX: i32 = (LCPIDX + 1);
const LIPIDX: i32 = (LDPIDX + 1);
const LCWIDX: i32 = (LIPIDX + 1);
const LDWIDX: i32 = (LCWIDX + 1);
const LIWIDX: i32 = (LDWIDX + 1);
const NMLIDX: i32 = (LIWIDX + 1);
const CHR: i32 = 1;
const DP: i32 = 2;
const INT: i32 = 3;
const TIME: i32 = 4;

//$Procedure      ZZEKDPS ( EK, delete page from segment )
pub fn ZZEKDPS(
    HANDLE: i32,
    SEGDSC: &mut [i32],
    TYPE: i32,
    P: i32,
    ctx: &mut Context,
) -> f2rust_std::Result<()> {
    let mut SEGDSC = DummyArrayMut::new(SEGDSC, 1..=SDSCSZ);
    let mut MBASE: i32 = 0;
    let mut LOC: i32 = 0;
    let mut TREE: i32 = 0;

    //
    // SPICELIB functions
    //

    //
    // Non-SPICELIB functions
    //

    //
    // Local variables
    //

    //
    // Use discovery check-in.
    //
    //
    // Ashes to ashes, dust to dust.  This page goes to the free list.
    //
    ZZEKPGFR(HANDLE, TYPE, P, ctx)?;

    if FAILED(ctx) {
        return Ok(());
    }

    //
    // Update the segment's metadata.  For type 1 segments,
    // the new page into the page tree of the appropriate data type.
    //
    // If this page is the last one in use in the segment, set the last
    // word in use of the appropriate type to the maximum number.  This
    // prevents further writing to the page we're deleting.
    //
    MBASE = SEGDSC[IMDIDX];

    if (TYPE == CHR) {
        TREE = SEGDSC[CPTIDX];

        if (SEGDSC[LCPIDX] == P) {
            DASUDI(HANDLE, (MBASE + LCWIDX), (MBASE + LCWIDX), &[CPSIZE], ctx)?;
        }

        if (P == SEGDSC[LCPIDX]) {
            SEGDSC[LCWIDX] = CPSIZE;
        }
    } else if (TYPE == DP) {
        TREE = SEGDSC[DPTIDX];

        if (SEGDSC[LDPIDX] == P) {
            DASUDI(HANDLE, (MBASE + LDWIDX), (MBASE + LDWIDX), &[DPSIZE], ctx)?;
        }

        if (P == SEGDSC[LDPIDX]) {
            SEGDSC[LDWIDX] = DPSIZE;
        }
    } else if (TYPE == INT) {
        //
        // The remaining possibility is that TYPE is INT.  If we had had
        // an unrecognized type, one of the allocation routines would have
        // complained.
        //
        TREE = SEGDSC[IPTIDX];

        if (SEGDSC[LIPIDX] == P) {
            DASUDI(HANDLE, (MBASE + LIWIDX), (MBASE + LIWIDX), &[IPSIZE], ctx)?;
        }

        if (P == SEGDSC[LIPIDX]) {
            SEGDSC[LIWIDX] = IPSIZE;
        }
    }

    //
    // Remove the page's number from the data page tree of the
    // appropriate type.  This removal requires finding the key that
    // points to the page to be removed.
    //
    LOC = ZZEKTRLS(HANDLE, TREE, P, ctx)?;

    ZZEKTRDL(HANDLE, TREE, LOC, ctx)?;

    Ok(())
}