
>>>>>>>>>>>>>>>>>>> FILE: ../sys/errmsg.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE ERRINI
C
C     SUBROUTINE ERRMSG( STR)
      CHARACTER*(*)      STR
C
C     SUBROUTINE ERRWRT( STR)
C
C     SUBROUTINE ERRGUN( ERRU)
      INTEGER            ERRU
C
C     SUBROUTINE ERRPRM( STR, RDU)
      INTEGER            RDU
C
C     SUBROUTINE ERRABT( CALLER, MSG)
      CHARACTER*(*)      CALLER, MSG
C
C-----------------------------------------------------------------------
C  ERRINI (ERRor INItialize) opens a connection to the standard error
C  device STDERR (which is usually the user's screen).
C
C-----------------------------------------------------------------------
C  ERRMSG (ERRor MeSsaGe) writes a specified message string to both the
C  STDERR and STDOUT devices.  The output to STDERR occurs only if
C  ERRINI has been called to open the connection to STDERR.  Trailing
C  blanks are truncated from the string on output.
C
C  Input:
C   STR  String to write to STDERR and STDOUT.
C
C-----------------------------------------------------------------------
C  ERRWRT (ERRor WRiTe) writes a specified string to the STDERR device.
C  If ERRINI has not been called to open the connection to STDERR, the
C  string is written to STDOUT instead.  Trailing blanks are truncated
C  from the string on output.
C
C  Input:
C   STR  String to write to STDERR and STDOUT.
C
C-----------------------------------------------------------------------
C  ERRGUN (ERRor Get Unit Number) returns the unit number associated
C  with error output.  If ERRINI has been called, the unit number is
C  associated with STDERR.  Otherwise, it is associated with STDOUT.
C
C  Output:
C   ERRU  Unit number of connection to STDERR.
C
C-----------------------------------------------------------------------
C  ERRPRM (ERRor PRoMt) prompts the user for input by writing the
C  specified string to either STDERR or STDIN.  The former device is
C  used if ERRINI has been called, the latter device if ERRINI has not
C  been called.  The full length of the prompt string is output, without
C  truncation of trailing blanks.  The unit number to use for reading
C  the response is returned.
C
C  Input:
C   STR  Prompt string.
C
C  Output:
C   RDU  Unit number for response input.
C
C-----------------------------------------------------------------------
C  ERRABT (ERRor ABorT) writes a message line and a line indicating the
C  name of the calling routine to both STDERR and STDOUT and then
C  terminates execution.  The output to STDERR occurs only if ERRINI has
C  been called to open the connection to STDERR.
C
C  Inputs:
C   CALLER  Name of the calling routine.
C   MSG     Message describing the reason for the abort;
C            not written if blank.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/exauth.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE     EXAUTH( CALLER)
      CHARACTER*(*)  CALLER
C
C-----------------------------------------------------------------------
C  EXAUTH (EXport runtime AUTHorization) allows only specified machines
C  to execute the calling program.
C
C  Input:
C   CALLER  Name of calling program.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/getcla.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE GETCLA( ARG, L)
      CHARACTER*(*)      ARG
      INTEGER            L
C
C     SUBROUTINE GETCLR( INCPRV, LIN, L)
      LOGICAL            INCPRV
      CHARACTER*(*)      LIN
C
C     SUBROUTINE GETCLN( NUM, ARG, L)
      INTEGER            NUM
C
C     SUBROUTINE GETCLI
C
C     SUBROUTINE NCLARG( NUM)
C
C-----------------------------------------------------------------------
C  GETCLA (GET Command Line Argument) returns the next argument from the
C  command line, along with the trimmed length of the argument.  The
C  first time GETCLA is called, the first argument is returned.  If
C  there are no more arguments to return, GETCLA returns with the length
C  of the argument set to -1.  The command line is parsed into arguments
C  according to the rules of the operating system in use.
C
C  Outputs:
C   ARG     Command line argument.
C   L       Trimmed length of the argument, or -1 if no more arguments.
C
C-----------------------------------------------------------------------
C  GETCLR (GET Command Line Remaining text) returns the remaining text
C  on the command line, in as unparsed a form as possible.  In
C  implementations where the raw command line is not available, specific
C  assumptions are made about the command line in order to undo the
C  operating system's parsing into arguments.
C
C  Input:
C   INCPRV  Flag set TRUE to include the previous command line argument
C           in the text returned in LIN.  This flag has no effect if
C           GETCLA was not called previously.
C
C  Outputs:
C   LIN     Remaining text on command line.
C   L       Trimmed length of LIN; zero if LIN is all blanks.
C
C-----------------------------------------------------------------------
C  GETCLN (GET Command Line argument N) returns the Nth argument from
C  the command line, along with the trimmed length of the argument.  If
C  the index N is invalid, GETCLN returns with the length of the
C  argument set to -1.
C
C  Input:
C   N   Index of requested argument (0 returns the command name).
C
C  Outputs:
C   ARG     Command line argument.
C   L       Trimmed length of the argument, or -1 if no more arguments.
C
C-----------------------------------------------------------------------
C  GETCLI (GET Command Line Initialize).  Resets the argument index
C  back to the beginning of the line.
C
C-----------------------------------------------------------------------
C  NCLARG( Number of Command Line ARGuments) returns the number of
C  arguments available.
C
C  Outputs:
C   NUM     Number of command line arguments available.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/getenv.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE GETENV( VARNAME, VALUE)
      CHARACTER*(*)      VARNAME, VALUE
C
C-----------------------------------------------------------------------
C  GETENV (GET ENVironment) retreives the value of a specified
C  environment variable.
C
C  Input:
C   VARNAME  Character constant or variable containing the name of the
C            environment variable.
C
C  Output:
C   VALUE    Character variable into which is placed the current string
C            value of the environment variable.  If the string is
C            shorter than the length of VALUE, it is padded with
C            spaces; if the string is longer, it is truncated.  If the
C            variable is not currently defined, VALUE is filled with
C            spaces.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/lentrm.fpp <<<<<<<<<<<<<<<<<<<

      INTEGER FUNCTION LENTRM( STR)
      CHARACTER*(*)            STR
C
C-----------------------------------------------------------------------
C  LENTRM (LENgth TRiM) returns the length of a specified string
C  excluding trailing spaces.  If available, a system supplied version
C  will be called.
C
C  Inputs:
C   STR  String
C
C  Output:
C   <value of function>  Number of characters in STR, excluding trailing
C                        spaces, or 0, if STR is all spaces.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/oscomp.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE     OSCOMP( OS, COMP)
      CHARACTER*(*)  OS, COMP
C
C     SUBROUTINE     OSCOMN( MNM)
      CHARACTER*(*)  MNM
C
C-----------------------------------------------------------------------
C  OSCOMP (Operating System and COMPiler) returns the name of the
C  operating system under which the current program is running, and the
C  name of the compiler used to compile the program.
C
C  Outputs:
C   OS    Name of the operating system.
C   COMP  Name of the compiler.
C
C-----------------------------------------------------------------------
C  OSCOMN (Operating System and COmpiler MNemonic) returns a single
C  string mnemonic which identifies the current operating system and the
C  compiler used to compile the program.  This is an abbreviated version
C  of OSCOMP.
C
C  Output:
C   MNM   Mnemonic which identifies the OS and compiler.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/parsfn.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE PARSFN( FNAME, DEXT, PATH, BASE, EXT)
      CHARACTER*(*)      FNAME, DEXT, PATH, BASE, EXT
C
C     SUBROUTINE MAKEFN( PATH, BASE, EXT, FNAME)
C
C-----------------------------------------------------------------------
C  PARSFN (PARSe File Name) returns the path, basename, and extension of
C  a file specification.  This routine is system dependent because
C  different systems use different delimiters for drives, directories,
C  and extensions.  On systems such as UNIX, that allow the extension
C  delimiter to appear within the basename, the extension is defined as
C  that part of the file specification following the last extension
C  delimiter.  If the path or basename is omitted, this routine sets the
C  corresponding output variables to blanks.  If the extension is
C  omitted, the behavior of the routine depends on the system.  On
C  systems like DOS which commonly support default extensions, the
C  routine sets EXT to the default extension; on other systems such as
C  UNIX, EXT is set to blanks.  No error checking is performed to ensure
C  that output variables are long enough to contain the returned
C  strings; if not, the strings are simply truncated.
C
C  Input:
C   FNAME  Complete file specification.
C   DEXT   Default file extension.  A leading file extension delimiter
C          is optional.
C
C  Outputs:
C   PATH   Path name to file, including drive specification, if
C          specified, and trailing delimiter, if present.
C   BASE   Base name of file, excluding path and extension.
C   EXT    File extension, including the extension delimter as the first
C          character.
C
C-----------------------------------------------------------------------
C  MAKEFN (MAKE File Name) constructs a file specification from the
C  specified path, basename, and extension.  The path and extension may
C  be blank.  No error checking is performed: the output argument FNAME
C  must be long enough to contain the resulting file specification.
C
C  Inputs:
C   PATH   Path name to file, including optional drive specifier,
C          and optional trailing delimiter.  PATH may be blank.
C   BASE   Base name of file, excluding path and extension.
C          BASE must not be blank.
C   EXT    Extension to the filename, including optional leading
C          extension delimiter.  EXT may be blank.
C
C  Output:
C   FNAME  Complete file specification.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/prgdsp.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE PRGDSP( STR)
      CHARACTER*(*)      STR
C
C     SUBROUTINE PRGINI( STR)
C
C     SUBROUTINE PRGFIN( STR)
C
C     SUBROUTINE PRGCLO
C
C-----------------------------------------------------------------------
C  PRGDSP (PRoGress DiSPlay) displays a "progress" string on the user's
C  terminal, overwriting any previous displayed string.  The effect is
C  that only the characters that change from one string to the next
C  appear to change at a fixed location on the terminal screen.
C
C  Input:
C   STR   String to display.
C
C-----------------------------------------------------------------------
C  PRGINI (PRoGress display INItialize) initializes PRGDSP, opening a
C  connection to the appropriate output device.  If the device is not
C  already open for writing, it is opened using the unit number given.
C  If the initialization string starts with '^', no header is output and
C  the previous line is overwritten with the next call to PRGDSP.  If
C  the string is blank, no leading blank line is output
C
C  Input:
C   STR   An optional string to display above the "progress" string.
C         (If STR is blank, it is NOT displayed.)
C
C-----------------------------------------------------------------------
C  PRGFIN (PRoGress display FINish) disables the progress display and
C  displays a "completion" string if requested.
C
C  Input:
C   STR   An optional string displayed following the last "progress"
C         string.  (If STR is blank, it is NOT displayed.)
C
C-----------------------------------------------------------------------
C  PRGCLO (PRoGress display CLOse) output a final line-feed for versions
C  which do not handle Fortran carriage-control.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/spacing.fpp <<<<<<<<<<<<<<<<<<<

      DOUBLE PRECISION FUNCTION SPACING( X)
      DOUBLE PRECISION                   X
C
C-----------------------------------------------------------------------
C  SPACING returns the absolute spacing between floating point numbers
C  near the argument value.  If the argument is zero, the function
C  returns the smallest representable floating point number.  This is a
C  Fortran 77 double precision version of a Fortran 90 intrinsic
C  function.
C
C  Input:
C   X  Value around which spacing is computed.
C
C  Output:
C   <function value>  Absolute spacing around X.  Always positive.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/sstget.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE SSTINI
C
C     SUBROUTINE SSTGET( DT, S)
      INTEGER            DT(5)
      DOUBLE PRECISION   S
C
C-----------------------------------------------------------------------
C  SSTINI (SyStem Time INItialize) reads the system clock and stores the
C  current date and time internally.
C
C-----------------------------------------------------------------------
C  SSTGET (SyStem Time GET) gets the date and time stored in the last
C  call to SSTINI, and returns it in a "standard" binary format
C  consisting of a five-element integer array containing Year, Month,
C  Day, Hour, and Minute, and a double precision variable containing
C  Seconds.
C
C  Outputs:
C    DT(1..5)   Array containing Year, Month, Day, Hour, and Minute.
C    S          Seconds.
C
C$----------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>> FILE: ../sys/sysini.fpp <<<<<<<<<<<<<<<<<<<

      SUBROUTINE  SYSINI
C
C     SUBROUTINE  SYEXIT( STAT)
      INTEGER             STAT
C
C-----------------------------------------------------------------------
C  SYSINI (SYStem INItialize) performs system dependent initializations.
C  A call to this routine should typically be the first executable
C  statement in a program.
C
C-----------------------------------------------------------------------
C  SYEXIT (SYstem EXIT) exits the program, returning the specified
C  status code to the parent process.
C
C$----------------------------------------------------------------------
