freeform.h

/*
 * FILENAME: freeform.h
 *
 * CAVEAT:
 * No claims are made as to the suitability of the accompanying
 * source code for any purpose.  Although this source code has been
 * used by the NOAA, no warranty, expressed or implied, is made by
 * NOAA or the United States Government as to the accuracy and
 * functioning of this source code, nor shall the fact of distribution
 * constitute any such endorsement, and no responsibility is assumed
 * by NOAA in connection therewith.  The source code contained
 * within was developed by an agency of the U.S. Government.
 * NOAA's National Geophysical Data Center has no objection to the
 * use of this source code for any purpose since it is not subject to
 * copyright protection in the U.S.  If this source code is incorporated
 * into other software, a statement identifying this source code may be
 * required under 17 U.S.C. 403 to appear with any copyright notice.
 */
 
#ifndef FREEFORM_H__
#define FREEFORM_H__
 
#define FFND_LIB_VER "4.2.3"
 
#ifndef FREEFORM
#error "You must define FREEFORM as a preprocessor name."
#error "You must do this for the benefit of files in the FreeForm project"
#error "which do not include freeform.h"
#endif
 
/*
 
FreeForm ND has been compiled on the following platforms:
 
    PC running DOS
    PC running LINUX
    Macintosh running MacOS
    Sun Sparcstations running SUNOS
    SGI workstations running IRIX
    and various other Unix workstations, like:
        IBM6000, HP9000, DEC-Alpha, and SGI PowerChallenge
 
FreeForm ND compiles with these C compilers:
 
    Microsoft Visual C++ Versions 1.0 and 1.52
    Microsoft Visual C++ Version 4.0 (define MSVC4)
    Metroworks CodeWarrior Version 6 -- for Macintosh
    generic ANSI Unix C compilers
 
If you are using Microsoft Visual C++ 4.0 then define MSVC4 in addition to
defining PC.
 
To compile FreeForm on your machine you must define one of the
following preprocessor names:
 
   
    PC
    LINUX
    SUN
    IRIS4
    MAC
    IBM6000
    HP9000
    DEC_ALPHA
    IRIX
 
One of the above should be defined as a compiler preprocessor definition, such as on the
cc command line, or within your project settings.
   
*/
 
#define FF_OS_UNIX 1
#define FF_OS_MAC  2
#define FF_OS_DOS  3
 
#define FF_CC_MSVC1 1
#define FF_CC_MSVC4 2
#define FF_CC_MACCW 3
#define FF_CC_UNIX  4
 
#ifdef GOT_MACHINE
#undef GOT_MACHINE
#endif
 
#ifdef PC
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_DOS
 
#ifdef MSVC1
#define FF_CC FF_CC_MSVC1
#endif
 
#ifdef MSVC4
#ifdef FF_CC
#error "A PC compiler has already been defined"
#endif
#define FF_CC FF_CC_MSVC4
#endif
 
#ifndef FF_CC
/* Assume MSVC1 unless MSVC4 is defined */
#define FF_CC FF_CC_MSVC1
#endif
 
#endif /* PC */
 
#ifdef LINUX
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* LINUX */
 
#ifdef SUN
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* SUN */
 
#ifdef IRIS4
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* IRIS4 */
 
#ifdef MAC
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_MAC
#define FF_CC FF_CC_MACCW
 
#endif /* MAC */
 
#ifdef IBM6000
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* IBM6000 */
 
#ifdef HP9000
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_32
#define LONGS_ARE_32
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* HP9000 */
 
#ifdef DEC_ALPHA
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_64
#define LONGS_ARE_64
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* DEC_ALPHA */
 
#ifdef IRIX
 
// #ifndef IRIX
// #define IRIX
// #endif
 
#ifdef GOT_MACHINE
#define TOO_MANY_MACHINES
#else
#define GOT_MACHINE
#endif
 
#ifndef LONGS_ARE_64
#define LONGS_ARE_64
#endif
 
#define FF_OS FF_OS_UNIX
#define FF_CC FF_CC_UNIX
 
#endif /* IRIX */
 
#ifndef GOT_MACHINE
#error "Machine type has not been defined."
#error "Please define one in your makefile or project."
#endif
 
#ifdef TOO_MANY_MACHINES
#error "More than one machine type has been defined"
#ifdef PC
#error "PC is currently defined"
#endif
#ifdef SUN
#error "SUN is currently defined"
#endif
#ifdef IRIS4
#error "IRIS4 is currently defined"
#endif
#ifdef MAC
#error "MAC is currently defined"
#endif
#ifdef IBM6000
#error "IBM6000 is currently defined"
#endif
#ifdef HP9000
#error "HP9000 is currently defined"
#endif
#ifdef DEC_ALPHA
#error "DEC_ALPHA is currently defined"
#endif
#ifdef IRIX
#error "IRIX is currently defined"
#endif
#error "Please check your makefile or project."
#endif /* TOO_MANY_MACHINES */
 
#if !defined(LONGS_ARE_32) && !defined(LONGS_ARE_64)
#error "longs have not been defined as either 32 or 64 bits"
#error "This should never happen, contact support"
#endif
 
#ifndef FF_CC
#error "A C compiler has not been defined"
You should define one of the following:
 
    PC
    LINUX
    SUN
    IRIS4
    MAC
    IBM6000
    HP9000
    DEC_ALPHA
    IRIX
 
#endif
 
#ifndef FF_OS
#error "An operating system has not been defined"
You should define one of the following:
 
    PC
    LINUX
    SUN
    IRIS4
    MAC
    IBM6000
    HP9000
    DEC_ALPHA
    IRIX
 
#endif
 
/* Directory Separators: specifically for the three currently supported
   general operating systems, for path names in menu files (same as DOS) -- 
   NATIVE_DIR_SEPARATOR is set to one of the three os-specific separators
   at compile-time.
*/
 
#define UNIX_DIR_SEPARATOR '/'
#define UNIX_DIR_SEPARATOR_STRING "/"
 
#define MAC_DIR_SEPARATOR ':'
#define MAC_DIR_SEPARATOR_STRING ":"
 
#define DOS_DIR_SEPARATOR '\\'
#define DOS_DIR_SEPARATOR_STRING "\\"
 
#ifndef MAX_PATH
#define MAX_PATH 260
#endif
          
#if FF_OS == FF_OS_MACOS
 
#define NATIVE_DIR_SEPARATOR MAC_DIR_SEPARATOR
#define NATIVE_DIR_SEPARATOR_STRING MAC_DIR_SEPARATOR_STRING
 
#endif
 
#if FF_OS == FF_OS_DOS
 
#define NATIVE_DIR_SEPARATOR DOS_DIR_SEPARATOR
#define NATIVE_DIR_SEPARATOR_STRING DOS_DIR_SEPARATOR_STRING
 
#endif
 
#if FF_OS == FF_OS_UNIX
 
#define NATIVE_DIR_SEPARATOR UNIX_DIR_SEPARATOR
#define NATIVE_DIR_SEPARATOR_STRING UNIX_DIR_SEPARATOR_STRING
 
#endif
 
#define FFNT_INT8     0
#define FFNT_UINT8    1
#define FFNT_INT16    2
#define FFNT_UINT16   3
#define FFNT_INT32    4
#define FFNT_UINT32   5
#define FFNT_INT64    6
#define FFNT_UINT64   7
#define FFNT_FLOAT32  8
#define FFNT_FLOAT64  9
#define FFNT_ENOTE   10
 
#ifdef WANT_NCSA_TYPES
 
typedef signed char         int8;
typedef unsigned char       uint8;
typedef signed short int    int16;
typedef unsigned short int  uint16;
typedef float               float32;
typedef double              float64;
 
#endif
 
#define SIZE_INT8       1
#define SIZE_UINT8      1
#define SIZE_INT16      2
#define SIZE_UINT16     2
#define SIZE_INT32      4
#define SIZE_UINT32     4
#define SIZE_INT64      8
#define SIZE_UINT64     8
#define SIZE_INT128    16   /* No current plans for support */
#define SIZE_UINT128   16   /* No current plans for support */
 
#define SIZE_FLOAT32    4
#define SIZE_FLOAT64    8
#define SIZE_ENOTE      SIZE_FLOAT64
#define SIZE_FLOAT128  16    /* No current plans for support */
 
typedef double big_var_type;
typedef big_var_type align_var_type;
 
#define FFV_INT8_MIN   (-SCHAR_MAX-1)
#define FFV_INT8_MAX    SCHAR_MAX
#define FFV_UINT8_MIN           0
#define FFV_UINT8_MAX   UCHAR_MAX
#define FFV_INT16_MIN   (-SHRT_MAX-1)
#define FFV_INT16_MAX    SHRT_MAX
#define FFV_UINT16_MIN          0
#define FFV_UINT16_MAX  USHRT_MAX
#define FFV_FLOAT32_MIN  -FLT_MAX
#define FFV_FLOAT32_MAX   FLT_MAX
#define FFV_FLOAT64_MIN  -DBL_MAX
#define FFV_FLOAT64_MAX   DBL_MAX
#define FFV_ENOTE_MIN     FFV_FLOAT64_MIN
#define FFV_ENOTE_MAX     FFV_FLOAT64_MAX
 
