rsspice 0.1.0

//
// GENERATED FILE
//

use super::*;
use crate::SpiceContext;
use f2rust_std::*;

pub const CHAR: i32 = 1;
pub const INT: i32 = 3;
const NWC: i32 = 1024;
const NWD: i32 = 128;
const NWI: i32 = 256;
const FWDLOC: i32 = 2;
const CHRRNG: i32 = 3;
const DPRNG: i32 = (CHRRNG + 2);
const INTRNG: i32 = (DPRNG + 2);
const HIGH: i32 = 2;
const BEGDSC: i32 = 9;
const ACCLEN: i32 = 10;
const MAXFIL: i32 = 20;
const MAXVEC: i32 = (3 * MAXFIL);

struct SaveVars {
    ACCESS: Vec<u8>,
    BASERC: i32,
    CURTYP: i32,
    DIRREC: StackArray<i32, 256>,
    DSCLOC: i32,
    FIDX: i32,
    FREE: i32,
    HIADDR: i32,
    LSTREC: StackArray<i32, 3>,
    LSTWRD: StackArray<i32, 3>,
    MXADDR: i32,
    NCOMC: i32,
    NCOMR: i32,
    NDIRS: i32,
    NEXT: StackArray<i32, 3>,
    NFILES: i32,
    NREC: i32,
    NRESVC: i32,
    NRESVR: i32,
    NTYPES: i32,
    NW: StackArray<i32, 3>,
    NXTREC: i32,
    PREV: StackArray<i32, 3>,
    PRVHAN: i32,
    PRVTYP: i32,
    RANGE: StackArray<i32, 2>,
    RNGLOC: StackArray<i32, 3>,
    TBBASE: StackArray2D<i32, 60>,
    TBFWRD: StackArray<i32, 20>,
    TBHAN: StackArray<i32, 20>,
    TBMXAD: StackArray2D<i32, 60>,
    TBSIZE: StackArray2D<i32, 60>,
    UB: i32,
    FAST: bool,
    KNOWN: bool,
    PRVOK: bool,
    TBFAST: StackArray<bool, 20>,
    TBRDON: StackArray<bool, 20>,
    SAMFIL: bool,
    SEGOK: bool,
}

impl SaveInit for SaveVars {
    fn new() -> Self {
        let mut ACCESS = vec![b' '; ACCLEN as usize];
        let mut BASERC: i32 = 0;
        let mut CURTYP: i32 = 0;
        let mut DIRREC = StackArray::<i32, 256>::new(1..=NWI);
        let mut DSCLOC: i32 = 0;
        let mut FIDX: i32 = 0;
        let mut FREE: i32 = 0;
        let mut HIADDR: i32 = 0;
        let mut LSTREC = StackArray::<i32, 3>::new(1..=3);
        let mut LSTWRD = StackArray::<i32, 3>::new(1..=3);
        let mut MXADDR: i32 = 0;
        let mut NCOMC: i32 = 0;
        let mut NCOMR: i32 = 0;
        let mut NDIRS: i32 = 0;
        let mut NEXT = StackArray::<i32, 3>::new(1..=3);
        let mut NFILES: i32 = 0;
        let mut NREC: i32 = 0;
        let mut NRESVC: i32 = 0;
        let mut NRESVR: i32 = 0;
        let mut NTYPES: i32 = 0;
        let mut NW = StackArray::<i32, 3>::new(1..=3);
        let mut NXTREC: i32 = 0;
        let mut PREV = StackArray::<i32, 3>::new(1..=3);
        let mut PRVHAN: i32 = 0;
        let mut PRVTYP: i32 = 0;
        let mut RANGE = StackArray::<i32, 2>::new(1..=2);
        let mut RNGLOC = StackArray::<i32, 3>::new(1..=3);
        let mut TBBASE = StackArray2D::<i32, 60>::new(1..=3, 1..=MAXFIL);
        let mut TBFWRD = StackArray::<i32, 20>::new(1..=MAXFIL);
        let mut TBHAN = StackArray::<i32, 20>::new(1..=MAXFIL);
        let mut TBMXAD = StackArray2D::<i32, 60>::new(1..=3, 1..=MAXFIL);
        let mut TBSIZE = StackArray2D::<i32, 60>::new(1..=3, 1..=MAXFIL);
        let mut UB: i32 = 0;
        let mut FAST: bool = false;
        let mut KNOWN: bool = false;
        let mut PRVOK: bool = false;
        let mut TBFAST = StackArray::<bool, 20>::new(1..=MAXFIL);
        let mut TBRDON = StackArray::<bool, 20>::new(1..=MAXFIL);
        let mut SAMFIL: bool = false;
        let mut SEGOK: bool = false;

        {
            use f2rust_std::data::Val;

            let mut clist = [Val::I(2), Val::I(3), Val::I(1)].into_iter();
            NEXT.iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = [Val::I(3), Val::I(1), Val::I(2)].into_iter();
            PREV.iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = [Val::I(NWC), Val::I(NWD), Val::I(NWI)].into_iter();
            NW.iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = [Val::I(CHRRNG), Val::I(DPRNG), Val::I(INTRNG)].into_iter();
            RNGLOC
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        FAST = false;
        FIDX = 0;
        KNOWN = false;
        NFILES = 0;
        PRVHAN = 0;
        PRVOK = false;
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::I(-1), MAXVEC as usize))
                .chain([]);

