/**
 * @file   FLUCUPLB.h
 * @brief  FLUCUPLB - Description - Load module interface for FLUC subprogram
 * @author limes datentechnik gmbh
 * @date   18.02.2015
 * @copyright limes datentechnik (R) gmbh
 *
 * @mainpage FLUC Load Module Interface
 *
 * This interface provides all FLCL commands (CONV, XCNV, ...) based
 * on the Frankenstein Limes Universal Converter (FLUC) as simple to
 * use and programming language independent load modules. It is mainly
 * meant to be used for Assembler, COBOL and PL1 on mainframe systems.
 * It can also be used in C through the fetch() function, but the C like
 * FLUCUP native interface is easier to use in this case.
 *
 * For each command, there is a function that accepts a command line
 * and property file string that follows the FLCL syntax and produces
 * the same condition code as FLCL. The property file string is parsed
 * before the command line string. The property string may contain
 * command properties in the property file syntax of FLCL based on the
 * default owner "limes". You can read an FLCL property file
 * programmatically and provide its content as this string. To generate
 * a property file please use:
 *
 * <pre>
 *     FLCL GENPROP command=filename
 * </pre>
 *
 * It is currently not possible to change the owner id or program name.
 * In case this is required, please use the native FLUCUP interface.
 *
 * To manage a property file per command the function #FCUPRO() is
 * provided.
 *
 * The interface accepts the content of such a file as string, not the
 * filename itself! This allows to store properties in other formats
 * such as JSON, XML or binary and use it with the UP interface.
 *
 * The programming interface can be used to integrate the source (file)
 * to target (file) data conversion capabilities provided by FLUC into
 * a program.
 *
 * The interface also provides the interactive help, documentation and
 * syntax information to assist in understanding all commands.
 *
 * @section ITFSTD Interface standards
 * Each function is provided as a separate load module. All parameters
 * are call-by-reference and have no return value. All parameters must be
 * specified. There is no support to determine a variable amount of
 * parameter. There are 3 types of parameters:
 *
 * <pre>
 * INTEGER:   pointer to a 32 bit number in two's complement   (Cobol: PIC S9(9) COMP  or  PL/1: BIN FIXED(31,0))
 * STRING[x]: pointer to a byte (8 bit) array of length x      (Cobol: PIC X(x)        or  PL/1: CHAR(x))
 * STRING:    pointer to a variable length byte (8 bit) array  (Cobol: PIC X(n)        or  PL/1: CHAR(n))
 * </pre>
 *
 * The type INTEGER has local endianness. On mainframes, this is usually
 * big endian. This means that the most significant byte is stored first
 * (i.e. at the lowest memory address) and the least significant byte is
 * stored last. On x86 platforms, the byte order is little endian. This
 * means that the byte order is reversed.
 *
 * Input strings may be 0-terminated in which case the corresponding
 * length pointer may be NULL. All output strings are 0-terminated.
 *
 * For variable length byte arrays, the length will be determined based
 * on an additional INTEGER parameter. On input, this parameter must
 * contain the length of the string. On output, this parameter must be
 * loaded with the available size for the byte array and will be set to
 * the actually used size. If the size is too small, the string will be
 * cut and the length will be set to the respective value. This case
 * will be marked with the special condition code 10.
 *
 * For output files you can define ":STDERR" or ":STDOUT" to assign the
 * corresponding streams.
 *
 * @section ENVVAR Environment variables
 * For all default character conversions, it is useful to set the environment
 * variable LANG. Other used environment variables of FLAM can be found
 * in the FLCL manual. With version 5.1.19 a new function (#FCUENV()) to
 * load the FLAM environment was introduced. This function can be used
 * in front of the first API call to establish the same environment
 * used by FLAM utilities, subsystems and so on. This give the application
 * developer the possibility to adjust the environment before the first
 * real call is done. Till 5.1.18 each function has read the system
 * variables on z/OS. This is now part of the #FCUENV() function to give
 * complete control about the environment to the user of the API.
 *
 * @section CONDCODE Condition codes
 * The return codes of the subprogram are also called condition codes and
 * returned at subprogram termination.
 *
 * * 0  - command line, command syntax, mapping, execution and finish of the command was successful
 * * 1  - command line, command syntax, mapping, execution and finish of the command was successful but a warning can be found in the log
 * * 2  - command line, command syntax, mapping, execution was successful but cleanup of the command failed (may not happened)
 * * 4  - command line, command syntax and mapping was successful but execution of the command returns with a warning
 * * 8  - command line, command syntax and mapping was successful but execution of the command returns with an error
 * * 10 - Provided buffer for about, version or license string is too small
 * * 12 - command line and command syntax was OK but mapping failed
 * * 16 - command line was OK but command syntax was wrong
 * * 20 - command line was wrong (user error)
 * * 24 - initialization of the parameter structure of command failed (may not happened)
 * * 28 - configuration is wrong (user error)
 * * 32 - table error (something within the predefined tables is wrong)
 * * 36 - system error (e.g. load of environment or open of file failed)
 * * 40 - access control or license error
 * * 44 - interface error (e.g. parameter pointer equals NULL)
 * * 48 - memory allocation failed (e.g. dynamic string handling)\n
 * * 64 - fatal error (basic things are damaged)
 * * >64 - for few special conditions codes (see FLCLBOOK)
 *
 * The return code parameter can be a null pointer, then no return value
 * is set. Special condition codes can be found in FLCL manual (FLCLBOOK).
 *
 * @section RSNCODE Reason codes
 * The reason code (internal FLAM return code) can be determined together
 * with a corresponding message using the function #FCURSN. All FLAM reason
 * codes are listed in FLCL manual (FLCLBOOK).
 *
 * @section HLPSYN Help and Syntax
 * For the help, syntax and documentation functions, the command must be
 * specified as a constant number called 'what':
 *
 *  * &nbsp;&nbsp;1  - to get information about the INFO command string
 *  * &nbsp;&nbsp;2  - to get information about the CONV command string
 *  * &nbsp;&nbsp;3  - to get information about the XCNV command string
 *  * &nbsp;&nbsp;4  - to get information about the ICNV command string
 *  * &nbsp;&nbsp;5  - to get information about the FLAM command string
 *  * &nbsp;&nbsp;6  - to get information about the XCHK command string
 *  * &nbsp;&nbsp;7  - to get information about the HASH command string
 *  * &nbsp;&nbsp;8  - to get information about the UTIL command string
 *  * &nbsp;&nbsp;9  - to get information about the DIFF command string
 *  * &nbsp;&nbsp;10 - to get information about the KEY  command string
 *  * &nbsp;&nbsp;11 - to get information about the GREP command string
 *
 * The help, syntax and documentation can be used to determine the
 * complete context sensitive help, which is identical to the
 * content of the FLCL user manual section for the respective command.
 * </p>
 *
 * @section CMPLNK Compile and Link
 *
 * @subsection HOST On mainframes (z/OS, BS2000, ...):
 *
 * The interface is provided as DLL and each function of the DLL is also
 * available as separate load module.
 *
 * For dynamic linking of the load module (fetch) the hlq.FLAM.LOAD
 * library must be part of the STEPLIB concatenation.
 *
 * If you link one of the load modules statically to your application
 * (each load module contains all required entries of the interface),
 * you must include the DLL import files below to resolve the missing
 * external references:
 *
 * <pre>
 *     hlq.FLAM.IMPORT(FLUCUP)
 *     hlq.FLAM.IMPORT(FL5CORE)
 * </pre>
 *
 * To link dynamically against the DLL you must include the import DLL
 * file form the IMPORT library below:
 *
 * <pre>
 *     hlq.FLAM.IMPORT(FLUCUPLB)
 * </pre>
 *
 * We recommend to use application-specific runtime option defaults with
 * the CEEUOPT assembler language source program to establish application
 * default options. You can find the recommended runtime options as member
 * CEEUOPTx (x=3 for 31 bit and x=6 for 64 bit applications) in the
 * hlq.FLAM.SRCLIB partitioned dataset.
 *
 * @subsection OTHER On other platforms (Unix, Windows, ...):
 *
 * The interface is only available as dynamic link library (DLL) or
 * shared object (SO). You can link it dynamically, statically or load
 * the library at runtime (dlopen(), LoadLibrary()) with the common
 * DLL/SO mechanism of your operating system.
 *
 * @section SAMPLE Sample programs
 * Sample programs in C with name SCFCUCNV/GZP can be found as part of the
 * installation package for mainframe systems in the library SRCLIBC(SCFCUxxx),
 * with the corresponding compile and link step in JOBLIB(SBUILD).
 * For other platforms (Windows, UNIX) the sample program source of SCFCUCNV/GZP
 * is located in the 'sample' directory and the compile and link procedures
 * can be found in the Makefile of the same directory.
 *
 * Additional COBOL samples with name SOFCUCNV/KME can be found
 * in SRCLIB(SOFCUxxx). The corresponding PL1 sample is named SPFCUCNV.
 * The corresponding compile and link procedures is also located as separate
 * step in JOBLIB(SBUILD).
 *
 **********************************************************************/