#define FFV_FLOAT32_EPSILON FLT_EPSILON
#define FFV_FLOAT64_EPSILON DBL_EPSILON
#define FFV_ENOTE_EPSILON   FFV_FLOAT64_EPSILON
 
extern const char *fft_cnv_flags[FFNT_ENOTE + 1];
extern const char *fft_cnv_flags_width[FFNT_ENOTE + 1];
extern const char *fft_cnv_flags_prec[FFNT_ENOTE + 1];
extern const char *fft_cnv_flags_width_prec[FFNT_ENOTE + 1];
 
#ifdef LONGS_ARE_32
 
#ifdef LONGS_ARE_64
#error "longs have been defined as both 32 and 64 bits"
#error "This should never happen, contact support"
#endif
 
#ifdef WANT_NCSA_TYPES
 
typedef signed long int     int32;
typedef unsigned long int   uint32;
typedef char                int64;  /* not a real type for the PC */
typedef char                uint64; /* not a real type for the PC */
 
#endif
 
#define FFV_INT32_MIN   (-LONG_MAX-1)
#define FFV_INT32_MAX    LONG_MAX
#define FFV_UINT32_MIN          0
#define FFV_UINT32_MAX  ULONG_MAX
#define FFV_INT64_MIN           0
#define FFV_INT64_MAX           0
#define FFV_UINT64_MIN          0
#define FFV_UINT64_MAX          0
 
#endif /* LONGS_ARE_32 */
 
#ifdef LONGS_ARE_64
 
#ifdef LONGS_ARE_32
#error "longs have been defined as both 32 and 64 bits"
#error "This should never happen, contact support"
#endif
 
#ifdef WANT_NCSA_TYPES
 
typedef signed int          int32;
typedef unsigned int        uint32;
typedef signed long int     int64;
typedef unsigned long int   uint64;
 
#endif
 
#define FFV_INT32_MIN    (-INT_MAX-1)
#define FFV_INT32_MAX     INT_MAX
#define FFV_UINT32_MIN          0
#define FFV_UINT32_MAX   UINT_MAX
#define FFV_INT64_MIN   (-LONG_MAX-1)
#define FFV_INT64_MAX    LONG_MAX
#define FFV_UINT64_MIN          0
#define FFV_UINT64_MAX  ULONG_MAX
 
#endif /* LONGS_ARE_64 */
 
typedef double             ff_enote;
 
/* Variable Types */
/* FFV_NULL MUST BE zero -- NOTHING else can be zero */
#define FFV_NULL            (FF_TYPES_t)0x00000000
 
#define FFV_SIZE_1          (FF_TYPES_t)0x00000001
#define FFV_SIZE_2          (FF_TYPES_t)0x00000002
#define FFV_UNSIGNED        (FF_TYPES_t)0x00000004
#define FFV_INTEGER         (FF_TYPES_t)0x00000008
#define FFV_REAL            (FF_TYPES_t)0x00000010
#define FFV_TEXT            (FF_TYPES_t)0x00000020
/* FFV_CHAR is used for strings, but I think FFV_TEXT is a better name.
*/
#define FFV_CHAR     FFV_TEXT
 
#define FFV_CONSTANT        (FF_TYPES_t)0x00000040 /* if you change this bit pattern, change FFV_EOL too! */
#define FFV_INITIAL         (FF_TYPES_t)0x00000080
#define FFV_EOL             (FF_TYPES_t)0x00000140 /* |= FFV_CONSTANT */
 
/* above are masked by FFV_DATA_TYPES */
#define FFV_DATA_TYPES      (FF_TYPES_t)0x000001FF
 
#define FFV_CONVERT         (FF_TYPES_t)0x00000200
#define FFV_EQUATION        (FF_TYPES_t)0x00000400  
#define FFNT_CONSTANT        (FF_TYPES_t)0x00000800
#define FFNT_EQUIV          (FF_TYPES_t)0x00001000
#define FFV_TRANSLATOR      (FF_TYPES_t)0x00002000
#define FFV_ORPHAN          (FF_TYPES_t)0x00004000
#define FFV_EQN             (FF_TYPES_t)0x00008000
#define FFV_BIT_FIELD       (FF_TYPES_t)0x00010000
 
#define FFV_RECORD          (FF_TYPES_t)0x00010000
#define FFV_INTERNAL        (FF_TYPES_t)0x00020000
#define FFV_DELIM_VALUE     (FF_TYPES_t)0x00040000
#define FFV_DELIM_ITEM      (FF_TYPES_t)0x00080000
#define FFV_PARAM_NAME      (FF_TYPES_t)0x00100000
#define FFV_PARAM_VALUE     (FF_TYPES_t)0x00200000
 
#define DONT_USE_THIS_BIT_PATTERN 0x40000000 /* This is used by FF_ARRAY for both formats and variables */
 
#define FFV_INT8      (               FFV_INTEGER)
#define FFV_UINT8     (FFV_UNSIGNED | FFV_INTEGER)
#define FFV_INT16     (               FFV_INTEGER | FFV_SIZE_1)
#define FFV_UINT16    (FFV_UNSIGNED | FFV_INTEGER | FFV_SIZE_1)
#define FFV_INT32     (               FFV_INTEGER | FFV_SIZE_2)
#define FFV_UINT32    (FFV_UNSIGNED | FFV_INTEGER | FFV_SIZE_2)
#define FFV_INT64     (               FFV_INTEGER | FFV_SIZE_1 | FFV_SIZE_2)
#define FFV_UINT64    (FFV_UNSIGNED | FFV_INTEGER | FFV_SIZE_1 | FFV_SIZE_2)
#define FFV_FLOAT32   (               FFV_REAL    | FFV_SIZE_2)
#define FFV_FLOAT64   (               FFV_REAL    | FFV_SIZE_1 | FFV_SIZE_2)
#define FFV_ENOTE     (               FFV_REAL)
 
#define FFV_UCHAR    FFV_UINT8
#define FFV_SHORT    FFV_INT16
#define FFV_USHORT   FFV_UINT16
 
#ifdef LONGS_ARE_32
#define FFV_LONG     FFV_INT32
#define FFV_ULONG    FFV_UINT32
#endif
 
#ifdef LONGS_ARE_64
#define FFV_LONG     FFV_INT64
#define FFV_ULONG    FFV_UINT64
#endif
 
#define FFV_FLOAT    FFV_FLOAT32
#define FFV_DOUBLE   FFV_FLOAT64
 
#define IS_TEXT_TYPE(t)    (FFV_DATA_TYPE_TYPE(t) == FFV_TEXT)
#define IS_INT8_TYPE(t)    (FFV_DATA_TYPE_TYPE(t) == FFV_INT8)
#define IS_UINT8_TYPE(t)   (FFV_DATA_TYPE_TYPE(t) == FFV_UINT8)
#define IS_INT16_TYPE(t)   (FFV_DATA_TYPE_TYPE(t) == FFV_INT16)
#define IS_UINT16_TYPE(t)  (FFV_DATA_TYPE_TYPE(t) == FFV_UINT16)
#define IS_INT32_TYPE(t)   (FFV_DATA_TYPE_TYPE(t) == FFV_INT32)
#define IS_UINT32_TYPE(t)  (FFV_DATA_TYPE_TYPE(t) == FFV_UINT32)
#define IS_INT64_TYPE(t)   (FFV_DATA_TYPE_TYPE(t) == FFV_INT64)
#define IS_UINT64_TYPE(t)  (FFV_DATA_TYPE_TYPE(t) == FFV_UINT64)
#define IS_FLOAT32_TYPE(t) (FFV_DATA_TYPE_TYPE(t) == FFV_FLOAT32)
#define IS_FLOAT64_TYPE(t) (FFV_DATA_TYPE_TYPE(t) == FFV_FLOAT64)
#define IS_ENOTE_TYPE(t)   (FFV_DATA_TYPE_TYPE(t) == FFV_ENOTE)
#define IS_EQN_TYPE(t)     ((t) & FFV_EQN)
#define IS_CONSTANT_TYPE(t)((t) ? (((t) & FFV_CONSTANT) == FFV_CONSTANT) : FALSE)
#define IS_INITIAL_TYPE(t) ((t) ? (((t) & FFV_INITIAL) == FFV_INITIAL) : FALSE)
 
#define IS_RECORD_TYPE(t) ((t) & FFV_RECORD)
 
#define IS_INTERNAL_TYPE(t) ((t) & FFV_INTERNAL)
 
#define IS_DELIM_VALUE_TYPE(t) ((t) & FFV_DELIM_VALUE)
#define IS_DELIM_ITEM_TYPE(t) ((t) & FFV_DELIM_ITEM)
#define IS_PARAM_NAME_TYPE(t) ((t) & FFV_PARAM_NAME)
#define IS_PARAM_VALUE_TYPE(t) ((t) & FFV_PARAM_VALUE)
 