            TBBASE
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::L(false), MAXFIL as usize))
                .chain([]);

            TBFAST
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_bool());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::I(-1), MAXFIL as usize))
                .chain([]);

            TBFWRD
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::I(0), MAXFIL as usize))
                .chain([]);

            TBHAN
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::I(-1), MAXVEC as usize))
                .chain([]);

            TBMXAD
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::L(false), MAXFIL as usize))
                .chain([]);

            TBRDON
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_bool());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }
        {
            use f2rust_std::data::Val;

            let mut clist = []
                .into_iter()
                .chain(std::iter::repeat_n(Val::I(-1), MAXVEC as usize))
                .chain([]);

            TBSIZE
                .iter_mut()
                .for_each(|n| *n = clist.next().unwrap().into_i32());

            debug_assert!(clist.next().is_none(), "DATA not fully initialised");
        }

        Self {
            ACCESS,
            BASERC,
            CURTYP,
            DIRREC,
            DSCLOC,
            FIDX,
            FREE,
            HIADDR,
            LSTREC,
            LSTWRD,
            MXADDR,
            NCOMC,
            NCOMR,
            NDIRS,
            NEXT,
            NFILES,
            NREC,
            NRESVC,
            NRESVR,
            NTYPES,
            NW,
            NXTREC,
            PREV,
            PRVHAN,
            PRVTYP,
            RANGE,
            RNGLOC,
            TBBASE,
            TBFWRD,
            TBHAN,
            TBMXAD,
            TBSIZE,
            UB,
            FAST,
            KNOWN,
            PRVOK,
            TBFAST,
            TBRDON,
            SAMFIL,
            SEGOK,
        }
    }
}

