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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
//
// GENERATED FILE
//
use super::*;
use crate::SpiceContext;
use f2rust_std::*;
/// Map name of open file to its logical unit.
///
/// Map the name of an open file to its associated logical unit.
///
/// # Brief I/O
///
/// ```text
/// VARIABLE I/O DESCRIPTION
/// -------- --- --------------------------------------------------
/// FILNAM I Name of the file to be mapped to its logical unit.
/// LUNIT O The logical unit associated with the filename.
/// ```
///
/// # Detailed Input
///
/// ```text
/// FILNAM is the filename that is to be mapped to its associated
/// Fortran logical unit.
/// ```
///
/// # Detailed Output
///
/// ```text
/// LUNIT is the Fortran logical unit that is associated with the
/// filename FILNAM. The file must be open for this routine
/// to work properly.
/// ```
///
/// # Exceptions
///
/// ```text
/// 1) If the filename is blank, the error SPICE(BLANKFILENAME) is
/// signaled.
///
/// 2) If an error occurs during the execution of the Fortran INQUIRE
/// statement, the error SPICE(INQUIREFAILED) is signaled.
///
/// 3) If the filename is not associated with an open file, the
/// error SPICE(FILENOTOPEN) is signaled.
///
/// 4) If the filename is not associated with an existing file, the
/// error SPICE(FILEDOESNOTEXIST) is signaled.
///
/// 5) In the event of an error the contents of the variable LUNIT
/// are not defined, and should not be used.
/// ```
///
/// # Particulars
///
/// ```text
/// Use the Fortran INQUIRE statement to determine the filename
/// that is associated with the Fortran logical unit LUNIT.
/// ```
///
/// # Examples
///
/// ```text
/// The following code fragment illustrates the use of FN2LUN.
///
/// C
/// C Convert the logical unit to its filename and display it.
/// C
/// CALL FN2LUN ( FNAME, LUNIT )
/// WRITE (*,*) 'The logical unit is: ', LUNIT
/// ```
///
/// # Author and Institution
///
/// ```text
/// J. Diaz del Rio (ODC Space)
/// K.R. Gehringer (JPL)
/// ```
///
/// # Version
///
/// ```text
/// - SPICELIB Version 1.1.0, 12-AUG-2021 (JDR)
///
/// Added IMPLICIT NONE statement.
///
/// Edited the header to comply with NAIF standard.
///
/// - SPICELIB Version 1.0.0, 16-AUG-1994 (KRG)
/// ```
pub fn fn2lun(ctx: &mut SpiceContext, filnam: &str, lunit: &mut i32) -> crate::Result<()> {
FN2LUN(filnam.as_bytes(), lunit, ctx.raw_context())?;
ctx.handle_errors()?;
Ok(())
}
//$Procedure FN2LUN ( Map name of open file to its logical unit. )
pub fn FN2LUN(FILNAM: &[u8], LUNIT: &mut i32, ctx: &mut Context) -> f2rust_std::Result<()> {
let mut IOSTAT: i32 = 0;
let mut EXISTS: bool = false;
let mut OPENED: bool = false;
//
// SPICELIB functions
//
//
// Local variables
//
//
// Standard SPICE error handling.
//
if RETURN(ctx) {
return Ok(());
} else {
CHKIN(b"FN2LUN", ctx)?;
}
//
// First we test to see if the filename is blank.
//
if fstr::eq(FILNAM, b" ") {
SETMSG(b"The filename is blank.", ctx);
SIGERR(b"SPICE(BLANKFILENAME)", ctx)?;
CHKOUT(b"FN2LUN", ctx)?;
return Ok(());
}
//
// So simple, it defies explanation: just INQUIRE.
//
{
use f2rust_std::io;
let specs = io::InquireSpecs {
file: Some(FILNAM),
number: Some(LUNIT),
exist: Some(&mut EXISTS),
opened: Some(&mut OPENED),
..Default::default()
};
IOSTAT = io::capture_iostat(|| ctx.inquire(specs))?;
}
if (IOSTAT != 0) {
SETMSG(
b"INQUIRE error on file \'#\'. The value of IOSTAT is: #.",
ctx,
);
ERRCH(b"#", FILNAM, ctx);
ERRINT(b"#", IOSTAT, ctx);
SIGERR(b"SPICE(INQUIREFAILED)", ctx)?;
CHKOUT(b"FN2LUN", ctx)?;
return Ok(());
}
//
// A file cannot be open if it does not exist. We need to check this
// because for some environments files are considered to be open if
// they do not exist.
//
if !EXISTS {
SETMSG(b"No file with the name \'#\' was found.", ctx);
ERRCH(b"#", FILNAM, ctx);
SIGERR(b"SPICE(FILEDOESNOTEXIST)", ctx)?;
CHKOUT(b"FN2LUN", ctx)?;
return Ok(());
}
//
// Now check to see if the file is opened. If not, then it is an
// error, there cannot be a logical unit associated with it..
//
if !OPENED {
SETMSG(
b"There was not an open file associated with the filename \'#\'.",
ctx,
);
ERRCH(b"#", FILNAM, ctx);
SIGERR(b"SPICE(FILENOTOPEN)", ctx)?;
CHKOUT(b"FN2LUN", ctx)?;
return Ok(());
}
CHKOUT(b"FN2LUN", ctx)?;
Ok(())
}