#define IS_TEXT(v)    IS_TEXT_TYPE(FFV_DATA_TYPE(v))
#define IS_INT8(v)    IS_INT8_TYPE(FFV_DATA_TYPE(v))
#define IS_UINT8(v)   IS_UINT8_TYPE((FFV_DATA_TYPE(v))
#define IS_INT16(v)   IS_INT16_TYPE(FFV_DATA_TYPE(v))
#define IS_UINT16(v)  IS_UINT16_TYPE(FFV_DATA_TYPE(v))
#define IS_INT32(v)   IS_INT32_TYPE(FFV_DATA_TYPE(v))
#define IS_UINT32(v)  IS_UINT32_TYPE(FFV_DATA_TYPE(v))
#define IS_INT64(v)   IS_INT64_TYPE(FFV_DATA_TYPE(v))
#define IS_UINT64(v)  IS_UINT64_TYPE(FFV_DATA_TYPE(v))
#define IS_FLOAT32(v) IS_FLOAT32_TYPE(FFV_DATA_TYPE(v))
#define IS_FLOAT64(v) IS_FLOAT64_TYPE(FFV_DATA_TYPE(v))
#define IS_ENOTE(v)   IS_ENOTE_TYPE(FFV_DATA_TYPE(v))
#define IS_EQN(v)     IS_EQN_TYPE(FFV_TYPE(v))
 
#define IS_RECORD_VAR(v)  IS_RECORD_TYPE(FFV_TYPE(v)) 
 
#define IS_INTERNAL_VAR(v) IS_INTERNAL_TYPE(FFV_TYPE(v))
 
#define IS_DELIM_VALUE_VAR(v) IS_DELIM_VALUE_TYPE(FFV_TYPE(v))
#define IS_DELIM_ITEM_VAR(v) IS_DELIM_ITEM_TYPE(FFV_TYPE(v))
#define IS_PARAM_NAME_VAR(v) IS_PARAM_NAME_TYPE(FFV_TYPE(v))
#define IS_PARAM_VALUE_VAR(v) IS_PARAM_VALUE_TYPE(FFV_TYPE(v))
 
#define IS_UNSIGNED(v) (FFV_DATA_TYPE(v) & FFV_UNSIGNED)
#define IS_INTEGER(v) (FFV_DATA_TYPE(v) & FFV_INTEGER)
#define IS_REAL(v)    (FFV_DATA_TYPE(v) & FFV_REAL)
 
#define IS_UNSIGNED_TYPE(t) (FFV_DATA_TYPE_TYPE(t) & FFV_UNSIGNED)
#define IS_INTEGER_TYPE(t) (FFV_DATA_TYPE_TYPE(t) & FFV_INTEGER)
#define IS_REAL_TYPE(t)    (FFV_DATA_TYPE_TYPE(t) & FFV_REAL)
 
#define IS_BIT_FIELD(v)  ((v) ? (((v)->type & FFV_BIT_FIELD) == FFV_BIT_FIELD) : FALSE)
#define IS_CONVERT(v)    ((v) ? (((v)->type & FFV_CONVERT) == FFV_CONVERT) : FALSE)
#define IS_CONSTANT(v)   ((v) ? IS_CONSTANT_TYPE(FFV_TYPE(v)) : FALSE)
#define IS_INITIAL(v)    ((v) ? IS_INITIAL_TYPE(FFV_TYPE(v)) : FALSE)
#define IS_EQUATION(v)   ((v) ? ((v)->type & FFV_EQUATION) == FFV_EQUATION : FALSE)
#define IS_TRANSLATOR(v) ((v) ? ((v)->type & FFV_TRANSLATOR) == FFV_TRANSLATOR : FALSE)
#define IS_ORPHAN_VAR(v)     ((v) ? ((v)->type & FFV_ORPHAN) == FFV_ORPHAN : FALSE)
#define IS_EOL(v)        ((v) ? ((v)->type & FFV_EOL) == FFV_EOL : FALSE)
#define IS_FLAG(v)       ((v) ? (v)->type == FF_VAR_TYPE_FLAG : FALSE)
 
typedef unsigned long FF_TYPES_t;
#define FF_VAR_TYPE_FLAG (FF_TYPES_t)0xffffffff
 
#define IS_KEYWORDED_PARAMETER(p) ((p)[0] == '$')
 
typedef struct
{
    char       *string;
    FF_TYPES_t  number;
} FFF_LOOKUP, *FFF_LOOKUP_PTR;
 
#define NUM_VARIABLE_TYPES 25
extern FFF_LOOKUP variable_types[NUM_VARIABLE_TYPES];
 
/* FreeForm Format bit field masks */
#define FFF_FILE_TYPES (FFF_BINARY | FFF_ASCII | FFF_FLAT)
#define FFF_DATA_TYPES (FFF_DATA | FFF_HEADER | FFF_FILE | FFF_REC)         
#define FFF_GROUP      (FFF_FILE_TYPES | FFF_DATA_TYPES)
/* FD_TYPES == FFF_TABLE | FFF_DATA | FFF_HEADER | FFF_INPUT | FFF_OUTPUT */
 
/* FreeForm Format bit field constants */
/* FFF_NULL MUST BE zero -- NOTHING else can be zero */
#define FFF_NULL                (FF_TYPES_t)0x00000000
#define FFF_BINARY              (FF_TYPES_t)0x00000001
#define FFF_ASCII               (FF_TYPES_t)0x00000002
#define FFF_FLAT                (FF_TYPES_t)0x00000004
 
/* The order of the following must be preserved!!!  See sort_format_data_list */
#define FFF_TABLE               (FF_TYPES_t)0x00000008      
#define FFF_HEADER              (FF_TYPES_t)0x00000010
#define FFF_FILE                (FF_TYPES_t)0x00000020
#define FFF_REC                 (FF_TYPES_t)0x00000040
#define FFF_DATA                (FF_TYPES_t)0x00000080
 
#define FFF_SEPARATE            (FF_TYPES_t)0x00000100
#define FFF_VARIED              (FF_TYPES_t)0x00000200
#define FFF_INPUT               (FF_TYPES_t)0x00000400
#define FFF_OUTPUT              (FF_TYPES_t)0x00000800
#define FFF_IO                  (FF_TYPES_t)0x00000C00
 
#define FFF_SCALE               (FF_TYPES_t)0x00001000
#define FFF_ADD_HERE            (FF_TYPES_t)0x00002000
#define FFF_DELETE_ME           (FF_TYPES_t)0X00008000
 
#define FF_ARRAY                (FF_TYPES_t)0x40000000
#define FFF_RECORD              (FF_TYPES_t)0x80000000
 
/* IS_ARRAY used for either variables or formats */
#define IS_ARRAY_TYPE(t) ((t) & FF_ARRAY)
#define IS_ARRAY(x) IS_ARRAY_TYPE(FFF_TYPE(x))
 
#define FFF_ALL_TYPES           (FF_TYPES_t)0x0000FFFF
/* above masked by FFF_ALL_TYPES */
 
#define IS_BINARY_TYPE(t)   ((t) & FFF_BINARY)
#define IS_ASCII_TYPE(t)    ((t) & FFF_ASCII)
#define IS_FLAT_TYPE(t)    ((t) & FFF_FLAT)
 
#define IS_TABLE_TYPE(t)    ((t) & FFF_TABLE)
#define IS_DATA_TYPE(t)     ((t) & FFF_DATA)
#define IS_HEADER_TYPE(t)   ((t) & FFF_HEADER)
#define IS_FILE_TYPE(t)     ((t) & FFF_FILE)
#define IS_REC_TYPE(t)      ((t) & FFF_REC)
#define IS_FILE_HEADER_TYPE(t) (IS_FILE_TYPE(t) && IS_HEADER_TYPE(t))
#define IS_REC_HEADER_TYPE(t)  (IS_REC_TYPE(t) && IS_HEADER_TYPE(t))
#define IS_SEPARATE_TYPE(t) ((t) & FFF_SEPARATE)
#define IS_EMBEDDED_TYPE(t) (!IS_SEPARATE_TYPE(t))
#define IS_VARIED_TYPE(t)   ((t) & FFF_VARIED)
#define IS_INPUT_TYPE(t)    ((t) & FFF_INPUT)
#define IS_OUTPUT_TYPE(t)   ((t) & FFF_OUTPUT)
#define IS_SCALE_TYPE(t)    ((t) & FFF_SCALE)
 
#define IS_RECORD_FORMAT_TYPE(t)   ((t) & FFF_RECORD)
 
#define IS_BINARY(f)   IS_BINARY_TYPE(FFF_TYPE(f))
#define IS_ASCII(f)    IS_ASCII_TYPE(FFF_TYPE(f))
#define IS_FLAT(f)    IS_FLAT_TYPE(FFF_TYPE(f))
 
#define IS_TABLE(f)       IS_TABLE_TYPE(FFF_TYPE(f))
#define IS_DATA(f)        IS_DATA_TYPE(FFF_TYPE(f))
#define IS_HEADER(f)      IS_HEADER_TYPE(FFF_TYPE(f))
#define IS_FILE(f)        IS_FILE_TYPE(FFF_TYPE(f))
#define IS_FILE_HEADER(f) (IS_FILE_HEADER_TYPE(FFF_TYPE(f)))
#define IS_REC_HEADER(f)  (IS_REC_HEADER_TYPE(FFF_TYPE(f)))
#define IS_REC(f)         IS_REC_TYPE(FFF_TYPE(f))
#define IS_SEPARATE(f)    IS_SEPARATE_TYPE(FFF_TYPE(f))
#define IS_EMBEDDED(f)    (!IS_SEPARATE(f))
#define IS_VARIED(f)      IS_VARIED_TYPE(FFF_TYPE(f))
#define IS_INPUT(f)       IS_INPUT_TYPE(FFF_TYPE(f))
#define IS_OUTPUT(f)      IS_OUTPUT_TYPE(FFF_TYPE(f))
#define IS_SCALE(f)       IS_SCALE_TYPE(FFF_TYPE(f))
 
