:doctype: book

= FLSSRV manual

limes datentechnik gmbh <support@flam.de> +
v5.1.21-26794, 2020-01-03 20:24:34: +
release. +
 +
 +
 +
 +
Frankenstein Limes Integrated Extended Security (FLIES(R)) +
Copyright (C) limes datentechnik (R) gmbh +
All rights reserved +
 +
 +
 +
 +


== Trademarks

Below, you can find all trademarks or registered trademarks of limes
datentechnik (R) gmbh. These trademarked terms are marked with the
appropriate symbol ((R) or (TM)), indicating registered or common law
trademarks owned by limes datentechnik (R) gmbh at the time this
information was published. The following terms are trademarks of
limes datentechnik (R) gmbh in Germany, other countries, or both:

* limes(R) - Short company name of the owner of this document
* limes datentechnik(R) - Company name of the owner of this document
* FLCL(R)      - Frankenstein Limes Command Line
* FLCC(R)      - Frankenstein Limes Control Center
* FLAM(R)      - Frankenstein Limes Access Method
* FLUC(R)      - Frankenstein Limes Universal Converter
* FLIES(R)     - Frankenstein Limes Integrated Extended Security
* FLAMFILE(R)  - A file based on FLAM syntax


== Abstract

This document provides information about using the Frankenstein Limes
Integrated Extended Security (FLIES) Server. It contains advanced
guidelines and information to run this network server. With the
FLIES server FLAMFILES can be accessed over the net.


== Supported systems

FLAM is available for a variety of operating systems. For example:

------------------------------------------------------------------------
Platform:      Operating System:
x86            Linux, Windows, Solaris
SPARC          Solaris
pSeries        AIX, Linux
zSeries        z/OS, z/Linux
------------------------------------------------------------------------


[preface]
== Preface

The FLSSRV command line is implemented with the CLE/P library. The CLE/P
library was developed by limes datentechnik and released as open source
under the ZLIB license. CLE/P is a compiler to provide a platform
independent command line interface for each kind of batch processing
environment.
The CLE/P library provides a lot of features including all the built-in
functions below. For example: We use this library to automatically
create this document as part of our build process; If we add
a parameter to the CLE/P tables and build the FL5 project, this
manual will be regenerated as well in order to be always up to date.

This manual is generated with the built-in function GENDOCU provided by
the CLE/P library by calling the command below:

-----------------------------------------------------------------------
   flssrv gendocu flssrvbk.txt
-----------------------------------------------------------------------

Based on that the document is always in sync with the implementation
but some redundancies are the result of such generated documentation.
This manual was designed as a reference book and in this context it is
useful for a parameter to be described in all places where it is of
relevance.


[[clep.main]]
== 1. Command line parser

The COMMAND LINE PROCESSOR (CLEP) is a user application programming
interface for several platforms including Windows, Unix and z/OS that
simplifies and standardizes parameter string processing.

The CLEP provides two separate functions:

* COMMAND LINE PARSER (CLP)   - Compiles a parameter string from a command to a data structure
* COMMAND LINE EXECUTOR (CLE) - Supporting execution of different commands with parameter strings

The COMMAND LINE EXECUTOR provides a list of commands and some
built-in functions, please use <<CLEP.BUILTIN.MANPAGE,MANPAGE>>,
<<CLEP.BUILTIN.HELP,HELP>> and <<CLEP.BUILTIN.SYNTAX,SYNTAX>> to get
extensive information about these capabilities.

Additionally the built-in function <<CLEP.BUILTIN.GENDOCU,GENDOCU>> can
generate a complete or a part of the user manual.

To read the parameter of a command, a compiler (CLP) is applied. To see
the regular expressions (lexems) and the corresponding grammar, please
use the built-in functions <<CLEP.BUILTIN.LEXEM,LEXEM>> and
<<CLEP.BUILTIN.GRAMMAR,GRAMMAR>>.

The return/condition/exit codes of the executable and the reason codes
of the different commands can be reviewed with the built-in function
<<CLEP.BUILTIN.ERRORS,ERRORS>>.
See <<CLEP.APPENDIX.RETURNCODES,Appendix Returncodes>> and, if available,
<<CLEP.APPENDIX.REASONCODES,Appendix Reasoncodes>> for the meaning of the
used return and reason codes.

The CLE uses an owner management in order to separate the settings for
different clients and a property management for each command. If problems
occur, a trace might be activated.

For each command execution the owner and environment variables can be
defined in the configuration file. To see the current configuration use
the built-in function <<CLEP.BUILTIN.CONFIG,CONFIG>>.

The default trace file is 'stdout'. If the trace is activated before a
trace file is defined, the trace will be printed on the screen. To manage
the tracing use built-in function <<CLEP.BUILTIN.TRACE,TRACE>>.

Last but not least it is possible to view the license, version and other
information about the program.

This is the RELEASE build version of the FLAMCLEP.


=== 1.1. Command line considerations

The command line parser supports abbreviation of keywords depending on
the unique first characters. This is only useful if you work in dialog.
If the command is specified in a persistent way (e.g. in a script) writing
the complete keyword is recommended, to ensure that the script must not be
changed to work with a later version of the program. For example:

Version X supports only one keyword starting with V (VERSION). Version
X+1, supports the keywords VERSION and VERIFY. If you use version X with
VER=4711 anything is fine but with with version X+1 it will fail, because
one more character is required (VERS=4711) for the keyword to be unique.

The same is valid for the required string support. The CLP supports
strings without enclosing. These strings depend on the keywords used
in a name space. If new key words are added in future version, the string
could cause errors and must be enclosed. Concerning this it is
recommended to enclose strings if the command is defined in a script.
For example:

------------------------------------------------------------------------
Version X:
    STRING=my/data/Name NUMBER=42

Version X+1 supports the new keyword NAME, this requires:
    STRING='my/data/Name' NUMBER=42 NAME='Hugo'
------------------------------------------------------------------------

The last item which could result in a damaged command syntax after a
program update is the use of implicit array definitions after an
assignment, because the end of such an array might change, for
example if an array of numbers defined an a switch is the end. In a
new version such a switch could be a number with a default value, if
only the keyword is defined. In this case the defined number referenced
by this keyword is then part of the number array and the parameter is
lost. Concerning this it is recommended to use enclosed array
definitions. For example:

------------------------------------------------------------------------
instead of:
   FLOATARRAY=1,2,3,PI
use:
   FLOATARRAY[1,2,3,PI]
------------------------------------------------------------------------

All these capabilities are implemented to be compatible with several
existing command lines syntaxes and to limit the effort to port old
commands or to simplify the interactive use. But in certain cases,
the command interpretation could fail, if not the unique/enclosed
variant of keywords, strings and arrays are used.


[[clep.main.usedenv]]
=== 1.2. Used environment variables

Below you can find the list of environment variables used by CLE and CLP. 

* LANG    - to determine the CCSID on EBCDIC systems
* HOME    - to determine the home directory on UNIX/WIN
* USER    - to determine the current user id on UNIX/WIN
* ENVID   - for the current environment qualifier (D/T/P) if key label template mapping used (default is 'T')
* OWNERID - used for current owner if not already defined
* CLP_NOW - The current point in time used for predefined constants (0tYYYY/MM/DD.HH:MM:SS)
* CLP_STRING_CCSID - CCSID used for interpretation of critical punctuation character on EBCDIC systems (default is taken from LANG)
* CLP_DEFAULT_DCB - The default record format and record length in C file mode format (default is 'recfm=VB, lrecl=516' only for z/OS)
* FLSSRV_CONFIG_FILE - the configuration filename (default is '$HOME/.flssrv.config' on UNIX/WIN or '&SYSUID..FLSSRV.CONFIG' on mainframes)
* FLSSRV_DEFAULT_OWNER_ID - the default owner ID (default is 'limes')
* owner_FLSSRV_command_PROPERTY_FILENAME - To override default property file names
* path_argument - to override the hard coded default property value

Environment variables can be set from the system or in the program
configuration file with the built-in function <<CLEP.BUILTIN.SETENV,SETENV>>.
Particularly on mainframe systems the configuration file is an easy way
to define environment variables. Additionally on host systems the DD
name STDENV and with lower priority the data set name '&SYSUID..STDENV'
is supported. On the other architectures the file '.stdenv' in the
working or with lower priority in the home directory can be used to
define environment variables.

The STDENV files allows to define the FLSSRV_CONFIG_FILE,
FLSSRV_DEFAULT_OWNER_ID, LANG and other environment variables
in JCL:

Below a you can find a sample with a z/OS DD name allocation.
-----------------------------------------------------------------------
 //STDENV   DD *
 FLSSRV_CONFIG_FILE=GLOBAL.FLSSRV.CONFIG
 LANG=de_DE.IBM-1141
 HOME=/u/hugo
 USER=hugo
 ENVID=T
 /*
-----------------------------------------------------------------------
The definition of the LANG variable outside of the program configuration
file is recommended, so that the system character set is defined in each
situation. The program configuration file name is used as is, there are
no replacements (<USER>) possible, because it is used in front of
establishment of the environment it self.

Often it will be useful to have a dedicated environment per user on
mainframes. In such a case it makes sense to define the environment in
a dedicated file for each user.

-----------------------------------------------------------------------
 //STDENV   DD DSN=USER.ENVIR(&SYSUID.), DSP=SHR
-----------------------------------------------------------------------

Since z/OSv2r1 you can also used exported JCL symbols like environment
variables. The exported JCL symbols have lower priority then the same
environment variable. The service CEEGTJS is called dynamically and the
language environment must be in the STEPLIB concatenation to use it.
Additional all z/OS system symbols can be used in the in the string
replacement (<&LDAY>). The environment variable have the highest
priority, followed by the exported JCL symbols. The lowest priority have
system symbols. If the variable name not found, then no replacement are
done and the angle bracket keep still in place.

------------------------------------------------------------------------
 //E0       EXPORT SYMLIST=*
 //S1       SET    BLKSIZE=27886
 //S3       SET    LRECL=128
------------------------------------------------------------------------

For z/OS, the default record format and record length for non-existent
output files is `recfm=VB, lrecl=516`. An attempt is made to open an
existing file with `recfm=*` for overwriting (DISP=OLD). If this fails,
another attempt is made with `recfm=VB, lrecl=516` to write a new file
(DISP=NEW). The environment variable CLP_DEFAULT_DCB can be used to
change this default file mode string.
See 'Keyword Parameters for File Mode' for fopen() in
_z/OS XL C/C++ Runtime Library Reference_ for more information and for
the correct syntax. Beside 'recfm' with a valid record format (not
'*' or '+') and 'lrecl', the 'space' parameter can be set.
All other file mode parameters are managed by CLP.

Beside all the environment variables managed by CLE it is possible to
set all properties as environment variables to override the hard coded
default values with CLP. If a property is defined as environment variable
and in a property file, then the value in the property file overrides the
setting in the environment. The environment variable name for each
property is build by the rules below:

* convert all characters to upper case
* replace all dots (`.`) by underline (`_`)

To get a list and help for all properties please use the built-in
function 'GENPROP' to generate property files. The properties can be
defined per owner, per program and general. The owner specific
definition overrides the program specific definition and the program
specific definition overrides the general definition. Examples:

-----------------------------------------------------------------------
CONV_READ_TEXT_ENL2LF=OFF #in general the 0x15 to 0x25 conversion is off#
HUGO_FLCL_CONV_READ_TEXT_ENL2LF=ON # for owner 'hugo' the conversion is on#
-----------------------------------------------------------------------

The value string behind the sign (including the comment) will be used as
supplement for the command line processor. Aliases are not supported in
this case. You can only define properties for the main argument. If a
string must be enclosed with apostrophe, please don't use double
quotation marks, because these are used in addition if a new property
file is build based on the environment settings.

-----------------------------------------------------------------------
FLCL_ICNV_FROM='IBM-1141'         # this is the best solution 
FLCL_ICNV_TO=UTF-8                # "UTF-8" could result in errors
-----------------------------------------------------------------------

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.


=== 1.3. Environment variable mapping

Each value enclosed with angle brackets (`<>`) are replaced with the
corresponding environment variable (`<LANG>`). This feature is available
at each starting point of a lexem and inside of a normal string.

If the environment variable not defined the replacements below are still
possible:

* <SYSUID> - Current user id in upper case
* <USER>   - Current user id (case sensitive)
* <CUSER>  - Current user id in upper case == <SYSUID>
* <Cuser>  - Current user id in title case
* <cuser>  - Current user id in lower case
* <HOME>   - Replaces with the users data directory, if this not
               available the replacements below are done:
** On UNIX with /home/<USER>
** On USS with /u/<USER>
** On ZOS with <SYSUID>


[[clep.main.filemap]]
=== 1.4. Filename mapping

All filenames used by CLEP are additionally mapped based on the rules
below:

* The tilde character (`~`) is replaced with the string "<HOME>"
* DD names on mainframes must be prefixed with "DD:"
* Data set names on mainframes are always full qualified
* Path names on mainframes must contain a least one slash (`/`)
* Data set names on USS must start with //
** Full qualified names with HLQ must enclose in apostrophes ("//''")
** If apostrophes are not used the SYSUID is prefixed as HLQ
* Normal file names on other platforms could be relative

*ATTENTION:* If a requested environment variable is not defined, the
replacement is done with the empty string. This can result in
unexpected behavior.

To use a "<" or "~" as a part of a filename the character must be
specified twice.

Beside this rules the replacement technologies of your shell can be used,
but on some platforms $HOME, $USER or something similar might not
be available, for such cases the possibilities above are implemented.

This file name mapping is provided by the library CLEPUTL and should
also be used for file names managed by the commands supported with this
program.


=== 1.5. Key label name mapping

The key label name mapping works like the file name mapping, but you can
additional use `^` to replace it with the OWNERID (`^=<ONWERID>`), `!`
to replace it with the environment identifier (`!=<ENVID>`) and `~` is
only replaced with login user id. If the environment ID not defined then
`T` for test is used by default.


[[clep.main.ebcdic]]
=== 1.6. Special EBCDIC code page support

To interpret commands correctly the punctuation characters below are on
different code points depending on the EBCDIC CCSID used to enter these
values.

------------------------------------------------------------------------
   CRITICAL PUNCTUATION CHARACTERS: ! $ # @ [ \\ ] ^ ` { | } ~ 
------------------------------------------------------------------------

These critical characters are interpreted normally dependent on the
environment variable LANG. If the environment variable LANG is not
defined then the default CCSID IBM1047 (Open Systems Latin-1) is used.
Below is the current list of supported CCSIDs on EBCDIC systems.

------------------------------------------------------------------------
   SUPPORTED EBCDIC CODE PAGES FOR COMMAND ENTRY:
      "IBM-1140","IBM-1141","IBM-1142","IBM-1143",
      "IBM-1144","IBM-1145","IBM-1146","IBM-1147",
      "IBM-1148","IBM-1149","IBM-1153","IBM-1154",
      "IBM-1156","IBM-1122","IBM-1047","IBM-924",
      "IBM-500","IBM-273","IBM-037","IBM-875","IBM-424",
      "IBM-277","IBM-278","IBM-280","IBM-284","IBM-285",
      "IBM-297","IBM-871","IBM-870","IBM-1025","IBM-1112",
      "IBM-1157"
------------------------------------------------------------------------

You can define the code page explicitly (LANG=de_DE.IBM-1141) or only
the language code (LANG=de_DE, LANG=C). If only the language code
defined then the CCSID is derived from the language code (DE=IBM-1141,
US=IBM-1140, C=IBM-1047, ...).

If possible, these critical characters are also converted for print
outs. At output it is not possible to convert anything correctly,
because some strings for print out are coming from other sources (like
system messages and others). Only all known literals are converted, for
unknown variables such a conversion is not possible and CLEP expects that
such strings are encoded in the correct system code page, but there is no
guaranty for this.

To be independent of the environment escaping of the CLP strings is
possible for the critical punctuation characters on EBCDIC systems.
See list below:

------------------------------------------------------------------------
   ! = &EXC;   - Exclamation mark
   $ = &DLR;   - Dollar sign
   # = &HSH;   - Hashtag (number sign)
   @ = &ATS;   - At sign
   [ = &SBO;   - Square bracket open
   \\ = &BSL;   - Backslash
   ] = &SBC;   - Square bracket close
   ^ = &CRT;   - Caret (circumflex)
   ` = &GRV;   - Grave accent
   { = &CBO;   - Curly bracket open
   | = &VBR;   - Vertical bar
   } = &CBC;   - Curly bracket close
   ~ = &TLD;   - Tilde
------------------------------------------------------------------------

A escape sequence starts with the ampersand (&) followed be 3 character
(not case sensitive) and is terminated with semicolon (;). With an X and
2 hexadecimal digit the definition of a binary byte value are possible.
If such a sequence in the string required then the ampersand must be
typed twice (&&). To mark a part or the of whole string in a certain
CCSID the escape sequence must contain 1 to 6 digits. Few samples can
be found below:

------------------------------------------------------------------------
   &1047; all in 1047 &0; reset to system code page &1140; no in 1140
------------------------------------------------------------------------

At the beginning the system code page is active except the environment
variable CLP_STRING_CCSID is defined. The defined CCSID is valid till
the next CCSID definition. An unsupported CCSID (0) can be used to
restore the interpretation to the system code page.

*ATTENTION:* This is no character set conversion, only the UNICODE code
points 0-127 which are on different code points in the different EBCDIC
code pages are replaced. All other higher code points (e.g. German
Umlauts ('ä','ü','ö')) are not touched.

The partial CCSID conversion are mainly useful for application
programming interfaces. At compile time the CCSID for literals must be
defined. This CCSID could be differ from the system CCSID (local
character set) of variable parameter. In such a case a application can
mark the literal part in the CCSID used for literals at compile time,
and the variable part could be conform to the CCSID defined over the
LANG variable. See the C example below:

------------------------------------------------------------------------
   snprintf(acCmd,sizeof(acCmd),"&1047;get.file='&0;%s&1047'",pcFilename);
------------------------------------------------------------------------

C-Code are normally in 1047 and if no literal conversion defined then
the literals also in 1047. The file name is a parameter in local
character set. In Cobol the default code page for literals is 1140.
To define the CCSID for CLP strings from outside, the environment
variable CLP_STRING_CCSID can be defined. This is useful if an
application cannot recompile with the correct code page for the
literals.

On ASCII/UTF-8 platforms a miss-interpretation of punctuation characters
smaller than 128 is not possible. On such platforms the LANG variable is
not used for command interpretation or printouts. The escape and CCSID
sequences are supported but have no effect on these platforms. This
helps to develop platform independent code for CLP strings.


[[CLEP.BUILTIN.FUNCTIONS]]
=== 1.7. Built-in functions

Numerous built-in functions are available to obtain extensive help
about syntax, errors, commands and functions of a program with help
messages, manual pages and documentation.

Other built-in functions can be used for owner, property, environment
and trace management. All built-in functions have the purpose to
simplify handling of powerful and sometimes complex commands.


[[CLEP.BUILTIN.SYNTAX]]
==== 1.7.1. Function 'SYNTAX'

.Synopsis

-----------------------------------------------------------------------
HELP:   Provides the syntax for each command
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv SYNTAX [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]]
-----------------------------------------------------------------------

.Description

The syntax function shows how the arguments can be set on the
command line. Depending on depth the syntax is printed in one line or
in structured form. A structured print out means that you have a
question or exclamation mark before the argument.

 * question mark    - optional parameter
 * exclamation mark - required parameter

The *path* is a dotted keyword list in accordance with the syntax of
the corresponding command.

------------------------------------------------------------------------
   command.para1.para2.para3
------------------------------------------------------------------------

.Options

* DEPTH1 / DEPTH2 / ... / DEPTH9
** Specifies the depth of the output. Default is DEPTH1. If the depth is
   greater than 1 the structured print out is used.
* ALL
** Shows complete syntax for the specified path, not just DEPTH1.
   Structured print out is used.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV SYNTAX
   :> FLSSRV SYNTAX command
   :> FLSSRV SYNTAX command ALL
   :> FLSSRV SYNTAX command.para
   :> FLSSRV SYNTAX command.para ALL
-----------------------------------------------------------------------


[[CLEP.BUILTIN.HELP]]
==== 1.7.2. Function 'HELP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Provides quick help for arguments
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv HELP [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] [MAN]
-----------------------------------------------------------------------

.Description

The help function can provide extensive information about each parameter
which is adjustable on the command line. With the help functionality
you get a structured list of arguments:

* keyword           - the keyword for the argument
* (TYPE: ...)       - the type of this argument
* help message      - the short help text
* (PROPERTY: [...]) - the current hard coded property value (optional)

The keyword can be abbreviated, but it must be unique for this list.
The required letters are upper case if case sensitive mode is used.
With the case sensitive mode an additional line is required to mark
the appropriate letter.

The *path* is a dotted keyword list in accordance with the syntax of the
corresponding command.

------------------------------------------------------------------------
   command.para1.para2.para3
------------------------------------------------------------------------

Help can also be used to show the corresponding detailed description of
the manual pages with keyword *MAN*.

.Options

* DEPTH1 / DEPTH2 / ... / DEPTH9
** Specifies the depth of the output. Default is DEPTH1.
* ALL
** Shows complete help below specified path, not just DEPTH1 and includes
   all aliases defined for a certain argument.
* MAN
** Shows additionally the detailed description for this program, command
   or parameter and the next level of arguments including the aliases.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV HELP
   :> FLSSRV HELP MAN
   :> FLSSRV HELP command
   :> FLSSRV HELP command MAN
   :> FLSSRV HELP command ALL
   :> FLSSRV HELP command.para
   :> FLSSRV HELP command.para MAN
   :> FLSSRV HELP command.para ALL
-----------------------------------------------------------------------


[[CLEP.BUILTIN.MANPAGE]]
==== 1.7.3. Function 'MANPAGE'

.Synopsis

-----------------------------------------------------------------------
HELP:   Provides manual pages (detailed help)
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv MANPAGE [function | command[.path][=filename]] | [filename]
-----------------------------------------------------------------------

.Description

Shows the manpages of the program, all commands and built-in functions
and if available for each argument up to selections/constant definitions.

This function prints the corresponding section from the user manual on
the screen (doctype: *book*). If a filename is given then the doctype
*manpage* of ASCIIDOC is written to the file.

Do not use space characters between the key, assignment character (=)
and filename.

The files in ASCIIDOC format can be used to generate manpages with the
tool http://www.methods.co.nz/asciidoc/[ASCIIDOC].

.Examples

-----------------------------------------------------------------------
   :> FLSSRV MANPAGE
   :> FLSSRV MANPAGE filename
   :> FLSSRV MANPAGE command
   :> FLSSRV MANPAGE command=filename
   :> FLSSRV MANPAGE function
   :> FLSSRV MANPAGE function=filename
   :> FLSSRV MANPAGE command.para
   :> FLSSRV MANPAGE command.para=filename
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GENDOCU]]
==== 1.7.4. Function 'GENDOCU'

.Synopsis

-----------------------------------------------------------------------
HELP:   Generates auxiliary documentation (ASCIIDOC text format)
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GENDOCU [command[.path]=]filename [NONBR] [SHORT]
-----------------------------------------------------------------------

.Description

The complete user manual is generated when only the filename is given.
If a command, or command path, is specified the corresponding section
of the user manual is written to a file. The generated files are in
ASCIIDOC format, to be readable as normal text document on all
platforms and easily convertible into HTML, PDF or other formats
with http://www.methods.co.nz/asciidoc/[ASCIIDOC]. The example below
generates the complete manual and convert it in a second step to a HTML5
document.

------------------------------------------------------------------------
   :> flssrv gendocu book.txt
   :> asciidoc -b html5 -f asciidoc-html5.conf -a toc2 -a toclevels=4 -o book.html book.txt
------------------------------------------------------------------------

The numbering will vary in places where the complete manual uses a
bullet list for arguments and constants, when no detailed description
is available and some of these arguments are required for the path.

The numbering can be disabled by setting the optional keyword NONBR.
This is useful if numbering is generated by a post processing utility
(for example 'pdflatex').

To create a short manual without the CLP parameter description the
optional keyword SHORT can be used. This is useful for example, if you
deliver a text file and no dictionary can be used.

In opposite to the built-in function <<CLEP.BUILTIN.HTMLDOC,HTMLDOC>> at
text file generation the corresponding path string is written to the
synopsis but index chapter and index terms are not generated anymore.

Do not use space characters between the key, assignment character (=)
and filename.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GENDOCU flssrv.manual.txt NONBR
   :> FLSSRV GENDOCU flssrv.manual.txt SHORT
   :> FLSSRV GENDOCU command=command.manual.txt
   :> FLSSRV GENDOCU command.argument=argument.manual.txt
-----------------------------------------------------------------------


[[CLEP.BUILTIN.HTMLDOC]]
==== 1.7.5. Function 'HTMLDOC'

.Synopsis

-----------------------------------------------------------------------
HELP:   Generates the complete HTML documentation into a folder
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv HTMLDOC [path] [NUMBERS] [TYPE] [SHORT]
-----------------------------------------------------------------------

.Description

This built-in function generates the complete user manual in HTML format
into a folder. The folder can be defined as optional parameter. If no
path given, then the current directory is used as default.

With the optional keyword `NUMBERS` the numbering of headlines can be
activated. The keyword `TYPE` add the type information to each generated
headline. The keyword `SHORT` will result in a short version of the
document, not containing the parameter of the commands and other CLP
strings.

In opposite to the built-in function <<CLEP.BUILTIN.GENDOCU,GENDOCU>> at
HTML generation no path is written to the synopsis but index terms are
generated by default.

The built-in function can only be used if a call back function for HTML
documentation provided. If not a error will be issued if HTMLDOC is
executed. The callback function is called for each prepared page and the
unique pointer to the original manual string can be used to determine if
this page already created and if so then only a link to this existing
page is required. This interface allows to generated more flexible (with
dictionary, index, search) and redundancy free HTML documentation.

To understand the service provider interface (open, close and callback
function) for HTML generation see the DOXYGEN documentation of
FLAMCLE/CLP.h

.Examples

-----------------------------------------------------------------------
   :> FLSSRV HTMLDOC
   :> FLSSRV HTMLDOC . SHORT
   :> FLSSRV HTMLDOC /user/home/docu/flclbook
   :> FLSSRV HTMLDOC NUMBERS SHORT
   :> FLSSRV HTMLDOC /user/home/docu/flclbook SHORT
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GENPROP]]
==== 1.7.6. Function 'GENPROP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Generates a property file
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GENPROP [command=]filename
-----------------------------------------------------------------------

.Description

A property file is generated for all commands if only a filename
is provided. If a command is specified, a property file for this
specific command is created. Property files can be used to define
default settings for commands. For each parameter, a property entry is
written to a text file. The text file contains comments to help in
editing the properties. A property file can be activated with the
built-in function SETPROP.

Property files will be activated by their owner. A property file
overrides hard coded properties and properties defined over environment
variables. A specific property file overrides the general property file.
At time of generation all current default settings are written to the
property file.

We recommend to work only with command specific property files, because
the built-in function CHGPROP can be used to generate, update and 
activate a property file for a certain command.

Do not use space characters between the key, assignment character (=)
and filename.

To optimize the program performance, one can remove all unnecessary
properties.

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GENPROP owner.general.properties
   :> FLSSRV GENPROP command=owner.command.properties
-----------------------------------------------------------------------


[[CLEP.BUILTIN.SETPROP]]
==== 1.7.7. Function 'SETPROP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Activate a property file
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv SETPROP [command=]filename
-----------------------------------------------------------------------

.Description

The filename is set as current global property file when no command is
specified. The file name is set as current local property file when a
command is given. The property file can be generated with GENPROP and
will be activated for the current owner.

After generation you can activate the property file, but there will be
no effect until you change the settings inside the property file,
because the current default settings are written.

The filename can contain replacement/mapping rules (<HOME>/<USER>).

Do not use space characters between the key, assignment character (=)
and filename.

We recommend to work only with command specific property files, because
the built-in function CHGPROP can be used to generate, update and 
activate a property file for a certain command.

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV SETPROP general.properties
   :> FLSSRV SETPROP command=command.properties
-----------------------------------------------------------------------


[[CLEP.BUILTIN.CHGPROP]]
==== 1.7.8. Function 'CHGPROP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Change a property value in the currently active property file
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv CHGPROP command [path[=value]]*
-----------------------------------------------------------------------

.Description

The built-in function updates property values in the currently active
(see <<CLEP.BUILTIN.SETPROP,SETPROP>>) property file for a dedicated
command. If no property file is activated, a property file is generated
(see <<CLEP.BUILTIN.GENPROP,GENPROP>>), updated with the provided
property list and activated (see <<CLEP.BUILTIN.SETPROP,SETPROP>>).

The first argument of CHGPROP is the command name. All other arguments
are key-value pairs of properties that should be updated. The key is
internally prefixed with the root (owner.program.command.). The values
are enclosed in double quotation marks. Multiple properties of a command
can be updated at once by separating them with a space character (please
do not use spaces between key, assignment character (=) and the value).
This set of properties is parsed by the CLP. If no property is provided,
the property file for the command is either parsed or generated (if it
does not exist) and then activated without updating properties. This
behavior can be used to generate and activate command specific property
files for the different commands.

The built-in function reads and parses the currently active property
file. Then it parses the provided property list and writes the updated
property file back to disk. The currently active property file could be
a global, not command specific property file. In such a case, a new
command specific property file is generated and activated. Properties
from the global property file are copied into the newly generated one.

If no property file is defined (see <<CLEP.BUILTIN.SETPROP,SETPROP>>)
that corresponds to the owner, program and command, a property file is
generated. The filename formats below are used to read or write property
files from/to the home directory:

On non-mainframe systems (WINDOWS, UNIX, MAC):
------------------------------------------------------------------------
    ".owner.program.command.properties"
------------------------------------------------------------------------

On mainframe systems (ZOS, VSE, BS200, ...):
------------------------------------------------------------------------
    "<SYSUID>.OWNER.PROGRAM.COMMAND.PROPS"
------------------------------------------------------------------------

If the default filenames and/or path are not sufficient, you can change
the filename of each property file by setting environment variables
using the following naming convention:

------------------------------------------------------------------------
    OWNER_PROGRAM_COMMAND_PROPERTY_FILENAME
------------------------------------------------------------------------

If no home directory is defined, then the current working directory is
used as default directory to save the property files. On mainframes
SYSUID is used for the first level qualifier, to represent the
"home directory".

Property files are managed per owner: This means that updates are only
done for the current owner.

To delete a property you can simply specify the path without the root
and with out a sign.

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV CHGPROP command overlay.object.argument=value  
   :> FLSSRV CHGPROP command overlay.object.argument  
   :> FLSSRV CHGPROP command object.argument=value1 argument=value2 
-----------------------------------------------------------------------


[[CLEP.BUILTIN.DELPROP]]
==== 1.7.9. Function 'DELPROP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Remove a property file from configuration
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv DELPROP [command]
-----------------------------------------------------------------------

.Description

Without a command the current global property file is deleted from the
configuration data. A command specific property file can be deleted
from the configuration data when the command name is given.

Property files are managed per owner, this means that delete is only
done for the current owner.

We recommend to work only with command specific property files.

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV DELPROP
   :> FLSSRV DELPROP command
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GETPROP]]
==== 1.7.10. Function 'GETPROP'

.Synopsis

-----------------------------------------------------------------------
HELP:   Show current properties
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GETPROP [command[.path] [DEPTH1 | ... | DEPTH9 | DEPALL | DEFALL]]
-----------------------------------------------------------------------

.Description

All or certain properties can be shown for a dedicated path. The *path*
is a dotted keyword list according to the syntax of the corresponding
command.

------------------------------------------------------------------------
   command.para1.para2.para3
------------------------------------------------------------------------

A help message for a certain parameter will also show the assigned
property value.

See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current
property file content.

.Options

* `DEPTH1 / DEPTH2 / ... / DEPTH9`
** Specifies the depth of the output. Default is DEPTH1.
* `DEPALL`
** Shows all properties to the specified path, not just DEPTH1.
* `DEFALL`
** Shows all defined properties to the specified path.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GETPROP
   :> FLSSRV GETPROP command
   :> FLSSRV GETPROP command DEFALL
   :> FLSSRV GETPROP command.para
   :> FLSSRV GETPROP command.para DEPALL
-----------------------------------------------------------------------


[[CLEP.BUILTIN.SETOWNER]]
==== 1.7.11. Function 'SETOWNER'

.Synopsis

-----------------------------------------------------------------------
HELP:   Defines the current owner
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv SETOWNER name
-----------------------------------------------------------------------

.Description

The current owner id (prefix or separation) can be changed. The owner
concept is very powerful to separate different property settings. You
can run the same command with different properties simply by switching
the owner. The owner is a general solution to separate all settings and
can be used for environment, client and other purposes.

If not already defined, the owner is written to the environment table
under the key word OWNERID. This environment variable can for example
used as replacement in file names (~/<OWNERID>.dat) or to refer a 
signature key.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV SETOWNER com.company
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GETOWNER]]
==== 1.7.12. Function 'GETOWNER'

.Synopsis

-----------------------------------------------------------------------
HELP:   Show current owner setting
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GETOWNER
-----------------------------------------------------------------------

.Description

The current owner id (prefix for separation) will be shown. The owner
concept allows to manage different configurations as a logical
separation of what is done with this id.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GETOWNER
-----------------------------------------------------------------------


[[CLEP.BUILTIN.SETENV]]
==== 1.7.13. Function 'SETENV'

.Synopsis

-----------------------------------------------------------------------
HELP:   Set an environment variable
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv SETENV variable=value
-----------------------------------------------------------------------

.Description

This function allows to set environment variables within the 
configuration file for a certain owner. All defined environment
variables are placed in the current environment table of the process
before a command is executed.

Do not use space characters between the key, assignment character (=)
and value.

*Attention:* The environment variables will be temporary overwritten

.Examples

-----------------------------------------------------------------------
   :> FLSSRV SETENV LANG=DE_DE.IBM-1141
   :> FLSSRV SETENV LANG=DE_DE.UTF-8
   :> FLSSRV SETENV ENVID=T
   :> FLSSRV SETENV ENVID=P
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GETENV]]
==== 1.7.14. Function 'GETENV'

.Synopsis

-----------------------------------------------------------------------
HELP:   Show the environment variables
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GETENV
-----------------------------------------------------------------------

.Description

This function lists all environment variables which are set within the
configuration file for a certain owner. All shown environment variables
are placed in the environment table of the process.

*Attention:* The environment variables will be temporary overwritten

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GETENV
-----------------------------------------------------------------------


[[CLEP.BUILTIN.DELENV]]
==== 1.7.15. Function 'DELENV'

.Synopsis

-----------------------------------------------------------------------
HELP:   Delete an environment variable
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv DELENV variable
-----------------------------------------------------------------------

.Description

This function will delete environment variables from the configuration
file for a certain owner.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV DELENV LANG
-----------------------------------------------------------------------


[[CLEP.BUILTIN.TRACE]]
==== 1.7.16. Function 'TRACE'

.Synopsis

-----------------------------------------------------------------------
HELP:   Manage trace capabilities
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv TRACE ON | OFF | FILE=filename
-----------------------------------------------------------------------

.Description

Tracing for command line parser and commands can be enabled or disabled.
A trace is only required to diagnose errors. In such a case a trace
file must be defined first, then the trace can be activated, the
erroneous command executed and the trace file sent to the support team.

If no trace file is defined, stdout/stderr is used as default. To
prevent tracing on the screen, please define a trace file first before
tracing is switched on.

Do not use space characters between the key, assignment character (=)
and filename.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV TRACE FILE=filename
   :> FLSSRV TRACE ON
   :> FLSSRV TRACE OFF
-----------------------------------------------------------------------


[[CLEP.BUILTIN.CONFIG]]
==== 1.7.17. Function 'CONFIG'

.Synopsis

-----------------------------------------------------------------------
HELP:   Shows or clear all the current configuration settings
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv CONFIG [CLEAR]
-----------------------------------------------------------------------

.Description

The actual configuration list with owner id, property file names trace
setting, environment variables and more is shown. With the option CLEAR
the configuration data including the corresponding file will be deleted.

The configuration file name can be defined by the environment variable:

------------------------------------------------------------------------
   FLSSRV_CONFIG_FILE=config.file.name
------------------------------------------------------------------------

This can be used to work with a global configuration file. If this
location is not defined, the configuration file is stored in the
home directory with the name:

------------------------------------------------------------------------
   .flssrv.config
------------------------------------------------------------------------

If no home directory is defined for the current user (this case is very
improbable), the working directory is used.

To read the configuration file when the environment variable above is not
defined, CLE first looks in the working and then in the home directory.
This makes it possible to prefer a property file, by copying it to the
current working directory.

On mainframes the data set name 'SYSUID.FLSSRV.CONFIG' is used as default.
SYSUID as high level qualifier is a kind of replacement for the
current home directory in other operating systems in this way.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV CONFIG
   :> FLSSRV CONFIG CLEAR
-----------------------------------------------------------------------


[[CLEP.BUILTIN.GRAMMAR]]
==== 1.7.18. Function 'GRAMMAR'

.Synopsis

-----------------------------------------------------------------------
HELP:   Shows the grammar for commands and properties
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv GRAMMAR
-----------------------------------------------------------------------

.Description

The grammar used for interpreting the command line and property files
is shown. This is helpful for understanding how the commands and
property files are interpreted by the command line processor.

See <<CLEP.APPENDIX.GRAMMAR,Appendix Grammar>> for an explanation and
the output of this command.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV GRAMMAR
-----------------------------------------------------------------------


[[CLEP.BUILTIN.LEXEM]]
==== 1.7.19. Function 'LEXEM'

.Synopsis

-----------------------------------------------------------------------
HELP:   Shows the regular expressions accepted in a command
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv LEXEM
-----------------------------------------------------------------------

.Description

The regular expression used for the tokens of the command syntax will
be shown. This could be helpful in understanding how the commands and
property files are interpreted by the command line processor. Moreover
it will be shown how to define a number, a string, a keyword and other
values inside a command.

See <<CLEP.APPENDIX.LEXEM,Appendix Lexem>> for an explanation and the
output of this command.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV LEXEM
-----------------------------------------------------------------------


[[CLEP.BUILTIN.LICENSE]]
==== 1.7.20. Function 'LICENSE'

.Synopsis

-----------------------------------------------------------------------
HELP:   List license information for the program
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv LICENSE
-----------------------------------------------------------------------

.Description

The license string of the software product is shown. This string is
provided to the command line executer (CLE) by the calling program and
should reflect the current license text for this program.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV LICENSE
-----------------------------------------------------------------------


[[CLEP.BUILTIN.VERSION]]
==== 1.7.21. Function 'VERSION'

.Synopsis

-----------------------------------------------------------------------
HELP:   List version information for the program
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv VERSION
-----------------------------------------------------------------------

.Description

The version of the software product is shown. This string is
provided to the command line executer (CLE) by the calling program and
should reflect the current version information for this program.

See <<CLEP.APPENDIX.VERSION,Appendix Version>> for the output of this
command.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV VERSION
-----------------------------------------------------------------------


[[CLEP.BUILTIN.ABOUT]]
==== 1.7.22. Function 'ABOUT'

.Synopsis

-----------------------------------------------------------------------
HELP:   Show information about the program
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv ABOUT
-----------------------------------------------------------------------

.Description

Shows information about the software product like version, copyright,
external libraries, license and other attributes. This string is
provided to the command line executer (CLE) by the calling program and
should reflect the current about information for this program (flssrv).

See <<CLEP.APPENDIX.ABOUT,Appendix About>> for the output of this command.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV ABOUT
-----------------------------------------------------------------------


[[CLEP.BUILTIN.ERRORS]]
==== 1.7.23. Function 'ERRORS'

.Synopsis

-----------------------------------------------------------------------
HELP:   Show information about return and reason codes of the program
PATH:   limes.flssrv
TYPE:   BUILT-IN FUNCTION
SYNTAX: > flssrv ERRORS
-----------------------------------------------------------------------

.Description

This built-in function prints explanations for the return/condition/exit
codes of the executable and, if available, the reason codes of executed
commands.

The command line executer (CLE) initialized the CLP structure. Calls the
command line processor (CLP). Calls the mapping function, which converts
the CLP structure in a corresponding command structure. Then it runs the
command and as last step it calls the finish function with the command
structure, to close all files and free all the allocated memory. If one
of these steps fails, then a corresponding return (condition/exit) code
is given back from the executable. Only the command execution can result
in a error (return code 8) or in a warning (return code 4). The command
it self must return a reason code for such a warning or error. This
means that the return (condition/exit) code can be used to control the
batch processing. The reason code gives more information about the error
or warning.

See <<CLEP.APPENDIX.RETURNCODES,Appendix Returncodes>> and
<<CLEP.APPENDIX.REASONCODES,Appendix Reasoncodes>> for an
explanation and the output of this command.

.Examples

-----------------------------------------------------------------------
   :> FLSSRV ERRORS
-----------------------------------------------------------------------


== 2. FLIES Sever

The FLIES(R) server allows remote read and write access to a FLAMARCHIVE
(file, database, VSAM) by using a network connection with one of the
supported protocols (IP, MQ, ...). Additionally it can act as a gateway
to forward the client requests to another server.
Search requests for segments are also possible, thereby making the limes
access method network transparent.
The segements transferred on the network are compressed and encrypted
by the client if this was requested. This keeps control on the client
side and reduces the amount of network traffic.


=== 2.1. Synopsis

The synopsis collects the help, syntax and other important information
for a program, function or parameter. It is a kind of quick reference
and will used over the complete hierarchies in this document. Below you
can find for example the synopsis for program FLSSRV.


-----------------------------------------------------------------------
HELP:   FLIES Server (Remote FLAM)
PATH:   limes
TYPE:   PROGRAM
SYNTAX: > flssrv COMMAND/FUNCTION ...
-----------------------------------------------------------------------

=== 2.2. Environment Variables

* LANG                    - to determine the default CCSID for this platform (Format: de_DE.UTF-8)
* FLSSRV_CONFIG_FILE      - defines the config filename (if not set default is '.flssrv.config')
* FLSSRV_DEFAULT_OWNER_ID - defines the default owner ID (if not set default is 'limes')

The enviroment variables can be set over the system or over the FLSSRV
config file with built-in function 'SETENV'. Especially on mainframe
systems the config file is a easy way to define environment variables
for FLSSRV.


=== 2.3. Installation

The product FLAM with all its components (FLCL, FLCC, FLSSRV, ...) is
delivered in two parts. The main package contains the whole software and
is available as download or via package repository (various Linux
distributions). The second part is the license, which determines the
features and platforms that can be used, where and for what you can use
the software. If only the main package is installed, then a limited DEMO
license can be used.


==== 2.3.1. License

FLAM is protected against unauthorized use. The
authorized usage of FLAM is only possible with a
licence module provided by Limes Datentechnik.

A licence allows the usage of FLAM on one or multiple
computers, capacities, users or per usage.

There is a difference between test licences for a limited
period and unlimited (or limited) production licences.
A test licence allows the testing and benchmarking of
FLAM with all functions for a defined period (e.g. 30
days).

* Test licenses must not be given to a third party.
* During the test period, no backup copies of the
  test programs are allowed.
* After the test period is expired all test programs must
  be deleted.

A production licence allows the limited or unlimited
usage of FLAM on any computer for which a licence was
obtained.

FLAM compresses structure-oriented using an
algorithm that is a part of the Frankenstein-Limes
method. This method has been patented in the Federal
Republic of Germany and the United States of America
and at the European Patent Bureau, registered by the
inventor on 19th September 1985.


==== 2.3.2. Download

FLAM(R) can be downloaded from our website with the following link:

https://flam.de/en/download/flam/

INSTALL and README text files are included as guides for installation.

The download area distinguishes several operating systems:

[width="50%",cols="2,5",options="header"]
|====
|Operating system | Link to installation instructions
|AIX              | https://flam.de/en/download/flam/aix/install.txt
|HPUX             | https://flam.de/en/download/flam/hpux/install.txt
|Linux            | https://flam.de/en/download/flam/linux/install.txt
|Solaris          | https://flam.de/en/download/flam/solaris/install.txt
|Windows          | https://flam.de/en/download/flam/windows/install.txt
|zSeries Linux    | https://flam.de/en/download/flam/zSeries/linux/install.txt
|zSeries USS      | https://flam.de/en/download/flam/zSeries/uss/install.txt
|zSeries z/OS     | https://flam.de/en/download/flam/zSeries/zos/install.txt
|====

Manuals can be found at:

https://flam.de/en/technology/download/documentation/


=== 2.4. Syntax of FLSSRV

Below you can see the main syntax for this program. This content is
printed on the screen if the built-in function <<CLEP.BUILTIN.SYNTAX,SYNTAX>>
is used.

Each command can be entered as an argument list on the command line or
in a parameter file. To define a parameter file the assignment character
(`=`) must be used. For an argument list a blank or if the command
(main table) is of type overlay a dot (`.`) or if the command is of type
object a round bracket open (`(`) must be given. If the round bracket
open is used then the corresponding round bracket close (`)`) at the end
of the command is mandatory. The dot and parenthesis are in accordance
with the normal syntax.

If an argument list is used all parameters (argv[]) are concatenated
to one long string and this string is passed to the parser, to allow
usage of all features of the shell to build the command line input. To
make sure that anything you enter is passed one by one to the parser
please use double (WINDOWS(R), UNIX) or single (z/OS(R)) quotation marks
at the beginning and end of the argument list. If the dot for overlays
or parenthesis for objects are used then the complete command must be
included in double quotation marks. The examples below show all possible
command entries for the type object:

-----------------------------------------------------------------------
   :> FLSSRV command temp() dummy='str'
   :> FLSSRV command(temp() dummy='str')
   :> FLSSRV command "temp() dummy='str'"
   :> FLSSRV "command(temp() dummy='str')"
-----------------------------------------------------------------------

For a command of type overlay it looks like:

-----------------------------------------------------------------------
   :> FLSSRV command temp()
   :> FLSSRV command.temp()
   :> FLSSRV command "temp()"
   :> FLSSRV "command.temp()"
-----------------------------------------------------------------------

In a parameter file you can start with a dot for an overlay or
with parenthesis for an object or with the argument (overlay) or
argument list (object) directly.


------------------------------------------------------------------------
Syntax for program 'flssrv':
--| Commands: RUN
--|--| flssrv [OWNER=oid] command "... argument list ..." [MAXCC=[max][-min]] [QUIET/SILENT]
--|--| flssrv [OWNER=oid] command=" parameter file name " [MAXCC=[max][-min]] [QUIET/SILENT]
--|--| flssrv [OWNER=oid] command=>"parameter file name " [MAXCC=[max][-min]] [QUIET/SILENT]
--|--| You can optionally specify:
--|--|--| the owner id for this command (to use custom configuration files)
--|--|--| the maximum condition code (max) to suppress warnings
--|--|--| the minimum condition code (min), zero is returned if the condition code would be smaller
--|--|--| QUIET disables the normal log output of the command line executer
--|--|--| SILENT disables log and errors messages of the command line executer
--| Built-in functions:
--|--| flssrv SYNTAX [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]]
--|--| flssrv HELP [command[.path] [DEPTH1 | ... | DEPTH9 | ALL]] [MAN]
--|--| flssrv MANPAGE [function | command[.path][=filename]] | [filename]
--|--| flssrv GENDOCU [command[.path]=]filename [NONBR] [SHORT]
--|--| flssrv HTMLDOC [path] [NUMBERS] [TYPE] [SHORT]
--|--| flssrv GENPROP [command=]filename
--|--| flssrv SETPROP [command=]filename
--|--| flssrv CHGPROP command [path[=value]]*
--|--| flssrv DELPROP [command]
--|--| flssrv GETPROP [command[.path] [DEPTH1 | ... | DEPTH9 | DEPALL | DEFALL]]
--|--| flssrv SETOWNER name
--|--| flssrv GETOWNER
--|--| flssrv SETENV variable=value
--|--| flssrv GETENV
--|--| flssrv DELENV variable
--|--| flssrv TRACE ON | OFF | FILE=filename
--|--| flssrv CONFIG [CLEAR]
--|--| flssrv GRAMMAR
--|--| flssrv LEXEM
--|--| flssrv LICENSE
--|--| flssrv VERSION
--|--| flssrv ABOUT
--|--| flssrv ERRORS
------------------------------------------------------------------------

=== 2.5. Help for FLSSRV

Here you can see the static main help for this program. This content
is printed on the screen if the built-in function <<CLEP.BUILTIN.HELP,HELP>>
is used without any further arguments.


------------------------------------------------------------------------
Help for program 'flssrv':
--| Commands - to execute powerful subprograms
--|--| flssrv RUN      - run server
--| Built-in functions - to give interactive support for the commands above
--|--| flssrv SYNTAX   - Provides the syntax for each command
--|--| flssrv HELP     - Provides quick help for arguments
--|--| flssrv MANPAGE  - Provides manual pages (detailed help)
--|--| flssrv GENDOCU  - Generates auxiliary documentation (ASCIIDOC text format)
--|--| flssrv HTMLDOC  - Generates the complete HTML documentation into a folder
--|--| flssrv GENPROP  - Generates a property file
--|--| flssrv SETPROP  - Activate a property file
--|--| flssrv CHGPROP  - Change a property value in the currently active property file
--|--| flssrv DELPROP  - Remove a property file from configuration
--|--| flssrv GETPROP  - Show current properties
--|--| flssrv SETOWNER - Defines the current owner
--|--| flssrv GETOWNER - Show current owner setting
--|--| flssrv SETENV   - Set an environment variable
--|--| flssrv GETENV   - Show the environment variables
--|--| flssrv DELENV   - Delete an environment variable
--|--| flssrv TRACE    - Manage trace capabilities
--|--| flssrv CONFIG   - Shows or clear all the current configuration settings
--|--| flssrv GRAMMAR  - Shows the grammar for commands and properties
--|--| flssrv LEXEM    - Shows the regular expressions accepted in a command
--|--| flssrv LICENSE  - List license information for the program
--|--| flssrv VERSION  - List version information for the program
--|--| flssrv ABOUT    - Show information about the program
--|--| flssrv ERRORS   - Show information about return and reason codes of the program
For more information please use the built-in function 'MANPAGE'
------------------------------------------------------------------------

=== 2.6. FLSSRV commands

Commands are used to run powerful subprograms. The command line
processor compiles a table defined syntax in a corresponding
preinitialized data structure. This structure will be mapped to the
parameter structure of the corresponding subprogram.
The subprogram can be executed with the defined arguments/parameters.

To support these variable commands several built-in functions are
available and described in a separate <<CLEP.BUILTIN.FUNCTIONS,chapter>>.

Each supported command is explained in a separate section in this
document. Each section contains a synopsis including the help
message, the path, the type and the syntax followed by a detailed
description.

If an argument of this command is an object or overlay or, if a detailed
description is available for this argument, a separate section with
synopsis (help, path, type, syntax) and description is written, 
otherwise a bullet list is printed which contains the keyword, the
syntax and the help message.

For the syntax of an overlay braces `{}` are used to keep all possible
arguments of an overlay logically together. These braces are not part
of the real syntax. The braces are only written to demonstrate
clearly that one of these arguments must be selected with the
DOT operator (optional) for defining the overlay.

To be compatible with certain shells, the features below are
implemented:

* Strings can be enclosed with single '' or double "" quotation marks
* Integrated strings (without spaces) can also defined without quotes
* Keywords can also start with "-" or "--" in front of the qualifier
* If it unique then parenthesis and the dot can be omit for object and overlays

Commands can be declared in deep hierarchical depth. In order to
simplify their handling the path is a powerful instrument for managing
only relevant parts of it. Because of that the path is printed for each
synopsis.

To run commands under different owners, the owner id can be defined in
front of the command.

To suppress the outputs of the command line executer you can set QUIET
or SILENT as the last parameter. Additional to QUIET, SILENT suppressed
also the error messages. These options has no effect of the outputs of
the commands and built-in functions.

For job control, the maximum (and minimum) condition code
(MAXCC=[max][-min]) of the command execution can optionally be set as
the last parameter for each command. The value 'max' is the maximum
condition code. If the condition code, that would be returned if MAXCC
was not specified, would be greater than 'max', it is reduced to the
value of 'max'. If the condition code would be smaller than 'min', the
actually returned condition code is reduced to 0. Both, 'max' and 'min',
values are optional. To only specify the minimum, simply omit the 'max'
value, i.e. the MAXCC value starts with a hyphen.
Example: The clause `MAXCC=8-4` will set each condition code
greater than 8 to 8 and each condition code smaller than 4 to 0,
while `MAXCC=-4` only sets condition codes smaller than 4 to 0.

------------------------------------------------------------------------
flssrv [OWNER=oid] command "... argument list ..." [MAXCC=[max][-min]] [QUIET]
flssrv [OWNER=oid] command=" parameter file name " [MAXCC=[max][-min]] [QUIET]
------------------------------------------------------------------------

The parameter for each command can be provided as argument list on the
command line or as parameter file.


[[CLEP.COMMAND.RUN]]
==== 2.6.1. Command 'RUN'

.Synopsis

-----------------------------------------------------------------------
HELP:   run server
PATH:   limes.flssrv
TYPE:   OBJECT
SYNTAX: > flssrv RUN(PORT='str',CLIENT(),ROOTPATH='str',HLEN=num,DLEN=num,HANDLE_CLIENT=THREAD/PROCESS,DAEMONIZE,LOG())
-----------------------------------------------------------------------

.Description

The RUN command must be used to to execute the FLIES(R) server. It is an
object containg all parameters needed to configure its behaviour.

To run the server with default values

-----------------------------------------------------------------------
   FLSSRV RUN
-----------------------------------------------------------------------

is sufficient. To get help for a parameter use:

-----------------------------------------------------------------------
   FLSSRV HELP RUN.parameter[.parameter[...]]
-----------------------------------------------------------------------

To read the manual page for a parameter, please use:

-----------------------------------------------------------------------
   FLSSRV MANPAGE RUN.parameter[.parameter[...]]
-----------------------------------------------------------------------

To generate the user manual for the RUN command use:

-----------------------------------------------------------------------
   FLSSRV GENDOCU RUN=filename
-----------------------------------------------------------------------

Parameters can be defined by the command line (directly or per file) or
by properties read from the corresponding property file.

.Examples

-----------------------------------------------------------------------
   FLSSRV RUN rootpath='/srv/flam'
   FLSSRV RUN handle_client=process
-----------------------------------------------------------------------


.Arguments

* `NUMBER: HLEN=num - Initial buffer length for header`
* `NUMBER: DLEN=num - Initial buffer length for data`

[[CLEP.APPENDIX.LEXEM]]
== Appendix A. Lexem

The regular expressions used by the command line compiler are shown
below. This content is printed on the screen with the built-in
function `LEXEM`.

To describe the regular expression the following character classes are
used:

* :print:  - all printable characters
* :space:  - all blanks, tabs and new lines
* :cntr:   - all control characters
* :alpha:  - all letters ([[a-z]|[A-Z]])
* :alnum:  - all letters and digits [0-9]
* :digit:  - all decimal numbers [0-9]
* :xdigit: - all hexadecimal numbers [[0-9]|[a-f||[A-F]]

All comments and separators are ignored by the scanner and not passed
with the token to the parser. This means that the separators (SEP)
are used in the grammar but will never be part of or own tokens.

If a binary entry for a string is possible and no classification is
done it is taken as a binary string in local character set 
representation (c) without null termination. This default can be
changed. In this case the help message for this argument should be
described the default interpretation of the binary string. For binary
strings it is still possible to enter a null-terminated string, but
then the prefix *s* must be used. If no binary entry is feasible, only
a null-terminated string in local character representation (s) can be
built and taken by default.


------------------------------------------------------------------------
Lexemes (regular expressions) for argument list or parameter file
--| COMMENT   '#' [:print:]* '#'                              (will be ignored)
--| LCOMMENT  ';' [:print:]* 'nl'                             (will be ignored)
--| SEPARATOR [:space: | :cntr: | ',']*                  (abbreviated with SEP)
--| OPERATOR '=' | '.' | '(' | ')' | '[' | ']' | (SGN, DOT, RBO, RBC, SBO, SBC)
--|  '=>'| '+' | '-' | '*' | '/' | '{' | '}' (SAB, ADD, SUB, MUL, DIV, CBO,CBC)
--| KEYWORD   ['-'['-']][:alpha:]+[:alnum: | '_']*          (always predefined)
--| NUMBER    ([+|-]  [ :digit:]+)  |                       (decimal (default))
--| num       ([+|-]0b[ :digit:]+)  |                                  (binary)
--| num       ([+|-]0o[ :digit:]+)  |                                   (octal)
--| num       ([+|-]0d[ :digit:]+)  |                                 (decimal)
--| num       ([+|-]0x[ :xdigit:]+) |                             (hexadecimal)
--| num       ([+|-]0t(yyyy/mm/tt.hh:mm:ss)) |  (relativ (+|-) or absolut time)
--| FLOAT     ([+|-]  [ :digit:]+.[:digit:]+e|E[:digit:]+) | (decimal(default))
--| flt       ([+|-]0d[ :digit:]+.[:digit:]+e|E[:digit:]+)            (decimal)
--| STRING         ''' [:print:]* ''' |          (default (if binary c else s))
--| str       [s|S]''' [:print:]* ''' |                (null-terminated string)
--| str       [c|C]''' [:print:]* ''' |  (binary string in local character set)
--| str       [a|A]''' [:print:]* ''' |                (binary string in ASCII)
--| str       [e|E]''' [:print:]* ''' |               (binary string in EBCDIC)
--| str       [x|X]''' [:print:]* ''' |         (binary string in hex notation)
--| str       [f|F]''' [:print:]* ''' | (read string from file (for passwords))
--|           Strings can contain two '' to represent one '                    
--|           Strings can also be enclosed in " or ` instead of '              
--|           Strings can directly start behind a '=' without enclosing ('`")  
--|              In this case the string ends at the next separator or operator
--|              and keywords are preferred. To use keywords, separators or    
--|              operators in strings, enclosing quotes are required.          
--|                                                                            
--| The predefined constant keyword below can be used in a value expressions   
--| NOW       NUMBER - current time in seconds since 1970 (+0t0000)            
--| MINUTE    NUMBER - minute in seconds (60)                                  
--| HOUR      NUMBER - hour in seconds   (60*60)                               
--| DAY       NUMBER - day in seconds    (24*60*60)                            
--| YEAR      NUMBER - year in seconds   (365*24*60*60)                        
--| KiB       NUMBER - kilobyte          (1024)                                
--| MiB       NUMBER - megabyte          (1024*1024)                           
--| GiB       NUMBER - gigabyte          (1024*1024*1024)                      
--| TiB       NUMBER - terrabyte         (1024*1024*1024*1024)                 
--| RNDn      NUMBER - simple random number with n * 8 bit in length (1,2,4,8) 
--| PI        FLOAT  - PI (3.14159265359)                                      
--| LCSTAMP   STRING - current local stamp in format:           YYYYMMDD.HHMMSS
--| LCDATE    STRING - current local date in format:            YYYYMMDD       
--| LCYEAR    STRING - current local year in format:            YYYY           
--| LCYEAR2   STRING - current local year in format:            YY             
--| LCMONTH   STRING - current local month in format:           MM             
--| LCDAY     STRING - current local day in format:             DD             
--| LCTIME    STRING - current local time in format:            HHMMSS         
--| LCHOUR    STRING - current local hour in format:            HH             
--| LCMINUTE  STRING - current local minute in format:          MM             
--| LCSECOND  STRING - current local second in format:          SS             
--| GMSTAMP   STRING - current Greenwich mean stamp in format:  YYYYMMDD.HHMMSS
--| GMDATE    STRING - current Greenwich mean date in format:   YYYYMMDD       
--| GMYEAR    STRING - current Greenwich mean year in format:   YYYY           
--| GMYEAR2   STRING - current Greenwich mean year in format:   YY             
--| GMMONTH   STRING - current Greenwich mean month in format:  MM             
--| GMDAY     STRING - current Greenwich mean day in format:    DD             
--| GMTIME    STRING - current Greenwich mean time in format:   HHMMSS         
--| GMHOUR    STRING - current Greenwich mean hour in format:   HH             
--| GMMINUTE  STRING - current Greenwich mean minute in format: MM             
--| GMSECOND  STRING - current Greenwich mean second in format: SS             
--| GMSECOND  STRING - current Greenwich mean second in format: SS             
--| SnRND10   STRING - decimal random number of length n (1 to 8)              
--| SnRND16   STRING - hexadecimal random number of length n (1 to 8)          
--|                                                                            
--| SUPPLEMENT     '"' [:print:]* '"' |   (null-terminated string (properties))
--|           Supplements can contain two "" to represent one "                
--|           Supplements can also be enclosed in ' or ` instead of "          
--|           Supplements can also be enclosed in ' or ` instead of "          
--| ENVIRONMENT VARIABLES '<'varnam'>' will replaced by the corresponding value  
--| Escape sequences for critical punctuation characters on EBCDIC systems     
--|    '!' = '&EXC;'   - Exclamation mark                                      
--|    '$' = '&DLR;'   - Dollar sign                                           
--|    '#' = '&HSH;'   - Hashtag (number sign)                                 
--|    '@' = '&ATS;'   - At sign                                               
--|    '[' = '&SBO;'   - Square bracket open                                   
--|    '\' = '&BSL;'   - Backslash                                             
--|    ']' = '&SBC;'   - Square bracket close                                  
--|    '^' = '&CRT;'   - Caret (circumflex)                                    
--|    '`' = '&GRV;'   - Grave accent                                          
--|    '{' = '&CBO;'   - Curly bracket open                                    
--|    '|' = '&VBR;'   - Vertical bar                                          
--|    '}' = '&CBC;'   - Curly bracket close                                   
--|    '~' = '&TLD;'   - Tilde                                                 
--| Define CCSIDs for certain areas in CLP strings on EBCDIC systems (0-reset) 
--|    '&' [:digit:]+ ';  (..."&1047;get.file='&0;%s&1047;'",f)                
--| Escape sequences for hexadecimal byte values                               
--|    '&' ['X''x'] :xdigit: :xdigit: ';' ("&xF5;")                            
------------------------------------------------------------------------

[[CLEP.APPENDIX.GRAMMAR]]
== Appendix B. Grammar

Below you can see the grammar used by the command line compiler. This
content is printed on the screen if the built-in function
<<CLEP.BUILTIN.GRAMMAR,GRAMMAR>> is used.

There are two context free grammars, one is used for the command
line the other for the parameter file. The parameter file contains
mainly the same argument list as the command line. The property file
defines the default settings. For this a different grammar is applied.

Properties can be set for each argument, i.e. for arguments
not used or arguments in overlays. Based on that, properties are set
by using the path (dotted keyword list).

A property is always a 'SUPPLEMENT' for the argument list on the
command line or parameter file. Thus all defined properties have the
same effect as arguments on the command line. A property sets this
argument to the corresponding value if it is not defined on the
command line.



------------------------------------------------------------------------
Grammar for argument list, parameter file or property file
--| Command Line Parser                                              
--| command        -> ['('] parameter_list [')']       (main=object) 
--|                |  ['.'] parameter                  (main=overlay)
--| parameter_list -> parameter SEP parameter_list                   
--|                |  EMPTY                                          
--| parameter      -> switch | assignment | object | overlay | array 
--| switch         -> KEYWORD                                        
--| assignment     -> KEYWORD '=' value                              
--|                |  KEYWORD '=' KEYWORD # SELECTION #              
--|                |  KEYWORD '=>' STRING # parameter file #         
--| object         -> KEYWORD ['('] parameter_list [')']             
--|                |  KEYWORD '=' STRING # parameter file #          
--|                |  KEYWORD '=>' STRING # parameter file #         
--| overlay        -> KEYWORD ['.'] parameter                        
--|                |  KEYWORD '=' STRING # parameter file #          
--|                |  KEYWORD '=>' STRING # parameter file #         
--| array          -> KEYWORD '[' value_list   ']'                   
--|                |  KEYWORD '[' object_list  ']'                   
--|                |  KEYWORD '[' overlay_list ']'                   
--|                |  KEYWORD '=' value_list # with certain limitations #
--| It is recommended to use only enclosed array lists to know the end
--|                |  KEYWORD '[=' STRING ']' # parameter file #     
--|                |  KEYWORD '[=>' STRING ']' # parameter file #    
--| value_list     -> value SEP value_list                           
--|                |  EMPTY                                          
--| object_list    -> object SEP object_list                         
--|                |  EMPTY                                          
--| overlay_list   -> overlay SEP overlay_list                       
--|                |  EMPTY                                          
--| A list of objects requires parenthesis to enclose the arguments  
--|                                                                  
--| value          -> term '+' value                                 
--|                |  term '-' value                                 
--|                |  term                                           
--| term           -> factor '*' term                                
--|                |  factor '/' term                                
--|                |  factor                                         
--| factor         -> NUMBER | FLOAT | STRING                        
--|                |  selection | variable | constant                
--|                |  '(' value ')'                                  
--| selection      -> KEYWORD # value from a selection table        #
--| variable       -> KEYWORD # value from a previous assignment    #
--|                |  KEYWORD '{' NUMBER '}' # with index for arrays#
--| constant       -> KEYWORD # see predefined constants at lexem   #
--| For strings only the operator '+' is implemented as concatenation
--| Strings without an operator in between are also concatenated     
--| A number followed by a constant is a multiplication (4KiB=4*1024)
--|                                                                  
--| Property File Parser                                             
--| properties     -> property_list                                  
--| property_list  -> property SEP property_list                     
--|                |  EMPTY                                          
--| property       -> keyword_list '=' SUPPLEMENT                    
--| keyword_list   -> KEYWORD '.' keyword_list                       
--|                |  KEYWORD                                        
--| SUPPLEMENT is a string in double quotation marks ("property")    
------------------------------------------------------------------------

[[CLEP.APPENDIX.PROPERTIES]]
== Appendix C. Properties

All properties can be written to a global property file with the
built-in function <<CLEP.BUILTIN.GENPROP,GENPROP>>:
------------------------------------------------------------------------
   'GENPROP filename'.
------------------------------------------------------------------------
   
A property file for a certain command can be generated with:
------------------------------------------------------------------------
   'GENPROP command=filename'
------------------------------------------------------------------------

The first command shows the valid root path for the property file. A
property file can contain properties for more than one root path. The
property file parser will only interpret properties where the root
matches, i.e. if the property file is assigned to a certain owner and
possibly to a certain command, then only properties for this owner, the
program itself and possibly the command will be accepted, all other
properties are ignored.

The second long comment gives some help for handling a property
file. Thereafter the generated properties for this root are listed
for all supported commands. The format is:

------------------------------------------------------------------------
   path = SUPPLEMENT # Type: tttttt Help: hhh...hhh #
------------------------------------------------------------------------

The path denotes the unique dotted keyword list for one argument. The
'SUPPLEMENT' is a string normally in double quotation marks containing
the value list for this argument in accordance with the syntax of the
command line parser (strings then normally in single quotation marks,
a opposite usage of the quotation marks is possible but not
recommended). This means for example that a string that requires
apostrophes must be included in apostrophes `("'...'")`. The supplement
string is returned by the corresponding command line parser if no value
for this argument is entered on the command line or is included in the
parameter file.

Behind the property definition the type and help message are printed as
comment to help in editing the generated property file. The property
values can be related to the current default settings at time of
generation, what means that if hard coded default values or another
property file is already in use, then these values are taken over
into the new property file.

The property file can contain parameter which are not available on the
command line. Such parameter are only documented in the property file.
On the other side not all command line parameter are available as
property.

If a description for a property argument is available which is not a
part of the user manual this description is written as comment in
front of the corresponding property definition.

Below you can see the documentation of all parameter which are only
available as property followed by all defined default properties
in form of a sample property file for all available commands.


=== Appendix C.1. Remaining documentation

Below you can find the documentation for all parameters which are only
available over the property definitions. These parameters are not a part
of the description for each command above. This list is generated and
can be empty. In this case all parameters are available over the
command line. If available, the manual page otherwise the help message
is printed.


=== Appendix C.2. Predefined defaults

Below you can find a sample property file which contains all predefined
default values for all supported commands when this documentation was
created.


------------------------------------------------------------------------

# Property file for: limes.flssrv #
#------------------------------------------------------------------- #
#                                                                    #
# The property file can be used to overwrite the default values      #
# used if the argument is not defined on the command line.           #
#                                                                    #
#------------------------------------------------------------------- #
#                                                                    #
# The values is assigned between "" conforming to the syntax.        #
#   Example NUMBER array  : "4711, 1, 2, 3"                          #
#   Example STRING array  : "'str1' x'303000''str2',a'abc'"          #
#   Example FLOAT array   : "123.34, 1.58, PI" (PI as constant)      #
#                                                                    #
# The last example shows that one can use key words if a list        #
# of constants is defined for this argument.                         #
#                                                                    #
# For a SWITCH one can use the special key words ON/OFF to enable or #
# disable the SWITCH or define the value as a number                 #
#   Examples for a SWITCH : "ON"/"OFF"/"4711"                        #
#                                                                    #
# For an OBJECT only the special key word INIT can be used to ensure #
# that this OBJECT will be initialized if it was not set on the      #
# command line. If INIT is not set, then the elements of the OBJECT  #
# will be initialized only if you type at least obj() in the command #
# line. If you want an object to be initialized when you don't use it#
# on the command line then the special key word must be set.         #
#   Examples for an OBJECT: ""/"INIT"                                #
#                                                                    #
# For an OVERLAY it is the same logic as for objects but the keyword #
# of the element to initialize must be used if the overlay is not    #
# set in the command line.                                           #
#   Example OVERLAY array : "LINE TRIANGLE LINE RECTANGLE"           #
#   Example for a OVERLAY : "RECTANGLE"                              #
#                                                                    #
#------------------------------------------------------------------- #

------------------------------------------------------------------------

[[CLEP.APPENDIX.RETURNCODES]]
== Appendix D. Returncodes

The return codes of the program are also called completion codes and
returned at program termination. This content is printed on the screen
with the built-in function <<CLEP.BUILTIN.ERRORS,ERRORS>>.

* 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 returned with a warning
* 8  - command line, command syntax and mapping was successful but execution of the command returned with an error
* 12 - command line and command syntax was OK but mapping of the parameter for command execution failed
* 16 - command line was OK but command syntax was wrong (error from command line parser)
* 20 - command string was wrong (please use built-in function "SYNTAX" for more information)
* 24 - initialization of the parameter structure for the command failed (may not happened)
* 28 - configuration is wrong (determination of configuration data failed, configuration file might be damaged)
* 32 - table error (something within the predefined tables is wrong (internal error))
* 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 (only at call of subprogram interface))
* 48 - memory allocation failed (e.g. dynamic string handling)
* 64 - fatal error (basic things are damaged)
* >64 - special condition codes from the command for job control
 
The command line is interpreted by CLE the command string by CLP. For example:
 
------------------------------------------------------------------------

 :> flcl conv "read.file='test.txt' write.flam(file='test.adc')"
    |    |     |-- the command string is compiled by CLP
    |    |     |   and might result in a syntax error
    |    |-- conv is part of the command line
    |-- flcl is part of the command line
 
 :> flcl conv=para.txt
    |    |    |-- para.txt is part of the command line, but the content
    |    |        of para.txt might contain a CLP syntax error
    |    |-- conv is part of the command line
    |-- flcl is part of the command line
    
------------------------------------------------------------------------
 
A command execution (run) will return 0 or 1 on success, 4 if a warning
occurs (only some of the files converted), 8 in case of an error or
special condition codes greater then 64 can be returned.

If the command execution was successful (return code 0) but a relevant
warnings was logged then the return code is 1 (anything was fine, but
please have a look in the log (e.g. a key is close to expire)). A return
code of 2 indicates that a call to the finish function failed. Such a
fail of the finish function is not recognizable if the run function
(command execution) returns with a warning or an error. On the other
side, if the finish failed then an additional warning in the log cannot
determined because the condition code is still 2. All completion codes
bigger than 8 and smaller or equal to 64 indicate an error in front of
the command execution.

A relevant warning is a warning written to the log by a used component.
Warnings written by components which are removed from procession because
the format does not fit or something else, are still in the log but not
relevant for the completion code 1.


[[CLEP.APPENDIX.REASONCODES]]
=== Appendix D.1. Reasoncodes

Below you can find the list of reason codes returned after command
execution. Each command returns a reason code for the corresponding
warning (return code 4) or error (return code 8). This content is
printed on the screen with the built-in function
<<CLEP.BUILTIN.ERRORS,ERRORS>>.


* 1 - Fatal error (may not happen)
* 2 - System error (wrong size of data types)
* 3 - Handle error (not in right shape)
* 4 - Interface error (parameter incorrect)
* 5 - Activity not possible
* 6 - Memory allocation failed (not enough memory)
* 7 - Length error (need more data at read or more space at write)
* 8 - Control code wrong
* 9 - Version not supported
* 10 - Function not supported
* 11 - Mode not supported
* 12 - Suite not supported
* 13 - Confidentiality mode not supported
* 14 - Integrity mode not supported
* 15 - Verification mode not supported
* 16 - Wrong header checksum
* 17 - Wrong pot checksum
* 18 - Wrong data checksum
* 19 - Wrong checksum
* 20 - Wrong message authentication code (MAC)
* 21 - Wrong key test value
* 22 - Syntax error (file not formatted correctly)
* 23 - Count error (supplied or calculated amount wrong)
* 24 - End of list (handle points behind last or first element)
* 25 - Delete of file failed
* 26 - Type error (supplied or calculated type wrong)
* 27 - Rebuild required (flush not possible)
* 28 - No change (informational)
* 29 - Status error (handle not in right state)
* 30 - Orientation not supported
* 31 - Split method not supported
* 32 - Maximum delimiter amount achieved
* 33 - Error at compression
* 34 - Error at decompression
* 35 - Maximum header length achieved
* 36 - Maximum data length achieved
* 37 - Open of FLAMFILE failed
* 38 - Record format not supported
* 39 - Writing to file failed
* 40 - Reading from file failed
* 41 - Get position of file pointer failed
* 42 - Set position of file pointer failed
* 43 - End of file (informational)
* 44 - Rename of FLAMFILE failed
* 45 - Delete of FLAMFILE failed
* 46 - Close of FLAMFILE failed
* 47 - Seek in file does not work
* 48 - Set of buffer size for FIO failed
* 49 - FLAMFILE format not supported
* 50 - No FLAMFILE
* 51 - No entry found
* 52 - Construct is empty
* 53 - Connection error
* 54 - Unsupported FLAM-ID
* 55 - Remote procedure call failed
* 56 - Method not supported
* 57 - Open of original file failed
* 58 - Error from ZLIB (GZIP)
* 59 - Character set not supported
* 60 - Space too small
* 61 - Logging facility not available
* 62 - Error from character conversion module
* 63 - Open of hash output file failed
* 64 - Close of original file failed
* 65 - Error with FKME
* 66 - Error at character conversion
* 67 - Info not supported
* 68 - Band not supported
* 69 - Open of report file failed
* 70 - Size error (supplied or calculated size wrong)
* 71 - Invalid character encountered
* 72 - Incomplete character encountered
* 73 - Error with byte order mark (BOM)
* 74 - Format wrong or not supported
* 75 - Auto conversion not possible
* 76 - Error from BZIP2 library
* 77 - Environment variable are not or cannot be defined
* 78 - Dynamic load of a function failed
* 79 - Access control or license violation
* 80 - Compression limit not reached
* 81 - Error from LZMA/XZ library
* 82 - Error from XML parser (EXPAT)
* 83 - Whole first block is padding
* 84 - Command line parser failed
* 85 - Mapping failed
* 86 - Open of temporary file failed
* 87 - Wrong magic bytes
* 88 - Corrupted or no FLAMFILE
* 89 - Initialization error
* 90 - Parameter not formatted correctly
* 91 - Binary data detected
* 92 - From and to are equal
* 93 - Data is encrypted (key required)
* 94 - Key value wrong
* 95 - Reallocation required
* 96 - Invalid username
* 97 - Authentication failed
* 98 - Hash calculation failed
* 99 - Processing of one or more files failed
* 100 - Hash/checksum file is empty
* 101 - Read of hash/checksum file failed
* 102 - Name of hash/checksum file is not valid
* 103 - Hash/checksum file is not formatted correctly
* 104 - Open of code table failed
* 105 - Code table is not formatted correctly
* 106 - Attribute settings not supported
* 107 - Option wrong or not supported
* 108 - Invalid parameter combination
* 109 - Open of info file failed
* 110 - Protocol wrong or not supported
* 111 - Differences found
* 112 - Try again with an ASCII code page (LATIN1) for read
* 113 - Data incomplete
* 114 - Procedure not supported
* 115 - Key not found
* 116 - OpenPGP error
* 117 - Algorithm not supported
* 118 - Key is inactive
* 119 - Key is invalid
* 120 - Key is expired
* 121 - Positioning failed
* 122 - Sequence error, incorrect order
* 123 - Update not possible
* 124 - Regular expression error
* 125 - Value out of range
* 126 - Usage measurement not possible
* 127 - Dummy processing not possible
* 128 - Open of inverse file failed
* 129 - Internal error (may not happen)
* 130 - Micro Focus support failed
* 131 - Dynamic string library error
* 132 - Open of usage log failed
* 133 - Serialization failed
* 134 - Deserialization failed
* 135 - Program call (PC) failed
* 136 - Row specification wrong
* 137 - Record delimiter not supported
* 138 - End of table (informational)
* 139 - End of member (informational)
* 140 - Have more data (informational)
* 141 - Alignment error
* 142 - Not enough space available (internal buffer too small)
* 143 - Plausibility error
* 144 - Unexpected remaining rest (data don't fit within processing)
* 145 - Length parameter too small (the resulting space is not sufficient)
* 146 - Virus found
* 147 - Connection was closed
* 148 - Error from anti virus scanner
* 149 - Authorization failed
* 150 - Command execution failed

[[CLEP.APPENDIX.VERSION]]
== Appendix E. Version

Here you can see the version of the program and its components.
This content is printed on the screen if the built-in function
<<CLEP.BUILTIN.VERSION,VERSION>> is used.


------------------------------------------------------------------------
00 FLIES-SEVER VERSION: 5.1.21-26794 BUILD: RELEASE Jan  3 2020 19:55:24
------------------------------------------------------------------------

[[CLEP.APPENDIX.ABOUT]]
== Appendix F. About

This is the about information for the program (flssrv). Its content
is printed on the screen if the built-in function <<CLEP.BUILTIN.ABOUT,ABOUT>>
is used.


------------------------------------------------------------------------
00 Frankenstein Limes Integrated Extended Security Server (FLIES(R) Server)
01 FLIES-SEVER VERSION: 5.1.21-26794 BUILD: RELEASE Jan  3 2020 19:55:24
   Copyright (C) limes datentechnik (R) gmbh
   All rights reserved
The FLIES(R) server is a convenient method to access a remote FLAMARCHIVE.
On LINUX systems we use additionally the glibc as part of the operating system
   FLIES(R) server is a work that uses the library glibc in unmodified form based on the LGPL license
   Copyright (C) 1991-2012 Free Software Foundation, Inc.
   More information to this license you can find under:
      http://www.fsf.org/
      http://www.gnu.org/licenses/lgpl-3.0.txt
------------------------------------------------------------------------

[glossary]
== Glossary

:ADC: Abbreviation for Advanced Data Compression, which is the default
   compression algorithm of FLAM4.
:AES: The Advanced Encryption Standard (AES) is a symmetric crypto system,
   the successor of DES and 3DES. It uses the Rijndael algorithm
   with a fixed block size of 128 bits and a variable key length of 128,
   192 or 256 bits, providing a high grade of security.
:ASCII: The American Standard Code for Information Interchange (ASCII) is a
   7-Bit encoding, which is the source for later character sets
   based on more bits.
:AVS: Anti virus scanning
:BAS: Abbreviation for base encoding.
:BCS: Banking Communication Standard. +
   Specification for remote data transmission between customers and
   credit institutions. The BCS is used, for example, in cash management
   systems to enable multi-bank capability, i.e. the processing of data
   from different credit institutions with software.
:BIG ENDIAN: Endianness refers to the term byte order. A big-endian machine stores
   the most significant byte first, i.e. at the lowest byte address.
   This behavior is most important when two computers with different
   byte orders communicate with each other. The big-endian format is
   used by Motorola 6800 and 68k, Xilinx Microblaze, IBM POWER,
   System/360, System/370, ESA/390, z/Architecture and PDP-10.
:BIN: Abbreviation for binary.
:BOM: The Byte Order Mark (BOM) characterizes in which order the bytes
   are interpreted. This is important when exchanging data between
   different systems. For UTF-16 and UTF-32 a BOM sign at the beginning
   of the data stream is necessary, as more than one byte is used for
   the encoding of one character. UTF-8 uses the BOM sign "EF BB BF",
   which is used to mark a text file as UTF-8, even though byte order
   is not issue here.
:BOMUTF: With this option of the FLCL, you can determine the correct UTF CCSID
   from the byte order mark (BOM).
:BOMUCS: With this option of the FLCL, you can determine the correct UCS CCSID
   from the byte order mark (BOM).
:BYTE ORDER: The byte order is the order in which bytes are interpreted for
   entities that consist of multiple bytes, e.g. Unicode characters.
   This is important when exchanging data between different systems.
   A big-endian machine stores the most significant byte first, i.e. at
   the lowest byte address. A little-endian machine, however, stores the
   least significant byte first.
:BZ2: Abbreviation for BZIP2.
:CANONICAL EQUIVALENCE: Canonical equivalence is a fundamental equivalence between
   individual Unicode characters and sequences of Unicode
   characters.
:CASEMETHOD: FLCL offers a method for converting unicode characters to uppercase,
   lowercase or some special representation (CASE=UPPER/LOWER).
:CCSID: This is an abbreviation used by IBM for "Coded Character Set
   Identifier". The encoding of a specific code page is
   referred to by a 16-bit number.
   see also: https://en.wikipedia.org/wiki/CCSID[CCSID]
:CHAR: Abbreviation for the conversion of character streams.
:CHR: Abbreviation for character
:CLAMD: Clam Anti Virus Daemon
:CNV: Abbreviation for conversion. Collects all conversion
   components which transform data stream in data stream (e.g. character
   conversion, compression, de/encryption, de/encoding, ...).
:CODEPAGE: IBM introduced a numbering scheme to character encodings (16 bits).
   This scheme was taken over by other vendors like Microsoft, SAP or
   Oracle Corporation. The term Codepage is used synonymously for
   character encoding or character set.
:CODE POINT: A code point or code position is a single character in a list of
   characters represented as numerical values that create the code
   space. The Unicode code space has a total size of 17 * 65536 code
   points. The same code space may have several codepages.
:COMPATIBILITY EQUIVALENCE: One speaks of compatibility equivalence of two sets of characters
   if their full compatibility decompositions are identical.
:CONV: The sub-program FLUC offers all possible conversion and formatting
   methods via the CONV command. These are various read and write
   procedures, many useful conversion tools and some special data
   formatting features.
:CNV: Conversion component
:CRY: Abbreviation for crypto(graphy).
:CX7: Compression encoding as printable characters in FLAM4
:CX8: Compression encoding as binary data in FLAM4
:DAT: Abbreviation for data.
:DIACRITIC: A diacritic is also called diacritical mark, diacritical point or
   diacritical sign. Typical diacritical marks are the acute (´) and
   grave (`), which are often called accents. Diacritical marks may be
   a dash, dot or tick above or below a letter, or in some other
   position such as within the letter or between two letters.
:DIR: Abbreviation for directory (walk).
:EBCDIC: The Extended Binary Coded Decimals Interchange Code (EBCDIC) was
   developed by IBM as 8-Bit-encoding, which, however, does not use all
   code words. EBCDIC originates from the older 4-Bit-Code BCD (Binary
   Coded Decimals) and is applied solely on Mainframes. The EBCDIC
   codepages are available in German, US, Swedish, Arabian, Latin-1 and
   other languages. Moreover, there exists a Unicode set of characters
   based on EBCDIC and it is called UTF-EBCDIC.
:BLK: Abbreviation for block.
:ENV: Abbreviation for environment.
:FINGERPRINT: In public-key cryptography, a public key fingerprint is a short
   sequence of bytes used to identify a longer public key. Fingerprints
   are created by applying a cryptographic hash function to a public
   key. Since fingerprints are shorter than the keys they refer to, they
   can be used to simplify certain key management tasks. +
   see also: https://en.wikipedia.org/wiki/Public_key_fingerprint/[Public key fingerprint]
:FIO: Abbreviation for File I/O. All components to read or write files.
   The C programming language has a general mechanism for reading and
   writing files abstracting all Input/Output to streams of bytes.
   The operating system offers redirection which can be very useful.
   Examples are the standard input stream, standard output stream
   and standard error stream.
:FKME: FLAM Key Management Exit/Extension
   Service provider interface to connect FLAM till version 4 with
   different kinds of cryptographic infrastructure, hardware security
   modules and/or key management systems.
:FL4: Abbreviation for FLAM in Version 4 or lower.
:FL5: Abbreviation for FLAM in Version 5.
:FLAM: Frankenstein Limes Access Method. FLAM is our access method for
   encrypted and compressed data. In particular, FLAM is a utility for
   converting, compressing, encrypting (with AES (Advanced Encryption
   Standard)), signing and formatting of mass data with simple
   interfaces for integration in all kinds of solutions. All this is
   done with a minimum of CPU consumption, utilization of co-processors
   and the use of professional key management solutions. Ordinarily,
   FLAM provides - when used as sub-program - the commands COMP and DECO
   and makes use of an element interface for the
   subsystems/plugins/drivers and also the sub-program.
:FLAM4: This component writes a Flamfile record-oriented. You can state the
   name of a Flamfile or that of a member.
:FLAMFILE: The FLAMFILE is composed like a package file, as multiple files can
   be compressed. It is structured clearly and divided hierarchically
   in records, segments and members. In this connection a segment is
   referred to the single matrix of a compressed file and a member to
   the entity of segments that are part of the compressed file. In
   order to ensure the universal exchangeability, the FLAMFILE has to
   be available in a format that is representable on all operating
   systems (so-called heterogeneous compatibility). Each compressed
   data segment is unique referring to data content, environment and
   time. This allows - despite compression/encryption - an access down
   to the record-level, without decompressing/decrypting.
:FLCC: Frankenstein Limes Control Center (GUI).In contrast to FLCL this is
   the graphical user interface for running FLAM, FLUC and FLIES, quasi
   a dialogue utility
:FLCL: Frankenstein Limes Command Line. FLCL offers a command line for
   the three sub-programs FLAM, FLUC and FLIES. It is a quasi-batch
   utility for the sub-programs. Moreover, FLCL is a universal data
   format and character set converter, which can be included easily
   in professional internationalization projects. It supports
   different input and output formats (GZIP, PDF, B64...) and
   can be integrated into scripts or as sub-program. More than
   150 codepages are supported. FLCL can be applied to various
   commonly used platforms if working with processable data streams or
   file I/O.
:FLIES: Frankenstein Limes Integrated Extended Security. The sub-program
   FLIES governs the compressed and encrypted segments using commands
   like FIND and CHNGE. In particular, it is useful for processing
   Flamfiles, which however cannot be decrypted or decompressed. For
   instance the data in the file header is managed by FLIES to
   re-encrypt the file, change the data access, use as backup,
   archive or as mediator/headend.
:FLUC: Frankenstein Limes Universal Converter. FLUC is a universal text
   converter with special focus on the high requirements in
   professional internationalization projects, where Mainframes and
   external applications are used as central backend.
:FLUCUP: FLUC Subprogram as C interface (DLL) for Data source to target
    conversion.
:FMT: Abbreviation for formatting.
   All components to parse a data stream in FLAM5 element list or build
   a data stream from FLAM5 elements list.
:FROM-CODE: The FROM-Code specifies the character encoding of the input data that
   used as source encoding for character conversion.
:GZIP: GZIP is a compression program for nearly every operation system and
   uses the DEFLATE algorithm from the ZLIB library. GZIP is the short
   form for GNU zip. The used algorithm is a combination of LZ77 and
   Huffmann encoding. The source code is licensed under the GPL. The
   program has 9 compression steps providing either optimal CPU time
   or compression ratios. The compressed file has the ending ".gz".
   As GZIP compresses only single files. Several files must first be
   combined with (for example) "tar" to a tarball which can then be
   compressed to a ".tar.gz" file. GZIP files have a 10-byte header,
   containing a magic number, a version number and a timestamp. With
   FLCL you are able to read and write GZIP files, to mark content as
   text data in the header, set operating/file system or modified time
   (seconds since 1970).
:GZP: Abbreviation for GZIP.
:HOST: see MAINFRAME
:HSH: Abbreviation for hash (checksum)
:ICNV: Abbreviation for iconv conversion with simplified
   commands on the command line.
:ICONV: With the standard program iconv, characters can be translated between
   different encodings on UNIX-like systems. As iconv is now part of
   the GNU C Library, actual Linux systems are equipped with iconv.
   Under Windows(R), iconv is provided only as DLL or static library,
   which is under the license of the GPL and can be used via Cygwin or
   GnuWin32. Iconv is also supported as Dynamic Link Library for PHP.
:ID: Abbreviation for identifier.
:ISO-8859: The ISO-8859 norm family contains some useful 8-bit character sets
   (e.g. Latin-1 to Latin-15). The frequently used Latin-1 character
   set is identical with the first 256 characters of the Unicode
   character set. These codepages are also called extended Ascii.
:LITTLE ENDIAN: A little-endian machine stores the least significant byte first.
   The endianness of a 16, 32 or 64 bits word or even bits can occur
   in some Unicode representations. Also mixed forms of endianness are
   possible, for example when the byte order within a 16 bits word
   differs from that of a 16 bits word within a 32 bits word.
   The little-endian format is used by x86 (including x86-64), 6502
   (including 65802, 65C816), Z80 (including Z180, eZ80 etc.), MCS-48,
   8051, DEC Alpha, Altera Nios II, Atmel AVR, SuperH, VAX, and PDP-11.
:LOGGING: In FLCL various messages (warnings, errors, debug information,
   important information, input data) can be logged. The messages
   can be redirected from stderr to stdout or a file.
:LXZ: Abbreviation for LZMA XZ.
:MAINFRAME: A mainframe is a very complex and powerful computer system. Its
   capacity is far beyond that of a common Personal Computer and
   that of most servers. They are applied for the highly reliable
   processing of mass data, mass transactions and company critical
   data and gain importance again in connection with server
   consolidation and cloud computing.
:MODE: With the keyword MODE in FLCL you can select the mode of operation.
:NDC: Abbreviation for No Data Compression, which can be considered as
   copying data in FLAM4.
:NFC: This is Normalization Form C (Canonical Decomposition, followed by
   Canonical Composition).
:NFD: This is Normalization Form D (Canonical Decomposition).
:NFKC: This is Normalization Form KC (Compatibility Decomposition, followed
   by Canonical Composition).
:NFKD: This is Normalization Form KD (Compatibility Decomposition).
:Normalization: The transformation of a character sequence in one of the four normal
   forms is called normalization. Normalization is necessary, because
   there is more than one differing possibility for many characters to
   be represented as a sequence of Unicode characters. The four normal
   forms consist of one form for the canonical equivalence, one for the
   compatible equivalence, and both can be in a "composed" or
   "decomposed" form.
:OS: Abbreviation for operation/file system in the header
:PADDING: Padding are bytes inserted to align the data to certain lengths or
   storage positions. Padding bytes are most commonly appended after the
   the last data byte. When reading padded data, the padding bytes are
   discarded.
:PDS: Partitioned data set. A PDSE consists of a directory and
   zero or more members,
:PDSE: Partitioned data set extended. Exactly same as PDS in many respects.
   PDSE data sets can be stored only on DASD, not on tape. Interesting
   thing is the directory can expand automatically  as needed.
   Additionally it has an index which helps to locate the members inside
   the PDSE faster. SPACE from deleted members are automatically reused
   in PDSE .
:PGP: Abbreviation for pretty good privacy (OpenPGP).
:PLATFORM NEUTRAL: The components of FLAM are platform neutral. This means that they
   work independently from the used operating system. Operating systems
   can be for example LINUX, UNIX-like systems, WINDOWS(R) or z/OS(R).
:PO: Data set organisation partitioned organized.
:PS: Data set physical sequential file.
:REC: Abbreviation for record.
:SEPA: The Single Euro Payments Area (SEPA) is a project to harmonize
   the way retail payments are made and processed in Euro. The
   motivation behind it is to make payments in Euro and across the EU
   as fast, safe and efficient as national payments are now. SEPA
   shall enable customers to make cashless Euro payments to anyone in
   the EU, for instance by credit transfer, direct debit or debit card. +
   see also: https://en.wikipedia.org/wiki/Single_Euro_Payments_Area/[SEPA]
:SIG: Abbreviation for signature
:SSH: Secure shell +
   see also: https://en.wikipedia.org/wiki/Secure_Shell/[SSH]
:SUB CHARSET: A Sub Charset is a partial quantity of a character set. For instance
   the new identity card issued in Germany (nPa) requires that each
   printed character - even the diacritical characters - is "composed".
   It means that they remain in their original form and are not
   "decomposed" into several bytes. For that reason, the Sub Charset
   "Latin in Unicodes" with some more than 500 letters is used.
:SUBCHR: FLCL can substitute characters that are unsupported in their target
   encoding by system specific characters (e.g. 0x1A for ASCII or 0x3F
   for EBCDIC pages) or by arbitrary characters. In the first case, you
   must use SUBCHR=SYSTEM, in the other you can define your own
   substitution characters. On z/OS(R), the utility iconv is available
   on the system and replaces all invalid characters by system specific
   characters, including the BOM sign. Note that it does not stop in
   contrast to LINUX or WINDOWS(R) but completes conversion.
:SUBSTITUTE: If a character exists in the source code but not in the target code,
   it will be converted to a converter-defined substitute character.
:SURROGATE: The Unicode code space is divided into 17 planes of 65536 code points
   each. Some code points have no character value, some are reserved for
   private use, and some are permanently reserved as non-characters.
   UTF-16 with code points beyond these planes is encoded in 16 bit
   surrogate pairs (High surrogate and low surrogate), which are in fact
   replacement characters. UTF-16 surrogate values are illegal in
   UTF-32. Note that the conversion of UTF-16 strings into UTF-8 byte
   sequences requires that the High and Low surrogate have to be
   combined correctly before they are transfered into UTF-8.
:SYSTEM TABLE: FLCL makes use of a pre-loaded system substitution table for
   the transliteration of characters. This is comparable to
   "translit.h" of iconv under LINUX.
:TAB: Abbreviation for table.
:TAR: Tape Archiver; Short for Tape Archive, and sometimes referred to as
   tarball, a file that has the TAR file extension is a file in the
   Consolidated Unix Archive format. A program or command that can open
   archives is needed to open a TAR file.
   Because the TAR file format is used to store multiple files in one
   single file, it's a popular method for both archiving purposes and
   for sending multiple files over the internet, like for software
   downloads.
   The TAR file format is common in Linux and Unix systems, but only for
   storing data, not compressing it. TAR files are often compressed
   after being created, but those become TGZ files, using the TGZ,
   TAR.GZ, or GZ extension.
:TARGET: Trans-European Automated Real-time Gross Settlement Express Transfer
   System. +
   see also: https://www.ecb.europa.eu/paym/target/target2/html/index.en.html/[TARGET]
:TXT: Abbreviation for text.
:TO-CODE: With few utilities you can convert text from one encoding to
   another. The TO-Code specifies the output encoding that characters
   are converted to.
:TRANSCRIPTION: To transcribe the expression of a language means by dictionary,
   to represent it in another writing system rather in that, in which
   the language is usually written respectively in which it is
   available in written form. For the term of transcription it does not
   matter, in which medium the expression is available. Note that the
   transliteration of an expression is a particular type of
   transcription.
:TRANSLATION: This is the transfer of a (mostly written) and fixed text from the
   original language into any target language; the process will be also
   denoted as "Translating".
:TRANSLITERATION: To transliterate an expression represented in writing S1 into a
   writing system S2 means, that the characters contained in the
   expression are exchanged from S1 to S2 according to a fixed rule. In
   the simplest case, this can be a table which assigns each character
   of S1 a character of S2. Frequently, there are complications for the
   simple case, if for example a single character is assigned to a
   digraph or vice versa or if a character is mapped in context A onto
   a specific character, in context B however onto another character.
   For example: in a payment order from Germany, the name of the
   receiver must be written explicitly in Latin letters so that a
   transliteration of the original text with help of a table is
   required.
:UNICODE: The so-called Unicode is an attempt, started in the 90s, to
   standardize a single character set that eliminates the need for
   different and incompatible encodings in different countries and
   cultures. The text should be always readable with a
   Unicode-supporting appropriate editor. This allows an error
   free data exchange (for the purpose of readability) also on a global
   and international level. For this character set, 8 bits (1 byte) are
   no longer sufficient to for a representation of every possible
   character. The length of characters encoded in Unicode can be between
   1 and 4 bytes. ISO 10646 is a practically equal notation of the
   Unicode character set called Universal Character Set (UCS).
:URL: Uniform Resource Locator +
   see also: https://en.wikipedia.org/wiki/URL/[URL]
:USER TABLE: For character set conversion in FLCL you can define your own user
   substitution table to transliterate those characters that are not
   handled respectively replaced by the system table.
:UTF-8: The 8-Bit Unicode Transformation Format is the most commonly used
   encoding for Unicode characters. The term Unicode is used equivalent
   to UCS. UTF-8 has a central meaning in the global character
   conversion for internet protocols.
:UTF-16: In UTF-16 an encoded byte sequence with a length of 2 bytes is
   assigned to each Unicode character. UTF-16 is used in Java for
   internal character sequence representation. UTF-16 is the eldest
   format of the Unicodes.
:UTF-32: UTF-32 (UCS-4) is encoded with 4 bytes and therefore the most simple
   Unicode representation, as other formats need variable byte lengths
   for their representation. One disadvantage of UTF-32 is the greater
   space requirement compared to UTF-8 and ISO-8859 character sets and
   the missing backward compatibility to ASCII.#
:VSAM: Virtual Storage Access Method +
   see also: https://www.ibm.com/support/knowledgecenter/zosbasics/com.ibm.zos.zconcepts/zconcepts_169.htm/[VSAM]
:VR8: Enhanced compression encoding as binary data in FLAM4
:ZIP: ZIP is an archive file format that supports lossless data compression.


[colophon]
== Imprint

-----------------------------------------------------------------------
limes datentechnik(R) gmbh
Louisenstrasse 101
D-61348 Bad Homburg v.d.H.
phone: +49(0)6172-5919-0
fax:   +49(0)6172-5919-39
mail:  info@flam.de
web:   www.flam.de or www.limes.de
Amtsgericht: Bad Homburg vor der Hoehe HRB 3288 (gegr. 1985)
Geschaeftsfuehrer: Diplom-Mathematiker Heinz-Ulrich Wiebach
limes datentechnik(R): efficiency at the limit of possibility.
-----------------------------------------------------------------------