/*! @cond PRIVATE */
#ifdef __cplusplus
   extern "C" {
#endif

#ifndef INC_FLUCUPLB_H
#define INC_FLUCUPLB_H

/*! @endcond */

/**********************************************************************/
/**
* @defgroup FCUFUC FLUC Function Codes
*  Pass one of this to #FCUHLP(), #FCUVSN(), #FCUDOC() or #FCUPRO() to get
*  information about the corresponding command.
*  @{
*/
#define FLUC_INFO                   1 /**< @brief INFO command */
#define FLUC_CONV                   2 /**< @brief CONV command */
#define FLUC_XCNV                   3 /**< @brief XCNV command */
#define FLUC_ICNV                   4 /**< @brief ICNV command */
#define FLUC_FLAM                   5 /**< @brief FLAM command */
#define FLUC_XCHK                   6 /**< @brief XCHK command */
#define FLUC_HASH                   7 /**< @brief HASH command */
#define FLUC_UTIL                   8 /**< @brief UTIL command */
#define FLUC_DIFF                   9 /**< @brief DIFF command */
#define FLUC_KEY                   10 /**< @brief KEY  command */
#define FLUC_GREP                  11 /**< @brief GREP command */
/** @} */
/**********************************************************************/
 /**
  * @defgroup FUNC Functions
  * @{
  */

/**
 * @brief Version
 *
 * This function writes a string containing version information for
 * every used component into the 'vsn' parameter. This should be used
 * in a support case.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO         PIC S9(8)  COMP VALUE     0.
 * 01  F-VSNLEN        PIC S9(8)  COMP VALUE    30.
 * 01  F-VSN           PIC  X(30)      VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUVSN' USING F-RETCO, F-VSNLEN, F-VSN.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUVSN ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUVSN_PARAMETER,
 *            2 F_RETCO          BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_VSNLEN         BIN FIXED(31,0) INIT  (30),
 *            2 F_VSN            CHAR(30)        INIT (' ');
 * CALL FCUVSN  ( F_RETCO,
 *                F_VSNLEN,
 *                F_VSN );
 * </pre>
 * @param [out]     rtc    INTEGER Condition code
 * @param [inout]   vsnLen INTEGER Size/length of version string
 * @param [out]     vsn    STRING  Version string (is null-terminated)
 */
extern void FCUVSN(
   int*                 rtc,
   int*                 vsnLen,
   char*                vsn);

/**
 * @brief About
 *
 * This function writes a string with about information for this
 * library on multiple lines and license information for used
 * external libraries into the 'abo' parameter .
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO         PIC S9(8)  COMP VALUE     0.
 * 01  F-ABOLEN        PIC S9(8)  COMP VALUE    12.
 * 01  F-ABO           PIC  X(12)      VALUE 'Licence xyz\0'.
 * PROCEDURE DIVISION.
 * CALL  'FCUABO' USING F-RETCO, F-ABOLEN, F-ABO.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUABO ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUABO_PARAMETER,
 *            2 F_RETCO          BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_ABOLEN         BIN FIXED(31,0) INIT  (12),
 *            2 F_ABO            CHAR(12)        INIT ('Licence xyz\0');
 * CALL FCUABO  ( F_RETCO,
 *                F_ABOLEN,
 *                F_ABO );
 * </pre>
 * @param [out]     rtc    INTEGER Condition code
 * @param [inout]   aboLen INTEGER Size/length of about string
 * @param [out]     abo    STRING  About string (is null-terminated)
 */
extern void FCUABO(
   int*                 rtc,
   int*                 aboLen,
   char*                abo);

/**
 * @brief Get license text
 *
 * This function can be used to get the current license text on multiple
 * lines. The license text defines the permissible use of this library.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO         PIC S9(8) COMP VALUE     0.
 * 01  F-LICLEN        PIC S9(8) COMP VALUE    50.
 * 01  F-LIC           PIC  X(50)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCULIC' USING F-RETCO, F-LICLEN, F-LIC.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCULIC ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCULIC_PARAMETER,
 *            2 F_RETCO          BIN FIXED(31,0) INIT    (0) ALIGNED,
 *            2 F_LICLEN         BIN FIXED(31,0) INIT   (50),
 *            2 F_LIC            CHAR(50)        INIT  (' ');
 * CALL FCULIC  ( F_RETCO,
 *                F_LICLEN,
 *                F_LIC );
 * </pre>
 * @param [out]     rtc    INTEGER Condition code
 * @param [inout]   licLen INTEGER Size/length of license string
 * @param [out]     lic    STRING  Current license text (is null-terminated)
 */
extern void FCULIC(
   int*                 rtc,
   int*                 licLen,
   char*                lic);

/**
 * @brief Load the FLAM environment
 *
 * This function load the FLAM system variables (only on z/OS or in EDZ
 * environment), the STDENV definitions ('DD:STDENV' or '\<SYSUID>.STDENV'
 * on z/OS or '.stdenv' file in working or home directory on other system)
 * and a optional list if variables to the environment. You can adjust the
 * environment before the first call to a FLAM API function is done. This
 * function gives the possibility to work with the same environment used
 * by FLAM utilities, subsystems, etc.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO         PIC S9(8) COMP VALUE 0.
 * 01  F-SYSENV        PIC S9(8) COMP VALUE 1.
 * 01  F-STDENV        PIC S9(8) COMP VALUE 1.
 * 01  F-ENVLEN        PIC S9(8) COMP VALUE 31.
 * 01  F-ENVAR         PIC  X(31)
 *     VALUE 'KEYWORD1=VALUE1;KEYWORD2=VALUE2'
 * 01  F-ENVCNT        PIC S9(8) COMP VALUE 0.
 * PROCEDURE DIVISION.
 * CALL  'FCUENV' USING F-RETCO, F-SYSENV, F-STDENV,
 *                      F-ENVLEN, F-ENVAR, F-ENVCNT.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUENV ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUENV_PARAMETER,
 *            2 F_RETCO          BIN FIXED(31,0) INIT (0) ALIGNED,
 *            2 F_SYSENV         BIN FIXED(31,0) INIT (1),
 *            2 F_STDENV         BIN FIXED(31,0) INIT (1),
 *            2 F_ENVLEN         BIN FIXED(31,0) INIT (31),
 *            2 F_ENVAR          CHAR(31)        INIT
 *              ('KEYWORD1=VALUE1;KEYWORD2=VALUE2'),
 *            2 F_ENVCNT         BIN FIXED(31,0) INIT (0);
 * CALL FCUENV  ( F_RETCO,
 *                F_SYSENV,
 *                F_STDENV,
 *                F_ENVLEN,
 *                F_ENVAR,
 *                F_ENVCNT );
 * </pre>
 * @param [out] rtc     INTEGER Return code
 * @param [in]  sys     INTEGER True to load system variables, NULL or false no system variables active
 * @param [in]  std     INTEGER True to load standard environment, NULL or false no standard environment variables active
 * @param [in]  envLen  INTEGER Length of the optional environment string (NULL if optional or if zero termination)
 * @param [in]  envStr  STRING  Optional list (could be NULL or empty) of environment variables (KEYWORD=VALUE) separated by new line ('\\n') or semicolon (';')
 * @param [out] cnt     INTEGER Amount of environment variables set (optional, could be NULL)
 */
extern void FCUENV(
   int*                 rtc,
   const int*           sys,
   const int*           std,
   const int*           envLen,
   const char*          envStr,
   int*                 cnt);

/**
 * @brief FLUC INFO - Provides various information
 *
 * This function calls the INFO command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE  0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE 18.
 * 01  F-CMD-STR          PIC  X(18)     VALUE 'get.file=''test.gz'''.
 * 01  F-PRP-STR-LEN      PIC S9(8) COMP VALUE  0.
 * 01  F-PRP-STR          PIC  X(200)    VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE  7.
 * 01  F-OFILE-NAME       PIC  X(7)      VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE  0.
 * 01  F-TRFILE-NAME      PIC  X(45)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUINFO' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUINFO ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUINFO_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (18),
 *            2 F_CMD_STR         CHAR(18)        INIT
 *            ('get.file=''test.gz'''),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(45)        INIT (' ');
 * CALL FCUINFO ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string (must be set)
 * @param [in]  cmd    STRING  Command string with GET and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with GET and LOG instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 */
extern void FCUINFO(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC UTIL - Runs various simply functions on wildcard file lists
 *
 * This function calls the UTIL command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8)   COMP VALUE  0.
 * 01  F-CMD-LEN          PIC S9(8)   COMP VALUE 10.
 * 01  F-CMD-STR          PIC  X(10)       VALUE '~.test.**'''.
 * 01  F-PRP-STR-LEN      PIC S9(8)   COMP VALUE  0.
 * 01  F-PRP-STR          PIC  X(200)      VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8)   COMP VALUE  0.
 * 01  F-OFILE-NAME       PIC  X(45)       VALUE SPACE.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8)   COMP VALUE  0.
 * 01  F-TRFILE-NAME      PIC  X(45)       VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUUTIL' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUUTIL ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUUTIL_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (10),
 *            2 F_CMD_STR         CHAR(10)        INIT  ('~.test.**'''),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (0),
 *            2 F_OFILE_NAME      CHAR(45)        INIT (' '),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(45)        INIT (' ');
 * CALL FCUUTIL ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string (must be set)
 * @param [in]  cmd    STRING  Command string with RUN and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with RUN and LOG instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 */