#define IS_RECORD_FORMAT(f)   IS_RECORD_FORMAT_TYPE(FFF_TYPE(f))
 
#define NUM_FORMAT_TYPES 71
extern FFF_LOOKUP format_types[NUM_FORMAT_TYPES];
 
#define FF_DBG_LOG "ff_debug.log"
#define FF_DBG_LOG_SIZE 10240
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
 
#if defined(DEBUG) || defined(_DEBUG) && !defined(FF_DBG)
#define FF_DBG
#endif
 
#define assert(exp) ff_err_assert(exp)
 
#ifdef NDEBUG
#define ff_err_assert(exp) ((void)0)
#else /* NDEBUG */
#define ff_err_assert(exp) ( (exp) ? (void)0 : _ff_err_assert(#exp, __FILE__, __LINE__) )
void _ff_err_assert(char *, char *, unsigned);
#endif /* (ELSE) NDEBUG */
 
/* FF_CHK_ADDR is independent of NDEBUG */
#ifdef FF_CHK_ADDR
#define FF_VALIDATE(o) (((o) && ((void *)(o) == (o)->check_address)) ? (void)0 : _ff_err_assert(#o, __FILE__, __LINE__))
#else
#define FF_VALIDATE(o)
#endif
 
#include <errno.h>
 
/* Following are to be used when converting a floating point type to an
   integer type -- this should avoid the occasional truncation error */
 
#include <float.h>
#include <math.h>
#include <fcntl.h>
 
#define DOUBLE_UP DBL_EPSILON
#define FLOAT_UP FLT_EPSILON
#define STR_END '\0' /* NULL-terminator for the C-string data type */
 
#if FF_CC == FF_CC_UNIX
 
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
#define O_BINARY 0
 
#endif /* #if FF_CC == FF_CC_UNIX */
 
#if FF_CC == FF_CC_MSVC1 || FF_CC == FF_CC_MSVC4
 
#include <malloc.h>
#include <io.h>
#include <sys\types.h>
#include <sys\stat.h>
 
#endif /* FF_CC == FF_CC_MSVC1 || FF_CC == FF_CC_MSVC4 */
 
#include <dl_lists.h>
#include <os_utils.h>
#include <memtrack.h>
 
#include <ndarray.h>
 
#ifdef HUGE
#undef HUGE
#endif /* HUGE */
 
#if FF_CC == FF_CC_MSVC1
#define HUGE huge
#else
#define HUGE 
#endif /* (ELSE) FF_CC == FF_CC_MSVC1 */
 
typedef char HUGE *FF_DATA_BUFFER;
typedef void HUGE *FF_DATA_PTR;
 
typedef char **FF_STRING_HANDLE;
 
/* Utility macros */
#define FD_FORMAT(fd)           ((fd)->format)
#define FFF_FIRST(fl)           dll_first(fl)
#define FFF_NEXT(fl)            dll_next(fl)
#define FD_FIRST(fdl)           dll_first(fdl)
#define FD_LAST(fdl)            dll_last(fdl)
#define FFV_FIRST_VARIABLE(f)   ((VARIABLE_LIST)dll_first((f)->variables))
#define FFV_NEXT_VARIABLE(vl)   dll_next(vl)
#define FORMAT_LENGTH(f)        ((size_t)(f)->length)
#define FF_VAR_LENGTH(v)        ((size_t)(v)->end_pos - (size_t)(v)->start_pos + (size_t)1)
 
#define FFV_TYPE(v) ((v)->type)
#define FFV_DATA_TYPE_TYPE(t) ((t) & FFV_DATA_TYPES)
#define FFV_DATA_TYPE(v) FFV_DATA_TYPE_TYPE(FFV_TYPE(v))
#define FFF_TYPE(f) ((f)->type)
#define FFF_FORMAT_TYPE(f) (FFF_TYPE(f) & FFF_ALL_TYPES)
#define FD_TYPE(fd) (FFF_TYPE((fd)->format) & FFF_DATA_TYPES)
 
#define FD_IS_NATIVE_BYTE_ORDER(fd) (endian() == (BOOLEAN)(fd)->state.byte_order)
 
#define MAX_PV_LENGTH MAX_PATH /* Maximum parameter or parameter-value length */
#define MAX_NAME_LENGTH MAX_PV_LENGTH
#define TMP_BUFFER_SIZE 1024
#define LOGGING_QUANTA 10240U
#define SCRATCH_QUANTA 1024U
 
#define FMT_BUFSIZE_BUFFER_SIZE 4096 /* pick a reasonable size... */
 
/* even though ff_bss_t is an unsigned (long, in Unix) there will be problems
   if bytes_used or total_bytes ever takes on a value greater than LONG_MAX */
 
#define FFBS_GRAFT 0
 
typedef unsigned FF_BSS_t; /* FreeForm bufsize size type */
 
/*
 * FF_BUFSIZE
 */
 
typedef struct struct_ff_bufsize FF_BUFSIZE, *FF_BUFSIZE_PTR, **FF_BUFSIZE_HANDLE;
struct struct_ff_bufsize
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    char HUGE *buffer;
    unsigned short usage;
    FF_BSS_t  bytes_used;
    FF_BSS_t  total_bytes;
};
 
#ifndef INT_MAX
#include <limits.h>
#endif /* INT_MAX */
 
#define BUFSIZE_TOTAL_BYTES_UNKNOWN INT_MAX
 
/*
 * FF_STD_ARGS
 */
 
typedef struct struct_ff_std_args FF_STD_ARGS, *FF_STD_ARGS_PTR, **FF_STD_ARGS_HANDLE;
struct struct_ff_std_args
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    char           *input_file;           /* string: name of input file */
    FF_BUFSIZE_PTR  input_bufsize;         /* bufsize containing input data */
    char           *input_format_file;    /* string: name of input format file */
    char           *input_format_title;   /* string: input format title */
    char           *input_format_buffer;  /* string: input format description */
    char           *output_file;          /* string: name of output file */
    char           *log_file;             /* string: name of log file */
    FF_BUFSIZE_PTR  output_bufsize;        /* bufsize to contain output data */
    char           *output_format_file;   /* string: name of output format file */ 
    char           *output_format_title;  /* string: output forma title */
    char           *output_format_buffer; /* string: output format description */
    char           *var_file;             /* string: name of variable file */
    char           *query_file;           /* string: name of query file */
    unsigned long   cache_size;           /* integer: default data cacheing size */
    long            records_to_read;      /* integer: if negative, file tail */
 
    char           *error_log;            /* string: file name to send error messages */
    BOOLEAN         error_prompt;
 
    /* FF2SDE specific option flags */
    double          SDE_grid_size;
    double          SDE_grid_size2;
    double          SDE_grid_size3;
    
    /* Checkvar specific option flags */
    char   *cv_list_file_dir;
    int     cv_precision;
    int     cv_maxbins;
    BOOLEAN cv_maxmin_only;
    BOOLEAN cv_subset;
 
    char *sdts_terms_file;
    
    struct struct_std_args_user
    {
        unsigned int set_cv_precision : 1;
        unsigned int is_stdin_redirected : 1;
        unsigned int is_stdout_redirected : 1;
        unsigned int format_title : 1;
        unsigned int format_file : 1;
    } user;
};
 
#include <err.h>
 
/* ff_copy_variable depends on the contents of the VARIABLE structure, below.
   If you change this structure, you must also change ff_copy_variable
*/
 
 
typedef struct struct_ff_dll_node DLL_NODE, *DLL_NODE_PTR, **DLL_NODE_HANDLE;
 
typedef DLL_NODE_PTR  FORMAT_LIST,
                      VARIABLE_LIST,
                      FORMAT_DATA_LIST,
                      PROCESS_INFO_LIST,
                      FORMAT_DATA_MAP_LIST,
                      FF_ARRAY_CONDUIT_LIST,
                      FF_ERROR_LIST,
                      FF_DATA_FLAG_LIST;
 
typedef DLL_NODE_HANDLE  FORMAT_LIST_HANDLE,
                         VARIABLE_LIST_HANDLE,
                         FORMAT_DATA_LIST_HANDLE,
                         PROCESS_INFO_LIST_HANDLE,
                         FORMAT_DATA_MAP_LIST_HANDLE,
                         FF_ARRAY_CONDUIT_LIST_HANDLE,
                         FF_ERROR_LIST_HANDLE,
                         FF_DATA_FLAG_LIST_HANDLE;
 
typedef struct struct_ff_error FF_ERROR, *FF_ERROR_PTR, **FF_ERROR_HANDLE;
struct struct_ff_error
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
 
    int code;
 
    char *message;
    char *problem;
 
    int warning_ord;
    int error_ord;
};
 
#define FF_MAX_NAME MAX_PATH
 
#define FFV_MISC_INIT NULL
 
typedef unsigned long  FF_NDX_t;
 
/* ff_copy_format depends on the contents of the FORMAT structure, below.
   If you change this structure, you must also change ff_copy_format
*/
 