/// DAS, address to physical location
///
/// Map a DAS address to a physical location in a specified DAS file.
///
/// # Required Reading
///
/// * [DAS](crate::required_reading::das)
///
/// # Brief I/O
///
/// ```text
///  VARIABLE  I/O  DESCRIPTION
///  --------  ---  --------------------------------------------------
///  HANDLE     I   DAS file handle.
///  TYPE       I   Data type specifier.
///  ADDRSS     I   DAS address of a word of data type TYPE.
///  CLBASE,
///  CLSIZE     O   Cluster base record number and size.
///  RECNO,
///  WORDNO     O   Record/word pair corresponding to ADDRSS.
///  CHAR       P   Parameter indicating character data type.
///  INT        P   Parameter indicating integer data type.
/// ```
///
/// # Detailed Input
///
/// ```text
///  HANDLE   is the file handle of an open DAS file.
///
///  TYPE     is a data type specifier. TYPE may be any of
///           the parameters
///
///              CHAR
///              DP
///              INT
///
///           which indicate `character', `double precision',
///           and `integer' respectively.
///
///
///  ADDRSS   is the address in a DAS of a word of data
///           type TYPE. For each data type (double precision,
///           integer, or character), addresses range
///           from 1 to the maximum current value for that type,
///           which is available from DAFRFR.
/// ```
///
/// # Detailed Output
///
/// ```text
///  CLBASE,
///  CLSIZE   are, respectively, the base record number and
///           size, in records, of the cluster containing the
///           word corresponding to ADDRSS. The cluster spans
///           records numbered CLBASE through CLBASE +
///           CLSIZE - 1.
///
///  RECNO,
///  WORD     are, respectively, the number of the physical
///           record and the number of the word within the
///           record that correspond to ADDRSS. Word numbers
///           start at 1 and go up to NC, ND, or NI in
///           character, double precision, or integer records
///           respectively.
/// ```
///
/// # Parameters
///
/// ```text
///  CHAR,
///  DP,
///  INT      are data type specifiers which indicate
///           `character', `double precision', and `integer'
///           respectively. These parameters are used in
///           all DAS routines that require a data type
///           specifier as input.
/// ```
///
/// # Exceptions
///
/// ```text
///  If any of the following exceptions occur, the output arguments may
///  contain bogus information.
///
///  1)  If TYPE is not recognized, the error SPICE(DASINVALIDTYPE)
///      is signaled.
///
///  2)  ADDRSS must be between 1 and LAST inclusive, where LAST is
///      last address in the DAS for a word of the specified type. If
///      ADDRSS is out of range, the error SPICE(DASNOSUCHADDRESS) is
///      signaled.
///
///  3)  If this routine doesn't find an expected cluster descriptor
///      in a directory record, the error SPICE(BADDASDIRECTORY) is
///      signaled.
///
///  4)  If the input handle is invalid, an error is signaled by a
///      routine in the call tree of this routine.
/// ```
///
/// # Files
///
/// ```text
///  See the description of the argument HANDLE in $Detailed_Input.
/// ```
///
/// # Particulars
///
/// ```text
///  The DAS architecture allows a programmer to think of the data
///  within a DAS file as three one-dimensional arrays: one of
///  double precision numbers, one of integers, and one of characters.
///  This model allows a programmer to ask the DAS system for the
///  `nth double precision number (or integer, or character) in the
///  file'.
///
///  DAS files are Fortran direct access files, so to find the
///  `nth double precision number', you must have the number of the
///  record containing it and the `word number', or position, within
///  the record of the double precision number. This routine finds
///  the record/word number pair that specify the physical location
///  in a DAS file corresponding to a DAS address.
///
///  As opposed to DAFs, the mapping of addresses to physical
///  locations for a DAS file depends on the organization of data in
///  the file. For example, given a fixed set of DAS file summary
///  parameters, the physical location of the nth double precision
///  number can depend on how many integer and character records have
///  been written prior to the record containing that double precision
///  number.
///
///  The cluster information output from this routine allows the
///  caller to substantially reduce the number of directory reads
///  required to read a from range of addresses that spans
///  multiple physical records; the reading program only need call
///  this routine once per cluster read, rather than once per
///  physical record read.
/// ```
///
/// # Examples
///
/// ```text
///  1)  Use this routine to read integers from a range of
///      addresses. This is done in the routine DASRDI.
///
///         C
///         C     Decide how many integers to read.
///         C
///               NUMINT = LAST - FIRST + 1
///               NREAD  = 0
///
///         C
///         C     Find out the physical location of the first
///         C     integer. If FIRST is invalid, DASA2L will take care
///         C     of the problem.
///         C
///               CALL DASA2L (  HANDLE,  INT,     FIRST,
///              .               CLBASE,  CLSIZE,  RECNO,  WORDNO  )
///
///         C
///         C     Read as much data from record RECNO as necessary.
///         C
///               N  =  MIN ( NUMINT,  NWI - WORDNO + 1 )
///
///               CALL DASRRI ( HANDLE, RECNO, WORDNO, WORDNO + N-1,
///              .              DATA                                 )
///
///               NREAD  =  N
///               RECNO  =  RECNO + 1
///
///         C
///         C     Read from as many additional records as necessary.
///         C
///               DO WHILE ( NREAD .LT. NUMINT )
///         C
///         C        At this point, RECNO if RECNO refers to
///         C        a record in the current cluster, RECNO
///         C        is the correct number of the record to read
///         C        from next. Otherwise, the next cluster of
///         C        records containing integer data must be located.
///         C        CLBASE is the number of the first record of
///         C        the cluster we're about to read from.
///         C
///                  IF (  RECNO  .LT.  ( CLBASE + CLSIZE )  ) THEN
///         C
///         C           We can continue reading from the current
///         C           cluster.
///         C
///                     N  =  MIN ( NUMINT - NREAD,  NWI )
///
///                     CALL DASRRI (  HANDLE,
///              .                     RECNO,
///              .                     1,
///              .                     N,
///              .                     DATA ( NREAD + 1 )   )
///
///                     NREAD   =   NREAD + N
///                     RECNO   =   RECNO + 1
///
///
///                  ELSE
///         C
///         C           We must find the next integer cluster to
///         C           read from. The first integer in this
///         C           cluster has address FIRST + NREAD.
///         C
///                     CALL DASA2L ( HANDLE,
///              .                    INT,
///              .                    FIRST + NREAD,
///              .                    CLBASE,
///              .                    CLSIZE,
///              .                    RECNO,
///              .                    WORDNO  )
///
///                  END IF
///
///               END DO
/// ```
///
/// # Author and Institution
///
/// ```text
///  N.J. Bachman       (JPL)
///  J. Diaz del Rio    (ODC Space)
///  K.R. Gehringer     (JPL)
///  W.L. Taber         (JPL)
/// ```
///
/// # Version
///
/// ```text
/// -    SPICELIB Version 3.0.1, 12-AUG-2021 (JDR)
///
///         Edited the header to comply with NAIF standard. Removed
///         unnecessary entries from $Revisions section.
///
/// -    SPICELIB Version 3.0.0, 09-FEB-2015 (NJB)
///
///         Updated to use DAF/DAS handle manager subsystem.
///
/// -    SPICELIB Version 2.0.0, 15-APR-2014 (NJB)
///
///         Previous update was 25-FEB-2014
///
///         Bug fix: value of variable FAST for "unknown" files with one
///         directory record is now stored in TBFAST. The routine
///         previously computed correct outputs but did so more slowly
///         than necessary when multiple "fast" files were accessed.
///
///         Functional change: new entries in the file attribute table are
///         now inserted at index 1; the existing part of the table is
///         shifted to make room. Old entries drop off the end of the
///         list. The previous algorithm simply overwrote the first entry
///         once the table became full.
///
///         The file attribute table was expanded to store values of a
///         "read only" flag for each file. This enables the routine to
///         avoid look up of maximum addresses for known, read-only,
///         non-segregated files.
///
///         Tests of FAILED and backup loop termination checks
///         were added. Logic was introduced to prevent reliance on
///         previous values of logical flags unless those flags were
///         set on a successful call. On any call that fails, the
///         table entry for the current file is marked as unused by
///         setting the handle entry to zero.
///
///         The state variables FIRST and RDONLY have been removed.
///
///         Unneeded declarations were removed.
///
///         The code was re-structured to improve clarity.
///
/// -    SPICELIB Version 1.2.1, 20-NOV-2001 (NJB)
///
///         Comment fix: diagram showing directory record pointers
///         incorrectly showed element 2 of the record as a backward
///         pointer. The element is actually a forward pointer.
///
/// -    SPICELIB Version 1.2.0, 03-JUL-1996 (NJB)
///
///         Bug fix: calculation to determine whether file is segregated
///         has been fixed.
///
/// -    SPICELIB Version 1.1.1, 19-DEC-1995 (NJB)
///
///         Corrected title of permuted index entry section.
///
/// -    SPICELIB Version 1.1.0, 03-NOV-1995 (NJB)
///
///         Re-written to optimize address calculations for segregated,
///         read-only files.
///
/// -    SPICELIB Version 1.0.1, 26-OCT-1993 (KRG)
///
///         Fixed a typo in the $Brief_I/O section of the header.
///
///         Removed references to specific DAS file open routines in the
///         $Detailed_Input section of the header. This was done in order
///         to minimize documentation changes if the DAS open routines ever
///         change.
///
/// -    SPICELIB Version 1.0.0, 11-NOV-1992 (NJB) (WLT)
/// ```
///
/// # Revisions
///
/// ```text
/// -    SPICELIB Version 1.2.0 03-JUL-1996 (NJB)
///
///         Bug fix: calculation to determine whether file is segregated
///         has been fixed. An incorrect variable name used in a bound
///         calculation resulted in an incorrect determination of whether
///         a file was segregated, and caused arithmetic overflow for
///         files with large maximum addresses.
///
///         In the previous version, the number of DAS words in a cluster
///         was incorrectly calculated as the product of the maximum
///         address of the cluster's data type and the number of words of
///         that data type in a DAS record. The correct product involves
///         the number of records in the cluster and the number of words of
///         that data type in a DAS record.
/// ```
pub fn dasa2l(
    ctx: &mut SpiceContext,
    handle: i32,
    type_: i32,
    addrss: i32,
    clbase: &mut i32,
    clsize: &mut i32,
    recno: &mut i32,
    wordno: &mut i32,
) -> crate::Result<()> {
    DASA2L(
        handle,
        type_,
        addrss,
        clbase,
        clsize,
        recno,
        wordno,
        ctx.raw_context(),
    )?;
    ctx.handle_errors()?;
    Ok(())
}