extern void FCUUTIL(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC CONV - Simplified data conversion
 *
 * This function calls the CONV command of FLUC
 *
 * Example (Cobol):
 * <pre>
 *  01  FCUCONV-PARAMETER.
 *     02  F-RETCO     PIC S9(8)   COMP VALUE ZERO.
 *        88 FLAM-OK                    VALUE    0.
 *     02  F-CMDLEN    PIC S9(8)   COMP VALUE  300.
 *     02  F-COMMAND   PIC  X(300)      VALUE
 *     'READ.RECORD(FILE=''DD:INPUT'' CCSID=''1141'' SUPPAD)
 *     'WRITE.TEXT(FILE=''DD:OUTPUT''
 *     ' METHOD=WINDOWS CCSID=''1252'' COMP.GZIP())'.
 *     02  F-PROLEN    PIC S9(8)   COMP VALUE    0.
 *     02  F-PROPERTY  PIC  X(200)      VALUE  ' '.
 *     02  F-LOGLEN    PIC S9(8)   COMP VALUE    9.
 *     02  F-LOGFILE   PIC  X(9)        VALUE 'DD:LOGOUT'.
 *     02  F-TRCLEN    PIC S9(8)   COMP VALUE ZERO.
 *     02  F-TRCFILE   PIC  X(45).
 * PROCEDURE DIVISION.
 * CALL 'FCUCONV' USING F-RETCO,
 *                      F-CMDLEN,
 *                      F-COMMAND,
 *                      F-PROLEN,
 *                      F-PROPERTY,
 *                      F-LOGLEN,
 *                      F-LOGFILE,
 *                      F-TRCLEN,
 *                      F-TRCFILE.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUCONV ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUCONV_PARAMETER,
 *            2 F_RETCO          BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMDLEN         BIN FIXED(31,0) INIT (300),
 *            2 F_COMMAND        CHAR(300)       INIT
 *          ('READ.RECORD(FILE=''DD:INPUT'' CCSID=''1141'' SUPPAD)WRITE.TE
 * XT(FILE=''DD:OUTPUT'' METHOD=WINDOWS CCSID=''1252'' COMP.GZIP())' ),
 *            2 F_PROLEN         BIN FIXED(31,0) INIT   (0),
 *            2 F_PROPERTY       CHAR(200)       INIT (' '),
 *            2 F_LOGLEN         BIN FIXED(31,0) INIT   (9),
 *            2 F_LOGFILE        CHAR(9)         INIT ('DD:LOGOUT'),
 *            2 F_TRCLEN         BIN FIXED(31,0) INIT   (0),
 *            2 F_TRCFILE        CHAR(45)        INIT (' ');
 * CALL FCUCONV ( F_RETCO,
 *                F_CMDLEN,
 *                F_COMMAND,
 *                F_PROLEN,
 *                F_PROPERTY,
 *                F_LOGLEN,
 *                F_LOGFILE,
 *                F_TRCLEN,
 *                F_TRCFILE );
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string (must be set)
 * @param [in]  cmd    STRING  Command string with READ, WRITE and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with READ, WRITE and LOG instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 *
 */
extern void FCUCONV(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC XCNV - Extended data conversion
 *
 * This function calls the XCNV command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE 300.
 * 01  F-CMD-STR          PIC  X(300)    VALUE
 *     'inp(sav.fil(fio.blk(name='test.txt')
 *     'cnv.chr(from=''IBM-1141''
 *     'to=''UTF-8'') fmt.txt()))
 *     'out(sav.fil(fio.blk(name='test.out')))'.
 * 01  F-PRP-STR-LEN      PIC S9(8) COMP VALUE  0.
 * 01  F-PRP-STR          PIC  X(200)    VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE  7.
 * 01  F-OFILE-NAME       PIC  X(7)      VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE  0.
 * 01  F-TRFILE-NAME      PIC  X(45)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUXCNV' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUXCNV ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUXCNV_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT (300),
 *            2 F_CMD_STR         CHAR(300)       INIT
 *          ('inp(sav.fil(fio.blk(name='test.txt nv.chr(from=''IBM-1141''
 * cnv.chr(from=''IBM-1141'' to=''UTF-8'') fmt.txt())) out(sav.fil(fio.bl
 * k(name='test.out')))' ),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(44)        INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUXCNV ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string ()
 * @param [in]  cmd    STRING  Command string with INP, OUT and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with INP, OUT and LOG instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 */
extern void FCUXCNV(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC GREP - Matching pattern in files like GREP
 *
 * This function calls the GREP command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8)  COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8)  COMP VALUE  62.
 * 01  F-CMD-STR          PIC  X(62)      VALUE
 *     'input=''~.**'' pattern=''^IBM'' output=''DD:OUTPUT'''
 * 01  F-PRP-STR-LEN      PIC S9(8)  COMP VALUE   0.
 * 01  F-PRP-STR          PIC  X(200)     VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8)  COMP VALUE   7.
 * 01  F-OFILE-NAME       PIC  X(7)       VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8)  COMP VALUE   0.
 * 01  F-TRFILE-NAME      PIC  X(45)      VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUGREP' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUGREP ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUGREP_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (62),
 *            2 F_CMD_STR         CHAR(62)        INIT
 *          ('input=''~.**'' pattern=''^IBM'' output=''DD:OUTPUT'''),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUGREP ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  cmdLen  INTEGER Length of command string (must be set)
 * @param [in]  cmd     STRING  Command string with GREP parameter
 * @param [in]  proLen  INTEGER Length of property string (0 if no properties)
 * @param [in]  pro     STRING  Property string with GREP parameter
 * @param [in]  outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out     STRING  Filename for printouts
 * @param [in]  trcLen  INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]  trc     STRING  Filename for tracing