/*
 * FORMAT
 */
 
typedef struct struct_ff_format FORMAT, *FORMAT_PTR, **FORMAT_HANDLE;
struct struct_ff_format
{
#ifdef FF_CHK_ADDR
    void          *check_address;     /* assert(format->check_address == format); */
#endif
    VARIABLE_LIST  variables;         /* the DLL of variable structures */
    char           *name; /* title if given in a format file or menu section */
    char           *locus;  /* path-name or menu section title of format */
    FF_TYPES_t     type;              /* format type, see FFF_LOOKUP format_types */
    unsigned int   num_vars;       /* number of variables in format */
    FF_NDX_t       length;        /* record length in bytes */
};
 
#define FORMAT_NAME_INIT "Format Was Untitled"
#define FORMAT_LOCUS_INIT "Unknown Origin"
#define FORMAT_LOCUS_GV_EDIT "GeoVu Format Editor"
 
/* ff_copy_variable depends on the contents of the VARIABLE structure, below.
   If you change this structure, you must also change ff_copy_variable
*/
 
/* I don't know if I should copy the EQUATION_INFO or not... */
 
/*
 * VARIABLE
 */
 
#include <eval_eqn.h>
 
/* define the conversion between user's variable name and value to geovu name and value */
 
typedef struct struct_ff_translator /* define value translation table */
{
#ifdef FF_CHK_ADDR
    void           *check_address;
#endif
    FF_TYPES_t                   gtype;  /* corresponding geovu data type */
    void                        *gvalue; /* corresponding geovu data value */
    FF_TYPES_t                   utype;  /* define the user's data type */
    void                        *uvalue; /* define the user's data value */
    struct struct_ff_translator *next;
} TRANSLATOR, *TRANSLATOR_PTR;
 
typedef struct struct_ff_variable VARIABLE, *VARIABLE_PTR, **VARIABLE_HANDLE;
 
/* Define MAX_MIN structure */
 
typedef struct struct_ff_max_min
{
#ifdef FF_CHK_ADDR
    void* check_address;        /* MAX_MIN address in memory */
#endif
    unsigned long cur_record;     /* Current record being processed */
    unsigned long min_record;       /* Record where min occurs */
    unsigned long max_record;       /* Record where max occurs */
    void *minimum;          /* Minimum variable value */
    void *maximum;          /* Maximum variable value */
    void *max_flag;         /* Upper missing data limit */
    void *min_flag;         /* Lower missing data limit */
} MAX_MIN, *MAX_MIN_PTR;
 
struct struct_ff_variable
{
#ifdef FF_CHK_ADDR
    void       *check_address;      /* assert(variable->check_address == variable); */
#endif
    EQUATION_INFO_PTR eqn_info; /* For derived output variables */
    union
    {
        TRANSLATOR_PTR nt_trans;   /* TRANSLATOR_PTR */
        int   cv_var_num; /* conversion function number */
        MAX_MIN_PTR mm;
    } misc;
    char        *name;      /* the variable name */
    FF_TYPES_t  type;       /* variable type, see FFF_LOOKUP variable_types */
    FF_NDX_t    start_pos;  /* starting byte of variable in a record, counting from 1 (one) */
    FF_NDX_t    end_pos;    /* ending byte of variable in a record */
    short       precision;  /* implied (if integer) or real (if floating point) precision, i.e., number of decimal places */
    char *array_desc_str;
    char *record_title;     /* if type == FF_VAR_TYPE_FLAG */
};
 
/*
 * FORMAT_DATA
 */
 
typedef struct struct_ff_format_data FORMAT_DATA, *FORMAT_DATA_PTR, **FORMAT_DATA_HANDLE;
struct struct_ff_format_data
{
/* generic io_element suitable for name tables, headers, and caches --
   anything that contains data in a dynamic buffer described by a format
*/
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    FORMAT_PTR format;
    FF_BUFSIZE_PTR data;
    struct struct_fd_state
    {
        unsigned int byte_order : 1; /* 1=big endian (Unix), 0=little endian */
        unsigned int new_record : 1; /* 1=new data that hasn't been accessed yet */
        unsigned int locked     : 1;
        unsigned int unused     : 13;
    } state;
};
 
typedef FORMAT_DATA          NAME_TABLE,
                            *NAME_TABLE_PTR,
                           **NAME_TABLE_HANDLE;
 
typedef FORMAT_DATA_LIST     NAME_TABLE_LIST,
                            *NAME_TABLE_LIST_HANDLE;
 
#include <name_tab.h>
 
/*
 * FORMAT_DATA_MAPPING
 */
 
typedef struct struct_ff_format_data_mapping FORMAT_DATA_MAPPING, *FORMAT_DATA_MAPPING_PTR, **FORMAT_DATA_MAPPING_HANDLE;
struct struct_ff_format_data_mapping
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    FORMAT_DATA_PTR input;
    FORMAT_DATA_PTR middle;
    FORMAT_DATA_PTR output;
};
 
typedef enum enum_pp_object
{
    PPO_FORMAT_LIST = 0,
    PPO_NT_LIST     = 1,
    ADD_YOUR_TYPE_HERE = 2
} PP_OBJECT_TYPES;
 
/*
 * PP_OBJECT
 */
 
typedef struct struct_ff_pp_object PP_OBJECT, *PP_OBJECT_PTR, **PP_OBJECT_HANDLE;
struct struct_ff_pp_object
{
    union union_u
    {
        FORMAT_LIST_HANDLE hf_list;
        struct struct_nt_list
        {        
            FF_TYPES_t nt_io_type;
            NAME_TABLE_LIST_HANDLE hnt_list;
        } nt_list;
        void *add_your_object_here;
    } u;
    PP_OBJECT_TYPES ppo_type;
};
 
/*
 * FF_ARRAY_DIPOLE
 */
typedef unsigned long FF_ARRAY_OFFSET_t;
 
typedef struct struct_ff_array_dipole FF_ARRAY_DIPOLE, *FF_ARRAY_DIPOLE_PTR, **FF_ARRAY_DIPOLE_HANDLE;
struct struct_ff_array_dipole
{
#ifdef FF_CHK_ADDR
    void                    *check_address;
#endif
    char                    *name;  /* the array variable name */
    FF_ARRAY_DIPOLE_PTR      mate;
    FORMAT_DATA_MAPPING_PTR  format_data_mapping;
    ARRAY_MAPPING_PTR        array_mapping;
    FORMAT_DATA_PTR          fd;
    struct struct_connect
    {
        NDARR_SOURCE id; /* NDARRS_FILE or NDARRS_BUFFER */
#if defined(_DEBUG) || defined(DEBUG)
        struct struct_locus
        {
            char *filename; /* file name if NDARRS_FILE */
            FF_BUFSIZE_PTR bufsize; /* FF_BUFSIZE_PTR if NDARRS_BUFFER */
        } locus;
#else
        union union_locus
        {
            char *filename; /* file name if NDARRS_FILE */
            FF_BUFSIZE_PTR bufsize; /* FF_BUFSIZE_PTR if NDARRS_BUFFER */
        } locus;
#endif
        struct struct_file_info
        {
            FF_ARRAY_OFFSET_t first_array_offset; /* file header size if NDARRS_FILE */
            FF_ARRAY_OFFSET_t current_array_offset; /* file header size if NDARRS_FILE */
        } file_info;
        unsigned long bytes_left;
        unsigned long bytes_done; /* read for input, converted for output */
        int array_done;
    } connect;
};
 
/*
 * FF_ARRAY_CONDUIT
 */
 
typedef struct struct_ff_array_conduit FF_ARRAY_CONDUIT, *FF_ARRAY_CONDUIT_PTR, **FF_ARRAY_CONDUIT_HANDLE;
struct struct_ff_array_conduit
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    char name[FF_MAX_NAME]; /* the array variable name */
    FF_ARRAY_DIPOLE_PTR input;
    FF_ARRAY_DIPOLE_PTR output;
};
 
/*
 * PROCESS_INFO
 */
 
typedef struct struct_ff_process_info PROCESS_INFO, *PROCESS_INFO_PTR, **PROCESS_INFO_HANDLE;
struct struct_ff_process_info
{
#ifdef FF_CHK_ADDR
    void *check_address;
    void *locked_buffer;
#endif
    char *name;
    FF_ARRAY_DIPOLE_PTR pole;
 
    PROCESS_INFO_PTR mate;
};
 
/*
 * DATA_FLAG
 */
 
typedef struct struct_ff_data_flag
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    double        value;
    double        temp_dvar;
    VARIABLE_PTR  var;
    char          value_exists;
} FF_DATA_FLAG, *FF_DATA_FLAG_PTR;
 
 
#ifdef FF_DBG
VARIABLE_PTR           FF_VARIABLE(VARIABLE_LIST);
FORMAT_PTR             FF_FORMAT(FORMAT_LIST);
FORMAT_DATA_PTR       FD_FORMAT_DATA(FORMAT_DATA_LIST);
FF_ARRAY_CONDUIT_PTR      FF_AC(FF_ARRAY_CONDUIT_LIST);
PROCESS_INFO_PTR       FF_PI(PROCESS_INFO_LIST);
FF_ERROR_PTR           FF_EP(FF_ERROR_LIST);
FF_DATA_FLAG_PTR       FF_DF(FF_DATA_FLAG_LIST);
 