//$Procedure DASA2L ( DAS, address to physical location )
pub fn DASA2L(
    HANDLE: i32,
    TYPE: i32,
    ADDRSS: i32,
    CLBASE: &mut i32,
    CLSIZE: &mut i32,
    RECNO: &mut i32,
    WORDNO: &mut i32,
    ctx: &mut Context,
) -> f2rust_std::Result<()> {
    let save = ctx.get_vars::<SaveVars>();
    let save = &mut *save.borrow_mut();

    //
    // Programmer's note: the TSPICE routine P_DASA2L must be
    // kept in sync with this routine. Current version of that
    // routine is
    //
    //    TSPICE Version 1.0.0 APR-11-2014 (NJB)
    //

    //
    // SPICELIB functions
    //

    //
    // Local parameters
    //

    //
    // Words per data record, for each data type:
    //

    //
    // Directory forward pointer location
    //

    //
    // Directory address range locations
    //

    //
    // Index of highest address in a `range array':
    //

    //
    // Location of first type descriptor
    //

    //
    // Access word length
    //

    //
    // File table size
    //

    //
    // Local variables
    //

    //
    // Saved variables
    //

    //
    // Initial values
    //
    //
    // NEXT and PREV map the DAS data type codes to their
    // successors and predecessors, respectively.
    //

    //
    // Discovery check-in is used in this routine, even though
    // this routine calls routines that can signal errors. This
    // routine is a special case, because fast operation is very
    // important.
    //
    //
    // DAS files have the following general structure:
    //
    //       +------------------------+
    //       |      file record       |
    //       +------------------------+
    //       |    reserved records    |
    //       |                        |
    //       +------------------------+
    //       |     comment records    |
    //       |                        |
    //       |                        |
    //       |                        |
    //       +------------------------+
    //       | first data directory   |
    //       +------------------------+
    //       |      data records      |
    //       |                        |
    //       |                        |
    //       |                        |
    //       |                        |
    //       +------------------------+
    //                   .
    //                   .
    //       +------------------------+
    //       | last data directory    |
    //       +------------------------+
    //       |     data records       |
    //       |                        |
    //       |                        |
    //       +------------------------+
    //
    //
    //    Within each DAS data record, word numbers start at one and
    //    increase up to NWI, NWD, or NWC: the number of words in an
    //    integer, double precision, or character data record.
    //
    //
    //       +--------------------------------+
    //       |       |       |   ...  |       |
    //       +--------------------------------+
    //           1      2                NWD
    //
    //       +--------------------------------+
    //       |   |   |       ...          |   |
    //       +--------------------------------+
    //         1   2                       NWI
    //
    //       +------------------------------------+
    //       | | |           ...                | |
    //       +------------------------------------+
    //        1 2                               NWC
    //
    //
    //    Directories are single records that describe the data
    //    types of data records that follow. The directories
    //    in a DAS file form a doubly linked list: each directory
    //    contains forward and backward pointers to the next and
    //    previous directories.
    //
    //    Each directory also contains, for each data type, the lowest
    //    and highest logical address occurring in any of the records
    //    described by the directory.
    //
    //    Following the pointers and address range information is
    //    a sequence of data type descriptors. These descriptors
    //    indicate the data type of data records following the
    //    directory record. Each descriptor gives the data type
    //    of a maximal set of contiguous data records, all having the
    //    same type. By `maximal set' we mean that no data records of
    //    the same type bound the set of records in question.
    //
    //    Pictorially, the structure of a directory is as follows:
    //
    //       +----------------------------------------------------+
    //       | <pointers> | <address ranges> | <type descriptors> |
    //       +----------------------------------------------------+
    //
    //    where the <pointers> section looks like
    //
    //       +-----------------------------------------+
    //       | <backward pointer> | <forward pointer>  |
    //       +-----------------------------------------+
    //
    //    the <address ranges> section looks like
    //
    //       +-------------------------------------------+
    //       | <char range> | <d.p. range> | <int range> |
    //       +-------------------------------------------+
    //
    //    and each range looks like one of:
    //
    //       +------------------------------------------------+
    //       | <lowest char address> | <highest char address> |
    //       +------------------------------------------------+
    //
    //       +------------------------------------------------+
    //       | <lowest d.p. address> | <highest d.p. address> |
    //       +------------------------------------------------+
    //
    //       +------------------------------------------------+
    //       | <lowest int address>  | <highest int address>  |
    //       +------------------------------------------------+
    //
    //    The type descriptors implement a run-length encoding
    //    scheme. The first element of the series of descriptors
    //    occupies two integers: it contains a type code and a count.
    //    The rest of the descriptors are just signed counts; the data
    //    types of the records they describe are deduced from the sign
    //    of the count and the data type of the previous descriptor.
    //    The method of finding the data type for a given descriptor
    //    in terms of its predecessor is as follows: if the sign of a
    //    descriptor is positive, the type of that descriptor is the
    //    successor of the type of the preceding descriptor in the
    //    sequence of types below. If the sign of a descriptor is
    //    negative, the type of the descriptor is the predecessor of the
    //    type of the preceding descriptor.
    //
    //       C  -->  D  -->  I  -->  C
    //
    //    For example, if the preceding type is `I', and a descriptor
    //    contains the number 16, the type of the descriptor is `C',
    //    whereas if the descriptor contained the number -800, the type
    //    of the descriptor would be `D'.
    //
    //
    // Logic cases
    // ===========
    //
    // There are three kinds of file attributes that this
    // routine distinguishes:
    //
    //    Attributes
    //    ----------
    //    "FAST"           read-only and segregated
    //    "READONLY"       read-only and unsegregated
    //    "WRITABLE"       writable
    //
    // There are three kinds of file histories that this
    // routine distinguishes:
    //
    //    History
    //    -------
    //    "SAME"           file is the same as seen on
    //                     the previous call
    //
    //    "KNOWN"          file is not the same as seen
    //                     on the previous call, but file
    //                     information is buffered
    //
    //    "UNKNOWN"        file information is not buffered.
    //
    // All combinations of attributes and history are possible,
    // so there are nine cases.
    //
    // Mapping actions to cases
    // ========================
    //
    //    Action                             Cases
    //    ------                             -----
    //    Set SAMFIL, PRVOK                  ALL
    //    Data type check                    ALL
    //    Set KNOWN                          not (FAST and SAME)
    //    Get access method                  UNKNOWN
    //    Buffer insertion                   UNKNOWN
    //    Set
    //        TBHAN
    //        TBRDON
    //        TBFAST
    //        TBFWRD                         UNKNOWN
    //    Get file summary                   UNKNOWN or WRITABLE
    //    Set TBMXAD                         UNKNOWN or WRITABLE
    //    Segregation check                  UNKNOWN and not WRITABLE
    //    Set TBBASE, TBSIZE                 FAST and UNKNOWN
    //    Set FAST                           not SAME
    //    Address range check                ALL
    //    Address search                     READONLY or WRITABLE
    //    Set CLBASE, CLSIZE                 ALL
    //
    // ========================
    //
    //
    // Make sure the data type is valid.
    //
    if ((TYPE < CHAR) || (TYPE > INT)) {
        CHKIN(b"DASA2L", ctx)?;
        SETMSG(b"Invalid data type: #. File was #", ctx);
        ERRINT(b"#", TYPE, ctx);
        ERRHAN(b"#", HANDLE, ctx)?;
        SIGERR(b"SPICE(DASINVALIDTYPE)", ctx)?;
        CHKOUT(b"DASA2L", ctx)?;
        return Ok(());
    }

    //
    // Decide whether we're looking at the same file as we did on the
    // last call. We can use data from the previous call only if that
    // call succeeded.
    //
    save.SAMFIL = ((HANDLE == save.PRVHAN) && save.PRVOK);
    //
    // PRVOK defaults to .FALSE. and will be reset if this call
    // succeeds.
    //
    save.PRVOK = false;

    //
    // Fast files get priority handling. If we have a fast file
    // that we saw on the previous call, skip directly to the
    // address range check.
    //
    if !(save.FAST && save.SAMFIL) {
        //
        // Is this a file we recognize?
        //
        if save.SAMFIL {
            save.KNOWN = true;
        } else {
            save.FIDX = ISRCHI(HANDLE, save.NFILES, save.TBHAN.as_slice());
            save.KNOWN = (save.FIDX > 0);
        }

        if save.KNOWN {
            save.FAST = save.TBFAST[save.FIDX];
        } else {
            //
            // This file is not in our list. We'll buffer information
            // about this file.
            //
            // Shift the table and insert the new entry at the front. The
            // entry at the back will be lost if the table is full.
            //
            // Note that unused entries (those for which the DAS handle is
            // 0) will drop out of the list automatically.
            //
            save.UB = intrinsics::MIN0(&[save.NFILES, (MAXFIL - 1)]);

            for I in intrinsics::range(save.UB, 1, -1) {
                save.TBHAN[(I + 1)] = save.TBHAN[I];
                save.TBRDON[(I + 1)] = save.TBRDON[I];
                save.TBFAST[(I + 1)] = save.TBFAST[I];
                save.TBFWRD[(I + 1)] = save.TBFWRD[I];

                for J in 1..=3 {
                    save.TBBASE[[J, (I + 1)]] = save.TBBASE[[J, I]];
                    save.TBSIZE[[J, (I + 1)]] = save.TBSIZE[[J, I]];
                    save.TBMXAD[[J, (I + 1)]] = save.TBMXAD[[J, I]];
                }
            }
            //
            // Insert the new table entry at index 1.
            //
            save.NFILES = intrinsics::MIN0(&[(save.NFILES + 1), MAXFIL]);
            save.FIDX = 1;
            save.TBHAN[save.FIDX] = HANDLE;
            //
            // Set FAST to .FALSE. until we find out whether the file
            // is read-only and segregated.
            //
            save.FAST = false;
            save.TBFAST[save.FIDX] = save.FAST;
            //
            // FIDX is now set whether or not the current file is known.
            //
            // TBRDON(FIDX) and TBFAST(FIDX) are set.
            //
            // Find out whether the file is open for read or write access.
            // We consider the file to be `slow' until we find out
            // otherwise. The contents of the arrays TBBASE, TBSIZE, and
            // TBMXAD are left undefined for slow files.
            //
            DASHAM(HANDLE, &mut save.ACCESS, ctx)?;

            if FAILED(ctx) {
                //
                // Make sure the current table entry won't be found
                // on a subsequent search.
                //
                save.TBHAN[save.FIDX] = 0;
                return Ok(());
            }

            //
            // TBRDON(FIDX) indicates whether the file is read-only.
            //
            save.TBRDON[save.FIDX] = fstr::eq(&save.ACCESS, b"READ");
        }

        //
        // FIDX, KNOWN and TBRDON( FIDX ) are set.
        //
        // Get the file summary if it isn't known already.
        //
        if !(save.KNOWN && save.TBRDON[save.FIDX]) {
            //
            // The file is new or it's writable; in either case the
            // maximum addresses are unknown. Get the current address
            // range for the file.
            //
            DASHFS(
                HANDLE,
                &mut save.NRESVR,
                &mut save.NRESVC,
                &mut save.NCOMR,
                &mut save.NCOMC,
                &mut save.FREE,
                save.TBMXAD.subarray_mut([1, save.FIDX]),
                save.LSTREC.as_slice_mut(),
                save.LSTWRD.as_slice_mut(),
                ctx,
            )?;

            if FAILED(ctx) {
                //
                // Make sure the current table entry won't be found
                // on a subsequent search.
                //
                save.TBHAN[save.FIDX] = 0;
                return Ok(());
            }

            //
            // Set the forward cluster pointer.
            //
            save.TBFWRD[save.FIDX] = ((save.NRESVR + save.NCOMR) + 2);
        }

        //
        // TBMXAD is set.
        //
        // If this is an unknown file and is read-only, determine
        // whether the file is segregated
        //
        if (!save.KNOWN && save.TBRDON[save.FIDX]) {
            //
            // The file is read-only; we need to know whether it is
            // segregated. If so, there are at most three cluster
            // descriptors, and the first directory record's maximum
            // address for each type matches the last logical address for
            // that type.
            //
            // FAST has been initialized to .FALSE. above.
            //
            // NREC is the record number of the first directory record.
            //
            save.NREC = save.TBFWRD[save.FIDX];

            DASRRI(HANDLE, save.NREC, 1, NWI, save.DIRREC.as_slice_mut(), ctx)?;

            save.NXTREC = save.DIRREC[FWDLOC];

            if (save.NXTREC <= 0) {
                //
                // If this file is segregated, there are at most three
                // cluster descriptors, and each one points to a cluster
                // containing all records of the corresponding data type.
                // For each data type having a non-zero maximum address,
                // the size of the corresponding cluster must be large
                // enough to hold all addresses of that type.
                //
                save.NTYPES = 0;

                for I in 1..=3 {
                    if (save.TBMXAD[[I, save.FIDX]] > 0) {
                        save.NTYPES = (save.NTYPES + 1);
                    }
                }

                //
                // Now look at the first NTYPES cluster descriptors,
                // collecting cluster bases and sizes as we go.
                //
                save.BASERC = (save.NREC + 1);
                save.PRVTYP = save.PREV[save.DIRREC[BEGDSC]];
                save.DSCLOC = (BEGDSC + 1);
                save.SEGOK = true;

                while ((save.DSCLOC <= (BEGDSC + save.NTYPES)) && save.SEGOK) {
                    //
                    // Find the type of the current descriptor.
                    //
                    if (save.DIRREC[save.DSCLOC] > 0) {
                        save.CURTYP = save.NEXT[save.PRVTYP];
                    } else {
                        save.CURTYP = save.PREV[save.PRVTYP];
                    }

                    save.PRVTYP = save.CURTYP;
                    save.TBBASE[[save.CURTYP, save.FIDX]] = save.BASERC;
                    save.TBSIZE[[save.CURTYP, save.FIDX]] = i32::abs(save.DIRREC[save.DSCLOC]);
                    save.BASERC = (save.BASERC + save.TBSIZE[[save.CURTYP, save.FIDX]]);

                    save.SEGOK = (save.TBMXAD[[save.CURTYP, save.FIDX]]
                        <= (save.TBSIZE[[save.CURTYP, save.FIDX]] * save.NW[save.CURTYP]));

                    save.DSCLOC = (save.DSCLOC + 1);
                    //
                    // This loop will terminate after at most 3
                    // iterations. No further checks are needed.
                    //
                }

                //
                // Update FAST and TBFAST based on the segregation check.
                //
                save.FAST = save.SEGOK;
                save.TBFAST[save.FIDX] = save.FAST;
                //
                // If the file is FAST,
                //
                //    TBBASE
                //    TBSIZE
                //
                // have been updated as well.
                //
            }
        }
        //
        // End of the segregation check.
        //
    }
    //
    // End of the NOT FAST or NOT SAME case.
    //
    // At this point we have the logical address ranges for the
    // file. Check the input address against them.
    //
    save.MXADDR = save.TBMXAD[[TYPE, save.FIDX]];

    if ((ADDRSS < 1) || (ADDRSS > save.MXADDR)) {
        //
        // Make sure the current table entry won't be found on a
        // subsequent search.
        //
        save.TBHAN[save.FIDX] = 0;

        CHKIN(b"DASA2L", ctx)?;
        SETMSG(
            b"ADDRSS was #; valid range for type # is # to #.  File was #",
            ctx,
        );
        ERRINT(b"#", ADDRSS, ctx);
        ERRINT(b"#", TYPE, ctx);
        ERRINT(b"#", 1, ctx);
        ERRINT(b"#", save.MXADDR, ctx);
        ERRHAN(b"#", HANDLE, ctx)?;
        SIGERR(b"SPICE(DASNOSUCHADDRESS)", ctx)?;
        CHKOUT(b"DASA2L", ctx)?;
        return Ok(());
    }

    //
    // If we're looking at a "fast" file, we know the cluster base and
    // size. HIADDR is the highest address (not necessarily in use) in
    // the cluster.
    //
    if save.TBFAST[save.FIDX] {
        //
        // The current file is "fast": read-only and segregated.
        //
        *CLBASE = save.TBBASE[[TYPE, save.FIDX]];
        *CLSIZE = save.TBSIZE[[TYPE, save.FIDX]];
        save.HIADDR = (*CLSIZE * save.NW[TYPE]);
    } else {
        //
        // If we're not looking at a "fast" file, find the cluster
        // containing the input address, for the input data type.
        //
        // Find out which directory describes the cluster containing this
        // word. To do this, we must traverse the directory list. The
        // first directory record comes right after the last comment
        // record. (Don't forget the file record when counting the
        // predecessors of the directory record.)
        //
        // Note that we don't need to worry about not finding a directory
        // record that contains the address we're looking for, since
        // we've already checked that the address is in range.
        //
        save.NREC = save.TBFWRD[save.FIDX];
        save.NDIRS = 1;

        DASRRI(
            HANDLE,
            save.NREC,
            save.RNGLOC[TYPE],
            (save.RNGLOC[TYPE] + 1),
            save.RANGE.as_slice_mut(),
            ctx,
        )?;

        while (save.RANGE[HIGH] < ADDRSS) {
            //
            // The record number of the next directory is the forward
            // pointer in the current directory record. Update NREC with
            // this pointer. Get the address range for the specified type
            // covered by this next directory record.
            //
            DASRRI(
                HANDLE,
                save.NREC,
                FWDLOC,
                FWDLOC,
                std::slice::from_mut(&mut save.NXTREC),
                ctx,
            )?;

            save.NREC = save.NXTREC;
            save.NDIRS = (save.NDIRS + 1);

            DASRRI(
                HANDLE,
                save.NREC,
                save.RNGLOC[TYPE],
                (save.RNGLOC[TYPE] + 1),
                save.RANGE.as_slice_mut(),
                ctx,
            )?;

            if FAILED(ctx) {
                //
                // Make sure the current table entry won't be found
                // on a subsequent search.
                //
                save.TBHAN[save.FIDX] = 0;

                return Ok(());
            }
        }

        //
        // NREC is now the record number of the directory that contains
        // the type descriptor for the address we're looking for.
        //
        // Our next task is to find the descriptor for the cluster
        // containing the input address. To do this, we must examine the
        // directory record in `left-to-right' order. As we do so, we'll
        // keep track of the highest address of type TYPE occurring in
        // the clusters whose descriptors we've seen. The variable HIADDR
        // will contain this address.
        //
        DASRRI(HANDLE, save.NREC, 1, NWI, save.DIRREC.as_slice_mut(), ctx)?;

        if FAILED(ctx) {
            //
            // Make sure the current table entry won't be found on a
            // subsequent search.
            //
            save.TBHAN[save.FIDX] = 0;

            return Ok(());
        }

        //
        // In the process of finding the physical location corresponding
        // to ADDRSS, we'll find the record number of the base of the
        // cluster containing ADDRSS. We'll start out by initializing
        // this value with the number of the first data record of the
        // next cluster.
        //
        *CLBASE = (save.NREC + 1);

        //
        // We'll initialize HIADDR with the value preceding the lowest
        // address of type TYPE described by the current directory.
        //
        save.HIADDR = (save.DIRREC[save.RNGLOC[TYPE]] - 1);

        //
        // Initialize the number of records described by the last seen
        // type descriptor. This number, when added to CLBASE, should
        // yield the number of the first record of the current cluster;
        // that's why it's initialized to 0.
        //
        *CLSIZE = 0;

        //
        // Now find the descriptor for the cluster containing ADDRSS.
        // Read descriptors until we get to the one that describes the
        // record containing ADDRSS. Keep track of descriptor data
        // types as we go. Also count the descriptors.
        //
        // At this point, HIADDR is less than ADDRSS, so the loop will
        // always be executed at least once.
        //
        save.PRVTYP = save.PREV[save.DIRREC[BEGDSC]];
        save.DSCLOC = (BEGDSC + 1);

        while (save.HIADDR < ADDRSS) {
            if (save.DSCLOC > NWI) {
                //
                // This situation shouldn't occur, but it might if the
                // DAS file is corrupted.
                //
                // Make sure the current table entry won't be found
                // on a subsequent search.
                //
                save.TBHAN[save.FIDX] = 0;

                CHKIN(b"DASA2L", ctx)?;
                SETMSG(b"Directory record # in DAS file with handle # is probably corrupted. No high cluster address at or above the input address # was found, though it should have been. High address was #. Data type was #.", ctx);
                ERRINT(b"#", save.NREC, ctx);
                ERRINT(b"#", HANDLE, ctx);
                ERRINT(b"#", ADDRSS, ctx);
                ERRINT(b"#", save.HIADDR, ctx);
                ERRINT(b"#", TYPE, ctx);
                SIGERR(b"SPICE(BADDASDIRECTORY)", ctx)?;
                CHKOUT(b"DASA2L", ctx)?;
                return Ok(());
            }
            //
            // Update CLBASE so that it is the record number of the
            // first record of the current cluster.
            //
            *CLBASE = (*CLBASE + *CLSIZE);
            //
            // Find the type of the current descriptor.
            //
            if (save.DIRREC[save.DSCLOC] > 0) {
                save.CURTYP = save.NEXT[save.PRVTYP];
            } else {
                save.CURTYP = save.PREV[save.PRVTYP];
            }

            //
            // Forgetting to update PRVTYP is a Very Bad Thing (VBT).
            //
            save.PRVTYP = save.CURTYP;

            //
            // If the current descriptor is of the type we're interested
            // in, update the highest address count.
            //
            if (save.CURTYP == TYPE) {
                save.HIADDR = (save.HIADDR + (save.NW[TYPE] * i32::abs(save.DIRREC[save.DSCLOC])));
            }

            //
            // Compute the number of records described by the current
            // descriptor. Update the descriptor location.
            //
            *CLSIZE = i32::abs(save.DIRREC[save.DSCLOC]);
            save.DSCLOC = (save.DSCLOC + 1);
        }
        //
        // At this point, the variables
        //
        //    CLBASE
        //    CLSIZE
        //    HIADDR
        //
        // are set.
        //
    }

    //
    // At this point,
    //
    //    -- CLBASE is properly set: it is the record number of the
    //       first record of the cluster containing ADDRSS.
    //
    //    -- CLSIZE is properly set: it is the size of the cluster
    //       containing ADDRSS.
    //
    //    -- HIADDR is the last logical address in the cluster
    //       containing ADDRSS.
    //
    // Now we must find the physical record and word corresponding
    // to ADDRSS. The structure of the cluster containing ADDRSS and
    // HIADDR is shown below:
    //
    //    +--------------------------------------+
    //    |                                      |  Record # CLBASE
    //    +--------------------------------------+
    //                       .
    //                       .
    //                       .
    //    +--------------------------------------+
    //    |      |ADDRSS|                        |  Record # RECNO
    //    +--------------------------------------+
    //                       .
    //                       .
    //                       .
    //    +--------------------------------------+  Record #
    //    |                               |HIADDR|
    //    +--------------------------------------+  CLBASE + CLSIZE - 1
    //
    //
    *RECNO = (((*CLBASE + *CLSIZE) - 1) - ((save.HIADDR - ADDRSS) / save.NW[TYPE]));

    *WORDNO = (ADDRSS - (((ADDRSS - 1) / save.NW[TYPE]) * save.NW[TYPE]));
    //
    // Update PRVHAN and set PRVOK to .TRUE. only if the call succeeded.
    //
    save.PRVHAN = HANDLE;
    save.PRVOK = true;

    Ok(())
}