*/
extern void FCUGREP(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC ICNV - Character conversion like ICONV
 *
 * This function calls the ICNV command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8)  COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8)  COMP VALUE  62.
 * 01  F-CMD-STR          PIC  X(62)      VALUE
 *     'in=''test.txt'' from=''IBM-1141'' to=''UTF-8''
 *     'ENL2LF out=''test.out'''.
 * 01  F-PRP-STR-LEN      PIC S9(8)  COMP VALUE   0.
 * 01  F-PRP-STR          PIC  X(200)     VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8)  COMP VALUE   7.
 * 01  F-OFILE-NAME       PIC  X(7)       VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8)  COMP VALUE   0.
 * 01  F-TRFILE-NAME      PIC  X(45)      VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUICNV' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUICNV ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUICNV_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (62),
 *            2 F_CMD_STR         CHAR(62)        INIT
 *          ('in=''test.txt'' from=''IBM-1141'' to=''UTF-8'' ENL2LF
 * out=''test.out''' ),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUICNV ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  cmdLen  INTEGER Length of command string (must be set)
 * @param [in]  cmd     STRING  Command string with ICNV parameter
 * @param [in]  proLen  INTEGER Length of property string (0 if no properties)
 * @param [in]  pro     STRING  Property string with ICNV parameter
 * @param [in]  outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out     STRING  Filename for printouts
 * @param [in]  trcLen  INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]  trc     STRING  Filename for tracing
*/
extern void FCUICNV(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC FLAM - Support of FLAM4 command in FLUC
 *
 * This function calls the FLAM command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE 100.
 * 01  F-CMD-STR          PIC  X(100)    VALUE
 *     'COMP MODE=ADC FLAMIN=''test.txt''
 *     'FLAMFILE=''test.adc'''.
 * 01  F-PRP-STR-LEN      PIC S9(8) COMP VALUE   0.
 * 01  F-PRP-STR          PIC  X(200)    VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE   7.
 * 01  F-OFILE-NAME       PIC  X(7)      VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE   0.
 * 01  F-TRFILE-NAME      PIC  X(44)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUFLAM' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUFLAM ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUFLAM_PARAMETER,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT (100),
 *            2 F_CMD_STR         CHAR(100)       INIT
 *          ('COMP MODE=ADC FLAMIN=''test.txt'' FLAMFILE=''test.adc'''),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUFLAM ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out]      rtc     INTEGER Condition code
 * @param [in]       cmdLen  INTEGER Length of command string (must be set)
 * @param [in]       cmd     STRING  Command string with FLAM parameter
 * @param [in]       proLen  INTEGER Length of property string (0 if no properties)
 * @param [in]       pro     STRING  Property string with FLAM parameter
 * @param [in]       outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]       out     STRING  Filename for printouts
 * @param [in]       trcLen  INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]       trc     STRING  Filename for tracing