DLL_NODE_PTR dll_next(DLL_NODE_PTR node);
DLL_NODE_PTR dll_previous(DLL_NODE_PTR node);
 
#else
#define FF_VARIABLE(vl)              ((VARIABLE_PTR)(vl)->data.u.var)
#define FF_FORMAT(fl)                  ((FORMAT_PTR)(fl)->data.u.fmt)
#define FD_FORMAT_DATA(fdl)       ((FORMAT_DATA_PTR)(fdl)->data.u.fd)
#define FF_AC(acl)           ((FF_ARRAY_CONDUIT_PTR)(acl)->data.u.ac)
#define FF_PI(pil)               ((PROCESS_INFO_PTR)(pil)->data.u.pi)
#define FF_EP(el)                    ((FF_ERROR_PTR)(el)->data.u.err)
#define FF_DF(dfl)               ((FF_DATA_FLAG_PTR)(dfl)->data.u.df)
 
#define dll_next(n) ((n)->next)
#define dll_previous(n) ((n)->previous)
 
#endif
 
DLL_NODE_PTR dll_first(DLL_NODE_PTR node);
DLL_NODE_PTR dll_last(DLL_NODE_PTR node);
 
typedef enum enum_ff_dll_data_types
{
    DLL_VAR = 1,
    DLL_FMT = 2,
    DLL_FD  = 3,
    DLL_AC  = 4,
    DLL_PI  = 5,
    DLL_ERR = 6,
    DLL_DF  = 7,
    DLL_HEAD_NODE = SHRT_MAX
} FF_DLL_DATA_TYPES;
 
typedef struct struct_ff_dll_data DLL_DATA, *DLL_DATA_PTR, **DLL_DATA_HANDLE; 
struct struct_ff_dll_data
{
    union union_struct_ff_dll_data_u
    {
        VARIABLE_PTR var;
        FORMAT_PTR fmt;
        FORMAT_DATA_PTR fd;
        FF_ARRAY_CONDUIT_PTR ac;
        PROCESS_INFO_PTR pi;
        FF_ERROR_PTR err;
        FF_DATA_FLAG_PTR df;
    } u;
  FF_DLL_DATA_TYPES type;
};
 
struct struct_ff_dll_node
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    DLL_DATA data;
    DLL_NODE_PTR previous;
    DLL_NODE_PTR next;
#ifdef DLL_CHK
    unsigned int status;
    size_t count; /* head node: count of non-head nodes */
#endif
};
 
/* Define BIN structures */
 
typedef struct struct_databin
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    char *title;
 
    EQUATION_INFO_PTR eqn_info;
 
    FF_ARRAY_CONDUIT_LIST array_conduit_list;
    
    NAME_TABLE_LIST table_list;
} DATA_BIN, *DATA_BIN_PTR, **DATA_BIN_HANDLE;
 
typedef struct struct_ff_array_dim_info
{
#ifdef FF_CHK_ADDR
    void *check_address;
#endif
    long start_index;
    long end_index;
    long granularity;
    long separation;
    long grouping;
    long num_array_elements;
} FF_ARRAY_DIM_INFO, *FF_ARRAY_DIM_INFO_PTR, **FF_ARRAY_DIM_INFO_HANDLE;
 
#define DEFAULT_CACHE_SIZE  16384L
 
#define FF_MAX_CACHE_SIZE (unsigned long)UINT_MAX
 
#define DBSET_INPUT_FORMATS             1
#define DBSET_OUTPUT_FORMATS            2
#define DBSET_HEADERS                   3
#define DBSET_READ_EQV                  4
#define DBSET_CACHE_SIZE                5
#define DBSET_HEADER_FILE_NAMES         6
#define DBSET_QUERY_RESTRICTION         7
#define DBSET_VARIABLE_RESTRICTION      8
#define DBSET_BYTE_ORDER                  9
#define DBSET_CREATE_CONDUITS          10
#define DBSET_USER_UPDATE_FORMATS      11
#define DBSET_INIT_CONDUITS            12
#define DBSET_FORMAT_MAPPINGS          13
#define DBSET_EQUATION_VARIABLES       14
#define DBSET_SETUP_STDIN              15
#define DBSET_VAR_MINMAX               16
 
#define DBASK_FORMAT_SUMMARY            1
#define DBASK_PROCESS_INFO              2
#define DBASK_VAR_NAMES                 3
#define DBASK_VAR_MINS                  4
#define DBASK_VAR_MAXS                  5
#define DBASK_VAR_UNITS                 6
#define DBASK_VAR_FLAGS                 7
#define DBASK_ARRAY_DIM_NAMES           8
#define DBASK_ARRAY_DIM_INFO            9
#define DBASK_BYTES_TO_PROCESS         10
#define DBASK_FORMAT_DESCRIPTION       11
#define DBASK_FORMAT_LIST_DESCRIPTION       12
#define DBASK_TAB_TO_ARRAY_FORMAT_DESCRIPTION 13
#define DBASK_FORMAT_DESCRIPTION_TO_USER       14
#define DBASK_FORMAT_LIST_DESCRIPTION_TO_USER       15
 
#define DBDO_READ_FORMATS               1
#define DBDO_WRITE_FORMATS              2
#define DBDO_CONVERT_DATA               3
#define DBDO_BYTE_SWAP                  4
#define DBDO_FILTER_ON_QUERY            5
#define DBDO_CONVERT_FORMATS            6
#define DBDO_PROCESS_FORMATS            7
#define DBDO_READ_STDIN                 8
#define DBDO_CHECK_STDOUT               9
#define DBDO_PROCESS_DATA              10
 
/* not needed */
#define DBDO_WRITE_OUTPUT_FMT_FILE      255
 
#ifdef NT_ANYWHERE
#error "NT_ANYWHERE is already defined!"
#endif
#define NT_HEADERS   FFF_FILE | FFF_REC | FFF_HEADER
#define NT_TABLE     FFF_TABLE /* Don't change this w/o looking at every occurrence of IS_TABLE! */
 
#define NT_INPUT      FFF_INPUT | NT_HEADERS | NT_TABLE
#define NT_OUTPUT    FFF_OUTPUT | NT_HEADERS | NT_TABLE
 
#define NT_ANYWHERE  FFF_FILE | FFF_REC | FFF_HEADER | FFF_TABLE
 
/* Internal stuff */
#define PINFO_POLE(pi)        ((pi)->pole)
#define PINFO_FD(pi)          (PINFO_POLE(pi)->fd)
#define PINFO_DATA(pi)        (PINFO_FD(pi)->data)
#define PINFO_BUFFER(pi)      (PINFO_DATA(pi)->buffer)
#define PINFO_BYTES_USED(pi)  (PINFO_DATA(pi)->bytes_used)
#define PINFO_TOTAL_BYTES(pi) (PINFO_DATA(pi)->total_bytes)
#define PINFO_STATE(pi)       (PINFO_FD(pi)->state)
#define PINFO_LOCKED(pi)      (PINFO_STATE(pi).locked)
#define PINFO_NEW_RECORD(pi)  (PINFO_STATE(pi).new_record)
#define PINFO_BYTE_ORDER(pi)  (PINFO_STATE(pi).byte_order)
#define PINFO_FORMAT(pi)      (PINFO_FD(pi)->format)
 
#define PINFO_SUPER_ARRAY_BYTES(pi)  (PINFO_ARRAY_MAP(pi)->super_array->contig_size)
#define PINFO_SUB_ARRAY_BYTES(pi)    (PINFO_ARRAY_MAP(pi)->sub_array->contig_size)
 
#define PINFO_SUPER_ARRAY_ELS(pi)  (PINFO_ARRAY_MAP(pi)->super_array->total_elements)
#define PINFO_SUB_ARRAY_ELS(pi)    (PINFO_ARRAY_MAP(pi)->sub_array->total_elements)
 
#define PINFO_ARRAY_BYTES(pi) (PINFO_ARRAY_MAP(pi)->super_array->contig_size)
 
#define PINFO_ARRAY_DIMS(pi) (PINFO_ARRAY_MAP(pi)->super_array->num_dim)
#define PINFO_ARRAY_NAME(pi, dim) (PINFO_ARRAY_MAP(pi)->super_array->dim_name[dim])
#define PINFO_ARRAY_DIM_SIZE(pi, dim) (PINFO_ARRAY_MAP(pi)->super_array->dim_size[dim])
 
/* External stuff */
#define PINFO_TYPE(pi)          (PINFO_FORMAT(pi)->type)
#define PINFO_NAME(pi)          (PINFO_FORMAT(pi)->name)
#define PINFO_ORIGIN(pi)        (PINFO_FORMAT(pi)->locus)
#define PINFO_RECL(pi)          (FORMAT_LENGTH(PINFO_FORMAT(pi)))
#define PINFO_CACHEL(pi)        (PINFO_TOTAL_BYTES(pi) - 1)
#define PINFO_NUMVARS(pi)       (PINFO_FORMAT(pi)->num_vars)
#define PINFO_IS_FILE(pi)       (PINFO_POLE(pi)->connect.id & NDARRS_FILE)
#define PINFO_IS_BUFFER(pi)     (PINFO_POLE(pi)->connect.id & NDARRS_BUFFER)
#define PINFO_IS_ARRAY(pi)      (IS_ARRAY(PINFO_FORMAT(pi)))
#define PINFO_IS_BROKEN(pi)     (PINFO_ARRAY_MAP(pi)->sub_array->type == NDARRT_BROKEN)
#define PINFO_FNAME(pi)         (PINFO_POLE(pi)->connect.locus.filename)
#define PINFO_LOCUS_BUFSIZE(pi) (PINFO_POLE(pi)->connect.locus.bufsize)
#define PINFO_LOCUS_BUFFER(pi)  (PINFO_POLE(pi)->connect.locus.bufsize->buffer)
#define PINFO_LOCUS_SIZE(pi)    (PINFO_POLE(pi)->connect.locus.bufsize->total_bytes)
#define PINFO_LOCUS_FILLED(pi)  (PINFO_POLE(pi)->connect.locus.bufsize->bytes_used)
#define PINFO_FIRST_ARRAY_OFFSET(pi)  (PINFO_POLE(pi)->connect.file_info.first_array_offset)
#define PINFO_CURRENT_ARRAY_OFFSET(pi)  (PINFO_POLE(pi)->connect.file_info.current_array_offset)
#define PINFO_ARRAY_DONE(pi)    (PINFO_POLE(pi)->connect.array_done)
#define PINFO_BYTES_LEFT(pi)    (PINFO_POLE(pi)->connect.bytes_left)
#define PINFO_BYTES_DONE(pi)    (PINFO_POLE(pi)->connect.bytes_done)
#define PINFO_ARRAY_MAP(pi)     (PINFO_POLE(pi)->array_mapping)
#define PINFO_ID(pi)            (PINFO_POLE(pi)->connect.id)
#define PINFO_FORMAT_MAP(pi)    (PINFO_POLE(pi)->format_data_mapping)
 
#define PINFO_SUPER_ARRAY(pi)   (PINFO_ARRAY_MAP(pi)->super_array)
#define PINFO_SUB_ARRAY(pi)     (PINFO_ARRAY_MAP(pi)->sub_array)
 
#define PINFO_NUM_DIMS(pi)      (PINFO_ARRAY_MAP(pi)->super_array->num_dim)
 
#define PINFO_DIM_NAME(pi,i)             (PINFO_ARRAY_MAP(pi)->super_array->dim_name[i])
#define PINFO_DIM_START_INDEX(pi, i)  (PINFO_ARRAY_MAP(pi)->super_array->start_index[i])
#define PINFO_DIM_END_INDEX(pi, i)    (PINFO_ARRAY_MAP(pi)->super_array->end_index[i])
#define PINFO_DIM_GRANULARITY(pi, i)  (PINFO_ARRAY_MAP(pi)->super_array->granularity[i])
#define PINFO_DIM_SEPARATION(pi, i)   (PINFO_ARRAY_MAP(pi)->super_array->separation[i])
#define PINFO_DIM_GROUPING(pi, i)     (PINFO_ARRAY_MAP(pi)->super_array->grouping[i])
 
#define PINFO_MATE(pi) ((pi)->mate)
 
/* Internal stuff */
#define PINFO_MATE_POLE(pi)        PINFO_POLE(PINFO_MATE(pi))
#define PINFO_MATE_FD(pi)          PINFO_FD(PINFO_MATE(pi))
#define PINFO_MATE_DATA(pi)        PINFO_DATA(PINFO_MATE(pi))
#define PINFO_MATE_BUFFER(pi)      PINFO_BUFFER(PINFO_MATE(pi))
#define PINFO_MATE_BYTES_USED(pi)  PINFO_BYTES_USED(PINFO_MATE(pi))
#define PINFO_MATE_TOTAL_BYTES(pi) PINFO_TOTAL_BYTES(PINFO_MATE(pi))
#define PINFO_MATE_STATE(pi)       PINFO_STATE(PINFO_MATE(pi))
#define PINFO_MATE_LOCKED(pi)      PINFO_LOCKED(PINFO_MATE(pi))
#define PINFO_MATE_NEW_RECORD(pi)  PINFO_NEW_RECORD(PINFO_MATE(pi))
#define PINFO_MATE_BYTE_ORDER(pi)  PINFO_BYTE_ORDER(PINFO_MATE(pi))
#define PINFO_MATE_FORMAT(pi)      PINFO_FORMAT(PINFO_MATE(pi))
 
#define PINFO_MATE_SUPER_ARRAY_BYTES(pi)  PINFO_SUPER_ARRAY_BYTES(PINFO_MATE(pi))
#define PINFO_MATE_SUB_ARRAY_BYTES(pi)    PINFO_SUB_ARRAY_BYTES(PINFO_MATE(pi))
 
#define PINFO_MATE_SUPER_ARRAY_ELS(pi)  PINFO_SUPER_ARRAY_ELS(PINFO_MATE(pi))
#define PINFO_MATE_SUB_ARRAY_ELS(pi)    PINFO_SUB_ARRAY_ELS(PINFO_MATE(pi))
 
#define PINFO_MATE_ARRAY_BYTES(pi) (PINFO_MATE_ARRAY_MAP(pi)->sub_array->contig_size)
 
#define PINFO_MATE_SUPER_ARRAY(pi)   (PINFO_MATE_ARRAY_MAP(pi)->super_array)
#define PINFO_MATE_SUB_ARRAY(pi)     (PINFO_MATE_ARRAY_MAP(pi)->sub_array)
 
/* External stuff */
#define PINFO_MATE_TYPE(pi)          PINFO_TYPE(PINFO_MATE(pi))
#define PINFO_MATE_NAME(pi)          PINFO_NAME(PINFO_MATE(pi))
#define PINFO_MATE_ORIGIN(pi)        PINFO_ORIGIN(PINFO_MATE(pi))
#define PINFO_MATE_RECL(pi)          PINFO_RECL(PINFO_MATE(pi))
#define PINFO_MATE_CACHEL(pi)        PINFO_CACHEL(PINFO_MATE(pi))
#define PINFO_MATE_NUMVARS(pi)       PINFO_NUMVARS(PINFO_MATE(pi))
#define PINFO_MATE_IS_FILE(pi)       PINFO_IS_FILE(PINFO_MATE(pi))
#define PINFO_MATE_IS_BUFFER(pi)     (PINFO_MATE_POLE(pi)->connect.id & NDARRS_BUFFER)
#define PINFO_MATE_FNAME(pi)         PINFO_FNAME(PINFO_MATE(pi))
#define PINFO_MATE_LOCUS(pi)         PINFO_LOCUS(PINFO_MATE(pi))
#define PINFO_MATE_ARRAY_OFFSET(pi)  PINFO_ARRAY_OFFSET(PINFO_MATE(pi))
#define PINFO_MATE_ARRAY_DONE(pi)    PINFO_ARRAY_DONE(PINFO_MATE(pi))
#define PINFO_MATE_BYTES_LEFT(pi)    PINFO_BYTES_LEFT(PINFO_MATE(pi))
#define PINFO_MATE_BYTES_DONE(pi)    PINFO_BYTES_DONE(PINFO_MATE(pi))
#define PINFO_MATE_BUFFER_SIZE(pi)   PINFO_BUFFER_SIZE(PINFO_MATE(pi))
#define PINFO_MATE_ARRAY_MAP(pi)     PINFO_ARRAY_MAP(PINFO_MATE(pi))
#define PINFO_MATE_ID(pi)            PINFO_ID(PINFO_MATE(pi))
 
void dll_assign(void *data, FF_DLL_DATA_TYPES type, DLL_NODE_PTR node);
 
typedef BOOLEAN (*pgenobj_cmp_t)(void *, void *); /* pointer to generic object comparison function */
 
int list_replace_items(pgenobj_cmp_t lmi_cmp, DLL_NODE_PTR list);
 
/* Function Prototypes */
 
size_t ffv_type_size(FF_TYPES_t var_type);
 
DLL_NODE_PTR dll_init(void);
DLL_NODE_PTR dll_add(DLL_NODE_PTR);
DLL_NODE_PTR dll_insert(DLL_NODE_PTR next_node);
void dll_delete(DLL_NODE_PTR);
void dll_delete_node(DLL_NODE_PTR);
int dll_free_list(DLL_NODE_PTR head);
int dll_free_holdings(DLL_NODE_PTR head);
void dll_rewind(DLL_NODE_HANDLE head_handle);
 
/* Format Attributes and object types */
#define FFF_NAME_CASE        (FF_TYPES_t)2
 
int db_set(DATA_BIN_PTR, int, ...);
int db_ask(DATA_BIN_PTR, int, ...);
int db_do(DATA_BIN_PTR, int, ...);
 
/* Format List Functions */
FORMAT_DATA_PTR fd_get_header(DATA_BIN_PTR dbin, FF_TYPES_t header_type);
FORMAT_DATA_PTR fd_get_data(DATA_BIN_PTR dbin, FF_TYPES_t data_type);
 
void db_format_list_mark_io(FORMAT_LIST f_list, FF_TYPES_t format_type, char *input_file_name, char *output_file_name);
FORMAT_DATA_PTR fd_find_format_data(FORMAT_DATA_LIST, ...);
FORMAT_PTR db_find_format(FORMAT_LIST, ...);
 