*/
extern void FCUFLAM(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC XCHK - Support of XCHK command in FLUC
 *
 * This function calls the XCHK command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8)  COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8)  COMP VALUE  50.
 * 01  F-CMD-STR          PIC  X(50)      VALUE
 *     'inp(sav.fil(fio.blk(name=''test.txt'') cnv.hsh()))'.
 * 01  F-PRP-STR-LEN      PIC S9(8)  COMP VALUE   0.
 * 01  F-PRP-STR          PIC  X(200)     VALUE SPACE.
  * 01  F-OFILE-NAME-LEN  PIC S9(8)  COMP VALUE   7.
 * 01  F-OFILE-NAME       PIC  X(7)       VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8)  COMP VALUE   0.
 * 01  F-TRFILE-NAME      PIC  X(45)
 *     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUXCHK' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUXCHK ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUXCHK,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (50),
 *            2 F_CMD_STR         CHAR(50)        INIT
 *          ('inp(sav.fil(fio.blk(name=''test.txt'') cnv.hsh()))'),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUXCHK ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out]      rtc     INTEGER Condition code
 * @param [in]       cmdLen  INTEGER Length of command string (must be set)
 * @param [in]       cmd     STRING  Command string with FLAM parameter
 * @param [in]       proLen  INTEGER Length of property string (0 if no properties)
 * @param [in]       pro     STRING  Property string with FLAM parameter
 * @param [in]       outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]       out     STRING  Filename for printouts
 * @param [in]       trcLen  INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]       trc     STRING  Filename for tracing
*/
extern void FCUXCHK(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC HASH - Support of HASH command in FLUC
 *
 * This function calls the HASH command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE   0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE  30.
 * 01  F-CMD-STR          PIC  X(30)     VALUE
 *     'file=''test.txt'' algo=sha512'.
 * 01  F-PRP-STR-LEN      PIC S9(8) COMP VALUE   0.
 * 01  F-PRP-STR          PIC  X(200)    VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE   7.
 * 01  F-OFILE-NAME       PIC  X(7)      VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE   0.
 * 01  F-TRFILE-NAME      PIC  X(45)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUHASH' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUHASH ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUHASH,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (30),
 *            2 F_CMD_STR         CHAR(30)        INIT
 *          ('file=''test.txt'' algo=sha512'),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(45)        INIT (' ');
 * CALL FCUHASH ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out]      rtc     INTEGER Condition code
 * @param [in]       cmdLen  INTEGER Length of command string (must be set)
 * @param [in]       cmd     STRING  Command string with FLAM parameter
 * @param [in]       proLen  INTEGER Length of property string (0 if no properties)
 * @param [in]       pro     STRING  Property string with FLAM parameter
 * @param [in]       outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]       out     STRING  Filename for printouts
 * @param [in]       trcLen  INTEGER Length of trace filename (if 0 no trace is written)
 * @param [in]       trc     STRING  Filename for tracing