int nt_ask(DATA_BIN_PTR, FF_TYPES_t origin, char *name, FF_TYPES_t value_type, void *value);
int nt_put(DATA_BIN_PTR, FF_TYPES_t origin, char *name, FF_TYPES_t value_type, void *value);
BOOLEAN nt_askexist(DATA_BIN_PTR, FF_TYPES_t, char *);
char *nt_find_user_name(DATA_BIN_PTR dbin, FF_TYPES_t origin_type, char *value_name, NAME_TABLE_HANDLE);
char *nt_find_geovu_name(DATA_BIN_PTR dbin, FF_TYPES_t origin_type, char *geovu_name, NAME_TABLE_HANDLE);
 
int db_init(FF_STD_ARGS_PTR, DATA_BIN_HANDLE, int (*error_cb)(int));
 
void db_destroy(DATA_BIN_PTR);
BOOLEAN endian(void);
 
int create_array_conduit_list
    (
     FORMAT_DATA_LIST format_data_list,
     FF_STD_ARGS_PTR std_args,
     FF_ARRAY_CONDUIT_LIST_HANDLE array_conduit_list_handle
    );
 
char *ff_lookup_string(FFF_LOOKUP_PTR, FF_TYPES_t);
FF_TYPES_t ff_lookup_number(FFF_LOOKUP_PTR, char *);
int ff_file_to_bufsize(char *fname, FF_BUFSIZE_HANDLE);
int ff_bufsize_to_textfile_overwrite(char *, FF_BUFSIZE_PTR);
int ff_bufsize_to_textfile_append(char *, FF_BUFSIZE_PTR);
 
int parse_command_line(int, char **, FF_STD_ARGS_PTR);
 
int ff_put_binary_data(VARIABLE_PTR var, void *in_data_ptr, size_t in_var_length, FF_TYPES_t in_data_type, void *out_data_ptr, FF_TYPES_t out_format_type);
int calculate_variable(VARIABLE_PTR var, FORMAT_PTR format, char *input_ptr, double *d);
int ff_get_double(VARIABLE_PTR, void *, double *, FF_TYPES_t);
int ff_binary_to_string(void *source, FF_TYPES_t data_type, int precision, char *target);
 
int ff_copy_variable(VARIABLE_PTR source, VARIABLE_PTR target);
FORMAT_PTR ff_copy_format(FORMAT_PTR format);
 
BOOLEAN ff_format_comp(FORMAT_PTR, FORMAT_PTR);
int ff_text_pre_parser(char *origin, FF_BUFSIZE_PTR, PP_OBJECT_PTR pp_object);
VARIABLE_PTR ff_make_variable(VARIABLE_PTR);
FORMAT_PTR ff_create_format(char *name, char *origin);
void ff_destroy_format(FORMAT_PTR);
void ff_destroy_variable(VARIABLE_PTR);
VARIABLE_PTR ff_create_variable(char *name);
 
FF_STD_ARGS_PTR ff_create_std_args(void);
void ff_destroy_std_args(FF_STD_ARGS_PTR);
 
void fd_destroy_format_data_list(FORMAT_DATA_LIST format_data_list);
 
FF_DATA_FLAG_PTR ff_create_data_flag(void);
void ff_destroy_data_flag(FF_DATA_FLAG_PTR);
 
FORMAT_PTR ff_find_format(FORMAT_LIST, ...);
FORMAT_PTR ff_afm2bfm(FORMAT_PTR, char *new_name);
FORMAT_PTR ff_xfm2struct(FORMAT_PTR, char *new_name);
size_t ffv_ascii_type_size(VARIABLE_PTR var);
FORMAT_PTR ff_bfm2dfm(FORMAT_PTR format, char *new_name);
int format_to_ISO8211DDR(FORMAT_PTR format, const char *first_fields, FF_BUFSIZE_HANDLE ddf);
VARIABLE_PTR ff_find_variable(char *, FORMAT_PTR);
VARIABLE_PTR ff_new_name(FORMAT_PTR, char *, char *);
unsigned char ff_var_length(VARIABLE_PTR);
int btype_to_btype(void *src_value, FF_TYPES_t src_type, void *dest_value, FF_TYPES_t dest_type);
BOOLEAN type_cmp(FF_TYPES_t type, void *value0, void *value1);
 
/* Other */
FF_BUFSIZE_PTR ff_create_bufsize(long total_bytes);
int ff_resize_bufsize(long new_size, FF_BUFSIZE_HANDLE hbufsize);
void ff_destroy_bufsize(FF_BUFSIZE_PTR bufsize);
void ff_destroy_array_conduit(FF_ARRAY_CONDUIT_PTR conduit);
void ff_destroy_array_pole(FF_ARRAY_DIPOLE_PTR pole);
void ff_destroy_error(FF_ERROR_PTR error);
void fd_destroy_format_data(FORMAT_DATA_PTR fd);
FORMAT_DATA_PTR fd_create_format_data(FORMAT_PTR format, long data_size, char *name);
 
void ff_destroy_process_info_list(PROCESS_INFO_LIST);
void ff_destroy_process_info(PROCESS_INFO_PTR);
 
int ff_create_format_data_mapping
    (
     FORMAT_DATA_PTR input,
     FORMAT_DATA_PTR output,
     FORMAT_DATA_MAPPING_HANDLE pd_h
    );
 
void ff_destroy_format_data_mapping(FORMAT_DATA_MAPPING_PTR pd);
 
void ff_destroy_array_conduit_list(FF_ARRAY_CONDUIT_LIST conduit_list);
 
int new_name_string__(const char *new_name, FF_STRING_HANDLE name_h);
 
int make_tabular_format_array_mapping
    (
     PROCESS_INFO_PTR pinfo,
     long num_records,
     long start_record,
     long end_record
    );
 
int initialize_middle_data
    (
     FORMAT_DATA_PTR input,
     FORMAT_DATA_PTR output,
     FORMAT_DATA_PTR middle
    );
 
int ff_process_format_data_mapping(FORMAT_DATA_MAPPING_PTR pd);
 
void update_format_var
    (
     FF_TYPES_t data_type,
     FF_NDX_t bytes_per_pixel,
     VARIABLE_PTR var,
     FORMAT_PTR format
    );
 
int update_following_offsets_or_size
    (
     PROCESS_INFO_PTR updater,
     PROCESS_INFO_LIST updater_list,
     long adjustment
    );
 
/* Define MAX_MIN Attributes/messages */
#define MM_MAX_MIN      101
#define MM_MISSING_DATA_FLAGS   102
 
/* MAX_MIN prototypes */
int     mm_free(MAX_MIN_PTR);
double      mm_getmx(VARIABLE_PTR);
double      mm_getmn(VARIABLE_PTR);
int mm_make(VARIABLE_PTR);
int         mm_print(VARIABLE_PTR);
int         mm_set(VARIABLE_PTR, ...);
 
/* Conversion Function Prototypes */
 
typedef int FF_CVF(VARIABLE_PTR, double*, FORMAT_PTR, FF_DATA_BUFFER);
 
/* ndarray-dbin prototype */
 
ARRAY_DESCRIPTOR_PTR ndarr_create_from_str(DATA_BIN_PTR dbin, char *arraystr);
 
 
FF_CVF cv_abs;
FF_CVF cv_abs_sign_to_value;
FF_CVF cv_units;
FF_CVF cv_date_string;
FF_CVF cv_time_string;
FF_CVF cv_deg;
FF_CVF cv_deg_nsew;
FF_CVF cv_degabs;
FF_CVF cv_degabs_nsew;
FF_CVF cv_deg_abs;
FF_CVF cv_dms;
FF_CVF cv_feet_to_meters;
FF_CVF cv_geo44tim;
FF_CVF cv_geog_quad;
FF_CVF cv_geog_sign;
FF_CVF cv_ipe2ser;
FF_CVF cv_lon_east;
FF_CVF cv_long2mag;
FF_CVF cv_mag2long;
FF_CVF cv_meters_to_feet;
FF_CVF cv_nsew;
FF_CVF cv_ser2ymd;
FF_CVF cv_ser2ipe;
FF_CVF cv_sea_flags;
FF_CVF cv_slu_flags;
FF_CVF cv_ymd2ser;
FF_CVF cv_ydec2ymd;
FF_CVF cv_ymd2ipe;
FF_CVF cv_noaa_eq;
 
/* Application function prototypes */
 
int do_log(FF_BUFSIZE_PTR log_bufsize, char *format, ...);
int wfprintf(FILE *stream, const char *format, ...);
 
int newform(FF_STD_ARGS_PTR std_args, FF_BUFSIZE_PTR log, FILE *to_user);
 
int checkvar(FF_STD_ARGS_PTR std_args, FF_BUFSIZE_PTR log, FILE *to_user);
 
int ff_lock(PROCESS_INFO_PTR pinfo, void **hbuffer, unsigned long *psize);
int ff_unlock(PROCESS_INFO_PTR pinfo, void **hbuffer);
 
FF_DATA_BUFFER ff_strnstr(char *pcPattern, FF_DATA_BUFFER pcText, size_t uTextLen);
 
int get_output_delims
    (
     DATA_BIN_PTR dbin,
     char *delim_item,
     short *distance,
     char *delim_value
    );
 
#endif  /* (NOT) FREEFORM_H__ */