*/
extern void FCUHASH(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC DIFF - Compares two data sources
 *
 * This function calls the DIFF command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE         0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE        56.
 * 01  F-CMD-STR          PIC  X(56)     VALUE
 *   'read.file=''./test.txt.gz'' compare.file=''~.test.fba'' DATA'.
 * 01  F-PRP-STR-LEN      PIC S9(8) COMP VALUE         0.
 * 01  F-PRP-STR          PIC  X(200)    VALUE     SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE         7.
 * 01  F-OFILE-NAME       PIC  X(7)      VALUE ':STDERR'.
 * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE         0.
 * 01  F-TRFILE-NAME      PIC  X(45)     VALUE     SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUDIFF' USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUDIFF ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUDIFF,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (56),
 *            2 F_CMD_STR         CHAR(56)        INIT
 *     ('read.file=''./test.txt.gz'' compare.file=''~.test.fba'' DATA'),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(44)        INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(44)        INIT (' ');
 * CALL FCUDIFF ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string (must be set)
 * @param [in]  cmd    STRING  Command string with READ, COMPARE and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with READ, COMPARE and LOG instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 */
extern void FCUDIFF(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief FLUC KEY - Key management functions
 *
 * This function calls the KEY command of FLUC
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8)  COMP VALUE     0.
 * 01  F-CMD-LEN          PIC S9(8)  COMP VALUE    32.
 * 01  F-CMD-STR          PIC  X(32)      VALUE
 *   'import.pgp(file=''./keyFile.pgp'')'.
 * 01  F-PRP-STR-LEN      PIC S9(8)  COMP VALUE     0.
 * 01  F-PRP-STR          PIC  X(200)     VALUE SPACE.
 * 01  F-OFILE-NAME-LEN   PIC S9(8)  COMP VALUE     7.
 * 01  F-OFILE-NAME       PIC  X(45)      VALUE ':STDERR'.
  * 01  F-TRFILE-NAME-LEN  PIC S9(8) COMP VALUE     0.
 * 01  F-TRFILE-NAME      PIC  X(45)      VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUKEY'  USING F-RETCO, F-CMD-LEN,         F-CMD-STR,
 *                                F-PRP-STR-LEN,     F-PRP-STR,
 *                                F-OFILE-NAME-LEN,  F-OFILE-NAME
 *                                F-TRFILE-NAME-LEN, F-TRFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUKEY ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUKEY,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN         BIN FIXED(31,0) INIT  (32),
 *            2 F_CMD_STR         CHAR(32)        INIT
 *     ('import.pgp(file=''./keyFile.pgp'''),
 *            2 F_PRP_STR_LEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_PRP_STR         CHAR(200)       INIT (' '),
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT (':STDERR'),
 *            2 F_TRFILE_NAME_LEN BIN FIXED(31,0) INIT   (0),
 *            2 F_TRFILE_NAME     CHAR(45)        INIT (' ');
 * CALL FCUKEY  ( F_RETCO,  F_CMD_LEN,         F_CMD_STR,
 *                          F_PRP_STR_LEN,     F_CMD_STR,
 *                          F_OFILE_NAME_LEN,  F_OFILE_NAME,
 *                          F_TRFILE_NAME_LEN, F_TRFILE_NAME);
 * </pre>
 * @param [out] rtc    INTEGER Condition code
 * @param [in]  cmdLen INTEGER Length of command string (must be set)
 * @param [in]  cmd    STRING  Command string with IMPORT/EXPORT/... and LOG instructions
 * @param [in]  proLen INTEGER Length of property string (0 if no properties)
 * @param [in]  pro    STRING  Property string with IMPORT/EXPORT/... instructions
 * @param [in]  outLen INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out    STRING  Filename for printouts
 * @param [in]  trcLen INTEGER Length trace filename (if 0 no trace is written)
 * @param [in]  trc    STRING  Filename for tracing
 *
 */
extern void FCUKEY(
   int*                 rtc,
   const int*           cmdLen,
   const char*          cmd,
   const int*           proLen,
   const char*          pro,
   const int*           outLen,
   const char*          out,
   const int*           trcLen,
   const char*          trc);

/**
 * @brief Returns reason code and message
 *
 * This function returns the reason code and optional a message after a
 * command fails. If the buffer is too small the message is truncated. 128 byte
 * is a good size for the message buffer.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE      0.
 * 01  F-CMD-LEN          PIC S9(8) COMP VALUE    128.
 * 01  F-CMD-STR          PIC  X(128)    VALUE  SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCURSN'  USING F-RETCO, F-CMD-LEN, F-CMD-STR.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCURSN ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCURSN,
 *            2 F_RETCO   BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 F_CMD_LEN BIN FIXED(31,0) INIT (128),
 *            2 F_CMD_STR CHAR(128)       INIT (' ');
 * CALL FCURSN  ( F_RETCO, F_CMD_LEN, F_CMD_STR);
 * </pre>
 * @param [out]     rsn    INTEGER Reason code (internal FLAM return code)
 * @param [inout]   msgLen INTEGER Size/length of message string (if 0 no message is returned)
 * @param [out]     msg    STRING  Message string (is null-terminated and optional)
 */
extern void FCURSN(
   int*                 rsn,
   int*                 msgLen,
   char*                msg);

/**
 * @brief Returns help information about the command strings
 *
 * This function can be used to get all help messages or man pages for
 * each parameter in the command string.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE     0.
 * 01  @ref FCUFUC "F-WHAT"             PIC S9(8) COMP VALUE     5.
 *     88 CMD-INFO        VALUE  1.
 *     88 CMD-CONV        VALUE  2.
 *     88 CMD-XCNV        VALUE  3.
 *     88 CMD-ICNV        VALUE  4.
 *     88 CMD-FLAM        VALUE  5.
 *     88 CMD-XCHK        VALUE  6.
 *     88 CMD-HASH        VALUE  7.
 *     88 CMD-UTIL        VALUE  8.
 *     88 CMD-DIFF        VALUE  9.
 *     88 CMD-KEY         VALUE 10.
 * 01  F-DEPTH            PIC S9(8) COMP VALUE     8.
 * 01  F-PATH-LEN         PIC S9(8) COMP VALUE    20.
 * 01  F-PATH             PIC  X(20)     VALUE 'conv.read.text.ccsid'.
 * 01  F-OLEN             PIC S9(8) COMP VALUE     0.
 * 01  F-OSTRING          PIC  X(45)     VALUE SPACE.
 * PROCEDURE DIVISION.
 * CALL  'FCUHLP'  USING F-RETCO, F-WHAT,     F-DEPTH,
 *                                F-PATH-LEN, F-PATH,
 *                                F-OLEN,     F-OSTRING.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUHLP ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUHLP,
 *            2 F_RETCO    BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 @ref FCUFUC "F_WHAT"     BIN FIXED(31,0) INIT   (5),
 *            2 F_DEPTH    BIN FIXED(31,0) INIT   (8),
 *            2 F_PATH_LEN BIN FIXED(31,0) INIT  (20),
 *            2 F_PATH     CHAR(200)       INIT  ('conv.read.text.ccsid'),
 *            2 F_OLEN     BIN FIXED(31,0) INIT   (0),
 *            2 F_OSTRING  CHAR(45)        INIT  (' ');
 * CALL FCUHLP  ( F_RETCO,  F_WHAT,     F_DEPTH
 *                          F_PATH_LEN, F_PATH,
 *                          F_OLEN,     F_OSTRING);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  what    INTEGER @ref FCUFUC "Constant number for the corresponding command string"
 * @param [in]  depth   INTEGER Number of levels to display (0-Man page, 1-One Level, 2-Two Level, ..., <9-All)
 * @param [in]  pathLen INTEGER Length of path string (0 to start at root)
 * @param [in]  path    STRING  Path (e.g. conv.read.text.ccsid) to limit help to the (sub)tree of a certain object
 * @param [in]  outLen  INTEGER Length of output filename (if 0 stderr is used)
 * @param [in]  out     STRING  Filename for printouts
 */
extern void FCUHLP(
   int*                 rtc,
   const int*           what,
   const int*           depth,
   const int*           pathLen,
   const char*          path,
   const int*           outLen,
   const char*          out);

/**
 * @brief Return syntax information about the command string
 *
 * This function can be used to determine the complete syntax of the
 * command strings.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO       PIC S9(8) COMP VALUE  0.
 * 01  @ref FCUFUC "F-WHAT"        PIC S9(8) COMP VALUE  5.
 *     88 CMD-INFO        VALUE  1.
 *     88 CMD-CONV        VALUE  2.
 *     88 CMD-XCNV        VALUE  3.
 *     88 CMD-ICNV        VALUE  4.
 *     88 CMD-FLAM        VALUE  5.
 *     88 CMD-XCHK        VALUE  6.
 *     88 CMD-HASH        VALUE  7.
 *     88 CMD-UTIL        VALUE  8.
 *     88 CMD-DIFF        VALUE  9.
 *     88 CMD-KEY         VALUE 10.
 * 01  F-DEPTH       PIC S9(8) COMP VALUE  8.
 * 01  F-PATH-LEN    PIC S9(8) COMP VALUE 20.
 * 01  F-PATH        PIC X(20)      VALUE 'conv.read.text.ccsid'.
 * 01  F-OLEN        PIC S9(8) COMP VALUE  0.
 * 01  F-OSTRING     PIC X(44)      VALUE ':STDERR'.
 * PROCEDURE DIVISION.
 * CALL  'FCUSYN'  USING F-RETCO, F-WHAT,     F-DEPTH,
 *                                F-PATH-LEN, F-PATH,
 *                                F-OLEN,     F-OSTRING.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUSYN ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUSYN,
 *            2 F_RETCO     BIN FIXED(31,0) INIT    (0) ALIGNED,
 *            2 @ref FCUFUC "F_WHAT"      BIN FIXED(31,0) INIT    (5),
 *            2 F_DEPTH     BIN FIXED(31,0) INIT    (8),
 *            2 F_PATH_LEN  BIN FIXED(31,0) INIT   (20),
 *            2 F_PATH      CHAR(20)        INIT ('conv.read.text.ccsid'),
 *            2 F_OLEN      BIN FIXED(31,0) INIT    (0),
 *            2 F_OSTRING   CHAR(44)        INIT (':STDERR');
 * CALL FCUSYN  ( F_RETCO,  F_WHAT,     F_DEPTH
 *                          F_PATH_LEN, F_PATH,
 *                          F_OLEN,     F_OSTRING);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  what    INTEGER @ref FCUFUC "Constant number for the corresponding command string"
 * @param [in]  depth   INTEGER Number of levels to display (0-Man page, 1-One Level, 2-Two Level, ..., <9-All)
 * @param [in]  pathLen INTEGER Length of path string (0 to start at root)
 * @param [in]  path    STRING  Path (e.g. conv.read.text.ccsid) to limit syntax to the (sub)tree of a certain object
 * @param [in]  outLen  INTEGER Length of output filename (if 0 stderr is used)
 * @param [in]  out     STRING  Filename for printouts
 */
extern void FCUSYN(
   int*                 rtc,
   const int*           what,
   const int*           depth,
   const int*           pathLen,
   const char*          path,
   const int*           outLen,
   const char*          out);

/**
 * @brief Return documentation
 *
 * This function can be used to determine the complete documentation of the
 * corresponding command.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO       PIC S9(8) COMP VALUE  0.
 * 01  @ref FCUFUC "F-WHAT"        PIC S9(8) COMP VALUE  5.
 *     88 CMD-INFO        VALUE  1.
 *     88 CMD-CONV        VALUE  2.
 *     88 CMD-XCNV        VALUE  3.
 *     88 CMD-ICNV        VALUE  4.
 *     88 CMD-FLAM        VALUE  5.
 *     88 CMD-XCHK        VALUE  6.
 *     88 CMD-HASH        VALUE  7.
 *     88 CMD-UTIL        VALUE  8.
 *     88 CMD-DIFF        VALUE  9.
 *     88 CMD-KEY         VALUE 10.
 * 01  F-PATH-LEN    PIC S9(8) COMP VALUE 20.
 * 01  F-PATH        PIC X(20)      VALUE 'conv.read.text.ccsid'.
 * 01  F-OLEN        PIC S9(8) COMP VALUE  7.
 * 01  F-OSTRING     PIC X(45)      VALUE ':STDERR'.
 * PROCEDURE DIVISION.
 * CALL  'FCUDOC'  USING F-RETCO, F-WHAT,
 *                                F-PATH-LEN, F-PATH,
 *                                F-OLEN,     F-OSTRING.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUDOC ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUDOC,
 *            2 F_RETCO     BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 @ref FCUFUC "F_WHAT"      BIN FIXED(31,0) INIT   (5),
 *            2 F_PATH_LEN  BIN FIXED(31,0) INIT   (20),
 *            2 F_PATH      CHAR(20)        INIT ('conv.read.text.ccsid'),
 *            2 F_OLEN      BIN FIXED(31,0) INIT    (7),
 *            2 F_OSTRING   CHAR(45)        INIT (':STDERR');
 * CALL FCUDOC  ( F_RETCO,  F_WHAT,
 *                          F_PATH_LEN, F_PATH,
 *                          F_OLEN,     F_OSTRING);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  what    INTEGER @ref FCUFUC "Constant number for the corresponding command string"
 * @param [in]  pathLen INTEGER Length of path string (0 to start at root)
 * @param [in]  path    STRING  Path (e.g. conv.read.text.ccsid) to limit docu to the (sub)tree of a certain object
 * @param [in]  outLen  INTEGER Length of output filename (if 0 stderr is used)
 * @param [in]  out     STRING  Filename for printouts
 */
extern void FCUDOC(
   int*                 rtc,
   const int*           what,
   const int*           pathLen,
   const char*          path,
   const int*           outLen,
   const char*          out);

/**
 * @brief Manage properties
 *
 * This function can be used to manage a property file for one of the
 * supported commands. You can generate a property file if 'ipro' not set
 * and 'opro' defined. You can printout the properties if 'ipro' defined
 * and 'opro' is not set. You can validate and copy property files if 'ipro'
 * and 'opro' defined. You can adjust a property file if 'ipro' defined,
 * 'prop' are used and 'opro' set.
 *
 * Sample call in COBOL:
 * <pre>
 * WORKING-STORAGE SECTION.
 * 01  F-RETCO            PIC S9(8) COMP VALUE            0.
 * 01  @ref FCUFUC "F-WHAT"             PIC S9(8) COMP VALUE            5.
 *     88 CMD-INFO        VALUE  1.
 *     88 CMD-CONV        VALUE  2.
 *     88 CMD-XCNV        VALUE  3.
 *     88 CMD-ICNV        VALUE  4.
 *     88 CMD-FLAM        VALUE  5.
 *     88 CMD-XCHK        VALUE  6.
 *     88 CMD-HASH        VALUE  7.
 *     88 CMD-UTIL        VALUE  8.
 *     88 CMD-DIFF        VALUE  9.
 *     88 CMD-KEY         VALUE 10.
 * 01  F-IPROLEN          PIC S9(8) COMP VALUE           10.
 * 01  F-IPRO             PIC X(10)      VALUE 'xxxxxxxxxx'.
 * 01  F-PROP-STR-LEN     PIC S9(8) COMP VALUE           10.
 * 01  F-PROP-STR         PIC X(10)      VALUE 'yyyyyyyyyy'.
 * 01  F-OPRO-STR-LEN     PIC S9(8) COMP VALUE           10.
 * 01  F-OPRO-STR         PIC X(200)     VALUE 'zzzzzzzzzz'.
 * 01  F-OFILE-NAME-LEN   PIC S9(8) COMP VALUE            7.
 * 01  F-OFILE-NAME       PIC X(7)       VALUE ':STDERR'.
 * PROCEDURE DIVISION.
 * CALL  'FCUPRO'  USING F-RETCO, F-WHAT,
 *                                F-IPROLEN,        F-IPRO,
 *                                F-PROP-STR-LEN,   F-PROP-STR,
 *                                F-OPRO-STR-LEN,   F-OPRO-STR,
 *                                F-OFILE-NAME-LEN, F-OFILE-NAME.
 * </pre>
 * Sample call in PL1:
 * <pre>
 * DCL FCUPRO ENTRY EXTERNAL OPTIONS (ASM, FETCHABLE);
 *    DCL  1  FCUPRO,
 *            2 F_RETCO           BIN FIXED(31,0) INIT   (0) ALIGNED,
 *            2 @ref FCUFUC "F_WHAT"            BIN FIXED(31,0) INIT   (5),
 *            2 F_IPROLEN         BIN FIXED(31,0) INIT  (10),
 *            2 F_IPRO            CHAR(10)        INIT  ('xxxxxxxxxx'),
 *            2 F_PROP_STR_LEN    BIN FIXED(31,0) INIT  (10),
 *            2 F_PROP_STR        CHAR(10)        INIT  ('yyyyyyyyyy'),
 *            2 F_OPRO_STR_LEN    BIN FIXED(31,0) INIT  (10),
 *            2 F_OPRO_STR        CHAR(200)       INIT  ('zzzzzzzzzz');
 *            2 F_OFILE_NAME_LEN  BIN FIXED(31,0) INIT   (7),
 *            2 F_OFILE_NAME      CHAR(7)         INIT  (':STDERR');
 * CALL FCUPRO  ( F_RETCO,  F_WHAT,
 *                          F_IPROLEN,        F_IPRO,
 *                          F_PROP_STR_LEN,   F_PROP_STR,
 *                          F_OPRO_STR_LEN,   F_OPRO_STR,
 *                          F_OFILE_NAME_LEN, F_OFILE_NAME);
 * </pre>
 * @param [out] rtc     INTEGER Condition code
 * @param [in]  what    INTEGER @ref FCUFUC "Constant number for the corresponding command string"
 * @param [in]  iproLen INTEGER Length of input property file string (0 to generate a property file)
 * @param [in]  ipro    STRING  Input property file string
 * @param [in]  propLen INTEGER Length of property string (if 0 then no manipulation of properties done)
 * @param [in]  prop    STRING  Property string to update the property file
 * @param [in]  oproLen INTEGER Length of output property file string (if 0 stdout is used)
 * @param [in]  opro    STRING  Output property file string
 * @param [in]  outLen  INTEGER Length of output filename (if 0 no output is produced)
 * @param [in]  out     STRING  Filename for printouts
 */
extern void FCUPRO(
   int*                 rtc,
   const int*           what,
   const int*           iproLen,
   const char*          ipro,
   const int*           propLen,
   const char*          prop,
   const int*           oproLen,
   const char*          opro,
   const int*           outLen,
   const char*          out);

/** @} */
/**********************************************************************/

/*! @cond PRIVATE */
#endif /* INC_FLUCUPLB_H */

#ifdef __cplusplus
   }
#endif
/*! @endcond */
