SEARCH_DATA.data.push([
[
"flcl_manual_5756.html",
"FLCL Manual",
"= FLCL Manual This document provides information about using the Frankenstein Limes Command Line (FLCL(R)). It contains guidelines and information about how to run the commands provided by FLAM(R). FLCL is the main utility to use FLAM in batch jobs or scripts. The most interesting part of this documentation for the day-to-day use is probably the <<flcl.commands,FLCL command reference>>. Basic topics like installation, environment, filename and directory handling, input to output name mapping, pre- and post-processing, as well as tables are described in the chapter <<flcl.utility,FLCL utility>>. Several APIs are available to use FLAM in own applications written in various languages (e.g. C, C++, Java, PL1 and Cobol). They allow your application to use FLAM for file-to-file, file-to-memory, memory-to-file and in-memory conversions (enterprise service bus). Some of these APIs require additional strings which are described in a <<flcl.api.strings,dedicated chapter>>. On Linux, <<flcl.appendix.flucfs,flucFS>> can be used. It is a FUSE filesystem that can be mounted to any directory. Everything written to the mounted folder is transparently converted, encrypted and/or compressed as defined in the configuration. Multiple conversions can be configured for the same mountpoint. On z/OS, the <<flcl.appendix.flucsub,FLUC subsystem>> (FLUC-sub) is available. It is a subsystem of the z/OS operating system and is activated by the subsystem interface of the command language (JCL). All calls of an application to file operations (e.g. opening, closing a file, reading and writing) are received and processed by FLUC-sub. Thus, FLUC-sub allows data conversions that are transparent to the application. The FLCL is based on the FLAMCLE and FLAMCLP (CLE/P(R)) which is an open source component for parsing, processing and executing command strings. It also handles various other aspects of commands, including configuration management (via property files and environment variables) and documentation. More details can be found in the <<clep.main,respective chapter>> and the <<CLEP.BUILTIN.FUNCTIONS,built-in function>> reference. <<CLEP.APPENDIX.LEXEMES,Lexemes>> and <<CLEP.APPENDIX.GRAMMAR,grammar>>, which comprise the command strings' syntax, as well as <<CLEP.APPENDIX.PROPERTIES,properties>> and <<CLEP.APPENDIX.RETURNCODES,return codes>> are addressed in this manual. Copyright (C) limes datentechnik (R) gmbh + All rights reserved ",
"",
""
],
[
"flcl_manual-preface_afc7.html",
"Preface",
"[preface] == Preface FLCL is based on 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 the <<CLEP.BUILTIN.FUNCTIONS,built-in functions>> used 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 can by generated with the built-in functions GENDOCU or HTMLDOC provided by CLE/P library by calling the command below: To generate HTML documentation yourself instead of using the pre-built documentation, a service provider DLL must be available. The text file can be fed to Asciidoctor to build a PDF and/or an HTML5 document. ",
"",
""
],
[
"flcl_manual-preface-trademarks_3e5e.html",
"Trademarks",
"=== 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 * FKMS(R)      - Frankenstein Key Management System * FKME(R)      - Frankenstein Key Management Extension/Exit * FLAMFILE(R)  - A file based on FLAM syntax * CLE/P(R)     - Command line Executer/Parser ",
"",
""
],
[
"flcl_manual-preface-license_terms_ec52.html",
"License Terms",
"=== License Terms The license terms for all software components owned by limes datentechnik gmbh(R) can be found in LICENSE(.txt) in the installation folder doc/txt or in the partitioned dataset HLQ.FLAM.DOCTXT. Additional license information for external libraries used by this software can be found in ABOUT(.txt). The replacement of external libraries (LGPL) is described following the changelog in the file README(.txt). All license terms of the external libraries are included as files (LICxxxxx(.txt)) in doc/txt folder or in HLQ.FLAM.DOCTXT partitioned dataset. All old FLAM components till version 4 are completely owned by limes datentechnik gmbh (R). Only on Linux systems the glibc is used in unmodified form as prerequisite (part of the operating system, not part of the distribution) based on the LGPL license. The old FLAM4 components don't provide additional about and version commands or functions. The service provider interfaces (exits, extensions) of FLAM are owned completely by limes datantechnik gmbh(R) and provided to our users for individual extension to this software. The driver is conforming to this license terms but LIMES(R) is not responsible for such individual implementations which are not part of our distributen. Our own implementations against these SPIs (e.g. FAVECAV, PKCS#11, IBM-CCA/ICSF) are in sync with the stated license terms here. A lot of this information is generated in the package build process and can be requested over the corresponding built-in commands of our utilities or the corresponding functions of the APIs. To request the current valid state, please use the command or functions below (there are more APIs with analog functions available): The about and version information are also added as appendix to the manual's provided by limes datentechnik gmbh(R). The version information contains version, release and revision number of each component followed by the current build number. The versioning of the different components is independent of each other. The build number must be the same for each component and must correspond to the build number of the installation package. If the build number is not identical for all compiled and linked components, then the installation is wrong.  ",
"",
""
],
[
"flcl_manual-preface-about_limes_0771.html",
"About Limes",
"=== About Limes Since 1985, limes datentechnik(R) gmbh has been successfully producing quality software that simplifies data exchange across platforms and across borders (formatting, converting), secures data archiving and transmitting (encrypting, signature) while reducing storage use (compressing), and, finally, allows accessing data without depending on particular platforms or data formats (access method). * Professional management of compressed and encrypted data including   strong access control * Secure data storage (archive) and data transfer * Protection of data privacy, integrity, and completeness * Cutting-edge security technologies for handling of sensitive data   being outsourced, securing clouds etc. * Meeting safety requirements such as 'need-to-know', PCIDSS, etc. * Easy data exchange across borders, platforms, and formats (with regard   to internationalization moves, when migrating, etc.) * Saving of time and money through automation options and reduced   resource utilization (CPU, memory, external storage) * Converting, compressing, encrypting, and signing of data * Reading and writing methods for various data and file formats * Transforming data into a neutral internal format (FLAMFILE(R)) that   allows searching and positioning within encrypted and compressed data * Storage of data in various formats (file, cluster, VSAM, database) * Separating data compression and encryption (client) from data storage (server) * Neutral access to individual data records, data elements, or bytes via various APIs * Connecting solutions to any cryptographic infrastructure with access   control via key-management including periodic or adhoc re-keying * Unrestricted extendibility and adaptability through customer-APIs for   Cobol/PL1, c/C++ and Java (other programming languages on request) * Transparent integration as I/O subsystem, user space file system, ISP,   driver or by incorporating as a subroutine * Scripting, backup, restart and stream capability for switching to automated operation * Programming in ANSI-C and assembler utilizing hardware accelerators   and special instructions of the various platforms * Beside decades of experience with cross-platform and cross-border data   exchange, limes datentechnik(R) stands for protection of your investment   and for lasting reliability due to the uncompromising downwards   compatibility of its products and the friendly customer care provided   as part of its support services. * limes datentechnik(R) not only offers solutions for bulk data handling   in the mainframe environment, it also supports all current platforms   and systems for migrating and long-term archiving. * For more than 30 years limes datentechnik(R), located in Bad Homburg,   Germany, has been providing resilient, error-free, high-quality   software meeting professional standards - guaranteed 'Made in Germany'. ",
"",
""
],
[
"flcl_manual-preface-overview_b2c9.html",
"Overview",
"=== Overview This document provides information about using the Frankenstein Limes Command Line (FLCL). It contains advanced guidelines and information to run the commands provided by this batch interface. FLCL is the main utility to run all the different subprograms of the FL5 infrastructure. Beside FLCL, the FL5 infrastructure consists of the components below: * FLCC - Frankenstein Limes Control Center (GUI) ** Graphical user interface to build FLCL commands, property files and more ** It is also useful to construct parameter strings for FLAM's APIs ** Interactive help and documentations, can be used as replacement for this book * FLUC - Subsystem for z/OS and Linux ** Application-transparent conversion, compression and encryption of files ** Can be used to make applications compliant to several security standards ** Implemented on z/OS as I/O-Subsystem and on Unix as user space file system ** Gives you complete control over the encrypted file ** One logical file can be written to multiple (local and/or remote) targets *** Note: Only one of these files can be read via this logical file view ** Supports remote files via SSH and different archives formats * FLUCUP - FLUC Subprogram as C interface (DLL) ** Data source to target conversion as described in this document ** Each command is available as function (flucconv()) ** FLCL command line = parameter string for subprogram ** `ret=flucinfo('get.file=test.txt');` * FLUCUPLB - FLUC Subprogram as load module interface ** All functions of FLUCUP (flucconv) are provided as load modules for    simple integration in COBOL, PL1 or assembler programs on mainframes. ** `FCUCONV('read.file=DD:INPUT')` * FLCBYT - Byte interface for original data (C like DLL) ** You can transparently read and write each kind of data source or    target as byte stream or records with a C like file-I/O interface    using the read or write overlays of the FLCL-CONV/XCNV commands    described in this document. ** `f=fcbopen('read.file=text.txt','format.record()');` ** `f=fcbopen('write.text(file=out.txt comp.bzip())','format.text()');` ** Beside file to memory, memory to memory conversion is also supported *** The memory to memory interface makes FLAM an enterprise service bus (ESB) * FLCBYTBF - C++ streambuf class for I/O streams based on FLCBYT ** You can pass an flcbyt_buffer object to an istream or ostream    instance in C++ and use the byte interface as a regular stream. ** `flcbyt_buffer buf('read.file=text.txt','format.bin()');`    `std::istream in(&buf);` ** `flcbyt_buffer buf('write.text(file=out.txt)','format.text()');`    `std::ostream out(&buf);` * FLCBYTJava - Java Native Interface (JNI) library for the FLUC byte   interface and corresponding stream classes for Java (like FLCBYTBF   for C++) ** This Java-wrapper of the FLCBYT library enables Java developers to    use all FLAM byte interface capabilities in any Java application. It    contains several classes that make working with the byte interface    much more comfortable, for example classes using the stream API or    in-memory conversion classes for different access patterns. * FLCRECLB - Record interface for original data (load modules) ** You can transparently read (GET) and write (PUT) each kind of data    source or target in a record-I/O-like interface also using the read    and write unions of the CONV command or the input and output objects    of the XCNV command in the corresponding file open function. All    functions are provided as separate load module for simple usage in    COBOL, PL1 or assembler programs. ** `FCROPN('read.auto(file=<SYSUID>.VASM.KSDS ccsid=1141)')` ** `FCROPN('write.text(method=win, ccsid=1252, comp.gzip(level=9))')` ** Additionally, you can parse XML datasets, or convert variable    records containing comma-separated values (CSV) into fixed-length    data structures (COPYBOOKs/FB-Records) and use a set of functions to    convert integers, floats, strings and binary blobs from various    representations (e.g. a number as UTF-8 string in an XML element)    into COBOL or PL1 data types (PIC S9(9) COMP). ** In-memory conversion is also supported ** Simple environment, system and JCL variable handling ** Supports Micro Focus EDZ environments ** The interface was designed to work with copybooks (static structures)    in COBOL or PL1 and to produce XML, CSV or other (dynamic) data    formats in clear, compressed and/or encrypted form. * FLCICV - FLUC character conversion module (ICONV like DLL) ** You can transparently use this libiconv-compatible interface for    memory to memory character conversions. It supports all feature of    our character conversion component (CNVCHR), including: *** Stop, ignore, substitution and transliteration for invalid characters *** EBCDIC new line to line feed management *** User table, subset support (SEPA, String.Latin(XOEF/NPA), ...) *** Normalization (NFC/NFD) and combined character support *** UTF-8 with 5 and 6 byte long encodings *** Case mapping, BOM management (including byte order change support) *** Comprehensive reporting of error positions (SUB, IGN, XLT, ...) ** `h=fliconv_open('IBM1141//ENL2LF','UTF-16LE//BOM//IGNORE//TRANSLIT(ICONV)//USRTAB(DELA)//REPORT(DD:REPORT)');` ** `fliconv(h,&indat,&inlen,&outdat,&outlen);` ** `fliconv_close(h);` ** Look for FLICONV utility program and the corresponding sample source This document is also useful for users of the stream, byte, record, element or subprogram interfaces of the FL5 infrastructure because all these interfaces use the same syntax as the command line. The format, conversion and state strings for these APIs are documented in Appendix A 'Other CLP strings' at the end of this book. Various C/C++ sample programs for the APIs above can be found in the library SRCLIBC as part of the installation package for mainframe systems. The corresponding compile and link step is in JOBLIB(SBUILD). Additional COBOL, PL1 and Assembler samples can be found in the library SRCLIB. The corresponding compile and link procedures are also located in JOBLIB(SBUILD) as separate steps. For other platforms (Windows, UNIX) the C, C++ and Java sample program sources are located in the 'sample' directory and the compile and link procedures can be found in the Makefile of the same directory. Beside all these new FL5 based components, the following FLAM4 components are still supported: * FLAM4-Utility - The command line program, also available as command                   FLAM in FLCL or as separated executable FLAM4 with all                   advantages of the new FL5 architecture. * FLAM4-Subprogram - Integration of file to file compression and                      decompression in other programs (works like                      FLUCUP[LB]. For new projects we recommend to use                      the flucflam() or FCUFLAM() functions, the FL5                      project offers also the FLM4UP and flamupc()                      entries which are backward compatible with FLAM4). * FLAM4-Record interface - Record-wise (length and data) read (GET) and                            write (PUT) access to compressed FLAMFILES. * FLAM4-Subsystem (only on z/OS) - Application-transparent integration                                    of FLAM at SVC99 file allocation ** `FILE DD DSN=&SYSUID.TEST,DISP=...,...,SUBSYS=FLAM` With FLAM5 new CLIST, PANELS and MESSAGES were added for ISPF on z/OS: * FLINFO - ISPF line command to show determined file attributes * FLVIEW - ISPF line command to show content of different files **         normal host data sets, members of PDS/PDSE, VSAM data sets **         Directory content of PDS/PDSE, FLAMFILES, GZIP/BZIP/XZ files **         binary transfered XML or text files from other platforms **         base encoded, encrypted, compressed files **         and much more * FLTEXT - ISPF line command like FLVIEW, but it produce dumps for binary files * FLVEDIT- ISPF line command to edit content of different files **         works like FLVIEW, but you can edit the data **         the data is then written back in the original format **         for example you can edit UTF-8 XML data in a GZIP file over ISPF * FLVEDITx - Like FLVEDIT but with limited record length and no cut of records * FLDEL - ISPF line command to delete each kind of file (incl. VSAM) * FLGREP - ISPF command to search for a regular expression pattern in any of            files using the directory walk (FLGREP pattern dsn) * FLHLP - ISPF command for interactive help of FLCL commands * FLSYN - ISPF command for interactive syntax of FLCL commands * FLMAN - ISPF command for interactive manual pages of FLCL commands * FLDOC - ISPF command for documentation generation of FLCL * FLGRA - ISPF command to show grammar of FLCL commands * FLLEX - ISPF command to show lexems of FLCL commands * FLABO - ISPF command to show about information of FLCL * FLVSN - ISPF command to show version information of FLCL * FLLIC - ISPF command to show license information of FLCL * FLSYS - ISPF command to show system information for FLCL Also with FLAM5, GUI tool flgt -c=info/view/edit/checksum were added for use via the Windows context menu. Registering the Windows context menu is performed during installation. * INFO - shows file properties such as file size, file format,   data type, charset, ... * VIEW - displays contents of a file; useful for compressed files or   text data files in a wrong charset; This tool decompresses and/or decodes   selected files and tries to open the result with the default program for   the respective file type. It can also be used for encrypted files, which   requires the appropriate key information to be set in your property file. * EDIT - like flview, but can edit files (default if no command defined) * CHECKSUM - easy way to calculate checksum (CRC/SHA/...) On Unix systems, these utilities are also available on command line. The integration in the context menu of the different desktop systems, must be done manually. On z/OS systems, we support zEDC, zIIP, CPACF, ICSF, RACF, SMF logging and a lot of mainframe-exclusive features. Please read the install.txt for z/OS carefully to set FLAM up correctly to allow it to use such features (e.g the FLAM started task (FLAMSTC), authorization and link list concatenation is often required). ",
"",
""
],
[
"flcl_manual-preface-use_cases_b5d8.html",
"Use Cases",
"=== Use Cases The comments in this file are used in FLCC to populate the use cases dialog. For this to work, each example use case documented here must be preceded by a comment section like the example here: example X title=example for an example entry cmd=conv 'read.auto() write.dummy()           message(erronly)' env=HOME=me env=LANG=de lines starting with a space are considered continuation lines of the previous line. The CLP string must be enclosed in '' when it is containing a quotation character. to work around the automatic content replacement of the file-string format the cmd= string in a comment must use f--string-- instead of: f'string' Below are a few common examples for the use of FLCL. This examples can be loaded in link:../../flcc/index.html[FLCC] from the use case dialog. example 1 title=Display information about a file cmd=INFO GET.FILE='test.zip' Display information for a file on Windows command shell. example 2 title=Show all supported CCSIDs cmd=INFO GET.CCSIDS Show all supported CCSIDs on z/OS using a JCL batch job. example 3 title=Read a FLAMFILE and write it as record-oriented dataset cmd=CONV 'READ.FLAM4(FILE='DD:INPUT') WRITE.RECORD(FILE='DD:OUTPUT')' Read a FLAMFILE and write it as record-oriented dataset on  z/OS. This is the same as FLAM DECO of FLAM4. If you use FLAMFILE/FLAMIN  and FLAMOUT as DD name, then the FILE specifications are not required.  The DD name FLAMIN is the default for input files on z/OS. If FLAMOUT  or FLAMFILE (only if it is a FLAMFILE) not allocated the default DSN  (original name plus extension) is used if no file specification given.  The default on other platforms would be the standard input or output  stream, so you can use this to pipe the data streams. example 4 title=Read a FLAMFILE member and write it character converted as record oriented dataset cmd=CONV 'READ.FLAM4(FILE='~.TEST.ADC' MEMBER=MEMBERNAME CCSID=1252) WRITE.RECORD(FILE=STREAM CCSID=IBM-1141)' Read a member from a FLAMFILE and write it as record oriented dataset on z/OS with character conversion from CP1252 to IBM1141 (same as the job above but with dynamic allocation). Be aware that tilde (abbreviation for '<SYSUID>') is a character with different code points in EBCDIC. The environment variable LANG or the corresponding system variables must be defined to the CCSID used to build the in line control statements so that CLP can interpret this correctly else you can define the CCSID used for this CLP string like in the example above. example 5 title=record-oriented read and write it to two targets at the same time cmd=CONV 'READ.RECORD() WRITE.FLAM(pass=f--PASSFILE--) WRITE.RECORD(encr.pgp(pass=f--PASSFILE--) archive.zip())' env=FLAMIN=DD DSN=&SYSUID..TEST.DAT,DISP=SHR env=FLAMFILE=DD DSN=&SYSUID..TEST.ADC,DISP=NEW env=FLAMOUT=DD DSN=&SYSUID..TEST.ZIP,DISP=NEW Read a record-oriented dataset on z/OS and write it to two targets at the same time.   default DD names FLAMIN and FLAMFILE/FLAMOUT.   file is an encrypted backup of the host dataset containing length fields   in front of each record and all relevant DCBs in the ZIP member header. The password for both instances is specified in a file (which is written inline for better understanding of the example). There is no parameter file assigned to the CONV command. In this case the default DD name 'FLAMPAR' are used. The next example shows how you can reconstruct the stored host dataset from the ZIP archive. The password is defined to use EBCDIC encoding as binary interpretation. With an 'a' you can ensure ASCII but normally we recommend to use 'x' for an hexadecimal string. example 6 title=Read PGP encrypted ZIP archive and reconstruct it with original name and DCB parameter cmd=CONV 'READ.RECORD(decode decr.pgp(pass=f--DD:PASSFILE--)) WRITE.RECORD()' env=FLAMIN=DD DSN=&SYSUID..TEST.ZIP,DISP=SHR Read the PGP encrypted host dataset from the ZIP archive and reconstruct it with the original name and DCB parameter. example 7 title=write a text file as EBCDIC records to a FLAMFILE for a German z/OS. cmd=conv 'read.text(file=test.txt) write.flam(file=test.adc ccsid=1141)' Read a text file on windows and write EBCDIC records to a FLAMFILE for a German z/OS. example 8 title=Read a remote text file and write to a record oriented dataset in EBCDIC(1047) cmd=CONV 'READ.TEXT(FILE=ssh://<cuser>@winserver/test.gz CCSID=1252)           WRITE.RECORD(FILE=<SYSUID>.OUTPUT.DAT CCSID=1047)' Read a remote text file from a windows system (its a GZIP stream in the home directory) and write it on z/OS to a record oriented dataset in EBCDIC(1047). example 9 title=Write record oriented host dataset as UFT8 text to a remote PGP file in a ZIP archive cmd=CONV 'READ.RECORD(FILE=~.TEST.XMIT(MYTEXT) CCSID=1141)           WRITE.TEXT(FILE=ssh://<cuser>@unix.server.com/out.zip CCSID=UTF-8                      encrypt.pgp(userid='receiver.name' signid='my.name' armor())                      archive.zip(member='[member].txt'))' env=LANG=de_DE.IBM-1141 Write a record oriented host dataset as text in UTF-8 to a PGP file (signed and encrypted), which will be stored as ASCII-armor encoded member in a remote ZIP archive on a UNIX system and convert the member name to a path name. If the input output name mapping with square brackets used, then the CCSID for the correct interpretation of the CLP string must be defined (same for tilde). The '@' in the URL is also a character with different code points. In this case FLAM supports also the ampersand as separation between the user and the server, to prevent the requirement to know the CCSID used for correct interpretation. In the example above the DD name STDENV are used to define the most important environment variables required to run FLAM commands. example 10 title=write XML files from ZIP archive to FLAM archive for z/OS in EBCDIC cmd=conv 'read.xml(file=test.zip/?*.xml)           write.flam(file=test.adc member=<CUSER>.XMLPDS([base]) ccsid=1141)' Read all XML files from ZIP archive on UNIX in UTF-8 and convert it to a FLAM archive for z/OS in EBCDIC. XML in a FLAMFILE is record-oriented and pretty printed by default. example 11 title=text compare BZIP file with FLAMFILE cmd=diff 'read.text(file=test.bz ccsid=Latin-1 SUPTWS) compare.text(file=test.adc ccsid=1141 SUPTWS)' Compare the content of a BZIP file with the content of a FLAMFILE text record by text record with suppression of trailing whitespace on a UNIX system. $ flcl diff 'read.text(file=test.bz ccsid=Latin-1 SUPTWS)              compare.text(file=test.adc ccsid=1141 SUPTWS)' $ cat test.txt | flcl flam comp | flcl flam $ flcl setenv FL_DEFAULT_PGPRNGPARA='pub='~/.pgp/pubrng.pgp',sec='~/.pgp/secrng.pgp',pass=f'~/.pgp/keyring.pwd'' $ flcl key 'gen.pgp(user='<cuser>')' $ flcl key 'exp.pgp(user='<cuser>' file=~/mykey.pgp)' $ flcl key 'imp.pgp(file=~/max.pgp kidver=12B738)' $ flcl conv 'read.binary(file='message.txt')              write.binary(file='message.pgp' encrypt.pgp(userid['Max','<cuser>'] signid='<cuser>'))' $ flcl conv 'read.binary(file='message.pgp' deco)              write.binary(file='message.out')' C:> flcl conv read.text(net.ssh(hostkeycheck=ask,                                 user='<cuser>',                                 host='winserver')                         file='test.zip/?*' remove ccsid=1251)        write.text(file=ssh://<cuser>@unixserver/[name].gz                   ccsid='UTF-8' comp.gzip()) //FLCLCONV EXEC PGM=FLCL,REGION=0M,PARM='XCNV=DD:PARM' //STEPLIB  DD DSN=&SYSUID..FLAM.LOAD,DISP=SHR //SYSOUT   DD SYSOUT=* //SYSPRINT DD SYSOUT=* //PARM     DD *    INPUT(SAV.FIL(FIO.REC(NAME='DD:FBINP')                  FMT.TAB(FORMAT=FIX ROW='DD:FBROW')))    OUTPUT(SAV.FIL(FMT.TAB(FORMAT=CSV DEFAULTS(NOHDLN))                   FIO.REC(NAME='DD:CSVOUT'))) //FBROW    DD *  NAME='my.fb.record'  COLUMN(      NAME='name'      TYPE.STRING(CHRSET(WHITESPACE=COLLAPSE))      MAXLEN=32  COLUMN(      NAME='age'      TYPE.INTEGER(FORMAT.BCD(TYPE=PACKED))      MAXLEN=4 flcl xcnv    input(save.file(       fio.blk(file=wrtorg.bin               pre(command='sha1sum [copy]'                   stdout=wrtorg.local.sha1))    output(save.file(       fio.blk(file=ssh://<USER>:limes@tests.limes.de/wrtorg.bin               post(command='sha1sum [copy]'                   stdout=wrtorg.remote.sha1))       post(command='diff wrtorg.local.sha1 wrtorg.remote.sha1'           stdout=log))) flcl xcnv  input(save.file(fio.blk(file=wrtorg.bin)))  output(save.file(   fio.blk(file=ssh://<USER>:limes@zos22/wrtorg.bin   postpro(command='cp -B [copy] '//TEST.XMIT([base])'')   postpro(command='rm [copy]' on=success)))) //COPYMAC  EXEC PGM=FLCL,PARM='CONV=DD:PARM',REGION=0M //STEPLIB  DD DSN=LIMES.FLAM.LOAD,DISP=SHR //SYSOUT   DD SYSOUT=* //SYSPRINT DD SYSOUT=* //PARM     DD * READ.TEXT(FILE='/u/<cuser>/git/FL5/HASMMAC/*.mac'           FILE='/u/<cuser>/git/FL5/HASMMAC/ZOS/*.mac'           FILE='/u/<cuser>/git/FL5/HASMMAC/COLUMBUS/*.mac'           CCSID=1140) WRITE.RECORD(FILE='<SYSUID>.LICORDER.HASMMAC([base])'              FALLOC(ORGA=LIB RECF=FB RECL=80                     SPACE(PRIMARY=1 SECONDARY=1)                     RENEW)              CCSID=1140) MESSAGE(MINIMAL) //FLCLMAIL EXEC PGM=FLCL,REGION=0M,PARM='CONV' //STEPLIB  DD DSN=&SYSUID..AUTH.LOAD,DISP=SHR //SYSOUT   DD SYSOUT=* //SYSPRINT DD SYSOUT=* //FLAMPAR  DD * read.record(file='<SYSUID>.SCLM.FITSTOUT.*' ccsid=1141) write.text(method=unix ccsid='UTF-8' file='[copy].gz'   FALLOC(SYSOUT(FORMAT.MAIL(     FROM='<SYSNAME>@zos.limes.de'     TO='system@flam.de')))   COMPRESS.GZIP()) flcl xcnv 'input(save.file(fio.blk(file='wrtorg.bin' frcblk)))            output(save.file(                   cnv.edc(KDF=PBKDF2 ALGO=AES MODE=CBC KEYLEN=KL256                           PASS=a'123456789012345678901234567890')                   fio.blk(file='wrtorg.bin.enc')))' flcl xcnv 'input(save.file(fio.blk(file='wrtorg.bin.enc' frcblk)                            cnv.edc(KDF=PBKDF2 ALGO=AES MODE=CBC KEYLEN=KL256                                    PASS=a'123456789012345678901234567890')))            output(save.file(fio.blk(file='wrtorg.bin')))' //FIND     EXEC PGM=FLCL,PARM='CONV',REGION=0M //STEPLIB  DD DSN=LIMES.FLAM.LOAD,DISP=SHR //SYSOUT   DD SYSOUT=* //SYSPRINT DD SYSOUT=* //FLAMPAR  DD * READ.TEXT(FILE='HLQ.**' SUPTWS           CCSID=DEFAULT CHRMODE=SUBSTITUTE           REGEXP(PATTERN='^find$' NOCASE IGNREC)) WRITE.TEXT(FILE=DUMMY CCSID=LOCAL CHRMODE=SUBSTITUTE) DIR(LINK ALIAS HIDDEN RECURSIVE ARCHIVE) MESSAGE(MATCH,SOURCE) ",
"",
""
],
[
"flcl_manual-preface-supported_systems_a016.html",
"Supported Systems",
"=== Supported Systems FLAM is available for a variety of operating systems. For example: ",
"",
""
],
[
"flcl_manual-preface-technical_support_7e52.html",
"Technical Support",
"=== Technical Support FLAM support sites and other useful links: * use the link:../../index.html[start page] of our locally installed FLAM documentation * visit the up to date http://www.flam.de/en/technology/download/documentation[FLAM documentation] on our website * view examples of what you can do with FLAM inside link:../../flcc/index.html[FLCC] * to request support write a mail to <support@flam.de> * to report an issue go to our https://issues.flam.de[bug tracker] When reporting an issue it will help if the output of the command is submitted too. This is the same as the *System Information* available in FLCC.  ",
"",
""
],
[
"flcl_manual-command_line_parser_be9b.html",
"Command Line Parser",
"[[clep.main]] == Command Line Parser The COMMAND LINE PROCESSOR (CLE/P(R)) is a user application programming interface for several platforms including Windows, Unix and z/OS that simplifies and standardizes parameter string processing. The CLE/P(R) 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 (lexemes) and the corresponding grammar, please use the built-in functions <<CLEP.BUILTIN.LEXEMES,LEXEMES>> 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 sections <<CLEP.APPENDIX.RETURNCODES,return codes>> and, if available, <<CLEP.APPENDIX.REASONCODES,reason codes>> 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. ",
"",
""
],
[
"flcl_manual-command_line_parser-command_line_considerations_aebc.html",
"Command Line Considerations",
"=== 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: 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: 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. ",
"",
""
],
[
"flcl_manual-command_line_parser-used_environment_variables_8b63.html",
"Used Environment Variables",
"[[clep.main.usedenv]] === Used Environment Variables Environment variables can be managed via the operating system or via the FLCL configuration. The latter can be managed with the built-in functions <<CLEP.BUILTIN.SETENV,SETENV>>, <<CLEP.BUILTIN.GETENV,GETENV>> and <<CLEP.BUILTIN.DELENV,DELENV>>. To list the current state of all usable environment variables the built-in function <<CLEP.BUILTIN.LSTENV,LSTENV>> can be used. For help messages for each usable environment variable please use <<CLEP.BUILTIN.HLPENV,HLPENV>> There are also some platform-specific mechanisms that can be used to set environment variables: Environment variables are read from the file `.stdenv` in the current working directory or the user's home directory. The file in the home directory is only considered if the file does not exist in the working directory or cannot be read. `DD:STDENV` or the data set name `&SYSUID..STDENV` can alternatively be used to set environment variables. The `STDENV` file allows to define the `FLCL_CONFIG_FILE`, `FLCL_DEFAULT_OWNER_ID`, `LANG` and other environment variables in JCL. Example with a z/OS DD name allocation: 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 filename is used as is. No placeholder substitutions (e.g. `<USER>`) are possible. It might 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. Since z/OSv2r1 you can also use exported JCL symbols like environment variables. The exported JCL symbols have lower priority than the same environment variable. The service CEEGTJS is called dynamically and the language environment must be in the STEPLIB concatenation to use it. Additionally, all z/OS system symbols can be used in the string replacement (<&LDAY>). The environment variables have the highest priority, followed by the exported JCL symbols. System symbols have the lowest priority. If the variable name is not found, then no replacement is done and the angle brackets are kept in place. 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 built 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 globally. The owner-specific definition overrides the program specific definition and the program-specific definition overrides the global definition. Examples: 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 built based on the environment settings. See <<CLEP.APPENDIX.PROPERTIES,Appendix Properties>> for the current property file content. Below you can find the list of static environment variables. * LANG (&FLANGLC_&FLANGCC.&FLANGCS) - The default language and CCSID/encoding string for this platform (Format: de_DE.UTF-8 or de_DE.IBM-1141) * HOME - To determine the home directory on UNIX/WIN * USER - To determine the current user id on UNIX/WIN * CUSER - To determine the current user in upper case * Cuser - To determine the current user in title case * cuser - To determine the current user in lower case * SYSUID - To determine the current user id on z/OS * ENVID (&FLENVID) - The current environment qualifier for key label templates (default value is 'T'  or the first valid letter of &SYSCLONE on z/OS) * OWNERID - Used for current owner if not already defined (used in key label templates (can also be used in file names)) * HOSTNAME - Current host name * MAILADDR - The email address used as sender for outgoing emails (only relevant on z/OS with SYSOUT format set to MAIL) * CLE_QUIET - Disables the normal log output of the command line executer (must set to YES or ON) ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * CLE_SILENT - Disables log and errors messages of the command line executer (must set to YES or ON) ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * 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) * CLP_SYMTAB_STATISTICS - Print symbol table statistics to STDERR stream at close (must set to YES or ON) ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * CLP_MALLOC_STATISTICS - Print memory allocation statistics to STDERR stream at close (must set to YES or ON) ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * FL_PLATFORM - Platform definition (WIN/UNX/MAC/ZOS/USS/BS2[.B/.L]) for emulation at read or write operations ** WIN - Choose Windows as platform (CRLF) ** UNX - Choose Unix derivative as platform (LF) ** ZOS - Choose ZOS as platform (NL) ** USS - Choose USS of ZOS as platform (NL) ** VSE - Choose VSE as platform (NL) ** BS2 - Choose BS2000-OSD as platform (NL) ** MAC - Choose MAC as platform (CR) * FL_DEFAULT_ASCII_CCSID - Default CCSID for ASCII character sets (if ASCII machine and LANG, then default is taken from LANG else default is 'ISO-8859-1')) * FL_DEFAULT_EBCDIC_CCSID - Default CCSID for EBCDIC character sets (if EBCDIC machine and LANG, then default is taken from LANG else default is 'IBM-1047')) * FL_PGP_PREF_SYMALG_AES128 (&FLPA128) - Invert order of preferred symmetric algorithms from AES256/192/128 to AES128/192/256 in PGP certificates ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * FL_ALLOW_LOW_ENTROPY - If defined and no source of entropy is available, the random number generate is seeded with a low entropy which may result in weak encryption keys * FL_DEFAULT_CHAR_MODE (&FLCHARM) - Default error handling if character not available in target character set [STOP] ** STOP - Stop at the first non-convertible character ** IGNORE - Ignore non-convertible characters ** SUBSTITUTE - Substitute non-convertible characters ** IDENTITY - Copy non-convertible characters (supported only for single byte conversions) ** TRANSLIT - Activate ICONV transliteration and ignore the rest (MODE=IGNORE SYSTAB=ICONV) * FL_DEFAULT_PGPCCAPARA - Default PGP IBM-CCA (ICSF) parameter (normally not required, only profile and pin (if applicable) or trust store name) * FL_DEFAULT_PGPP11PARA - Default PGP PKCS#11 parameter (LIB=/usr/lib/libsofthsm2,PIN=f'pkcs11.pin') * FL_DEFAULT_PGPRNGPARA - Default PGP key ring parameter (pub='pubrng.pgp',sec='secrng.pgp',pass=f'keyring.pwd') * FL_DEFAULT_CCALIB - Default path/name of CCA library (not required for ICSF) * FL_DEFAULT_CCAPKDS - Default path/name of CCA public key data set * FL_DEFAULT_P11LIB - Default path/name of PKCS#11 library * FL_DEFAULT_P11PIN - Default PIN/passphrase for PKCS#11 token (it is not recommended to use this if authentication is required) * FL_DEFAULT_P11SLOT - Default PKCS#11 slot number * FL_DEFAULT_RNGPUBFIL - Default public key file for key ring implementation * FL_DEFAULT_RNGSECFIL - Default secret key file for key ring implementation * FL_DEFAULT_RNGPASSWD - Default password for key ring implementation (it is not recommended to use this if authentication is required) * FL_INFO_BLOCK_SIZE - Set a custom block size for the INFO command (useful mainly for PGP files) * FL_USAGE_SYSLOG_IDENT (&FLOGIDT) - Activate usage logging to SYSLOG on each platform (in addition to the usage log stream on z/OS) * FL_DEACTIVATE_HW_CRYPTO_ACCELERATION - Deactivate hardware acceleration for cryptographic operations (enforce use of software implementation) * FL_PRIMARY_SPACE_TRK (&FLPRISP) - Default primary space in tracks (only relevant on mainframes, default is 600) * FL_SECONDARY_SPACE_TRK (&FLSECSP) - Default secondary space in tracks (only relevant on mainframes, default is 1200) * FL_DIRECTORY_BLOCKS (&FLDIRBL) - Default directory blocks (only relevant on mainframes, default is 45) * FL_ZEDC_SUPPORT (&FLZEDC) - Controls use of RCF1951 (GZIP) compression in FLAM4 ADC modules (ON, OFF, AUTO(default), threshold (nnn) in percent) * FL_SSH_HOME_DIR - Directory containing SSH key files and known_hosts file (/home/user/.ssh) * FL_GZ_EXPANSION_FACTOR (&FLGZEXP) - Expansion factor for GZIP decompression (default is 5) * FL_GZ_COMPRESSION_FACTOR (&FLGZCMP) - Compression factor for GZIP compression (default is 2) * FL_BZ_EXPANSION_FACTOR (&FLBZEXP) - Expansion factor for BZIP2 decompression (default is 6) * FL_BZ_COMPRESSION_FACTOR (&FLBZCMP) - Compression factor for BZIP2 compression (default is 2) * FL_XZ_EXPANSION_FACTOR (&FLXZEXP) - Expansion factor for XZ decompression (default is 10) * FL_XZ_COMPRESSION_FACTOR (&FLXZCMP) - Compression factor for XZ compression (default is 2) * FL_ZS_EXPANSION_FACTOR (&FLZSEXP) - Expansion factor for ZSTD decompression (default is 10) * FL_ZS_COMPRESSION_FACTOR (&FLSZCMP) - Compression factor for ZSTD compression (default is 2) * FL_KEY_EXPIRE_WARN_DAYS (&FLKEYWD) - Amount of days to warn before a key will expire (default is 90 (3 months)) * FL_RETURN_IF_LOG_WARNING (&FLRLOGW) - If set to OFF, the completion code 0 is returned instead of 1 if a relevant warning is written to the log ** YES - Yes, do it (same as ON) ** ON - Activate it (same as YES) ** NO - No, don't do it (same as OFF) ** OFF - Deactivate it (same as NO) * FL_FAVE_LIBRARY - Set default library for anti virus scanning (default is 'libfave') * FL_FAVE_FUNCTION - Set default function for anti virus scanning (default is 'CLAMAVC') * FL_FAVE_PARAMETER - Set default parameter for anti virus scanning (default is 'clamav.daemon:3310') * FL_CLAMAV_DAEMON - Set default communication parameter for ClamAV client (default is 'clamav.daemon:3310:10') * FL_AVSCAN_READ - If defined, anti virus scanning when reading is activated (corresponding default values must be defined) * FL_AVSCAN_WRITE - If defined, anti virus scanning when writing is activated (corresponding default values must be defined) * FL_AVSCAN_COMPRESS - If defined, anti virus scanning is done on a compressed GZIP data stream (must be supported by service provider) * FL_SYSOUT_MAIL_CLASS (&FLSOMC) - Default class for SYSOUT allocation if FORMAT.MAIL() is used (only on z/OS) * FL_SYSOUT_MAIL_WRITER (&FLSOMW) - Default program for SYSOUT allocation if FORMAT.MAIL() is used (only on z/OS) * FL_LITERAL_CACHE_SIZE (&FLITCS) - Size of the hash table used (by power of 2) for the literal cache (8>=x<=20 (256 to 1.048.576 entries)) * FL_RECORD_FORMAT_MAPPING (&FLRECFM) - If this variable is not set to DATATYPE (is the default), records with length field (RECF=VAR) are used ** DATATYPE - Binary data as binary (RECF=BIN), Text as text (RECF=TXT) * FL_IBM_UNICODE_SERVICE (&FLIBMUS) - Define use of z/OS Unicode Services for simple character conversions to lower performance [AUTO] ** AUTO - Use it, if behavior the same and faster ** ON - Activate it (with round trip conversion) ** OFF - Deactivate it (no use of Unicode Services) * FLAM4MF - Enable Microfocus Enterprise Server support for FLAM and FLUC record interfaces (ccsid/yes/no) * FLAM4MF_TRACEFILE - Enable a trace file for the MF-EDZ stubs supporting the record interface (Windows or Linux filename) * FLAM4MF_STATIC_SYSVAR - Static system variables are read from filename into the environment (filename in EBCDIC or ASCII, Syntax: 'SYMBOL=value', also use 'DD:SYSVAR') * FLAM4MF_DYNAMIC_SYSVAR - Dynamic system variables are read from filename into the environment (in conjunction with the JCL User Exit of MF-EDZ to add dynamic variables) * _EDC_ZERO_RECLEN (&FLZRECL) - Used for handling of empty records (see dedicated <<flcl.handling.empty.records,chapter>> below) on z/OS Beside the static environment variables there a lot of dynamic formed environment variables supported. * FLCL_CONFIG_FILE - the configuration filename (default is '$HOME/.flcl.config' on UNIX/WIN or '&SYSUID..FLCL.CONFIG' on mainframes) * FLCL_DEFAULT_OWNER_ID - the default owner ID (default is 'limes') * owner_FLCL_command_PROPERTY_FILENAME - To override default property file names * path_argument - to override the hard coded default property value On platforms (mainly mainframe systems) where system symbols are available, some of the environment variables can be pre-defined over corresponding system variables. See install.txt or use built-in function <<CLEP.BUILTIN.HLPENV,HLPENV>> (in round brackets the corresponding system symbols are listed). Trailing whitespace is removed from variable values before being used. A system symbol must start with `&` or an alphabetic character followed by alphanumeric characters. The environment variable LANG is also used on EBCDIC systems to interpret several syntax characters correctly, which depend on the codepage. See chapter <<CLEP.MAIN.EBCDIC,special EBCDIC code page support>> for how the CCSID can be defined. It is important to set this variable to the correct value on EBCDIC systems. If this environment variable is not set, files and literals are interpreted in IBM-1047 on z/OS and USS. If you use another CCSID for entry, you must define the environment variable LANG to enable correct parsing for strings that contain special characters like `~`. We recommend to define the corresponding system variables (&FLANGLC, &FLANGCC and &FLANGCS) via `SYS1.PARMLIB(IEASYMxx)` on z/OS (see also install.txt). These three system symbols are used to build the environment variable LANG based on the string below: For example with the definitions below the environment variable below is defined. The language code (de) is important for correctly selecting the default CCSID if an ASCII code page was detected. The `ENVID` variable is normally one character to separate test and production environments. On z/OS the default is simply the first letter of system symbol `&SYSCLONE` or if not defined (on all platforms) 'T' for test. The variable FLAM4MF and (if needed) FLAM4MF_TRACEFILE should be set in the environment of the Microfocus Enterprise Server instance where the FLAM or FLUC record interfaces are used. To define static and dynamic system variables, the FLAM4MF_STATIC/DYNAMIC_SYSVAR environment variable can be used to read the system variables to the environment. The second file was mainly introduce for the MF-EDZ JCL user exit, which can be used to provide the dynamic symbols like JOBNAME as keyword=value pair as the dynamic file. All the files read to build the environment undergo automatic ASCII and EBCDIC detection. A semicolon can be used to mark the end of a keyword-value pair (an inline FB80 encoding in JCL on EDZ does not contain new line characters). To undefine an environment variable, there must be no characters behind the equal sign. To replace a variable with nothing upon use, the environment variable must be set to one or more whitespace character(s). Trailing whitespace is removed from the value string, so a value which contains only whitespace characters will result in an empty string upon substitution. For Micro Focus EDZ environments, the DD name SYSVAR is supported to define system variables. The function used to read the `keyword=value` pairs automatically detects if EBCDIC is used (character > 0x80) and converts the lines automatically to the local character set. The LE-less part of FLAM can only use system symbols. Below is a list of available variables: *&FLREUCEE - Activate reuse of language environment in FLAM ZEDC support *&FLOGQL1  - First qualifier to specify the FLAM usage log stream name *&FLOGQL2  - Second qualifier to specify the FLAM usage log stream name *&FLOGQL3  - Third qualifier to specify the FLAM usage log stream name See install.txt for z/OS for more information. ",
"",
""
],
[
"flcl_manual-command_line_parser-environment_variable_mapping_1a27.html",
"Environment Variable Mapping",
"=== 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 lexeme 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 * <HOSTNAME> - The current host name of the system * <ENVID>    - The environment ID (default is T for test) * <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> Additional few abbreviation are supported for different kind of strings. * '~' for <HOME> in file strings * '!' for <ENVID> in key labels * '~' for <SYSUID> in key labels * '^' for <OWNERID> in key labels All these abbreviation character have different code points in EBCDIC code pages and can only be used if the CCSID known be CLP, see chapter <<CLEP.MAIN.EBCDIC,special EBCDIC code page support>> how the CCSID can be defined for CLP. ",
"",
""
],
[
"flcl_manual-command_line_parser-filename_mapping_f829.html",
"Filename Mapping",
"[[clep.main.filemap]] === Filename Mapping All filenames used by CLE/P(R) 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 fully qualified * Path names on mainframes must contain at least one slash (`/`) * Data set names on USS must start with `//` ** Fully qualified names with HLQ must be enclosed in apostrophes (`//''`) ** If apostrophes are not used the SYSUID is prefixed as HLQ * Normal file names on other platforms could be relative NOTE: 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. ",
"",
""
],
[
"flcl_manual-command_line_parser-key_label_mapping_293d.html",
"Key Label Mapping",
"=== Key Label 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. ",
"",
""
],
[
"flcl_manual-command_line_parser-special_ebcdic_codepage_support_fc70.html",
"Special EBCDIC Codepage Support",
"[[CLEP.MAIN.EBCDIC]] === Special EBCDIC Codepage Support To interpret commands correctly the punctuation characters below are on different code points depending on the EBCDIC CCSID used to enter these values. 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. 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 CLE/P(R) 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: 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: 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. NOTE: 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: 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. ",
"",
""
],
[
"flcl_manual-built_in_functions_679c.html",
"Built-in Functions",
"[[CLEP.BUILTIN.FUNCTIONS]] == 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]] === SYNTAX indexterm:[Built-in Function, SYNTAX] 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. * 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. [[CLEP.BUILTIN.HELP]] === HELP indexterm:[Built-in Function, HELP] 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. Help can also be used to show the corresponding detailed description of the manual pages with keyword *MAN*. * 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. [[CLEP.BUILTIN.MANPAGE]] === MANPAGE indexterm:[Built-in Function, MANPAGE] 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]. [[CLEP.BUILTIN.GENDOCU]] === GENDOCU indexterm:[Built-in Function, GENDOCU] 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. 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. [[CLEP.BUILTIN.HTMLDOC]] === HTMLDOC indexterm:[Built-in Function, HTMLDOC] 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 [[CLEP.BUILTIN.GENPROP]] === GENPROP indexterm:[Built-in Function, GENPROP] 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. [[CLEP.BUILTIN.SETPROP]] === SETPROP indexterm:[Built-in Function, SETPROP] 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. [[CLEP.BUILTIN.CHGPROP]] === CHGPROP indexterm:[Built-in Function, CHGPROP] 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): On mainframe systems (ZOS, VSE, BS200, ...): 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: 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. [[CLEP.BUILTIN.DELPROP]] === DELPROP indexterm:[Built-in Function, DELPROP] 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. [[CLEP.BUILTIN.GETPROP]] === GETPROP indexterm:[Built-in Function, GETPROP] 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. 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. * `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. [[CLEP.BUILTIN.SETOWNER]] === SETOWNER indexterm:[Built-in Function, SETOWNER] 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. [[CLEP.BUILTIN.GETOWNER]] === GETOWNER indexterm:[Built-in Function, GETOWNER] 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. [[CLEP.BUILTIN.SETENV]] === SETENV indexterm:[Built-in Function, SETENV] 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 [[CLEP.BUILTIN.GETENV]] === GETENV indexterm:[Built-in Function, GETENV] 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 [[CLEP.BUILTIN.DELENV]] === DELENV indexterm:[Built-in Function, DELENV] This function will delete environment variables from the configuration file for a certain owner. [[CLEP.BUILTIN.LSTENV]] === LSTENV indexterm:[Built-in Function, LSTENV] This function will list the status of all possible useable environment variables. [[CLEP.BUILTIN.HLPENV]] === HLPENV indexterm:[Built-in Function, HLPENV] This function will print the help message for all possible usable environment variables. [[CLEP.BUILTIN.TRACE]] === TRACE indexterm:[Built-in Function, TRACE] 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. [[CLEP.BUILTIN.CONFIG]] === CONFIG indexterm:[Built-in Function, CONFIG] 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: 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: 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.FLCL.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. [[CLEP.BUILTIN.GRAMMAR]] === GRAMMAR indexterm:[Built-in Function, GRAMMAR] 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. [[CLEP.BUILTIN.LEXEMES]] === LEXEMES indexterm:[Built-in Function, LEXEMES] 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.LEXEMES,Appendix Lexemes>> for an explanation and the output of this command. [[CLEP.BUILTIN.LICENSE]] === LICENSE indexterm:[Built-in Function, LICENSE] 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. [[CLEP.BUILTIN.VERSION]] === VERSION indexterm:[Built-in Function, VERSION] 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. [[CLEP.BUILTIN.ABOUT]] === ABOUT indexterm:[Built-in Function, ABOUT] 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 (flcl). See <<CLEP.APPENDIX.ABOUT,Appendix About>> for the output of this command. [[CLEP.BUILTIN.ERRORS]] === ERRORS indexterm:[Built-in Function, ERRORS] 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 sections <<CLEP.APPENDIX.RETURNCODES,return codes>> and <<CLEP.APPENDIX.REASONCODES,reason codes>> for an explanation and the output of this command. ",
"",
""
],
[
"flcl_manual-flcl_utility_1728.html",
"FLCL Utility",
"[[flcl.utility]] == FLCL Utility Frankenstein Limes Command Line (FLCL) is a batch utility to execute the following subprograms: * FLUC  - Frankenstein Limes Universal Converter (conversion) * FLAM  - Frankenstein Limes Access Method (compression and encryption) * FLIES - Frankenstein Limes Integrated Extended Security (management) Each subprogram is also available as DLL/SO or load modules to integrate FLAM into your own applications. The subprogram interface supports each command as dedicated function, which accepts the corresponding command string. For example, this call of FLCL: is also available in C programming language as: or in COBOL as: The subprograms are called through the commands below: * INFO - a command of the subprogram 'FLUC'  -> flucinfo() * CONV - a command of the subprogram 'FLUC'  -> flucconv() * XCNV - a command of the subprogram 'FLUC'  -> flucxcnv() * XCHK - a command of the subprogram 'FLUC'  -> flucxchk() * HASH - a command of the subprogram 'FLUC'  -> fluchash() * UTIL - a command of the subprogram 'FLUC'  -> flucutil() * COMP - a command of the subprogram 'FLAM'  -> flamcomp() * DECO - a command of the subprogram 'FLAM'  -> flamdeco() * FIND - a command of the subprogram 'FLIES' -> flisfind() * CHNG - a command of the subprogram 'FLIES' -> flischng() The FLCL can be used in scripts to automate batch processing. The command interpretation is platform independent and optimized for different shells like Windows(R) batch files, Unix bash or z/OS(R) JCL. ",
"",
""
],
[
"flcl_manual-flcl_utility-installation_faf3.html",
"Installation",
"=== 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. ",
"",
""
],
[
"flcl_manual-flcl_utility-installation-license_ca41.html",
"License",
"==== 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. ",
"",
""
],
[
"flcl_manual-flcl_utility-installation-download_b416.html",
"Download",
"==== 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/latest/aix/install.txt |Linux            | https://flam.de/en/download/flam/latest/linux/install.txt |Solaris          | https://flam.de/en/download/flam/latest/solaris/install.txt |Windows          | https://flam.de/en/download/flam/latest/windows/install.txt |zSeries Linux    | https://flam.de/en/download/flam/latest/zSeries/linux/install.txt |zSeries USS      | https://flam.de/en/download/flam/latest/zSeries/uss/install.txt |zSeries z/OS     | https://flam.de/en/download/flam/latest/zSeries/zos/install.txt Manuals can be found at: https://flam.de/en/technology/download/documentation/ ",
"",
""
],
[
"flcl_manual-flcl_utility-installation-replace_external_libraries_f2da.html",
"Replace External Libraries",
"==== Replace External Libraries External libraries under LGPL are linked in dynamic form and can be replaced by another dynamic library which fulfills the corresponding interface. This can be done by deleting the library in the program directory if the replacement library is located in the library path or by overwriting the library in the program directory. The list below contains all LGPL based libraries used by FL5 per platform. glibc on Linux:    This library is part of the operating system and a prerequisite to    run the FL5 infrastructure on Linux systems. FL5 can be used with    different version and distributions of linux. Replacement of glibc    will be done by the normal update process of your linux installation. libfuse on Unix:    This library is part of the operating system and a prerequisite to    run the FL5 file systems on Linux systems. The file systems are    delivered for libfuse version 2 and 3. Replacement of libfuse    will be done by the normal update process of your Unix installation. libssh:    The libssh library can be found in the installation directory. A    customized version is used that is not compatible with the official    libssh releases. The modified libssh source can be found at:    https://github.com/limes-datentechnik-gmbh/libssh Attention: In all cases we recommend using the tested and supported libraries from this package. If a supplied library is replaced, the license terms and warranty of the new library become valid, replacing the license and warranty of the replaced library. ",
"",
""
],
[
"flcl_manual-flcl_utility-filename_handling_57a7.html",
"Filename Handling",
"=== Filename Handling All filenames are mapped by CLE/P, which means that all replacement mechanisms it supports are also valid for each filename used within a command. See <<clep.main.filemap,filename mapping>> of <<clep.main,Command Line Processor>>. All filenames specified in command strings are parsed and handled in a unified way across the different platforms. Standard replacements by shells are usually not usable within the command syntax. There are some special attributes that can be appended to a filename when using paths or the URL-like syntax by using one of the following separators followed by a value string: * `/?` - member name (to access a member in an archive by name) * `/:` or `/#` - member index (to access a member in an archive by position) * `/&` - CCSID that the file's contents are encoded in If the URL-like syntax is used, special characters can be URL-encoded as a percent character followed by two hex digits (%xx). If no schema is provided, but a raw path, URL-encoded characters are not decoded because the string is not a URL. The schema `file://` can be used to access a local file on the system in URL-like syntax. Providing a CCSID is mainly intended to be used for parameter files which are read to memory from a remote location which may require conversion to the local character set. The filename is the only way to specify the CCSID for this type of files. Filenames in archives (ZIP, TAR, FLAM) or certain file headers (GZIP, PGP) are sanitized when reading or writing to prevent directory traversal attacks. This type of attack aims at writing files in arbitrary locations in the filesystem by storing specially crafted paths in the archive or file header. For example, extracting a ZIP file containing paths such as `/etc/passwd` or `../../../../../../etc/passwd` as user root on a Unix-based system could lead to a lock-out of all users. Path sanitization removes all path components that lead to an extraction outside the desired output directory. This includes turning absolute paths into relative ones and removing all `..` directory components. Both example paths above would be transformed to `etc/passwd` which are safe for extraction. The filename handling works as follows: Usually, a filename has to be specified fully qualified, because a dynamic allocation is done in most cases. The following substitutions can be used, which are automatically replaced by their respective value during execution: If the environment variables below are not defined, the following defaults are used: The syntax to define a DD name is: A replacement may also be used in a DD name definition: Additionally, you can specify member names in a DD name definition if a PDS(E) is allocated. The member name can be fully qualified or contain wildcards. Member names for archives can be specified as part of the URL-like notation or it can be specified separately. When using static allocation (DD name) for writing, the DCB parameter must be provided if the file does not exist. Otherwise, the defaults of the runtime environment (often `PS RECFM=UNDEFINED LRECL=0 BLKSIZE=6144`) are used. A static allocation is only useful to write the logical byte stream in a certain physical file format. In all other cases, we recommend to use dynamic allocation when writing new files. Since version 5.1.22-28565 the DD name must not be prefixed with 'DD:' anymore. If only one qualifier given, if it a valid DD name and if a allocation for it found, then the qualifier will be used as DD name. If you use FILE=STREAM when reading the file descriptor STDIN (DD:SYSIN) and when writing STDOUT (DD:SYSPRINT) is used. All other messages are printed by default to STDERR (DD:SYSOUT). For read the default DD name 'FLAMIN' and for write the default DD name 'FLAMOUT' is preferred if no file specification given. If such a allocation not found at write the default dataset name (original name plus extension) is used. For read or write of a FLAMFILE additional the DD name 'FLAMFILE' are supported to be backward compatible with the old FLAM utility. A Unix path name must contain a forward slash (`/`). To use a file in the current directory `./filename` must be used. Paths relative to the home directory may start with a tilde character (`~`) as an abbreviation for <HOME> for UNIX pathnames or <SYSUID> for host dataset names. NOTE: Starting with version 5.1.5, the plus sign (`+`) can no longer be used as abbreviation for the user's home directory. The tilde (`~`) remains unaffected and is now the only valid abbreviation. The plus sign (`+`) is now a wildcard character. It was supported as alternative for EBCDIC systems, because tilde is located on different code points depending on the EBCDIC code page. Since version 5.1.5, we support the correct interpretation of diacritical characters on EBCDIC systems based on the CCSID defined in the environment variable LANG. see <<clep.main.usedenv,Used environment variables>> and <<CLEP.MAIN.EBCDIC,SPECIAL EBCDIC CODE PAGE SUPPORT>> of <<clep.main,Command Line Processor>> To specify the casing (mainly useful for USS on ZOS) for a user ID, the following definitions can be used (if not defined as environment variable): A filename may be an absolute or relative path and may contain any of the substitutions (including ~) mentioned in the previous section. To use a smaller than character (`<`) as part of a filename, the character must be escaped by doubling it. We recommend not to use special or whitespace characters in filenames. The ampersand character (`&`) can be used instead of at sign (`@`) because the letter has different code points in EBCDIC. (the alternative character on EBCDIC, if `@` is not working, is `§` (the command line parser converts the `@` corresponding to the environment variable LANG on EBCDIC systems, if the value not set or wrong, then you can use `&` or try `§`)). On USS and Micro Focus EDZ, DD names are supported. A UNIX path name is distinguished from a data set name in the same way as it is done in the z/OS runtime environment. Example on USS or EDZ: If the variable FLAM4MF is set to `yes` or a valid CCSID, a DD name is assumed unless it contains a dot character and is used as the dataset name. Otherwise a DD name must be specified as DD:name and a dataset is given with `//'name'` This corresponds with the syntax for host dataset names on USS of z/OS. With the Microfocus support for Windows and Linux, you can work on x86 Windows and Linux systems with the local MF-EDZ-Enterprise-Server like you work with the catalog access on USS for MVS files. If you work with EBCDIC on the record interface in a EDZ environment then you must set the FLAM4MF environment variable to the used CCSID (e.g. IBM1141). If a CCSID is defined and starts with `IBM`, this will also override the default CCSID in the character conversion component and mark it as z/OS platform. In an error situation, it is possible to enable writing a trace to a file, which can be used to analyze problems. The environment variable `FLAM4MF_TRACEFILE` must contain a valid filename to write the trace output. To set the missing system variables for MF-EDZ, several solutions are implemented including `DD:SYSVAR` and the environment variables `FLAM4MF_STATIC/DYNAMIC_SYSVAR` documented above. Instead of local filenames, complete URLs defining all communication parameters and (if required) the member name or index can be used. Optionally a CCSID for this file can be added. The syntax is: If the URL-like syntax is used, special characters can be URL-encoded as a percent character followed by two hex digits (%xx). If no schema is provided, but a raw filename, URL-encoded characters are not decoded as the string is not a URL. The schema `file://` can be used to access a local file on the system in URL-like syntax. Currently, remote file access via SSH is supported for all file types including FLAM4 archives. The `ssh://` prefix indicates remote access via SSH. The userid is optional, the default is the current login user ID. You can use replacements also in the connection parameter. I.e. `<cuser>` gets replaced with the lower case login user id, which is useful mainly on mainframes, where the SYSUID is in upper case. The password is optional. If no password is specified, public key authentication is attempted. The hostname/IP is mandatory and the port is optional, defaulting to the SSH standard port 22. The hostname and the remote file path are separated by a slash. An IPv6 address must be put in square brackets (e.g. `[::1]`). An absolute path requires another slash (i.e. // after the hostname). Otherwise, the path is relative to the current directory after login to the SSH server. See examples below: This URL notation is a simplified form of accessing files via SSH. For even more connection options, you can use the `net.ssh()` object which allows, e.g., the configuration of the public/private key file path or different host key check procedures. See the documentation for the `net.ssh()` object for further details. If both, URL notation and `net.ssh()` object, are used to configure the SSH connection, communication parameters specified in the URL have higher priority. So, if a username is given within the URL as well as the through the object, the username from the URL is used. The file for an inverse command cannot be on a remote system. If a remote report, info or log file is specified, the output data written to the remote system is in the local system's character set. When reading user tables, checksum files, password files or other miscellaneous text files, an automatic character conversion to the local character set is performed. When accessing files via SSH from a mainframe system, the remote file is handled like a file from a non-mainframe platform that does not support datasets since SSH file access is block-oriented and not record-oriented. This means that, if record I/O is used, records are written or expected in one of the open formats on the remote system. For example: This statement for the CONV command of FLCL reads a local physical sequential variable block dataset with a logical record length of 133. A pair of 4 byte length field followed by the record data is written to the remote file for each read record. This is because the default mapping of the host record format (`VB`) to a non-host platform is `OPN_VAR`. With version 5.1.21 the file name specification was extended to an array. This make it possible to provide a list of files/URLs in the forms below: In the last case a parameter file containing the list with the URLs can be provided using dynamic or static allocation (DD: only for z/OS). In the case a lot of URLs with several connections can be used. FLAM supports now a connection cache with the result that only the required connections are open. The `NET` overlay provides the default settings for each different URL. In each file specification wildcards are still possible. The feature can be used to combine different files in one archive. ",
"",
""
],
[
"flcl_manual-flcl_utility-directory_support_2ee5.html",
"Directory Support",
"=== Directory Support Multiple input files can be processed at once by using wildcard patterns as input filename and recursion into directories. It is also possible to select only certain members of FLAMFILEs by pattern or index and to specify how directories are traversed. Input file or member names can contain the wildcards below. The wildcards are supported on subprogram level, i.e. wildcards are available in the batch utility and in subprogram calls. Wildcards are not supported on record or byte interface level. If one of the wildcard characters is part of the filename itself, you can escape the wildcard character with the caret (`^`). For MVS datasets each qualifier is separated with a period (`.`). If you want to let the asterisk (`*`) or plus sign (`+`) match more than one qualifier, you must put it twice (i.e. `**` or `++`). On non dataset based systems (UNIX, Windows, USS, Linux) this mechanism is not available as there are no qualifiers in filenames and hence periods are handled like any other character. Below you can find some examples: The directory support for MVS includes Generation Data Groups (GDG). If you want to read only the previous generation of all GDG's under your SYSUID, you must type as follows: Is a wildcard used at read and the different files should be written into a generation data group as several versions. The file index in minimal amount of digest '[ind0]' could be used the define the next generations '(+[ind0])'. The enclosing quotation marks are required because the file name string contains round brackets. Strings without quotation marks are terminated at the first space character or curved or squared bracket. NOTE: If you use a wildcard in the first/high level qualifier, the catalog search interface (CSI) is used to return each dataset in the catalog. All these datasets are then compared against the corresponding pattern. This can consume a lot of time. Be careful with wildcards in the first/high level qualifier at ZOS dataset names. NOTE: Using wildcards at the beginning of a pattern (for example '**(MEMBER)') could result in opening a dataset which is stored on a tape which is not available immediately. This could result in the process waiting for console input. By default, datasets on tapes are not included in the dataset list retrieved by the wildcard mechanism. If you want to include datasets on tapes, then you must enable the corresponding switch. However, this will not prevent a console request. Files in catalog where the volume is not available, will result in the same behavior. Be careful with wildcards at the beginning of the search pattern. The escape character can be used for datasets, but this is not required. If the match string contains parenthesis `()`, only PO datasets are matched. To match GDG, the first character inside the parenthesis must be `+`, `-` or a number. In all other cases, a PO dataset is assumed. Relative generation numbers are currently not supported for PO datasets. To process only certain members inside archives, a match string for members can be used. A member can be defined as part of the URL with `?` as separator. Alternatively, for FLAMFILEs, a dedicated member specification can be used. In this case a leading question mark (`?`) is ignored. For a question mark as first wildcard, specify two of them. You can also select members from archives based on the member index. In this case, the member name must start with a hash (`#`) or colon (`:`) and can contain a list of indexes and/or index ranges (two indices separated by minus (`-`), inclusive) separated by comma. For example: All four variants read the 3rd, 5th, 8th, 9th, 10th and 15th member from files in the current directory that end with '.adc'. To define how wildcard strings are matched, there is an object called 'DIR' that contains some switches. These include recursion into sub-directories, recursion into archives, inclusion of hidden files, symbolic link, etc. See the chapter to the 'DIR' object below for more information. Missing directories are created automatically. To prevent this the switch 'NOMKDAR' must be activated. Overwriting of existing files can be prevented with the 'REMAIN' switch (see below). To convert the file names matched to a certain file name for writing see <<flcl.input.output.name.mapping,INPUT TO OUTPUT NAME MAPPING>>. ",
"",
""
],
[
"flcl_manual-flcl_utility-input_to_output_name_mapping_43e0.html",
"Input to Output Name Mapping",
"[[flcl.input.output.name.mapping]] === Input to Output Name Mapping When creating/extracting an archive, converting files or (more generally) doing batch processing, one might wish to automatically generate new filenames based on a pattern applied to the input filenames. Example: You might want to read a member from a FLAMFILE which was created on a mainframe and contains dataset names. You wish to convert the dataset name into a path-based file name. You can achieve this by defining a pattern for the output file or member name. An output filename pattern can consist of simple text strings and tokens. Text strings are used as-is as output filename. Tokens are enclosed in square brackets (`[]`) and describe processing rules applied to the original file or member name. The pattern can consist of an arbitrary number of text strings and tokens (including none at all). A token can consist of one or more processing rules. Multiple processing rules are separated by a pipe character (`|`). Every processing rule within a token receives the output of the previous rule as its input. This allows chaining of processing rules. Characters inside tokens can be escaped by a preceding caret (`^`) to avoid interpretation as pattern syntax. Outside of tokens, carets are treated literally, except in front of squared brackets to treat a bracket literally and not as token delimiter. The keywords of the tokens below are not case sensitive. This is the list of supported processing rules: * [path]   - Extracts the string before the last slash or backslash, i.e. the path without trailing (back)slash * [name]   - Extracts the part after the last (back)slash, i.e. the filename * [base]   - Extracts the part between the last (back)slash and the last dot, i.e. the filename without extension * [ext]    - Extracts the part after the last dot, i.e. the file extension * [member] - Extracts a string enclosed in round brackets from the filename part of the string, e.g. a PDS member name on z/OS * [copy]   - Simply copies the input string (useful if you only want to add an extension) * [upper]  - Converts all characters to upper case * [lower]  - Converts all characters to lower case * [title]  - Converts the first character to upper case, all others to lower case * [cutX]   - Cuts off the string after the X-th character, where X is a positive or negative number              indicating how many characters to keep, counting from the front (positive) or back (negative) * [indN]   - Inserts the current index as decimal number of at least length N (padded with preceding zeros)              N is any number between 0 and 9, where 0 results in variable length numbers with their shortest              possible representation (no preceding zeros) * [rndN]   - Inserts random numbers of length N (with preceding zeros)              N is any number between 0 and 9, where 0 results in variable length numbers (no preceding zeros) * [AX]     - A is a place holder for a single-byte character, X is a positive or negative number;              Extracts the string part between the X-th occurrence of the specified character and the next              occurrence of that same character. If X is negative, search starts at the back and in reverse.              If X is 0, the part before the first occurrence of A is extracted. * [AX-]    - A is a placeholder for a single-byte character, X is a positive or negative number;              Extracts the string part after the X-th occurrence of the specified character.              If X is negative, search starts at the back and in reverse.              If X is 0, the input string is copied. * [AX-BY]  - A and B are placeholders for a single-byte character, X and Y are positive or negative numbers;              Extracts the string part between the X-th occurrence of A and (relative to that occurrence)              the Y-th occurrence of B. Like above, negative numbers mean counting from the back. * [search=replace]  - Replaces the first occurrence of the string 'search' with the string 'replace' * [search=*replace] - Replaces all occurrences of the string 'search' with the string 'replace' * [regex:/pattern/replace/modifiers] - String replacement with Perl-compatible regular expressions * [table]  - Evaluates to the current table name if end of table handling is activated (only when reading tables) Regular expressions (short: regex) can be used to apply arbitrarily complex matching rules and substitute these matches using the syntax `[regex:/pattern/replace/modifiers]`. They can be chained like any other processing rules using the pipe character, e.g. `[regex:/pattern/replace/modifiers|upper]` The character immediately following the keyword `regex:` is a delimiter to separate the pattern, replacement string and optional modifiers. The delimiter can be any single-byte character that does not occur in the pattern or replacement string and is expected exactly three times. You can also use pairs of brackets as delimiters in which case the matching closing bracket is expected to follow an opening bracket. A few examples using different delimiters, all performing the same replacement: * `[regex:/pattern/replace/modifiers]` * `[regex:#pattern#replace#modifiers]` * `[regex:{pattern}{replace}modifiers]` The pattern and replacement strings must not be escaped with carets (`^`), even though they are inside a token (`[]`). Regular expression patterns in the Perl flavor are matched against the input string to find the substrings that are to be replaced. Writing regular expressions may seem like a daunting task if you never did so before. Understanding the basics is not as complicated as it may seem. You can find a tutorial that will get you started quickly here: + https://www.regular-expressions.info/quickstart.html Countless other tutorials and documentation for regular expressions can be found on the web. We recommend to consult these ressources to familiarize yourself with regular expressions. Advanced users can find the complete syntax documentation for writing regular expression patterns by following this URL: + https://www.pcre.org/current/doc/html/pcre2pattern.html Replacement strings are mostly string literals, except for the dollar character. A dollar character is an escape character that can specify the insertion of characters from capture groups and names from `(*MARK)` or other control verbs in the pattern. In other words, it can be used to insert parts of the match into the replacement string. Capture groups in a regex pattern are sub-expressions in parentheses. These can be accessed by their numerical index starting at 1 (`$1`, `$2`, ...). The capture group accessed by `$0` always references the whole match. Capture groups can also be referenced by name. A named group in a regex pattern uses the syntax `(?<name>subpattern)`. This group can then be referenced in the replacement with `\$\{name}`. Modifiers change the behavior of regular expression matching and/or replacement. Modifiers are optional and must be placed after the final delimiter. Multiple modifiers can be combined. Currently, these modifiers are supported: * `g`: Enables global matching. The regular expression is applied        repeatedly and all matches are replaced. By default, regular        expression matching stops after the first match has been replaced. * `E`: Fail with an error if the regular expression does not produce any        match. By default, the input string remains unchanged if there        is no match. * `R`: Instead of replacing matches in the input string, only the        replacement string is returned. * `i`: Enables case insensitive matching. * `m`: Enables multi-line matching. By default `^` and `$` only match at        the start/end of the entire input string. With multi-line matching,        they also match after/before newlines. Note, however, that unless        the `s` modifier is set, the 'any character' metacharacter (`.`)        does not match at a newline. * `s`: If set, a dot metacharacter in the pattern matches any character,        including one that indicates a newline. However, it only ever        matches one character, even if newlines are coded as CRLF.        By default, a dot does not match at a newline. * `x`: Enables extended matching mode. Most whitespace characters in        the pattern are ignored except when escaped or inside a character        class. Characters between an unescaped `#` outside a character        class and the next newline, inclusive, are also ignored, which        makes it possible to include comments inside complicated patterns. * `n`: Disables numbered capturing groups (inside parentheses) in the        pattern. Any opening parenthesis that is not followed by `?`        behaves as if it were followed by `?:` but named parentheses can        still be used for capturing (and they acquire numbers in the        usual way). The last example shows a wildcard used at read and the different targets should be written into a generation data group as several versions. The file index in minimal amount of digest '[ind0]' could be used to define the next generations '(+[ind0])'. Patterns can be used for output file and member names. This mapping mechanism is very powerful. For example, it can be used to compress each directory into a separate FLAMFILE, with each FLAMFILE containing all files of that directory. If you define an output filename pattern that results in the same path being generated more than once, the second and further occurrences will append the data to previously written files. If no pattern defined, this means that all matching files on input, will be written to one output file or archive, the append flag is automatically enabled starting with the second file. ",
"",
""
],
[
"flcl_manual-flcl_utility-key_label_handling_6b95.html",
"Key Label Handling",
"=== Key Label Handling For cryptographic operations (signing, encryption) keys are required. Beside passwords and passphrases FLAM supports professional key management solutions, based on different cryptographic infrastructures and hardware security modules. For example, on z/OS ICSF on other IBM platforms CCA and on distributed platforms PKCS#11 are supported. If a key protected by a shielded hardware module it must be normally referenced by a name called key label. These names or better the convention for these key labels can be different from client to client. To support different key label conventions FLAM supports key label templates. Key label templates using the same replacement mechanismen for environment variables (<ENNVAR>) described in the file name handling above. Only the sepcial characters used as abbrevation are differ. FLAM use hard coded default key label templates for the different encryption solutions. For the OpenPGP support for example: Depending on the application several %x replacments can be supported. These qualifier (%u/%t) are replaced with the corresponding variables. In the OpenPGP example above %u are replaced with the USERID or KEYID and %t are replaced with the internal used key type definition. If you provide as USERID for example '~' or '<SYSUID>' then the current logon name is used a user id. First the %x is replaced by the variable and then the replacement with the defined environemnt variables is done. Below you can see a few examples with an environment id 'T' for TEST and the internal types 'PUBLIC' or 'PRIVATE': The internal type is defined by the application (mainly the used FLAM key management extension version 5 (FKM5)). Over the key template only the position of the internal type can be defined, the value is given by FLAM. The key template handling and limitations (how long, which characters, how many qualifiers also) are depending on the FKM5. The underlying cryptographic infrastructure defines what is possible. For example, a key label in PKCS#11 can be free defined and for ICSF/CCA it must conform to host data set names. Have a look at the FKM5BOOK for these details. Since version 5.1.16, the replacement characters are no longer case sensitive. The two templates below are equivalent This change is making it easier to define such templates in JCL (CAPS ON) on z/OS. ",
"",
""
],
[
"flcl_manual-flcl_utility-password_handling_6b3b.html",
"Password Handling",
"=== Password Handling Several components allow entering passwords, for example to encrypt files or establish SSH connections. Putting such sensitive information inside a script, a JCL or entering it directly on the command line can be serious security issue. Therefore, any string assingment within a command can be sourced out to a file which is much easier protected against prying eyes. The prefix 'f' tells CLE/P that the string must be read from the specified filename. The file itself must contain the CLE/P string value. With SSH you can provide the password as part of the URL: In this case, it may not be very useful to put the whole URL inside a file. Instead, the password can be specified through the corresponding NET object, where the password is a separate parameter. The rest of the connection information can remain in the URL: If you wish, you could also put all connections parameters inside the NET object, so that the URL form is not needed: If a connection parameter is specified in the URL as well a in the SSH NET object, the values from the URL takes precedence. The special replacement capabilities (~) for file names, however, are only available for the URL. In the NET.SSH object only the simple string replacements (<cuser>) can be used. Sometimes it is convenient to use a parameter file for an object, overlay or command which contains the password. All these capabilities can be used to protect passphrases, but we recommend to use public key authentication with SSH and the use of our key management extension (FKME/FKM5) for PGP or FLAMFILEs to protect the keys by professional cryptographic infrastructure (e.g. with a HSM (hardware security module)). ",
"",
""
],
[
"flcl_manual-flcl_utility-handling_of_empty_records_8268.html",
"Handling of Empty Records",
"[[flcl.handling.empty.records]] === Handling of Empty Records The handling of empty records is complicated on z/OS. FLAM5 uses the language environment (LE) to read and write records. If the environment variable '_EDC_ZERO_RECLEN' is not defined, it defaults to Y(es) for the record I/O operations. When reading, this results in an empty record being converted to a neutral FLAM5 record element. When writing, however, an empty variable length record is not written at all by the LE. To circumvent this, a padding character (default: 0x00) is written for an empty variable length record. To suppress this added padding character when reading the output file later, a record of length 1 with 0x00 or 0x40 will result in an empty record of length 0 if the environment variable '_EDC_ZERO_RECLEN' is set to 'Y'. In any other case, empty variable length records are converted to a record of length 1 containing the padding character by default on z/OS (binary files: 0x00, text files: whitespace character (0x40)). On platforms which support writing empty variable length records, when writing fixed-length records or when print control characters are used, this kind of dirty padding of empty variable length records is not done. ",
"",
""
],
[
"flcl_manual-flcl_utility-handling_of_spanned_records_7e5a.html",
"Handling of Spanned Records",
"[[flcl.handling.spanned.records]] === Handling of Spanned Records Spanned records are supported by FLAM5 components with a record length of up to 1 MiB. This length can be extended on request. The old FLAM4 components do not support such large records. To write large records to the old FLAMFILE, the matrix with the records must be convert to a block with record length fields in order to write this block into a FLAMFILE. The FLAM4 components will handle such a block as an undefined byte stream. When reading, the conversion from block to records must be requested with the same method to restore the original records. With XCNV, block/record formatting or conversion capabilities can be used. The CONV command offers the LARGER switch when reading and writing FLAMFILEs to activate the this type of conversion. When LARGER is used the block conversion is performed with the B4X method. There is currently no automatic approach implemented for it. The following example uses the XCNV command to read a VBS file and write the large records to a FLAMFILE with block formatting. To read the created FLAMFILE back to records and write it as VBS, the job below can be used, using record conversion. The READ/WRITE.FLAM4() objects with the LARGER switch actived will do the same, but without the possibility to change the format of the length field with the METHOD parameter. The FLAM command of FLCL and the new FLAM4 utility will also support the LARGER switch when reading and writing FLAMFILEs. By default, the record length for VS/VBS is 1 MiB. To save memory, this can be reduced with the RECLEN parameter. The FLAM5 I/O will read large V(B)S records by default. This can be deactivated for record I/O by using the switch NOSPAN. This switch is active for the FLAM command of FLCL, or the new FLAM4 utility, if the LARGER switch is not enabled to ensure backwards compatibility. NOTE: Automatic record length detection will not work with large records (>=32768). This requires to set the record formatting method when reading such a FLAMFILE. ",
"",
""
],
[
"flcl_manual-flcl_utility-use_of_ibm_unicode_services_6a92.html",
"Use of IBM Unicode Services",
"[[flcl.use.of.unicode.serives]] === Use of IBM Unicode Services Since version 5.1.27, FLAM supports the use of IBM Unicode Services on system Z. The Unicode Services are used only if no user table, transliteration, case mapping, subsets, whitespace handling, reporting, normalization or other complex conversion is requested. If a simple conversion is done, in a few cases the implementation of FLAM is faster and FLAM will still use this faster implementation. In all other cases, the IBM Unicode Services will be used by default to reduce CPU and memory utilization. It is important to note the differences in behavior of the IBM Unicode Services: * If an incomplete character is encountered and the error handling is not   STOP, the FLAM character conversion module ignores or substitutes this   incomplete character. The IBM Unicode Services does return an EINVAL   error in this case. * IBM Unicode Services can produce errors for technically valid code   points when processing UTF-8 encoded data. The FLAM character   conversion module first decodes UTF-8 and verifies the code point   afterwards, independent of the encoding. This means you can encode   code points in multiple forms (e.g. the character 0 as 0x30 or   0xFC80808080B0). The IBM Unicode Services support only the shortest   form (0x30) of an encoding for a code point and all other possible   encodings are not accepted and will result in an error (invalid   character). * Depending on the Unicode Services version (APAR) a BOM character in   the data might remain for UTF character sets or might be replaced by   a substitution character for single byte character sets.   When calling the Unicode Service FLAM will request the BOM removal, and   FLAM will remove a BOM character if it is causing an invalid character   error, but both will not work with certain versions of Unicode Services. * No error is caused by a wrong BOM (invalid character) in the middle of   the data and a BOM change from LE to BE or vice versa is also not detected.   For data with mixed endianness the Unicode Services should be deactivated. To prevent these changes in behavior you must set the system symbol `&FLIBMUS` or the environment variable `FL_IBM_UNICODE_SERVICE` to `OFF`, but this will result in more CPU and memory utilization for simple character conversions (see chapter <<clep.main.usedenv,Used Environment variables>>). The environment variable's default is `AUTO` which ensures that only the minimal behavior changes above are in place. To use the Unicode Services also for character conversion mode `STOP` the environment variable has to be set to `ON`. This will cause FLAM to use the round trip conversion technique of the Unicode Services, which results in the behavior changes below: * A lot of non-convertible characters will be converted to a unique   character in the target character set without an error using the round   trip conversion scheme. * A substitution character is only converted with activated substitution.   Without substitution, the substitution character 0x1A in ASCII/UTF or 0x3F   in EBCDIC will cause an error. Based on that behavior FLAM will request   the substitution if Unicode Services are used. We recommend to set FL_IBM_UNICODE_SERVICE=ON to maximize performance if the limitations described above are acceptable because checking each character if it is valid or not has a significant performance impact. ",
"",
""
],
[
"flcl_manual-flcl_utility-table_support_c92a.html",
"Table Support",
"[[flcl.table.support]] === Table Support Since version 5.1.16, FLAM supports conversion of tables in the form of fixed and variable record structures (based on length fields or binary delimiter) and CSV (comma separated values) files. Tables can be encoded, encrypted and compressed like any other file. Tables can be converted easily between FB/VB datasets, CSV, XML and other file formats. Table columns can be re-ordered, removed or written in multiple representations (adds additional columns). The table format must be described as row specification. This is a CLP string which contains an unlimited amount of columns. There can be more than one row specification per file, which means that multiple tables may be present in a source. Support for tables is most useful when used through our stream, byte and record interfaces. For example, a Java or C/C++ application that can process CSV files, can also process tables stored in physical FB or VB datasets by converting back and forth between both formats with FLAM. A COBOL or PL1 application could use the record interface to put or get fixed or veriable structures, but in reality a CVS or XML file is read or written on a local or remote system. When reading, the format of each column must be described, so that FLAM knows how to break up records into cells of the table. For example, a simple method is to cut records into multiple cells based on a fixed length for each column. When writing, columns are written in their original format unless a row specification is provided that describes how the columns are joined together with the other elements in this row to a certain data format. For each column, an unlimited number of pre-processing steps can be specified which are executed before neutralisation of the read element. A pre-processing step could be column decryption or type conversion, e.g. conversion of a BCD number to a neutral FLAM-internal integer representation, or any other supported conversion. When writing, this neutralised number could be written to a column as decimal number string. An unlimited amount of post-processing steps (e.g. encryption) can follow before a table cell is written out. For hierarchical formats an additional format-specific path must be provided for each column. There can be more than one such path to support different hierarchical formats for the same table. This allows to convert the same table, for example, to a CSV file (no path required), to an XML file (XML path required) and to a Swift MT103 message (TVD path required). For more information, please read the table formatting sections. ",
"",
""
],
[
"flcl_manual-flcl_utility-pre__and_post_processing_8cac.html",
"Pre- and Post-processing",
"=== Pre- and Post-processing Starting with version 5.1.21, custom commands can be executed before and/or after conversions. These pre or post commands can be executed per file and/or per conversion task. Pre and post commands can be executed on the reading and the writing side of a conversion. Per-file commands are executed either before the correspond file is opened or after it is closed. Commands are executed on the machine where the file is read from / written to. So, when writing a file via SSH, associated per-file commands are also executed on the remote host. Executing commands per file is only supported with the FIO objects of the XCNV command at INPUT and OUTPUT. The READ and WRITE overlays of the CONV object currently only support global pre and post commands. Per-file commands can access the filename / path of the associated file through the square bracket syntax known from filenames (see the section <<flcl.input.output.name.mapping,INPUT TO OUTPUT NAME MAPPING>> for details). At write the file post-processing are only done by default in the final close of the I/O component. This results at directory walk in only one post-processing for the final file. This is required for example if you will write all the files to one archive or append anything to one file. If you process n input files to n output files it could be useful to enforce the post processing per file. Since version 5.1.24 of FLAM the switch 'PERFILE' could be activate for this. Below you can find an example using XCNV with pre and post commands: In the input portion, a pre-processing step makes sure that the input file exists on the remote host. Output written to stdout or stderr by the command is ignored. Only in case of an error, the first bytes of stderr output are written to the error trace. The CCSID parameter can be set to the charset used on the remote system. This converts any command output from this CCSID to the local character set. For commands executed via SSH, this defaults to UTF-8 with automatic fallback to Latin-1. For local commands, the local character set is used by default. In the example above, the correct CCSID for USS on z/OS is included as comment. The post-processing step deletes the input file, but only if the conversion succeeds. This command's standard output (stdout) and standard error (stderr), if any, is written as STDOUT to the log. The default CCSID (UTF-8/Latin-1) normally fit, but if the Euro-Symbol in the data, ISO8859-15 would be the better choice. In the output portion, there are two post processing steps, one is executed on successful conversion, the other when an error occurs. On success, a SHA1 checksum of the written gzip file is calculated and the output is written (in UTF-8) to a file on the SSH host of the input file for verification purposes. The command output is converted to UTF-8 (from 'UTF-8' with 'Latin-1' fallback because no CCSID is specified. On error, it is attempted to delete the possibly partially written file. We recommend to use SAF checks to restrict how this feature can be used because it can execute arbitrary shell commands with the rights of the current user. ",
"",
""
],
[
"flcl_manual-flcl_utility-use_of_built_in_functions_0fd4.html",
"Use of Built-in Functions",
"=== Use of Built-in Functions The generated description of the built-in functions are independent of the program, owner and command names. This may make it difficult to use them. Below, you can find some examples for the use of built-in functions of FLCL. All built-in functions not listed here do not require any parameters. On mainframe systems, using built-in functions in JCL looks like: For documentation, help and syntax you can also use the ISPF commands FLDOC, FLHLP and FLSYN under menu 6. ",
"",
""
],
[
"flcl_manual-flcl_utility-conv_versus_xcnv_and_icnvs_d27e.html",
"CONV versus XCNV and ICNVs",
"=== CONV versus XCNV and ICNVs Sometimes it is difficult to figure out which command is the right one. Especially for the conversion commands (CONV/XCNV/ICNV) understanding the differences is important: * simple to use, more automatisms, fewer parameters * the user must not know how the data is formatted or where it came from * the conversion is done on a best-fit basis for platform specific formats * there are no possibilities to do dirty things * converted data can be written to only a single target * the automated detection and conversion can result in more CPU usage * only global pre- and post-processing at read and write is supported * gives access to all capabilities of FLUC (more complex to use) * the user must know how the inout data is formatted and where it came from * the conversion is done as good as possible to the original data * dirty things (e.g. manipulation of file modification time) are possible * conversions are limited to a minimum of CPU usage * output can be written to multiple targets via an array of file I/O specifications * supports global pre- and post-processing and pre- and post-processing per file * provides only character set conversion for block or record-oriented files * is much simpler than CONV and XCNV ",
"",
""
],
[
"flcl_manual-flcl_utility-conv_read_write_overview_7926.html",
"CONV READ/WRITE Overview",
"=== CONV READ/WRITE Overview The 'read' part describes how input data should be handled, whereas the 'write' part describes how to write the data which strongly depends on how it was read. * RECORD ** FIX, read records with a fixed length ** VARIABLE, e.g. record starts with length field ** DELIM, record ends with defined delimiter (like READ.TEXT but just one delimiter is defined) ** Character conversion, if CCSID is set, else binary handling ** Records as output * TEXT ** Record length is ignored/lost ** Text is split at delimiters (all usual text delimiters) and separated into a record and a rest portion (trailing whitespace + delimiter) ** Automatic character conversion ** Records as output * CHAR ** Record length is ignored/lost ** Reads all characters, delimiters are also part of the data ** Automatic character conversion ** Blocks as output (block handling) * BIN ** Record length is ignored/lost ** Reads all bytes as is ** Blocks as output (block handling) [cols='2h,5,5',options='header',width='100%'] | READ / WRITE | RECORD | TEXT | RECORD * FIX, write with fixed length * VARIABLE, e.g. write with length fields * Character conversion only if CCSID is set ** If printable characters ** Else binary handling * Read records are complemented with a delimiter ** Non Host files e.g. USS ** Definition of own delimiter is possible ** Automatic character conversion | TEXT * Read text records are written (rest portion is dropped) ** Usually VB * Other record formats also possible ** Padding on FIX records * Automatic character conversion * Read text records are written (rest portion is dropped) * Supplemented with system delimiter ** Definition of own delimiter is allowed * Automatic character conversion |CHAR * Usually not useful! * Read blocks are cut into records * Default: ** VB with n records and smaller rest at the end * Automatic character conversion * !!! ERROR !!! |BIN * Usually not useful! * Read blocks are cut into records * Default: ** VB with n records and smaller rest at the end * Automatic character conversion, if required * !!! ERROR !!! [cols='2h,5,5',options='header',width='100%'] | READ / WRITE | CHAR | BIN | RECORD * Records are concatenated * Automatic character conversion * No delimiter supplement * Records are concatenated * Binary handling | TEXT * Read text records are written with original delimiters * Automatic character conversion * Keep internal representation (UTF-8) of text * Read text records are written with original delimiters |CHAR * Automatic character conversion * Keep internal representation (UTF-8) of text |BIN * Read data is assumed to be in local charset * Writes character blocks ** Possibly character conversion * Read binary blocks will be written ",
"",
""
],
[
"flcl_manual-flcl_utility-security_considerations_d11e.html",
"Security Considerations",
"=== Security Considerations Safety is an important issue for FLAM. FLAM can help to fulfill many security requirements (e.g. PCIDSS, ISO27001, ...), using encryption (OpenPGP, SSH), hardware security modules (PKCS#11 and IBM CCA/ICSF for key exchange and signing), strong access control and checksums, antivirus scanning and much more, nevertheless the following points must be observed for the secure operation of FLAM. TODO: With a maintenance contract you can register in the customer portal for a newsletter about security vulnerabilities. This newsletter will be sent if a security vulnerability for FLAM comes up. This is useful in supporting your secure operating center (SOC). In the `install.txt` for your platform under prerequisites you will find the software on which FLAM is based or depends. If nothing is listed, then only the operating system with the language environment and the corresponding libc is affected. In the `about.txt` you can see all the external libraries and their versions that FLAM integrates. Both pieces of information can be used to determine whether the use of FLAM might be affected by an emerging security vulnerability.  With the call `flcl version` a version of each software component is written. The installation of FLAM will be coherent if all build numbers are the same. The build number is the last number of the version behind the minus character. Especially for dynamic linked parts of the software it will be important to check if the installation was well done. We recommend establishing an installation verification process which runs the built-in function `VERSION` and verifies that the build numbers are all the same. limes support code signing for modules and installation packages if it is possible on a platform. If not limes provides secure checksums to allow verification of the packages after download. There are a lot of environment variables or system symbols which are security related. Below you can find some important examples (please note: this list is incomplete): * FL_PGP_PREF_SYMALG_AES128 - Invert order of preferred symmetric algorithms from AES256/192/128 to AES128/192/256 in PGP certificates * FL_ALLOW_LOW_ENTROPY      - If defined and no source of entropy is available, the random number generated is seeded with a low entropy which may result in weak encryption keys * FL_DEACTIVATE_HW_CRYPTO_ACCELERATION - Deactivate hardware acceleration for cryptographic operations (enforce use of software implementation) * FL_SSH_HOME_DIR           - Directory containing SSH key files and known_hosts file (/home/user/.ssh) * FL_KEY_EXPIRE_WARN_DAYS   - Amount of days to warn before a key will expire (default is 90 (3 months)) See <<clep.main.usedenv,Used Environment Variables>> and verify these settings. To get a list of the current environment please use the command below: For operating systems implementing a secure access facility (e.G. z/OS) FLAM supports a lot of policies and additional resources for better control about the usage of FLAM. For more information about this see <<flcl.saf.considerations,SAF Consideration>> and the `install.txt`.  Unfortunately, there is no such additional protection of application-specific resources for other operating systems. With the SAF support it is possible to ensure minimal key, password or hash length. Critical operations like input logging, packet capturing, antivirus scanning etc. can be deactivated and more. There are a lot of policies and resources defined for the supported cryptographic features (PGP, EDC, SSH), which will not be explained below in more details. Credentials (Passwords, PINs, Keys, ...) entered using the CLP strings are flagged as protected and will not be printed in clear form. Such values are replaced by `****** SECRET ******` unless the input logging is activated. In this case the complete command string is written to the log and might contain critical values. After parsing the command line FLAM knows the critical values and is replacing them. Additionally it is better to provide such sensitive input within parameter files. The file can be better protected. But the best solution in such cases is to use a hardware security module (HSMs).  FLAM supports hardware security modules (HSMs) over a service provider interface for session key procedures and signing (PGP, FLAMFILE, ...). Currently, the use of PKCS#11 and IBM CCA (including ICSF) are supported. We recommend using the HSM support instead of clear passwords for key stores or such critical things. The misuse of the service provider interface can be prevented completely with SAF support. All software cryptographic operations are done using a central crypto kernel (CryCore). This singleton determines the optimal implementation depending on the computer used. It supports hardware acceleration if possible. But before the concrete algorithm is used the first time a self test against the NIST test vectors is done, to ensure that the loaded functions do implement the algorithm correctly. For IBM mainframes mainly the CPACF functions are used to implement the cryptographic algorithms. For all other platforms the library libcrypto of the OpenSSL project is used.  To generate keys (mainly for SSH) it is important to have a high entropy. By default, FLAM ensure a high entropy which could result in an error, if only weak randomness is available. The environment variable  `FL_ALLOW_LOW_ENTROPY` allows low entropy to prevent such errors and the policy `LOW.ENTROPY` can be used to prevent this. In some cases the quality of randomness is not so important, in such cases it could be useful to allow low entropy and in another context it will be dangerous, and then it will be better to prevent this. FLAM supports secure delete of sensitive data (keys, passwords, pins). This means that erasing the memory is done as early as possible and the overwriting of the memory will not be eliminated by the optimizer for the release code. FLAM supports antivirus scanning over a service provider interface. It will be required by certain security standards to scan the clear content of a file before it is encrypted and stored on a remote system. In such a case the antivirus scanner can be used. Our standard implementation uses clamAV, but the interface can be implemented against each kind of antivirus scanner. Simultanously, this interface is a backdoor to intercept clear data and should be closed for all other cases. FLAM implements a complete set of SAF control mechanism which can be used to ensure this.  The input logging will write the complete input parameter string to the log (this is not done by default and only important for debugging in a few cases). In this case the content is not known and might contain critical data or credentials. The SAF policy `LOG.INPUT` can be used to prevent the activation of input parameter logging. Packet capturing is useful to find errors for remote connections (e.g. SSH) but packets might contain critical or sensitive data. With the SAF policy `SSH.PCAP.ALLOWED` you can control the usage of the PCAP feature and prevent this kind of backdoor for normal processing. The command pre- and post-processing is a powerful feature of FLAM and can be used in once or per file, locally or remote at read or write. The feature was implemented mainly for process automation but to run commands (often executable code) on remote systems could be dangerous. To prevent misuse FLAM has implemented a set of SAF controls. The FLAM started task (FLMSTC) on z/OS is an active component running in the background providing services to implement the subsystems, including the LE-less interface for the FLUC record interface. The FLAMSTC provides the scheduling of SRBs in another enclave for the zIIP support and the possibility to run authorized functions. This is realized with three different PC routines. The FLAMSTC does not implement own supervisor calls (SVCs). Functions of the FLAM and FLUC subsystems are called as part I/O SVCs. The QA process is using zACS to penetrate the PC routine and the corresponding recovery routines. The only findings of the zACS scan are regular program terminations of the FLAMSTC with 0C4. TODO: sollte nur under eigenen user laufen The error trace is an important feature of FLAM which help a lot to analyze errors. For a good cause determination the data involved in the error is often written to the error trace. This means that the error trace could include parts of sensitive data items. In a case of an error this trace might need protection. It is similar to a dump processing in an error situation. Such a dump could contain critical data and must be protected. limes is using vulnerability scanners and static code analysis for conformance with certain Coding Standards to prevent critical mistakes in our programs. Additional CPPCHECK and ScanBuild are used for static code analyzes. For each platform limes uses the standard memory checker (e.g. valgrind on linux) for dynamic code analysis running over all test cases. But there are a lot of platforms without a tool for runtime analyzes. Therefore, limes has implemented an own resource checker (memory, file handles, stack, ...) in the debug code to detect stack and memory overflows, missing frees(leaks) or unclosed or misused files.  Limes is using Coco(r) to determine the code coverage of FLAM and ensure that each part of the code is tested. Squish(r) is used to automate testing of our GUIs. For automated testing of each ISPF panel and limes command we use the API of the x3270 terminal program. For all testing limes is using an own test framework which runs all the unit and regression tests on all platforms. The cross-reference tests nsures that data produced by standard tools (e.g. gzip, openssl enc, gpg) is understood on each platform and produced output of FLAM from each platform can be read with the standard tools. We use continues integration, this means that all the build tests are running after each build, a rebuild must be successful before the code is taken over from the developer repository to the main repository and all the long-running tests (performance, large files, ...) will be started automatically each night and anything will be checked each morning. This allows us to deliver rolling releases, where a customer can request a new parameter on Wednesday, and we can deploy a new revision or release on Monday. For this each weekend is currently used to clean anything, rebuild anything, tests anything, package anything, install the new package to a clean system, test anything again. And if anything was successful then we can publish the new build for our users. Sometimes it takes long to get all tests to run with success, and we cannot release a new version each week. All regression tests must be successful before we publish a new version of FLAM. The publishing include an encrypted code escrow for the complete source used to build this release. All build results, all test results anything will be stored in an archive for this publication. So we can review the complete state if a customer has a problem with a certain build including all tests results, all compile and link lists and so on. We can install from this repository easily each published build, to set up the customer environment to reproduce an error or a behavior. limes is using a mixture of SCRUM and team concert with strict coding guidelines where requirement, design, development, build, test, packaging, installation, testing again and the deployment runs in parallel. Version control is done with GIT and anything is integrated in an eclipse workspace under Arch Linux for our developer. The software development process ensures that all described QA measures are adhered to. The documentation is generated from the source code and based on that it must be totally in sync with the application and components used. The quality of the description for a parameter or the manual page for an object or overlay could be bad, but any implemented feature is documented and vice versa. We use the FLAMCLEP command string parser and anything what this compiler is accepting is defined in tables and the help message and the manual page must be provided otherwise a table error occurs. The same method is used for interface specifications (API), where each function and each parameter for each function must be documented in form of comments in the code otherwise the docu generation will fail. This process ensures that the documentation is always up-to-date and in sync with the implementation and the user can trust that anything is documented. ",
"",
""
],
[
"flcl_manual-flcl_utility-performance_considerations_7a94.html",
"Performance Considerations",
"=== Performance Considerations Performance (CPU/memory utilization and throughput) is an important topic when using FLAM. The following points describe some major factors that contribute to the overall performance of FLAM. They should give you a good starting point if you experience performance issues. In order to minimize consumed CPU cycles during mass data processing, FLAM pre-calculates as much as possible before processing any data, which requires memory on the one hand and spends some CPU time on the other. If you process many small files with FLAM, this can have a negative effect on performance. FLAM is not designed and developed to process small amounts of data. FLAM uses special instructions of the respective hardware platforms to be able to accelerate some algorithms. On IBM's mainframes, for example, this concerns the use of CPACF and zEDC. For IBM mainframe systems, it is possible to outsource memory-to-memory functions (compression, conversion, formatting) as SRBs to so-called zIIP processors. Although this does not result in a performance advantage, it does save chargeable CPU time (MSU). FLAM processes data in self-sufficient segments, which represent a block or a certain number of records. The amount of data that is processed in one go determines the throughput performance. It is important to understand that there is an overhead per segment, so the segments should not be too small. However, if too much data is put into a segment, then the processing constantly takes place outside the caches, which also reduces the performance. Here, the block size or the record count must be optimally selected for the respective platform. For historical reasons, FLAM works with a default block size of 64 KiB and a record count of 512. This is a good average value across all platforms, but not always optimal. It should also be noted that such a segment is expanded after decompression, i.e. in this case one should always start with a smaller block size. On many systems, 256 KiB is now a good block size. The optimal record count is the optimal block size divided by the average record length. Character set conversion can take up a lot of CPU time. By default, FLAM checks each character for validity and stops processing with an error if invalid or unconvertible characters are found (MODE=STOP). This form of error handling is relatively expensive in terms of CPU utilization, but ensures detection of incorrectly encoded text data. Enabling error handling that leads to the replacement of these incorrect characters, processing can be accelerated. The character set conversion is faster if all characters of the input alphabet result in data of the same length in the output alphabet. With the environment variable `FL_DEFAULT_CHAR_MODE` (or the system variable `&FLCHARM` on z/OS), the default mode for error handling during character set conversion can be changed from `STOP` to `SUBSTITUTE`, for example, in order to achieve higher performance here. On z/OS, FLAM uses the IBM Unicode Services as long as it supports the required character set conversion and is known to be faster than FLAM's implementation. This only works for simple conversions without mappings, subsets, reporting or transliterations. The environment variable `FL_IBM_UNICODE_SERVICE` (or the system variable `&FLIBMUS`) can be used to enable/disable the use of IBM Unicode Services. By setting the variable to ON instead of the default AUTO, the IBM Unicode Services will also be used if STOP is selected as the character conversion mode, which saves a lot of CPU cycles, but at the cost of no longer noticing some errors in the character data. FLAM writes many log messages by default, which also takes up CPU time and I/O. The `QUIET` or `SILENT` keywords and the `MESSAGE` object can be used to control the amount of output and thus limit or increase the amount of work involved. Often, during the transition from test to production, people forget to reduce FLAM's chattiness, which cost both disk space and CPU cycles in production. FLAM uses a global literal cache to save memory and CPU when comparing strings. Here a hashtable is used. Its size can be defined via the environment variable `FL_LITERAL_CACHE_SIZE` (or system variable `&FLITCS`). In the debug log, the appropriate statistics are output, which may help you to make adjustments if necessary. When creating ZIP archives, offsets and statistics values must eventually be written into the member headers, which requires repositioning (fseek()) within the file. This is possible for host datasets on z/OS via so-called RBA access. In a PS-VB file, this requires a tree in the background where the OS remembers which relative byte address (RBA) is in which block, in which records at which offset in the record. This is extremely time-consuming and if there are many members in the ZIP archive, this can increase the runtime considerably. The maintenance of this tree also costs a lot of CPU, which is not charged to the application. To avoid this, you should use file types for ZIP archives that are suitable for RBA access. Under z/OS, these are primarily never files in the USS. Alternatively, FLAM also supports streamed ZIP archives, as they were developed for piping under Unix systems. With the keyword `STREAM`, you can force a purely sequential write, which then also works with a PS-VB, but you should check whether ZIP tool used for extraction understands this streamed format. With PS-FB datasets, the RBA access is faster because you do not need a tree, but there is padding at the end of the ZIP file. Since ZIP archives have to be read from behind, many other tools cannot cope with this padding because they expect the ZIP directory and not 0 bytes or blanks. With FLAM this is not a problem, but as already mentioned, many other tools then recognize the ZIP file as incomplete or not even as a ZIP file. For memory allocation, don't use the realloc control feature of CEE. FLAM is only tested with default settings. With some memory allocation strategies out of memory errors can occur. For good performance and enough memory we recommend the IBM default runtime options except for run CEEOPTS below: With `ALL31(OFF)` and `HEAP(,,BELOW,,)` the available memory is too small for the stack in some cases, especially when using the FLUC subsystem, table or large-record support. Since version 5.1.25, FLAM uses application-specific run-time option defaults with the `CEEUOPT` assembly language source program to set these application-specific option defaults. The `CEEUOPT3` member used for 31 bit and the `CEEUOPT6` member used for 64 bits are located in hlq.FLAM.SRCLIB. We recommend building and linking the examples if you are going to write applications that use our APIs (e.g. FLCREC). For batch processing we recommend to create a storage report (RPTSTG(ON)) and define the CEEOPTS like recommended in the report. ",
"",
""
],
[
"flcl_manual-flcl_utility-jcl_considerations_8b69.html",
"JCL Considerations",
"=== JCL Considerations If you use JCL to run FLCL batch programs, it is recommended to use the parameter file feature for inlining commands. Parameter files can also be used for each object and overlay (see example below): The parameter files (DD:PARM, DD:ZIPARCH) are read by the command line parser and executer (CLE/P). This works only in the expected manner if NUMBER=OFF is specified for this job in the ISPF editor. With NUMBER=ON, the numbering is part of the inline code and will result in a syntax error from the CLE/P. The same is valid for the DD name STDENV. In a parameter file, you can add a semicolon at the end of each line to handle the line number as comment. Since version 5.1.20-23372: On command level if no parameter given and no parameter file assigned, then the DD name 'FLAMPAR' is read. See the example below: To execute our commands we recommend the stack and heap definitions for the memory management of the language environment below (the IBM defaults are in comment above). If for example the increments to low (128 bytes), then the run and CPU time could increase significantly. Please use the storage report (above as comment) to determine the best values for your usage. With does a lot of work depending on the parameter given. It could possible depending on what is done with FLAM that better values increase performance and lower CPU utilization. With ALL31(OFF) and HEAP(,,BELOW,,) the available memory is too small for the stack in some cases, especially when using the FLUC subsystem, table or large-record support. Since version 5.1.25, FLAM uses application-specific run-time option defaults with the CEEUOPT assembly language source program to set these application-specific option defaults. The CEEUOPT3 member used for 31 bits and the CEEUOPT6 member used for 64 bits are located in hlq.FLAM.SRCLIB. We recommend to build and link the examples if you are going to write application that uses our APIs (e.g. FLCREC). To interpret commands correctly, some of the punctuation characters are on different code points depending on the EBCDIC CCSID used to enter these values. The environment variable LANG must be set to the correct CCSID to interpret tilde and other characters correctly. see <<CLEP.MAIN.EBCDIC,Special EBCDIC code page support>> of <<clep.main,Command Line Processor>> Since z/OS 2.1, a new service (CEEGTJS) is available to determine the values for exported JCL symbols in the application. The service is called dynamically and the language environment must be in the steplib concatenation to use it. If the service is not available, the exported JCL symbols cannot be used. If the environment variable replacement fails the exported JCL symbols are tried. This feature allows you to use exported JCL symbols in the control statements of FLCL like environment variables. This is mainly useful to build powerful JCL procedures. The environment variables have a higher priority. If there is an environment variable with the same name as an exported JCL symbol, the value of the environment variable is used. System variables available as JCL symbols (if SYSSYM=ALLOW is specified in the class definition) can be exported and used in the control statements. Since version 5.1.17 of FLAM, the system symbols are generally available for replacment (e.g '...<&LDAY>...') if no environment variable with the same name exists. This means that the system symbols have the lowest priority in the replacement process. To export all JCL symbols for an application, you can use 'SYMLIST=*'. The '&name.' replacment of JESS (DD *,SYMBOLS=JCLxxxx) can also be utilized if inline coding is used. For an external parameter file, however, the JCL symbols are only available with '<name>'. ",
"",
""
],
[
"flcl_manual-flcl_utility-saf_consideration_b19f.html",
"SAF Consideration",
"[[flcl.saf.considerations]] === SAF Consideration Beginning with version 5.1.21 a lot of additional checks against a System authorization facility (SAF) can be activated. These SAF support gives for example an RACF administrator on z/OS the possibility to activate different security policies and control a lot of resources used by FLAM. * Several security policies (disable PCAP, ensure finger prints, minimal key length, ...) * CLE/P parameter strings (complete control about the functionality) * Control access to pre- and post-processing commands (executed on remote or local systems) * To secure all service provider interfaces (FAVE, FCPE, FKME) ** Control to which AV daemon the clear data is transfered * Control access to complete URLs containing connection, path, filename and member ** Allow to protect members of PDS/E, ZIP or FLAM archives * Secure SSH connections (Control user, server and port) * PGP key management (User ID to import, export, generate, delete) * Control access to PGP user and key IDs for signing and key exchange * Control methods, algorithms, modes and a lot more of the en/decryption component * Activate and enforce additional SMF logging (e.g. record type 119 (SSH)) * All feature codes of the FLAM license module The complete SAF setup is documented in the corresponding install.txt and can be simply extended on user request. For z/OS with RACF we recommend at minimum the definitions below (be careful with this example, we are no RACF specialists): First (in step 1 and 2) the general resource class $FLAM must be setup. The last step defines the rights for the certain entities. The recommendation defines all the policies and enable anti virus scanning only with the defined ClamAV daemon (DSN must be adjusted). The entities for command execution or parameter string can include whitespace or one of the other 4 invalid characters '(),;'. If such an invalid character is encountered in an entity string, it is replaced by an underscore '_' before the SAF check. For example the PDS(E) 'HLQ.PO(HUGO)' results in the resource name 'FIOURL.HLQ.PO_HUGO_'. The global pre-write pre-processing command 'ls -l' results in the resource name 'CMD.PRE.WRITE.GLOBAL.ls_-l'. ",
"",
""
],
[
"flcl_manual-flcl_utility-flcl_synopsis_8bb4.html",
"FLCL Synopsis",
"=== FLCL 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 FLCL. ",
"",
""
],
[
"flcl_manual-flcl_utility-syntax_of_flcl_46de.html",
"Syntax of FLCL",
"=== Syntax of FLCL 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: For a command of type overlay it looks like: 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. ",
"",
""
],
[
"flcl_manual-flcl_utility-help_for_flcl_4e00.html",
"Help for FLCL",
"=== Help for FLCL 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. ",
"",
""
],
[
"flcl_manual-flcl_commands_63ee.html",
"FLCL Commands",
"[[flcl.commands]] == FLCL 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. The parameter for each command can be provided as argument list on the command line or as parameter file. ",
"",
""
],
[
"flcl_manual-flcl_commands-info_98a5.html",
"INFO",
"[[CLEP.COMMAND.INFO]] === INFO indexterm:[Command, INFO, INFO] The INFO command provides further information about local or remote files, CCSIDs among others. To use CONV and other commands it is sometimes useful to know which CCSIDs are supported or which members are in a FLAMFILE or how the file attributes are named. The system information (environment, default values, hardware support) may be helpful information to diagnose errors. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for a command, please use: Parameters can be defined by the command line (directly or per file) or by properties read from the corresponding property file. * `NUMBER: FMT=LIST/XML - Specify formatting of information [LIST]` ** `LIST - Provide information as list` ** `XML - Provide information in XML-structure` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-net_d4cd.html",
"NET",
"[[CLEP.COMMAND.INFO.NET]] ==== NET indexterm:[Overlay, NET, INFO.NET] With the overlay NET you can choose the protocol for the remote read access. Below, you can find the currently supported protocols and the corresponding parameters explained in a dedicated chapter. This feature requires a FLIES server. ",
"",
""
],
[
"flcl_manual-flcl_commands-info-net-ssh_bbb8.html",
"SSH",
"[[CLEP.COMMAND.INFO.NET.SSH]] ==== SSH indexterm:[Object, SSH, INFO.NET.SSH] The SSH method provides secure remote file access through the SSH file transfer protocol (SFTP). Due to the transport encryption of the SSH protocol, the transferred data is safe from eavesdroppers even if the data itself is unencrypted. The remote host only needs a running SSH server (e.g. OpenSSH). FLAM can read and write most locally supported types of files also via SSH, including the use of wildcards and recursion into directories. Only FLAMFILEs (work in progress) and record-oriented host datasets are currently not supported via SSH (limitation of the SSH server). Authentication methods supported are password and public key authentication. There are two ways of specifying authentication parameters: via the NET-SSH object or the file URL. The file URL may contain the SSH username, the password (is using password authentication), hostname and port. The NET-SSH object also allows to specify the paths of the known hosts, public and private key files as well as the private key password (if applicable) when using password authentication. Parameters specified in the file URL always take precedence over parameters set via the NET-SSH object. To successfully establish an SSH connection, at least a hostname/IP is required. Other options can be specified or can be loaded from a OpenSSH config file. By default, options are loaded from the per-user (~/.ssh/config) and system-wide (/etc/ssh/ssh_config) OpenSSH config files, if they exist. To disable loading those default config files, use the NODEFAULTCONFIG switch. A custom OpenSSH configuration file can be set with the CONFIGFILE option. SSH configuration options are priorized in the following order: Example: The known_hosts file path is set via net.ssh(knownhosts=...) and in one of the config files with the UserKnownHostsFile keyword. Since the options specified in the command string has higher priority, it is used. Below is an (incomplete) list of keywords of the most important keywords that are supported in SSH config files. They follow the OpenSSH syntax. Please refer to OpenSSH's documentation for a description: * Ciphers * Compression * ConnectTimeout * GlobalKnownHostsFile * Host * HostKeyAlgorithms * Hostname * IdentityFile * Include * KexAlgorithms * MACs * Match * Port * ProxyCommand * RekeyLimit * StrictHostKeyChecking * User * UserKnownHostsFile The port defaults to 22 and the username defaults to the local username unless specified in the command or one of the loaded config files. If a password is specified, authentication via password is attempted. For public key authentication, the paths to a public and/or private key file can be specified (via the net.ssh() object). A private key is mandatory. There are three cases:   this keypair is performed   by appending the extension .pub to the private key file path. If no   such file exists, the public key is extracted from the private key.   This has a security implication: If the server rejects the public key   for authentication, the private key was decrypted unnecessarily. If   the public key is stored in a separate file, the private key would   remain encrypted in the case of public key rejection by the server.   with only a public key. If the public key filename ends with .pub,   this extension is stripped to build the private key filename. If no   such file exists or the public key filename suffix is not .pub,   authentication will fail. If neither a password nor a public/private key file are specified, public key authentication in automatic mode is attempted. First, authentication via an SSH agent (e.g. from OpenSSH) is attempted if one is running and the environment variable SSH_AUTH_SOCK is set to the socket path of the SSH agent. If authentication via SSH agent fails, the keys defined in ~/.ssh/config and /etc/ssh/ssh_config are tried (keyword: IdentityFile) if present. If that fails as well, a series of default keys of the local user account is used (stored in ~/.ssh/id_*, e.g. id_ed25519, id_ecdsa, id_rsa, id_dsa). When establishing a connection, a known host check is performed to prevent an attacker from performing a man-in-the-middle attack and impersonate the destination host. For this purpose, the per-user known_hosts file (~/.ssh/known_hosts) and the system-wide file (/etc/ssh/ssh_known_hosts) are used by default. A different per-user known_hosts file can be specified with the KNOWNHOSTS option. A known_hosts consists of one line per previously seen host, each containing the hostname (or hash), key type and public key of the host. Establishing a connection will fail by default (strict hostkey checking) if the host is not in the known_hosts file or if the public key presented by the server during connection establishment does not match the key in known_hosts file. FLAM is designed to run without human interaction. Therefore, by default, connecting fails if no known_hosts entry is found. To connect to a host you have never connected to before, a known_hosts entry can be added manually. FLAM can also add the missing host entry for you to the per-user known_hosts. This, however, requires to activate interactive mode (hostkeycheck=ask). When you connect to a new host in interactive mode, the fingerprint of the remote host is displayed. You should verify that the fingerprint is correct (to avoid adding a key from a man-in-the-middle attacker that might have control over the communication path to the server) and confirm the key to have it added to your known hosts file. There are more hostkey check mechanisms implemented and described in a <<CLEP.COMMAND.INFO.NET.SSH.HOSTKEYCHECK,dedicated chapter>>. The parameter VERBOSITY (or VERBOSE) activates connection debug logging (CONDBG) in the log output. There are several levels of verbosity to control the amount of logged messages. The SYSTEM level logs some details about the connection (e.g. negotiated algorithms). Levels other than SYSTEM additonally log messages from the SSH library (libssh). Examples: Establish a connection to an SSH host for the first time by trying to read a dummy file (does not necessarily have to exist) in interactive mode: Read a file 'myfile.bin' from the home directory of a remote host using the default username (either from config file or the local username) in different but equivalent ways by using default public key authentication: Read a file with password authentication and a custom username: Read from an absolute path: Read and write from/to different remote hosts, one with public key, the other with password authentication and a non-default port: Get information for all text files in a remote home directory with several connection debug information and specification of the known host file: * `STRING: HOST/SERVER/DAEMON='str' - Hostname/IP` * `NUMBER: PORT/SERVICE=num - Port number [22]` * `STRING: USER='str' - User name [optional]` * `STRING: PASSWORD='str' - Password [optional]` * `STRING: CONFIGFILE='str' - Custom config file to load (OpenSSH format) [none]` * `SWITCH: NODEFAULTCONFIG - Don't automatically load default config files (~/.ssh/config & /etc/ssh/config) [OFF]` * `STRING: KNOWNHOSTS='str' - Known host file [system]` * `STRING: PUBKEYFILE='str' - Public key file [system]` * `STRING: PRIKEYFILE='str' - Private key file [system]` * `STRING: PWDKEYFILE='str' - Password for key file [none]` * `STRING: PCAPFILE='str' - File path for (unencrypted) packet capture) [disabled]` * `NUMBER: VERBOSITY/VERBOSE=SYSTEM/INFO/PROTOCOL/PACKET/FUNCTION/ALL - Logging verbosity of SSH connection [NONE]` ** `SYSTEM - Log connection info (enables CONDBG log type)` ** `INFO - Log informational messages of libssh` ** `PROTOCOL - Log high level protocol information of libssh` ** `PACKET - Log lower level protocol information (packet level of libssh)` ** `FUNCTION - Log every function path of libssh` ** `ALL - Log all messages of libssh` * `NUMBER: TIMEOUT=num - Timeout for SSH connection in seconds [30]` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-net-ssh-hostkeycheck_daca.html",
"HOSTKEYCHECK",
"[[CLEP.COMMAND.INFO.NET.SSH.HOSTKEYCHECK]] ==== HOSTKEYCHECK indexterm:[Parameter, HOSTKEYCHECK, INFO.NET.SSH.HOSTKEYCHECK] When an SSH client connects to an SSH server, the server identifies itself by sending its public key. It is an essential part of the security of SSH that the client must validate the server's public key to make sure that it belongs to the intended (trusted) host and not to an eavesdropper / man-in-the-middle. The file in <HOME>/.ssh/known_hosts is used to store combinations of trusted hosts and their public keys. Entries to this file can be added manually or can be added when establishing a connection for the first time. In any case, you should have verified the host keys you add belong to the indended party. The known hosts file format is identical and fully compatible to the known_hosts format of OpenSSH. The HOSTKEYCHECK selection is used to specify how strict the host key sent by the server is verified to decide whether to continue connecting and whether to add the key to the known_hosts file. Here are the available options in descending order of security: * `<Fingerprint>` - You can specify a specific fingerprint that must   match the public key sent by the server. If it does not, the connection   is terminated. If the key is not in the known hosts file, it is added.   Hence, this mode is also suitable to add a host key to the known_hosts   file upon first connection to a host in an environment where you cannot   manually verify the host key (e.g. in a batch job), but without accepting   any (potentially untrusted) arbitrary key.   The fingerprint is a hexadecimal MD5 checksum of the   host's public key with bytes separated by colons (e.g.   00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff). It is always printed   to the log (INFO level) when connecting. * `STRICT` - The host key sent by the server must match one of the keys   that are stored in the known_hosts file for this host. Otherwise, the   connection is terminated, which includes new/unknown hosts. * `ASK` - Like STRICT, but prints an interactive prompt when connecting   to a server for the first time and offers to add the known_hosts entry   after you confirm the key's authenticity. * `WARN` - Connecting will continue even if the server sends an unknown   host key. If no matching known_hosts entry exists, a warning is printed   to the log about the connection being potentially compromised. * `ACCEPTANY` - Like WARN, but additionally adds the host key to the   known_hosts file if no such entry exists. Hence, you explicitly trust   any key that the server sends which also extends to future connections   in STRICT mode. WARNING: Don't use host key check levels below ASK unless you know what you are doing. By allowing arbitrary host keys, your connections can be intercepted easily. * `STRICT - Verify host key against known_hosts, abort if not present or on host key mismatch` * `ASK - Like STRICT, but asks when the key is not present (interactive)` * `WARN - Prints a warning when there is no matching entry in known_hosts file, but continues (unsafe)` * `ACCEPTANY - Accepts any host key and adds it to known_hosts if not present (unsafe)` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-net-ssh-algorithms_5987.html",
"ALGORITHMS",
"[[CLEP.COMMAND.INFO.NET.SSH.ALGORITHMS]] ==== ALGORITHMS indexterm:[Object, ALGORITHMS, INFO.NET.SSH.ALGORITHMS] SSH clients and servers support various cryptographic algorithms to secure an SSH connection. In the handshake phase at the beginning of each SSH connection, both parties negotiate the algorithms that will be used for this connection. For this purpose, client and server exchange multiple lists of their respective supported algorithms for each type of algorithm. The algorithm lists are sent in order of preference. In other words, putting an algorithm at the beginning of the list is a suggestion to the other party to prefer this algorithm over others. Algorithms that do not appear in the list cannot be negotiated. The `algos` object can be used to specify custom lists of acceptable / preferred algorithms. Each list is a comma-separated string of one or more of the supported algorithms. Unsupported algorithms are silently ignored. Algorithm lists specified via `algos` object override those specified in any SSH config file. NOTE: The handshake will fail if none of the specified algorithms is supported by the server. Preferences for the following algorithm types can be customized: * KEX: The key exchange algorithms you want to use to negotiate the secret session key * HOSTKEYS: Acceptable host key algorithms for the server's public key in order of preference * CIPHERS: The cipher algorithms allowed for data encryption in order of preference; can be specified separately for each transmission direction * COMPRESSION: The compression algorithms allowed (or 'none'); can be specified separately for each transmission direction * HMAC: The HMAC algorithms allowed for integrity protection; can be specified separately for each transmission direction To get a list of algorithms supported by the libssh library (shipped with FLAM), connect to any existing SSH server with verbose logging enabled (`net.ssh(verbosity=all)`) and without specifying the `algos` object. (For example: `flcl info 'get.file=ssh://example.com/anypath net.ssh(verbosity=all)'`) Look for a line containing 'Changing host key method to' to find the default algorithm lists (which might already be modified by your SSH configuration files). The relevant log output looks similar to this: There is another list in the log containing the algorithms supported by the server. For some algorithms, HW-accelerated cipher and hash functions are used, reducing CPU utilization for cryptographic operations considerably. On IBM Z hardware, the appropriate CPACF Message Security Assist (MSA) extensions must be available and enabled. The supported MSA version determines which algorithms are implemented in hardware. This is detected automatically during SSH connection establishment. The appropriate implementation is used by default to accelerate data encryption with AES as well as HMAC computation based on MD5, SHA-1 and SHA-2. On other platforms, the hardware accleration implementation of OpenSSL is used transparently. * `STRING: KEX='str' - Preferred key exchange algorithms (comma-separated)` * `STRING: HOSTKEYS='str' - Acceptable hostkey algorithms (comma-separated)` * `STRING: CIPHERS_CS='str' - Preferred cipher algorithms client-to-server (comma-separated)` * `STRING: CIPHERS_SC='str' - Preferred cipher algorithms server-to-client (comma-separated)` * `STRING: COMPRESS_CS='str' - Preferred compression algorithms client-to-server (comma-separated)` * `STRING: COMPRESS_SC='str' - Preferred compression algorithms server-to-client (comma-separated)` * `STRING: HMAC_CS='str' - Preferred HMAC algorithms client-to-server (comma-separated)` * `STRING: HMAC_SC='str' - Preferred HMAC algorithms server-to-client (comma-separated)` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-get_ba26.html",
"GET",
"[[CLEP.COMMAND.INFO.GET]] ==== GET indexterm:[Overlay, GET, INFO.GET] With the overlay GET you can choose which information will be printed. * `SWITCH: SYSTEM - List system information` * `SWITCH: CCSIDS - List of supported CCSIDs` * `SWITCH: ENCODINGS - List of all encodings` * `STRING: FILE='str'/STREAM/DUMMY - Information about a file (flam4/gzip/xz/bzip2/pgp/zip...)` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-get-fkme_78be.html",
"FKME",
"[[CLEP.COMMAND.INFO.GET.FKME]] ==== FKME indexterm:[Object, FKME, INFO.GET.FKME] Through the object FKME you can define the library and function of an FKME module to get information, help and documentation of the corresponding FLAM Key Management Extension. By default, the 'libfkme' of FLAM is used. If no function name is specified, all known entries of this library are used. This works only for 'libfkme' as we do not know the function names for other libraries. The function codes for help and documentation might not be implemented by other FKMEs, i.e. these switches are mainly useful with the 'libfkme' from limes datentechnik. To get FKME info for load modules on mainframes, which must be fetched from STEPLIB, you must type a * for the library name. * `STRING: LIBRARY='str' - Library name [libfkme]` * `STRING: FUNCTION='str' - Function name (entry)` * `SWITCH: HELP - Get help message` * `SWITCH: DOCU - Get documentation` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-get-fkm5_290e.html",
"FKM5",
"[[CLEP.COMMAND.INFO.GET.FKM5]] ==== FKM5 indexterm:[Object, FKM5, INFO.GET.FKM5] Through the object FKM5 you can define the library and function of an FKM5 module to get information, help and documentation of the corresponding FLAM Key Management Extension v5. By default, the 'libfkm5' of FLAM is used. If no function name is specified, all known entries of this library are used. This works only for 'libfkm5' as we do not know the function names for other libraries. The function codes for help and documentation might not be implemented by other FKM5s, i.e. these switches are mainly useful with the 'libfkm5' from limes datentechnik. To get FKM5 info for load modules on mainframes, which must be fetched from STEPLIB, you must type a * for the library name. * `STRING: LIBRARY='str' - Library name [libfkme]` * `STRING: FUNCTION='str' - Function name (entry)` * `SWITCH: HELP - Get help message` * `SWITCH: DOCU - Get documentation` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-get-usagelog_549c.html",
"USAGELOG",
"[[CLEP.COMMAND.INFO.GET.USAGELOG]] ==== USAGELOG indexterm:[Object, USAGELOG, INFO.GET.USAGELOG] Through the object USAGELOG you can specify the start and end dates as well as other parameters for FLAM usage reporting. If no parameters are specified, the log stream name (only on mainframes) and the SYSLOG identifier (which is used for usage logging) are printed. If an end date is specified, then a summary about FLAM usage is generated. You can also specify start and end date lists (arrays) to calculate usage summaries for these time intervals. For example, it can be useful to evaluate the FLAM usage on system peak hours. These reports are useful to determine CPU usage that can be offloaded to co-processors and accelerators. Additionally, it provides the amount of bytes processed by FLAM. * `NUMBER: FROM=num/OLDEST - Indicates the starting time of the first record to be processed [OLDEST]` ** `OLDEST - From oldest entry` * `NUMBER: TO=num/YOUNGEST - Indicates the ending time of the last record to be processed [no report]` ** `YOUNGEST - To youngest entry` * `SWITCH: LOCAL - Specifies the time is local time [GMT]` * `SWITCH: SHORT - Print short report [FALSE]` * `SWITCH: JOBNAME - Add job names to list [FALSE] (only relevant for z/OS)` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-out_adbe.html",
"OUT",
"[[CLEP.COMMAND.INFO.OUT]] ==== OUT indexterm:[Parameter, OUT, INFO.OUT] With the OUT parameter you can choose the file (as STRING) or stream (STDOUT/STDERR) where the information is printed. If it not provided the log is used by default. * `STDOUT - Write output to stdout` * `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-dir_4b91.html",
"DIR",
"[[CLEP.COMMAND.INFO.DIR]] ==== DIR indexterm:[Object, DIR, INFO.DIR] This object defines multiple switches that control how input files are found. This is especially important when using wildcards in input filenames. There are switches to enable recursion into subdirectories, following symbolic links, finding hidden files, recursion into archive files, include files on tapes, resolving aliases and enforcing to not leave the filesystem. If the `recursive` flag is set, the filename portion of the input file string is searched for recursively. If a directory path containing wildcards is present, the filename portion is searched for recursively in all paths that match the directory path pattern, e.g. '*/path/*.txt' matches my/path/hugo.txt, another/path/hugo.txt as well as my/path/subdir/hugo.txt. Without the recursive flag, the last file would not be found. If the `archive` switch is enabled, FLAMFILES, TARBALLS, ZIP files and other kinds of supported archives are searched. All the matching members are extracted. In other words, archives are interpreted like subdirectories if the flag is enabled. If the `tape` switch is enabled, then datasets stored on tapes or if migrated (if VOLSER = 'MIGRAT' or 'ARCIVE' on z/OS) files are searched. If the name of such a file matches the pattern, then it might occur that console input and a manual intervention is required to retrieve the respective dataset(s). A special behavior was implemented for z/OS for files on DASD, where a SVC27(OBTAIN) is issued for nonVSAM data sets (normal PS/PO). To collect also files if the SVC27 failed the obtain switch must be set. Normally this will result in a warning and completion code 4. If the obtain switch is not defined, files without a corresponding control blocks are skipped. If the `link` switch is enabled, symbolic links are followed (otherwise they are ignored). Links are mainly supported on modern file systems. For dataset aliases on mainframe systems, see the alias flag. With the `alias` switch enabled, datasets names which are aliases of the real dataset are resolved to their actual names (otherwise they are ignored). Dataset aliases only exist on mainframe systems. This flag has no effect on other platforms. If a transparent read method (e.g. read.auto()) is used, then the `archive` flag is enabled by default and cannot be disabled. * `SWITCH: LINK - Include symbolic links` * `SWITCH: ALIAS - Resolve data set aliases` * `SWITCH: HIDDEN - Include hidden files` * `SWITCH: RECURSIVE - Include sub directories` * `SWITCH: ARCHIVE - Include archives (FLAMFILEs, ZIP, ...)` * `SWITCH: ONEFILESYSTEM - Don't cross file system boundaries` * `SWITCH: TAPE - Include files deposited on tapes (or if migrated or archived)` * `SWITCH: OBTAIN - Obtain control blocks if DSAD (z/OS only, warning if SVC27 failed)` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-log_57a0.html",
"LOG",
"[[CLEP.COMMAND.INFO.LOG]] ==== LOG indexterm:[Object, LOG, INFO.LOG] The LOG parameter allows flexible adjustment for the logging of messages. It is possible to specify the destination as well as which kind of message will be written. ",
"",
""
],
[
"flcl_manual-flcl_commands-info-log-message_2468.html",
"MESSAGE",
"[[CLEP.COMMAND.INFO.LOG.MESSAGE]] ==== MESSAGE indexterm:[Object, MESSAGE, INFO.LOG.MESSAGE] The log message specification is a classification of the messages to write to the selected log destination. Each type is selectable individually by adding its argument inside this object. For added convenience, the special types NON, ALL, MINIMAL select the proper message types with just one argument. If no message specification is given, a DEFAULT is used which writes out messages of these types: * ERROR * ERRTRACE * WARNING * NOTICE * PARAMETER * STATISTICS * INFO * LICID * SUMMARY * OUTPUT * SOURCE * TARGET * `SWITCH: NONE - No messages will be logged` * `SWITCH: ERROR - Error messages will be logged` * `SWITCH: ERRTRACE - Error trace will be logged` * `SWITCH: WARNING - Warnings will be logged` * `SWITCH: NOTICE - Notices will be logged` * `SWITCH: DEBUG - Debug information will be logged` * `SWITCH: ABOUT - About information will be logged` * `SWITCH: VERSION - Version information will be logged` * `SWITCH: INPUT - Input data will be logged (dangerous for passwords)` * `SWITCH: PARAMETER - Parsed parameters will be logged` * `SWITCH: STATISTICS - Statistics will be logged` * `SWITCH: SUMMARY - Summary will be logged` * `SWITCH: INFO - Requested information will be logged` * `SWITCH: LICID - License ID will be logged` * `SWITCH: LICENSE - License summary will be logged` * `SWITCH: PROGRESS - Progress bar will be logged` * `SWITCH: OUTPUT - Output values will be logged` * `SWITCH: USAGE - Usage reporting will be logged` * `SWITCH: CONDBG - Debug information for remote connections` * `SWITCH: SOURCE - List final physical source names at read` * `SWITCH: TARGET - List final physical target names at write` * `SWITCH: STDOUT - Standard output from third-party application` * `SWITCH: STDERR - Standard error output from third-party application` * `SWITCH: MATCH - Match count will be logged` * `SWITCH: REPLACE - Replacement count will be logged` * `SWITCH: ALL - All messages are logged` * `SWITCH: DEFAULT - Relevant messages are logged` * `SWITCH: MINIMAL - Only important messages are logged` * `SWITCH: ERRONLY - Only errors and error trace are logged` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-log-destination_5c2b.html",
"DESTINATION",
"[[CLEP.COMMAND.INFO.LOG.DESTINATION]] ==== DESTINATION indexterm:[Overlay, DESTINATION, INFO.LOG.DESTINATION] Each log message starts with the current time and date. All the possible destinations allow to specify a custom identification string which will be printed after time and date of each message. This is done with the IDENT argument. If no IDENT specified the default will be 'owner.program.command' If no log destination defined stream will be used as default. ",
"",
""
],
[
"flcl_manual-flcl_commands-info-log-destination-stream_d780.html",
"STREAM",
"[[CLEP.COMMAND.INFO.LOG.DESTINATION.STREAM]] ==== STREAM indexterm:[Object, STREAM, INFO.LOG.DESTINATION.STREAM] The STREAM object allows the log messages to be written to the standard output or the standard error output. Standard error output is used if STDOUT is not specified. NOTE: The FLAM log output is written to STDERR. It can be written to a       file with `log=FILE NAME` or `2>FILE NAME`. * `STRING: IDENT='str' - Identifier used to identify log entries [owner]` * `NUMBER: FORMAT=STANDARD/DIALOG/MINIMAL - Format of log message [STANDARD]` ** `STANDARD - Standard logging format (timestamp ident *level* message)` ** `DIALOG - For dialog processing (ident *level* message)` ** `MINIMAL - For output processing (message)` * `SWITCH: STDOUT - Log messages to STDOUT instead of STDERR` ",
"",
""
],
[
"flcl_manual-flcl_commands-info-log-destination-file_f176.html",
"FILE",
"[[CLEP.COMMAND.INFO.LOG.DESTINATION.FILE]] ==== FILE indexterm:[Object, FILE, INFO.LOG.DESTINATION.FILE] The flat file option allows the log messages to be written to a normal file. The name of the file must be specified for this destination. The log messages will be appended to this file if it already exists. For the log file, all rules and replacements are valid which are described under 'FILENAME HANDLING' above. For example: NOTE: Parallel process cannot share the same log file. * `STRING: IDENT='str' - Identifier used to identify log entries [owner]` * `NUMBER: FORMAT=STANDARD/DIALOG/MINIMAL - Format of log message [STANDARD]` ** `STANDARD - Standard logging format (timestamp ident *level* message)` ** `DIALOG - For dialog processing (ident *level* message)` ** `MINIMAL - For output processing (message)` * `STRING: NAME='str' - Filename for appending log messages` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv_8fe7.html",
"CONV",
"[[CLEP.COMMAND.CONV]] === CONV indexterm:[Command, CONV, CONV] The CONV command converts data between various formats with an easy to use syntax. It was designed to simplify the use of the powerful Frankenstein Limes Universal Converter (FLUC). It can be used to read local or remote data sources (requires a FLIES or SSH server) of various formats, convert the data (e.g. decrypt, decompress and character conversion) and write the result to an unlimited amount of local or remote targets in different formats. As an example, the CONV command can be used to read an encoded, encrypted and compressed text file in UTF-16 from a Windows system, generate or verify a checksum, write each line as text record into a mainframe dataset with a dedicated record format (FB, VB, ...) in EBCDIC with ASA control characters and write an additional copy of these records in UTF-8 with line delimiters as PGP file to a remote ZIP file. All these conversions are done in one step to reduce CPU and I/O utilization. The following features are supported: * Different kinds of remote access protocols (SSH, IP-Native, MQ-Series) * Different kinds of data sources (Files, Streams, Tables) * Different kinds of archive formats (ZIP, FLAMFILE, TAR) * Different kinds of I/O methods (Binary, Character, Text, Record, FLAM) * Different data encodings (HEX (Base16), Base32, Base64, ASCII armor) * Different encryption methods (FLAM, PGP) * Different compression methods (GZIP, BZIP2, XZ) * Automatic decoding of data encodings during read operations * Auto-detection and decoding of length fields in data blocks * Auto-detection of character sets and language based conversion * Auto-detection of freely defined table formats * Powerful character conversion based on CCSIDs with ** subset support, reporting, mapping, input assistance ** Unicode support within EBCDIC code pages to work with 3270 * Different logical data formatting (BIN, TEXT, XML, tables (FB-CSV-VB), ...) If the CONV command is not sufficient to meet your requirements, you can use the XCNV command which provides all full conversion capabilities of FLAM in a kind of expert mode with maximum configurability. The CONV command provides an easy to use subset of all conversion capabilities. In contrast to XCNV, the CONV command performs various types of auto detection and automated conversions to get a data representation that fits the current system and 'makes sense' in the given context. To use the XCNV command, you must know what kind of data is read and can fully control how the data is written. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or by parameter file) or via properties taken from the corresponding property file Reads remote a binary file, calculates a SHA-256 checksum in GNU style, automatically decompresses the data (as text cannot be compressed), performs a character conversion to UTF-8 (no report required), formats the data into text records and rest elements, convert the text records to old German EBCDIC (IBM-273) with transliteration, substitution and a report file (upgrade-proof) and writea the text records to a variable blocked dataset with ASA print control characters. The user table 'DELA' ensures that only the subset of characters are valid which are available in CP1252, IBM-1141 and ISO-8859-15. Reads records from a VBA dataset, does a character conversion to UTF-8, formats the data as text with carriage return and line feed as delimiter, converts the text data to Latin-1 and writes the result to BZIP file. Conversion stopped if a character is not convertible. Assuming the input file is the output of the previous example, this cannot be the case because the user table DELA used to create the file '<SYSUID>.text(swift)' prevents characters not available in Latin-1 (a.k.a. ISO-8859-1). The previous example would transliterate the EURO sign (`€`) to 'EUR' because the CCSID was IBM-273 (does not include the EURO sign). To retain the EURO sign, the CCSID IBM-1141 (=IBM273+EURO) would have to be used in the previous example and ISO-8859-15 (=LATIN1=ISO-8859-1+EURO) in this example. Reads XML, text or binary data in encoded or clear form and converts the data to records which are printed to STDOUT (STREAM) in EBCDIC (IBM1141) where longer records are truncated (RECMODE=CUT), not convertible characters are transliterated (SYSTAB=ICONV) and if this not possible substituted (CHRMODE=SUB). With this command you can read any kind of file on mainframes and convert it to readable records. This command is used as part of the ISPF line command FLVIEW. It reads normal record oriented host datasets (PS, PDS(E) as VB/FB/UNDEFINED with or without ASA or machine print control character), VSAM-ESDS/RRDS/KSDS, FLAMFILEs, binary transfered text or XML files from other platforms, encoded and/or compressed text or XML files, etc. Reads an encrypted PGP file containing a text file with fixed length records of length 80 with CCSID IBM-037 from another mainframe system and writes the records with the local CCSID (for example IBM-1141) to an FB80 dataset. A copy is written in UTF-8 (with 0x0A as record delimiter) to a ZIP archive on a remote SSH server. This example shows the exchange of fixed-length records through of block-oriented data formats. The CONV command supports the auto detection of 4 byte length fields (read.binary()) or text delimiters (read.text()) in the data to simply exchange variable length record formats. To exchange fixed length records you can use or for text records READ.CHAR(), in contrast to READ.TEXT(), was designed to read text without delimiters. A fixed length dataset contains no delimiters and the internal record length table must be built after all the decoding steps, but before character conversion. The RECLENGTH parameter in READ.TEXT() is used after character conversion if no delimiters and no internal record length table are found to wrap the data blocks into records. If character conversion is done from EBCDIC to UTF-8 like in the example above, it may happen that some characters are converted to multibyte UTF-8 characters. In this case, the record length is no longer fixed. This means that splitting a block into records after character conversion will result in incorrectly wrapped UTF-8 records. To wrap a block into fixed-length records, READ.BINARY() or READ.CHAR() should be used. Lists all determined file attributes including CCSID, delimiter, possible base encodings and (if appropriate) the member list of (concatenated) FLAMFILEs, GZIP, BZIP2, XZ files or a PGP dump. * `SWITCH: NORUN - Don't run the command only show parsed parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read_3fb8.html",
"READ",
"[[CLEP.COMMAND.CONV.READ]] ==== READ indexterm:[Overlay, READ, CONV.READ] With the overlay READ you can choose the kind of data (binary, text, character, record, FLAM4FILE, table, ...) to read or you can use 'auto' for auto detection of the file/data format. For each read method, a dedicated behavior is implemented and the corresponding parameters can be used to detail the procedure. For example: If we know it is text and the data is compressed then the data will be automatically de-compressed, because compressed data cannot be converted to text records. If the compressed data is, for example, Base64 encoded, then a decoding is done before decompression and so on. Based on the knowledge about the kind of data you want to read, we have simplified the way to automatically do the right things for you. Reading files transparently for each kind of data format can be very powerful. After the read operation, you can choose the same or another write operation to convert your data between different platforms, file and data formats, character sets, compression, encryption or encoding methods. Additionally you can calculate or verify checksums on the binary data stream direct after the read operation. Below, you can find the currently supported data sources explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary_e808.html",
"BINARY",
"[[CLEP.COMMAND.CONV.READ.BINARY]] ==== BINARY indexterm:[Object, BINARY, CONV.READ.BINARY] Read binary operates on blocks of binary data. By default, no decompression or any other conversions are performed. These must explicitly be turned on using the respective parameters. If the 'decode' parameter is set, the data is automatically decrypted and uncompressed. If the encrypted or compressed data is encoded (e.g. Base64), it is decoded before uncompression/decryption. If a 4 byte record length format detected and decoding should be done, then the records are parsed before the next decoding step. If the uncompressed/decrypted data is encoded, it is only decoded if 'decode' is set to 'CMPDEC' or 'ALWAYS'. By setting 'decode' to one of the available values, you have further control over the enabled automatisms. If you provide a record length, the data stream is wrapped into fixed- length binary records. This is useful to exchange fixed-length records with open standards like PGP or GZIP. If you provide a binary delimiter, the data stream is wrapped into variable-length binary records. If you provide row specifications through the table object, the binary blob is split into neutral FL5 table elements (rows and columns). Binary data blocks are the simplest form of data type handled by FLAM. Binary data can only be accessed by byte offset. The structure of the data is unknown to FLAM. Using only binary blocks with FLAM mainly equals the behavior and abilities of other encryption and compression tools. You may want to try one of the other available read methods to read structured data. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECLENGTH=num - Length to activate fixed length record wrapping [0-OFF]` * `NUMBER: DECODE=NONE/ARCHIVE/FIODEC/DECRYP/CRYDEC/DECOMP/CMPDEC/ALWAYS - Decode encoded, encrypted or compressed data [0=NONE]` ** `NONE - No automated decoding` ** `ARCHIVE - Transparently read archives` ** `FIODEC - Base decoding after file IO, before decryption` ** `DECRYP - Decryption of encrypted data` ** `CRYDEC - Base decoding after decryption, before decompression` ** `DECOMP - Decompression of compressed data` ** `CMPDEC - Base decoding after decompression, before formatting` ** `ALWAYS - Always decode encoded data (causes the same as DECOMP)` * `SWITCH: RLDECO - Activate additional record length decoding [FALSE]` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to parse end of record [NONE]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: SUPPADDING - Suppress trailing padding/equal characters` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCBLK - Enforce block orientation on record oriented devices [FALSE]` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-net_e4ec.html",
"NET",
"[[CLEP.COMMAND.CONV.READ.BINARY.NET]] ==== NET indexterm:[Overlay, NET, CONV.READ.BINARY.NET] With the overlay NET you can choose the protocol for the remote read or write access. Below, you can find the currently supported protocols and the corresponding parameters explained in a dedicated chapter. This feature requires a FLIES server. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-blksize_614d.html",
"BLKSIZE",
"[[CLEP.COMMAND.CONV.READ.BINARY.BLKSIZE]] ==== BLKSIZE indexterm:[Parameter, BLKSIZE, CONV.READ.BINARY.BLKSIZE] The block size parameter defines the amount of data which is processed at a time. Conversion and formatting steps can result in a expansion or contraction of the internal block size. A block can contain a bunch of records before and elements after formatting. It depends on the block size how many records/elements fit into one data block. If this parameter is not specified (0), the default block size is determined from the system / catalog. On block I/O, this default has a minimum of 64 KiB or 4 records to ensure that all format detection algorithms get sufficient amounts of data. If a block size is specified, these automatism are disabled. If you set a smaller block size, the internal memory utilization would be smaller, the CPU time for auto detection is smaller, but more CPU time is spent for the overhead used to handle the data units. Auto detection is only performed on the first block of data. If you define a small block size and use auto detection services, it is more likely that detection fails or yields incorrect results. A large block size results in better format detection and usually in a faster operation. By default or if you define a block size greater than 64 KiB on record-oriented systems (MVS), the internal block size is greater than the valid block size range and at file allocation the optimal block size is used, because in this case we use a block size of 0 for dynamic allocation. If the internal block size within a valid range, we use the next possible block size. The 'FALLOC' object can be used to override the block size used for file allocation. The internal block size is only the default, if no block size for file allocation is defined. Only if you use record I/O without any conversions which expand or shrink the data chunks, you can be sure that the block size used for reading is the same used for writing. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt_ef8e.html",
"DECRYPT",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT]] ==== DECRYPT indexterm:[Overlay, DECRYPT, CONV.READ.BINARY.DECRYPT] With the overlay decrypt you can define the decryption parameters for the decryption methods. For some decryption methods you must provide the passphrase, key label templates, email addresses or other information to use the correct key. This overlay is an array which allows the definition of an unlimited amount of decryption parameter sets. Each parameter set is used sequentially to attempt decryption of the data until one succeeds. Here is an example with two passwords and an FKME which are tried for decryption. Both of the following notations are equivalent: *Try more than one decryption* Another example: *OpenPGP decryption with ICSF/CCA* See below for the decryption possibilities. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-f4pwd_73cc.html",
"F4PWD",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.F4PWD]] ==== F4PWD indexterm:[Object, F4PWD, CONV.READ.BINARY.DECRYPT.F4PWD] Uses a password for FLAM4 password-based decryption. If you provide no password, a hardcoded default password is used. Passwords can be provided in four different ways: * In hexadecimal format (recommended): `password=x'hex'` * In ASCII format: `PASSWORD=a'ascii'` * In EBCDIC format: `PASSWORD=e'ebcdic'` * In local charset: `PASSWORD='system'` NOTE: Don't use the local charset variant if you wish to open the file on different platforms. IMPORTANT: Encrypting using the default password is strongly discouraged in production as this equals using a publicly known password! The data is merely obfuscated. To prevent passwords from being logged and for a better protection, we recommend to store passwords in files and use that password file instead passing the password directly. NOTE: In a password file, you can define the password in one of the variants described above. * `STRING: PASSWORD/CRYPTOKEY='bin'/DEFAULT - Passphrase to encrypt the FLAMFILE ['********']` ** `DEFAULT - FLAM4 default password` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-f4kme_7f08.html",
"F4KME",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.F4KME]] ==== F4KME indexterm:[Object, F4KME, CONV.READ.BINARY.DECRYPT.F4KME] Activates FLAM4 decryption based on the FLAM4 key management extension (FKME). The FLAM data key is provided by an FKME module. The library name, function name and corresponding parameter list must be provided. On mainframe systems, the load module name and the entry name must be identical, the load module must be in the STEPLIB concatenation and the library name is ignored. If only a function name is provided, then the default library name is '' on mainframes and 'libfkme' on other platforms. If only a library name is provided, the default function name 'FKMESTD0' is used. If no FKME is provided (decr.f4kme()), then FKMESTD0 from the default library (see above) is used. The default FKMESTD0 returns a hardcoded key as encryption key identical to the default password when using decr.fl4pwd(). IMPORTANT: Encrypting using the default FKME is strongly discouraged in production as this equals using a publicly known password! The data is merely obfuscated. * `STRING: LIBRARY='str' - Library name for FKME ['libfkme']` * `STRING: FUNCTION='str' - Function name of FKME ['FKMESTD0']` * `STRING: PARAMETER='bin' - Parameter for the call of FKME ['']` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-pgp_445a.html",
"PGP",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.PGP]] ==== PGP indexterm:[Object, PGP, CONV.READ.BINARY.DECRYPT.PGP] Activates OpenPGP decryption based on passphrases or the FLAM key management extension version 5 (FKM5). If the PGP data key protected by an FKM5 module then the library name, function name and corresponding parameter list must be provided. On mainframe systems, the library name can be empty to choose a load module by function name from the STEPLIB concatenation. The default library name is 'LIBFKME' on mainframes and 'libfkme' on other platforms. The default function name is 'PGPCCA' on IBM and PGPP11 on all other platforms. Beside the FKM5 parameters needed to use your cryptographic infrastructure, you can change the key label templates for decryption and signature verification. You may also deactivate the PGP signature verification, in which case the signature template is ignored. Uses a password for OpenPGP password-based decryption. Passwords can be provided in four different ways: * In ASCII format: `PASSWORD=a'ascii'` * In EBCDIC format: `PASSWORD=e'ebcdic'` * In hexadecimal format: `PASSWORD=x'hex'` * In local charset: `PASSWORD='system'` NOTE: Don't use the local charset variant if you wish to open the file on different platforms. To prevent passwords from being logged and for a better protection, we recommend to store passwords in files and use that password file instead passing the password directly. NOTE: In a password file, you can define the password in one of the variants described above. Normally the key is chosen based on the key id provided in the PGP message. Some tools like GunPG support hidden recipients, where no key ID is stored. In such a case, the user ID must be provided to read the encrypted PGP file. If there are multiple keys for the same user ID and the required key is not the currently active key (i.e. the youngest of valid keys at the current point in time), a timestamp must also be provided which is used instead of the current time. It must be within the validity period of the key. Setting a timestamp has the same effect as setting the system time to the timestamp. So, if you specify a timestamp one year in the future, the key is selected that matches the user ID and is the youngest of valid keys at the date one year from now. If there is more than one matching key (multiple keys with same user ID and creation date), the key with the shortest validity period is chosen. * `STRING: PASSWORD='bin' - Passphrase of symmetrically encrypted OpenPGP File` * `SWITCH: NOSIGVERIFY - Disable signature verification [FALSE]` * `SWITCH: ENCRYPED - Enforce an error of PGP file is not encrypted [FALSE]` * `SWITCH: INTEGRITY - Enforce an error if PGP file is not integrity protected [FALSE]` * `SWITCH: SIGNING - Enforce an error if PGP file is not signed [FALSE]` * `SWITCH: INTERIM - Allow interim (no plain text) results [FALSE]` * `STRING: USERID='str' - Receiver user ID for decryption (only for hidden recipients)` * `NUMBER: TIMESTAMP=num - Time stamp (seconds since 1970) used for key selection [0 - current]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-pgp-fkm5_24e2.html",
"FKM5",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.PGP.FKM5]] ==== FKM5 indexterm:[Object, FKM5, CONV.READ.BINARY.DECRYPT.PGP.FKM5] The FKM5 object is used to choose the cryptographic infrastructure (with the corresponding method) used for encryption and/or signing. You can set the filename of the library (libfkm5) which implements the different FKM5 functions. On mainframe systems, the library name can be an empty string to fetch load modules from the STEPLIB concatenation. With FKM5 functions, you choose an entry in the library or a load module which implements certain cryptographic procedures (e.g. for OpenPGP) against a dedicated cryptographic infrastructure (e.g. CCA or PKCS#11). To initialize these infrastructures, you must provide FKM5-specific parameters. Please refer to the corresponding FKM5 documentation to find out how these strings are to be specified. For a permanent cryptographic infrastructure, it is useful to keep these parameters in property files. * `STRING: LIBRARY='str' - FKM5 library (DLL/SO) ['libfkm5']` * `STRING: FUNCTION='str' - FKM5 entry function (or load module) [AUTO]` * `STRING: PARAMETER='str' - FKM5 parameter ['']` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-pgp-reencypt_2069.html",
"REENCYPT",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.PGP.REENCYPT]] ==== REENCYPT indexterm:[Object, REENCYPT, CONV.READ.BINARY.DECRYPT.PGP.REENCYPT] Activates OpenPGP re-encryption based on passwords or the FLAM5 key management extension (FKM5). If re-encryption is used, the payload data will not be re-encrypted. Only the encrypted session key gets re-encrypted with the provided password or public key, making this operation very fast. The following re-encrytion modes are supported: * Add: Add new encrypted session key to existing encrypted session keys (Default). * Set: Remove all existing encrypted session keys, an set the new one The feature is useful with 'read.binary(... decode decrypt.pgp(...))) write.binary()'. If the PGP file was ASCII-armored and you activate ARMOR encoding when writing (write.binary(... encode.armor())), the ASCII-armor header is copied from the original file. If the PGP file, was not ASCII-armored and ARMOR encoding is activated when writing, the data format and character set of the encrypted data is not known and therefore cannot be added as ASCII-armor header by default. *Examples:* * `NUMBER: MODE=ADD/SET - Mode of re-encryption, what should happen with existing keys [ADD]` ** `ADD - Add new receiver, keep the other receiver` ** `SET - Set new receiver, don't keep the other receiver` * `STRING: PASSWORD['bin'...] - Passphrases for symmetrically re-encryption` * `STRING: USERID/RECEIVER['str'...] - Receiver user IDs for public key re-encryption` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-pwd_b4ce.html",
"PWD",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.PWD]] ==== PWD indexterm:[Object, PWD, CONV.READ.BINARY.DECRYPT.PWD] OpenSSL-compatible decryption based on passwords. This object is a subset of <<CNV.EDC,CNV.EDC()>>. For more information see the <<CNV.EDC,corresponding page>> of the `XCNV` command. The key for decryption is derived from the password and a salt value that is stored as header in the encrypted file. If no salt is found at the start of the file, decryption is not done (SKPFMT=SUPPREDU). To use keys, key labels or other advanced encryption options, please use the EDC object. Please be aware that there is no reliable way to determine if the provided password is correct other than by interpreting the decryption output. However, if the file is encrypted in a mode that uses padding (CBC), there is a chance of roughly 99.5% that decryption fails with an incorrect password due to bad padding bytes in the decryption output. Other modes don't use padding and decryption will always complete, but with unreadable output data. For the above reasons it makes no sense to specify more than one password-based decryption object. You cannot use it to try different passwords. Below you can find an example for OpenSSL-compatible encryption on mainframe and the corresponding decryption on any platform supported by OpenSSL. Write a compressed, encrypted and base64-encoded dataset to a remote system: The output is written with Unix-style newline characters (NL). Trailing whitespace will be suppressed (SUPTWS) and the character conversion is done from German EBCDIC (IBM-1141) to UTF-8. The resulting text file is compressed with GZIP and encrypted using password-based AES-256-CBC encryption and the PBKDF2 key derivation function. OpenSSL requires line endings for decoding (`openssl enc -d base64`). Therefore, the `LINE` and `DELIM` parameters in the `BASE64` object are needed. Below is the command line call for decoding it with FLCL: The encoding is automatically detected and removed because the header containing the salt value is found. For decryption, the algorithm parameters and the passphrase must be specified. The `DECODE` switch enables automatic GZIP decompression. The result is the text file which was prepared on the mainframe system. The same can be done with OpenSSL and GZIP standard utilities: * `NUMBER: ALGO=AES/TDES/CAST5/CAST128/IDEA/BLOWFISH/BF/CAMELLIA - Algorithm used for decryption [AES]` ** `AES - Advanced encryption standard (Rijndael)` ** `TDES - Triple DES (Data encryption standard)` ** `CAST5 - CAST5/CAST-128 (Carlisle Adams, Stafford Tavares)` ** `CAST128 - CAST-128/CAST5 (Carlisle Adams, Stafford Tavares)` ** `IDEA - International Data Encryption Algorithm` ** `BLOWFISH - Blowfish from Bruce Schneier` ** `BF - Blowfish from Bruce Schneier` ** `CAMELLIA - Camellia from Japan (Mitsubishi Electric and NTT)` * `NUMBER: KEYLEN=num/KL064/KL128/KL192/KL256/KL08/KL16/KL24/KL32 - Key length if passphrase used` ** `KL064 - Key length 64 bits (8 bytes)` ** `KL128 - Key length 128 bits (16 bytes)` ** `KL192 - Key length 192 bits (24 bytes)` ** `KL256 - Key length 256 bits (32 bytes)` ** `KL08 - Key length 8 bytes (64 bits)` ** `KL16 - Key length 16 bytes (128 bits)` ** `KL24 - Key length 24 bytes (192 bits)` ** `KL32 - Key length 32 bytes (256 bits)` * `NUMBER: MODE=ECB/CBC/OFB/CFB/CTR/GCM - Mode of operation [if TAG then GCM else CBC]` ** `ECB - Electronic codebook mode` ** `CBC - Cipher block chaining mode` ** `OFB - Output feedback mode` ** `CFB - Cipher feedback mode` ** `CTR - Counter mode` ** `GCM - Galois/Counter Mode ` * `NUMBER: PADDING=NONE/NOPAD/PKCS - Padding for CBC or ECB mode [PKCS]` ** `NONE - No padding (remaining data must have a multiple of the block length)` ** `NOPAD - No padding (remaining data must have a multiple of the block length)` ** `PKCS - OpenSSL conform PKCS padding` * `NUMBER: KDF/PW2KEY=OLDSSL/PBKDF2 - Password to key derivation function [OLDSSL]` ** `OLDSSL - Legacy OpenSSL key derivation (avoid use, default: SHA-256 with 1 round, hint: OpenSSL < 1.1.0 used MD5)` ** `PBKDF2 - PBKDF2 key derivation function (default: SHA-256 with 10000 rounds, available from OpenSSL 1.1.1)` * `NUMBER: MD/HASH=MD5/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512 - Hash algorithm for key derivation [SHA256]` ** `MD5 - Message Digest 5 with 128 bits` ** `SHA1 - Secure Hash Algorithm 1 with 160 bits` ** `SHA224 - Secure Hash Algorithm 2 with 224 bits` ** `SHA256 - Secure Hash Algorithm 2 with 256 bits` ** `SHA384 - Secure Hash Algorithm 2 with 384 bits` ** `SHA512 - Secure Hash Algorithm 2 with 512 bits` ** `SHA3-224 - Secure Hash algorithm 3 with 224 bits` ** `SHA3-256 - Secure Hash Algorithm 3 with 256 bits` ** `SHA3-384 - Secure Hash Algorithm 3 with 384 bits` ** `SHA3-512 - Secure Hash Algorithm 3 with 512 bits` * `NUMBER: ITER=num - Iteration count for PBKDF2, implies METHOD=PBKDF2 if specified [10000]` * `STRING: PASSWORD='str' - Salted passphrase for decryption` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-decrypt-edc_2ee7.html",
"EDC",
"[[CLEP.COMMAND.CONV.READ.BINARY.DECRYPT.EDC]] ==== EDC indexterm:[Object, EDC, CONV.READ.BINARY.DECRYPT.EDC] Decryption based on clear keys, passwords or the FLAM5 key management extension (FKM5) using a key label. This object is a subset of <<CNV.EDC,CNV.EDC()>>. For more information see the <<CNV.EDC,corresponding page>> of the `XCNV` command. The EDC object will not result in decryption if the data present conforms to a supported format or (except for ECB mode) has redundancies. This corresponds in the `CNV.EDC()` with `SKPFMT=SUPPREDU`. With the EDC component it is not possible to recognise whether the key is the correct one, therefore it does not make sense to keep more than one key value (clear key, passphrase or label). * `NUMBER: METHOD=CLEAR/PASSWORD/LABEL - Method for key determination [AUTO]` ** `CLEAR - Clear key crypto (en/decrypt with raw unprotected key value)` ** `PASSWORD - Password-based crypto (using key derivation function (KDF))` ** `LABEL - Protected key crypto using label (FKM5 required)` * `NUMBER: ALGO=AES/TDES/CAST5/CAST128/IDEA/BLOWFISH/BF/CAMELLIA - Algorithm used for decryption [AES]` ** `AES - Advanced encryption standard (Rijndael)` ** `TDES - Triple DES (Data encryption standard)` ** `CAST5 - CAST5/CAST-128 (Carlisle Adams, Stafford Tavares)` ** `CAST128 - CAST-128/CAST5 (Carlisle Adams, Stafford Tavares)` ** `IDEA - International Data Encryption Algorithm` ** `BLOWFISH - Blowfish from Bruce Schneier` ** `BF - Blowfish from Bruce Schneier` ** `CAMELLIA - Camellia from Japan (Mitsubishi Electric and NTT)` * `NUMBER: KEYLEN=num/KL064/KL128/KL192/KL256/KL08/KL16/KL24/KL32 - Key length if passphrase used` ** `KL064 - Key length 64 bits (8 bytes)` ** `KL128 - Key length 128 bits (16 bytes)` ** `KL192 - Key length 192 bits (24 bytes)` ** `KL256 - Key length 256 bits (32 bytes)` ** `KL08 - Key length 8 bytes (64 bits)` ** `KL16 - Key length 16 bytes (128 bits)` ** `KL24 - Key length 24 bytes (192 bits)` ** `KL32 - Key length 32 bytes (256 bits)` * `NUMBER: MODE=ECB/CBC/OFB/CFB/CTR/GCM - Mode of operation [if TAG then GCM else CBC]` ** `ECB - Electronic codebook mode` ** `CBC - Cipher block chaining mode` ** `OFB - Output feedback mode` ** `CFB - Cipher feedback mode` ** `CTR - Counter mode` ** `GCM - Galois/Counter Mode ` * `NUMBER: PADDING=NONE/NOPAD/PKCS - Padding for CBC or ECB mode [PKCS]` ** `NONE - No padding (remaining data must have a multiple of the block length)` ** `NOPAD - No padding (remaining data must have a multiple of the block length)` ** `PKCS - OpenSSL conform PKCS padding` * `NUMBER: KDF/PW2KEY=OLDSSL/PBKDF2 - Password to key derivation function [OLDSSL]` ** `OLDSSL - Legacy OpenSSL key derivation (avoid use, default: SHA-256 with 1 round, hint: OpenSSL < 1.1.0 used MD5)` ** `PBKDF2 - PBKDF2 key derivation function (default: SHA-256 with 10000 rounds, available from OpenSSL 1.1.1)` * `NUMBER: MD/HASH=MD5/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512 - Hash algorithm for key derivation [SHA256]` ** `MD5 - Message Digest 5 with 128 bits` ** `SHA1 - Secure Hash Algorithm 1 with 160 bits` ** `SHA224 - Secure Hash Algorithm 2 with 224 bits` ** `SHA256 - Secure Hash Algorithm 2 with 256 bits` ** `SHA384 - Secure Hash Algorithm 2 with 384 bits` ** `SHA512 - Secure Hash Algorithm 2 with 512 bits` ** `SHA3-224 - Secure Hash algorithm 3 with 224 bits` ** `SHA3-256 - Secure Hash Algorithm 3 with 256 bits` ** `SHA3-384 - Secure Hash Algorithm 3 with 384 bits` ** `SHA3-512 - Secure Hash Algorithm 3 with 512 bits` * `NUMBER: ITER=num - Iteration count for PBKDF2, implies METHOD=PBKDF2 if specified [10000]` * `STRING: IV='bin-hex'/ZERO - Initialization vector for all modes except ECB [ZERO]` ** `ZERO - Initialization vector of binary zeros` * `STRING: SALT='bin-hex'/NONE/RANDOM - Salt for salted passphrase-based decryption [AUTO]` ** `NONE - No salt (not recommended)` ** `RANDOM - Random generated salt` * `STRING: KEY='bin-hex' - Clear key value (direct entry of raw value (dangerous))` * `STRING: PASSWORD='str' - Passphrase with or without salting` * `STRING: LABEL='str' - Label to reference a protected key (FKM5 required)` * `STRING: TAG='bin-hex' - The tag value for verification (only for GCM mode)` * `NUMBER: OFFSET=num - Offset before decryption begins [0]` * `STRING: PARM='str'/STDOUT/STDERR - Side file with parameter used for decryption (merged if not empty else written)` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-fdecode_6387.html",
"FDECODE",
"[[CLEP.COMMAND.CONV.READ.BINARY.FDECODE]] ==== FDECODE indexterm:[Overlay, FDECODE, CONV.READ.BINARY.FDECODE] The overlay 'fdecode' allows you to add an additional decoding step after auto decoding ('decode' parameter defined) was done. On 'read.bin()' with the 'decode' parameter set, encrypted data (PGP, ...) is automatically decrypted and compressed data (GZIP, ...) is decompressed if the method is supported by FLAM. If the encrypted or compressed data is base encoded, it will decoded before decompression or decryption. However, there is no automatic base decoding of the decompressed or decrypted data since we are in binary mode and, therefore, it is impossible to guess whether you want to read base encoded or decoded data. The data might not even be base encoded, but just look like it is. 'fdecode' allows you to enforce base decoding after auto decoding by specifying the base to use. If you specify a base, but the data is not encoded with this base, you will get an error. If you define 'decode=CMPDEC' or 'decode=ALWAYS' then a base decoding after decompression is done, if a base decoding is possible. This option can be used on behalf of 'fdecode', but auto detection of the correct base may fail. Therefore, it is suitable to use the 'fdecode' parameter if you already know the base. The enforcement of base decoding can even be used if no auto decoding is activated (i.e. 'decode' parameter not specified). See below for the decoding possibilities. * `SWITCH: BASE64/ARMOR/PGP - Base64 decoding (RFC4648)` * `SWITCH: BASE32 - Base32 decoding (RFC4648)` * `SWITCH: BASE16 - Base16 decoding (RFC4648)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-prncontrol_9c40.html",
"PRNCONTROL",
"[[CLEP.COMMAND.CONV.READ.BINARY.PRNCONTROL]] ==== PRNCONTROL indexterm:[Parameter, PRNCONTROL, CONV.READ.BINARY.PRNCONTROL] Print control characters handling is a special feature for record- oriented files of mainframe systems. For print control, the ASA or machine control characters are often coded in the first byte of the record. For read operations, you can choose whether this byte will be part of the data (RETAIN), handled as separate attribute (DETACH) or ignored (ERASE). With DETACH, you can later (on write) decide how to handle the control character. With RETAIN, the character will be part of the data and with ERASE the control character is lost. If block I/O is used DETACH works like ERASE because the print control character cannot be stored as attribute for the records of a block. This is only possible with record I/O, where the print control character, slot numbers and other attributes are be manageable per record. If you want to read a block of data often, such print control characters are not useful and to transfer such files to an non-mainframe system can result in some strange behavior if there are ASA or MCC control characters in the data. On the other side, sometimes you may want to read a file with ASA and must write records with MCC control characters. In such cases, it is useful to still know the value. In most cases, DETACH is the best choice and is the default for print control handling. At read an additional replacement of print control character by certain empty records to produce a print like output (REPLACE) is supported. In this case a default line per page of 60 is used. This default can change over the parameter replace form feed (RPLFFD). If RPLFFD is 0 then 60 is assumed, if it 1 then form feeds are ignored and in each other case the missing records to fill up one page are added. * `DETACH - Manage print control character as record attribute` * `RETAIN - Leave print control character as part of the data record` * `ERASE - Erase the print control character from the record` * `REPLACE - Replace print control characters by additional records like printed` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-subsystem_1fc8.html",
"SUBSYSTEM",
"[[CLEP.COMMAND.CONV.READ.BINARY.SUBSYSTEM]] ==== SUBSYSTEM indexterm:[Object, SUBSYSTEM, CONV.READ.BINARY.SUBSYSTEM] The subsystem definition object can be used to activate a subsystem on platforms like z/OS(R) where a subsystem can be used for file I/O. To activate a subsystem, the name and a parameter list can be specified. The name is a string (up to 4 characters on z/OS). The parameter list must be comma separated. Single quotes can be used to enclose parameter values. For example: Please don't use whitespace characters in the parameter list. The parameter list can be empty. This is the default if the 'PARM' keyword is not specified. Empty parameter values can be created by writing two commas. The default for the subsystem name is 'FLAM'. The example below activates the FLAM subsystem without any parameter. The subsystem name and parameter are converted to uppercase. To write a file through the subsystem, the file must already exist. The allocation of a new file is not possible. * `STRING: NAME='str' - Name of the subsystem` * `STRING: PARM['str'...] - Parameter list for the subsystem (comma separated)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-remove_5c89.html",
"REMOVE",
"[[CLEP.COMMAND.CONV.READ.BINARY.REMOVE]] ==== REMOVE indexterm:[Parameter, REMOVE, CONV.READ.BINARY.REMOVE] When reading, the REMOVE switch causes the original file(s) to be deleted after the output has been written successfully. If any error occurs while a file is being written, the input file is not deleted. When writing, the remove switch causes the written file(s) to be deleted if an error occurs. The switch should not be used if the target is an archive file and wildcards are used. The original files are deleted as soon as they are written to the archive. If consecutive writes to the archive file (further input files or the archive trailer) fail, the archive may end up corrupted with the original files deleted. If the switch is used together with the append switch to write to an archive which already contains members, the whole archive will be deleted if an error occurs. Be careful with the remove switch when writing archives. If an error occurs, the archive will be deleted. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-platform_484e.html",
"PLATFORM",
"[[CLEP.COMMAND.CONV.READ.BINARY.PLATFORM]] ==== PLATFORM indexterm:[Parameter, PLATFORM, CONV.READ.BINARY.PLATFORM] The parameters LANG (mainly for character conversion), PLATFORM (mainly for text formatting (delimiter), default character set definitions and default endianness), OWNER (mainly used to sign data with the correct key) and ENVID (mainly for key label mapping) can be used to overwrite the corresponding environment variables LANG, FL_PLATFORM, OWNERID and ENVID for the read and/or the write operation. This is useful to emulate another system when reading or writing and uses FLAM's automatism for character conversion, delimiter handling, key referencing or big and little endian representation (byte order) of integers. Supported platform qualifiers: * WIN - Windows with CRLF (0x0D0A) in ASCII and little endian * UNX - Unix with LF (0x0A) in ASCII and little endian * MAC - MAC-OS with CR (0x0D) in ASCII and little endian * ZOS - z/OS with NL (0x15) in EBCDIC and big endian * USS - Unix system services on z/OS with NL (0x15) in EBCDIC and big endian * VSE - z/VSE with NL (0x15) in EBCDIC and big endian * BS2 - BS2000-OSD with NL (0x15) in EBCDIC and big endian Optionally you can append a '.L' to override the default endianness to little or a '.B' for big endian. This is mainly required for UNIX systems: * UNX.B - for zLinux, AIX on Power, Solaris on Sparc Three example scenarios: 1) You have a text file from a German Windows system that you wish to process on z/OS. It would be useful to read the file with the environment variable 'LANG' set to 'DE_DE.CP1252', but write the output with the default value for 'LANG' as set in the FLCL configuration file for z/OS. This can be done by specifying the 'LANG' variable with the read operation, e.g. 2) If you want to create a file for Windows on z/OS, the environment variable 'PLATFORM' set to 'WIN' ensures that the delimiter CRLF is used as default text delimiter: 3) If you wish to write a file on a UNIX system for USS on z/OS, you could set the environment variable LANG to 'EN_US.IBM1047' for the write operation and the platform to 'USS'. The default LANG variable on the UNIX system is used for the read operation. As a result, the file is written in IBM1047 and the records are delimited with NL (0x15): You may also implement an application against the byte, record or element interfaces and the environment ID must be defined for TEST, then you can set the parameter ENVID='T' to work with test keys or you can redefine the owner with OWNER='CLIENT'. * `WIN - Choose Windows as platform (CRLF)` * `UNX - Choose Unix derivative as platform (LF)` * `ZOS - Choose ZOS as platform (NL)` * `USS - Choose USS of ZOS as platform (NL)` * `VSE - Choose VSE as platform (NL)` * `BS2 - Choose BS2000-OSD as platform (NL)` * `MAC - Choose MAC as platform (CR)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-hash_2a05.html",
"HASH",
"[[CLEP.COMMAND.CONV.READ.BINARY.HASH]] ==== HASH indexterm:[Object, HASH, CONV.READ.BINARY.HASH] The hash component can be used to generate and check hash values (checksums). This can be useful to verify data integrity of files after transmission or on a storage device. If you do not specify the output filename, the output of this component is written to the log. For the output file, all rules and replacements are valid which are described under 'FILENAME HANDLING' above. For example: By using the 'check' overlay, data can be verified against a previously computed hash value that can either be passed directly or from an input file. The result is written to output. Passing an empty string or filename in the 'check' overlay implies only calculation of the hash without verification. You can also specify the CCSID parameter. It indicates the CCSID of the check file and the output file. The check file is read once as binary and once as string, with optional character conversion. So, you can generate an ASCII check file on an EBCDIC machine without having to convert this file in a separate step. The member name supports input output name mapping and can be used to define the file names written to the GNU or BSD formated checksum files. The default of such a member name at read is the original (source) name of the file. At write the target file name is used. * `NUMBER: ALGO=MD5/RIPEMD128/RIPEMD160/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512/CRC8/CRC16/CRC24/CRC32/CRC32C/CRC40/CRC64 - Hash algorithm [SHA1]` ** `MD5 - Message-Digest Algorithm 5 (128 bit)` ** `RIPEMD128 - RACE Integrity Primitives Evaluation Message Digest (128 bit)` ** `RIPEMD160 - RACE Integrity Primitives Evaluation Message Digest (160 bit)` ** `SHA1 - Secure Hash Algorithm 1 (160 bit)` ** `SHA224 - Secure Hash Algorithm 2 (224 bit)` ** `SHA256 - Secure Hash Algorithm 2 (256 bit)` ** `SHA384 - Secure Hash Algorithm 2 (384 bit)` ** `SHA512 - Secure Hash Algorithm 2 (512 bit)` ** `SHA3-224 - Secure Hash Algorithm 3 (224 bit)` ** `SHA3-256 - Secure Hash Algorithm 3 (256 bit)` ** `SHA3-384 - Secure Hash Algorithm 3 (384 bit)` ** `SHA3-512 - Secure Hash Algorithm 3 (512 bit)` ** `CRC8 - Cyclic Redundancy Check (8 bit)` ** `CRC16 - Cyclic Redundancy Check (16 bit)` ** `CRC24 - Cyclic Redundancy Check (24 bit)` ** `CRC32 - Cyclic Redundancy Check (32 bit)` ** `CRC32C - Cyclic Redundancy Check (32 bit) Castagnoli variant` ** `CRC40 - Cyclic Redundancy Check (40 bit)` ** `CRC64 - Cyclic Redundancy Check (64 bit)` * `NUMBER: FORMAT=GNU/BSD/HEX/BIN - Define printout format [GNU]` ** `GNU - Write output in GNU style` ** `BSD - Write output in BSD style` ** `HEX - Write output as hexadecimal string` ** `BIN - Write output as binary value (only in output file)` * `STRING: OUTPUT='str'/STDOUT/STDERR - Name of the output file [LOG]` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` * `STRING: MEMBER='str' - Member name in GNU or BSD format [original name at read, target name at write]` * `NUMBER: BLKSIZ=num - Block size for read operations [65536]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-hash-check_8a5a.html",
"CHECK",
"[[CLEP.COMMAND.CONV.READ.BINARY.HASH.CHECK]] ==== CHECK indexterm:[Overlay, CHECK, CONV.READ.BINARY.HASH.CHECK] The 'check' parameter defines the expected hash (checksum). The hash can be specified directly or read from a file. For the check file, all rules and replacements are valid which are described under 'FILENAME HANDLING' above. For example: Currently, checksum files can be in standard GNU format: HEX: BIN (only if oputput file is selected, else same as HEX): or BSD style: A check file can contain more than one checksum: which can be used to check each file separately * `STRING: VALUE='str' - Checksum as hex-string` * `STRING: FILE='str'/STREAM/DUMMY - File which contains Checksum as hex-string` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-hash-cut_29ca.html",
"CUT",
"[[CLEP.COMMAND.CONV.READ.BINARY.HASH.CUT]] ==== CUT indexterm:[Parameter, CUT, CONV.READ.BINARY.HASH.CUT] The 'cut' parameter defines the length of the checksum printed to log/output in bytes. You can cut off leading bytes with a positive value and trailing bytes with a negative value. If the cut value is larger than checksum length, you get checksum length. NOTE: Supported only with HEX and BIN formats. For example: ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-hash-ccsid_3844.html",
"CCSID",
"[[CLEP.COMMAND.CONV.READ.BINARY.HASH.CCSID]] ==== CCSID indexterm:[Parameter, CCSID, CONV.READ.BINARY.HASH.CCSID] The TO code defines the encoding string or CCSID for the output text stream. The default value of this CCSID for read operations is UTF-8. For write operations, the default value is derived from the environment variable LANG. If LANG is not set, the default ASCII or EBCDIC system-codepage is used, depending on the platform. To get a list of supported encoding strings, please use the command below: Depending on the platform, this function lists all known encoding strings. Some encodings may not be supported. To determine the supported CCSIDs please use: To define the CCSID, you can use one of the encoding strings or the decimal number for a CCSID displayed by the command above. Example: A numeric CCSID must start with a decimal digit. Optionally, you can use one of the keywords below to use the system-specific default ASCII or EBCDIC CCSID. * `DEFAULT - Use default CCSID (system-specific)` * `ASCII - Use default ASCII CCSID (environment)` * `EBCDIC - Use default EBCDIC CCSID (environment)` * `SYSTEM - Use system character set (environment/logical)` * `LOCAL - Use local character set (system/physical)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature_e431.html",
"SIGNATURE",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE]] ==== SIGNATURE indexterm:[Overlay, SIGNATURE, CONV.READ.BINARY.SIGNATURE] The sign component can be used to generate and check signatures in detached files. This can be useful to verify data integrity of files after transmission or on a storage device. As the name suggests, signature files contain only the signature and not the files they sign. The signed documents are not changed during signature generation or verification. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature-generation_5d50.html",
"GENERATION",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE.GENERATION]] ==== GENERATION indexterm:[Object, GENERATION, CONV.READ.BINARY.SIGNATURE.GENERATION] The signature generation object defines all parameters needed to generate a detached signature. This object contains signature file definitions, FKM5 parameters and also other format-specific parameters. As the signature files are part of the original data, signatures are completely held in the memory and written to the desired file. * `STRING: FILE='str'/STREAM/DUMMY - Name of the signature file` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature-generation-format_7b3e.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT] This overlay is used to choose the format for detached signatures. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature-generation-format-pgp_488a.html",
"PGP",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT.PGP]] ==== PGP indexterm:[Object, PGP, CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT.PGP] The object defines all parameters for a detached OpenPGP signature. With the SIGNID, you specify wich private key should be used. It is also possible to specify the algorithm to hash the document (the hash is used for signature generation). If no hash algorithm is specified, a default algorithm is chosen. The armor object converts binary signatures to Base64 and adds the ASCII armor header and trailer. * `NUMBER: SIGHSH/HSHALG=MD5/SHA1/RIPEMD/SHA224/SHA256/SHA384/SHA512 - Hash algorithm for signature generation [preferred]` ** `MD5 - 128 bit (16 byte) MD5 checksum` ** `SHA1 - 160 bit (20 byte) SHA checksum` ** `RIPEMD - 160 bit (20 byte) RipeMD checksum` ** `SHA224 - 224 bit (28 byte) SHA checksum` ** `SHA256 - 256 bit (32 byte) SHA checksum` ** `SHA384 - 384 bit (48 byte) SHA checksum` ** `SHA512 - 512 bit (64 byte) SHA checksum` * `STRING: SIGNID/SIGNER='str' - User ID of private key for signing` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature-generation-format-pgp-armor_1b32.html",
"ARMOR",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT.PGP.ARMOR]] ==== ARMOR indexterm:[Object, ARMOR, CONV.READ.BINARY.SIGNATURE.GENERATION.FORMAT.PGP.ARMOR] The overlay 'encode' can be used to convert the output data using one of a couple of base encoding schemes, resulting in printable text. Base encoding data results in expansion of the data. The ratio of expansion depends on the base used. Currently, Base16 (hexadecimal), Base32 and Base64 encodings are supported. Each of them is an object with further configurations options. Most base encoding schemes append some padding bytes to the end of output data to pad it to a multiple of a specific length. As a result, encoding can be performed in one of two modes: The block mode converts the data as one large block of data. Padding will only be added at the end of the output file. This mode is the default for all write modes except for 'write.record()'. This implies that record-based data will not retain the old record boundaries after encoding. As the output is printable text when encoding, it can optionally be split into multiple lines. The 'line' parameter specifies after how many characters a line is wrapped. The line delimiter can be configured via the 'delim' parameter. By default, the system-specific delimiter is used. When writing record-oriented (write.record()), each output line results in one record. Note that if the 'line' parameter is specified and a line delimiter is set, then the total maximum record length will be line length plus the length of the delimiter. In record mode (default for wrote.record()), each output record is encoded independently, which results in retaining the ability to access specific records by only decoding those specific records. Each output record is padded as required by the respective encoding scheme. Due to base encoding resulting in expansion of the data, the resulting records will be longer after encoding and shrink when decoding. A file that has been encoded in record mode, must also be read in record mode subsequently to decode the data correctly. Otherwise, the result might be garbage. The character set used (ASCII (UTF-8) or EBCDIC) can also be configured. By default, the system-specific default character set is used. Optionally, there is support for ASCII/EBCDIC armor headers and trailers around the base encoded data. This feature is mainly required to encode and decode PGP files (see RCF4880), but can also be used for other data and is independent of the encoding method (Base16/32/64). ASCII-armored data data is wrapped into lines, which can be written as records or as blocks with lines and delimiters. The default line length is 72 if no length is specified. The special OpenPGP encoding creates an ASCII armor output conforming to RFC4880 including the checksum. If you don't want the optional CRC24 checksum or if you want to use a line length other than 76, the Base64 encoding object with ASCII armor enabled should be used. Additionally, a CRC checksum can be appended to the encoded data using the mechanism defined for OpenPGP. For Base64, CRC24 is used (RFC4480). For all other encoding schemas, CRC variants are used that match the schema's block size. Therefore, Base16 use CRC32 and Base32 uses CRC40, known from the GSM network. The CRC calculation is optional and independent of the data, encoding schema and the ASCII armor support. When reading, the verification is only done, if the corresponding switch is enabled, because it make no sense to consume CPU cycles for the CRC calculation and at the end, there is no checksum found to compare the calculated value. * `NUMBER: FORMAT=OFF/STD/EXT - Format of ARMOR header (which information is printed) [EXT]` ** `OFF - Disable the printout of key value lines in ARMOR header` ** `STD - Only the standard key value pairs (Version, Comment, Chrset) for ARMOR header` ** `EXT - All available key value pairs are printed to ARMOR header (required for archiving)` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: DELIM/RECDLM=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Line delimiter to use when mode is BLOCK and line>0 [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `STRING: COMMENT='str' - Define comment for ARMOR header [default]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-signature-verification_9821.html",
"VERIFICATION",
"[[CLEP.COMMAND.CONV.READ.BINARY.SIGNATURE.VERIFICATION]] ==== VERIFICATION indexterm:[Object, VERIFICATION, CONV.READ.BINARY.SIGNATURE.VERIFICATION] The signature verification object defines all parameters needed to verify a detached signature. This object contains signature file definitions and FKM5 parameters. You can optionally specify the signature format to reduce detection overhead. Otherwise, the signature format is detected and an error eccors if detection fails. As the signature file is not part of the original data, it is completely read into memory. * `STRING: FILE='str'/STREAM/DUMMY - Name of the signature file` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-check_374b.html",
"CHECK",
"[[CLEP.COMMAND.CONV.READ.BINARY.CHECK]] ==== CHECK indexterm:[Parameter, CHECK, CONV.READ.BINARY.CHECK] The CHECK switch of CONV.READ activates these additional verifications: * Check the CRC checksum that is appended to ASCII-armored data (if available) * Check the ASCII armor trailer against the header when decoding ASCII armor In the future, there will be more optional verifications which can be activated through this switch. Example: Activate verification of CRC for ASCII-armored PGP file. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table_2893.html",
"TABLE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE]] ==== TABLE indexterm:[Object, TABLE, CONV.READ.BINARY.TABLE] The object 'format table' is used to describe the structure of rows in a table. There can be one or more row format specifications which tell FLAM how to break up rows/records into cells of the table. Each column is parsed independently with optional pre-processing steps (e.g. decryption). At least one row must be specified. If there are multiple row specifications and a format error occurs while trying to read the row according to the first row specification, reading with the next row specification is attempted until the row matches one row specification or until all available row specifications failed, which results in an error. NOTE: When specifying multiple row formats, you have to ensure that the row formats are distinct from each other to ensure that one row format cannot be mistaken for another. To simplify the specification of rows, you can set a format specifier and several default values. You still have to describe each column, but depending on the default settings, only the missing or differing parameters must be specified for each column. You can specify whether a block- or record-oriented method is used for parsing. By default, the method is assigned automatically depending on the data. The block-oriented procedure ignores the record length and interprets the data as one chunk of data. The record-oriented method ensures that each defined row must fit within a record. For XML files, only the block-oriented approach is reasonable. At the end of the data, a remaining rest results in a format error. You can activate the corresponding switch to ignore this. If you want to use the filename substitution rule [table] to split multiple tables contained in one input file into multiple files by using each table's name as part of the output filename when writing, the end of table handling must be activated. This switch will cause a FLMRTC_EOT error if the end of a table is reached. The error handling procedures in FLAM's utility programs will ensure that each table is written to the right output file. On the API level, the application must handle this error. A function of the respective API can be used to get the name of the current table after opening the input file and after an EOT error. To be backwards compatible with old applications, the EOT error handling has to be activated explicitly. For XML or other structured data formats, the optional starting path (e.g. root tag in XML) can be defined for the entire document. This path will be prefixed to the paths defined on higher levels. This simplifies the definition of the complete path to an element. A mix of XML with other data formats in one file makes no sense and is not supported. For more information about XML paths see FORMAT.XML(). * `NUMBER: METHOD=AUTO/BLOCK/RECORD - Method for handling incoming matrix [AUTO]` ** `AUTO - Use block for blocks and record for records` ** `BLOCK - Parse the blocks` ** `RECORD - Parse records` * `SWITCH: IGNRST - Ignore a remaining rest at the end of the data [FALSE]` * `SWITCH: ENDOFT - Activate end of table handling (file per table) [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [256KiB]` * `NUMBER: INICNT=num - Initial amount of rows/records for preallocation [128]` * `STRING: PATH/ROOT='str' - Define path to table (root) in a structured format (prefix for higher level)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-format_9aab.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.FORMAT]] ==== FORMAT indexterm:[Parameter, FORMAT, CONV.READ.BINARY.TABLE.FORMAT] This selection is used to define a base input format for a table to simplify the corresponding row specifications. If a default format is specified, then only the columns which differ from the defaults must describe theses differences. The format VAR is only useful and possible when reading from memory. An error occurs on attempts to read this format from a file. * `FIX - Read fixed length record (length and type must be provided)` * `LFD - Read variable length elements based on default (S2X) length fields (type must be provided)` * `DLM - Read variable length elements separated by default delimiter (strings required)` * `VAR - Read variable length elements as length pointer structure (only at read from memory)` * `CSV - Read a comma separated value stream (spread sheet)` * `TVD - Read a tag value delimiter text stream` * `XML - Read a XML (Extensible Markup Language) stream` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults_d042.html",
"DEFAULTS",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS]] ==== DEFAULTS indexterm:[Object, DEFAULTS, CONV.READ.BINARY.TABLE.DEFAULTS] Default values can be set for many values that would otherwise need to be specified for every single column. By setting defaults via this object, the values set here apply to all rows/columns which are defined within the same table object. The defaults set here can be overridden by specifying other values for the respective columns parameters. * `NUMBER: TYPE=BINARY/STRING/INTEGER/FLOAT - Default data type used for conversion [NONE]` ** `BINARY - Read binary data` ** `STRING - Read a string data type` ** `INTEGER - Read a integer value` ** `FLOAT - Read a fractional numbers` * `SWITCH: NOCASE - No case-sensitive comparison of tags and delimiter [FALSE]` * `SWITCH: CASEHL - Activate case sensitive comparison of headline identifier [FALSE]` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Default list of separator characters as Unicode codepoints for CSV files [COMMA,SEMICOLON]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDCHR[num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS...] - Default list of field enclosing characters as Unicode codepoints for CSV files [QUOTATION,APOSTROPHE,GRAVE]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: LENFLD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Default format of the length field [S2X (VARCHAR)]` ** `L4I - Parse binary 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse binary 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse binary 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse binary 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse binary 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse binary 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse binary 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse binary 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse binary 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse binary 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse binary 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse binary 4 byte length fields: System endian short (LLxx), length exclusive` ** `L2I - Parse binary 2 byte length fields: Little endian integer, length inclusive` ** `L2X - Parse binary 2 byte length fields: Little endian integer, length exclusive` ** `B2I - Parse binary 2 byte length fields: Big endian integer, length inclusive` ** `B2X - Parse binary 2 byte length fields: Big endian integer, length exclusive` ** `S2I - Parse binary 2 byte length fields: System endian integer, length inclusive` ** `S2X - Parse binary 2 byte length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Parse binary 1 byte length fields: Length inclusive` ** `S1X - Parse binary 1 byte length fields: Length exclusive` ** `D1I - Parse decimal 1 byte length fields: Length inclusive` ** `D2I - Parse decimal 2 byte length fields: Length inclusive` ** `D3I - Parse decimal 3 byte length fields: Length inclusive` ** `D4I - Parse decimal 4 byte length fields: Length inclusive` ** `D5I - Parse decimal 5 byte length fields: Length inclusive` ** `D6I - Parse decimal 6 byte length fields: Length inclusive` ** `D7I - Parse decimal 7 byte length fields: Length inclusive` ** `D8I - Parse decimal 8 byte length fields: Length inclusive` ** `D9I - Parse decimal 9 byte length fields: Length inclusive` ** `D0I - Parse decimal 10 byte length fields: Length inclusive` ** `D1X - Parse decimal 1 byte length fields: Length exclusive` ** `D2X - Parse decimal 2 byte length fields: Length exclusive` ** `D3X - Parse decimal 3 byte length fields: Length exclusive` ** `D4X - Parse decimal 4 byte length fields: Length exclusive` ** `D5X - Parse decimal 5 byte length fields: Length exclusive` ** `D6X - Parse decimal 6 byte length fields: Length exclusive` ** `D7X - Parse decimal 7 byte length fields: Length exclusive` ** `D8X - Parse decimal 8 byte length fields: Length exclusive` ** `D9X - Parse decimal 9 byte length fields: Length exclusive` ** `D0X - Parse decimal 10 byte length fields: Length exclusive` * `STRING: ELMDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter written after a data element [original]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: ANDEOD - Don't accept a delimiter at the end of a row [OFF]` * `NUMBER: INTFMT=BIN/BCD/STR - Default format for integer values [auto]` ** `BIN - Integer in binary format (two's complement)` ** `BCD - Binary coded decimal (BCD) number` ** `STR - String representation of an integer` * `NUMBER: FLTFMT=BIN/BCD/STR - Default format for floating point values [auto]` ** `BIN - Floating point number in binary format` ** `BCD - Binary coded decimal (BCD) floating point number` ** `STR - String representation of an floating point number` * `STRING: INTVAL='str' - Default value used, to produce an empty integer string [NONE]` * `STRING: FLTVAL='str' - Default value (period) used, to produce an empty float string [NONE]` * `NUMBER: DECODE/ENCODE=OFF/BASE16/BASE32/BASE64 - Default base decoding for binary data [BASE16(text input), NONE(binary input)]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `SWITCH: IGNSPC - Ignore whitespace characters during base decoding [FALSE]` * `NUMBER: INTBAS=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Default base / radix for integers [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: FLTTYP=SYSTEM - Default type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `SWITCH: FLTSIG - Default: floating point numbers are signed [FALSE]` * `SWITCH: INTSIG - Default: integers are signed [FALSE]` * `NUMBER: BCDTYP=UNPACKED/PACKED/ZONED - Default BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: FRADIG=num - Default number of fractional digits (after comma)` * `NUMBER: FRASEP=SYSTEM/PERIOD/COMMA/APOSTROPHE - Default floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Default byte order for binary numbers [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: XMLSCM=STRUCTURED/UNSTRUCTURED - Default scheme for XML parsing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `SWITCH: XMLNOC - Default if no check of optional branches for mandatory fields (increase performance) [FALSE]` * `NUMBER: XMLPFX=IGNOREALL/IGNEXCXML/IGNXMLNS - Ignore prefix (pfx:tag) at tag compare [NONE]` ** `IGNOREALL - Ignore each prefix` ** `IGNEXCXML - Ignore each prefix except starting with 'xml'` ** `IGNXMLNS - Ignore each prefix except starting with 'xmlns' and prevent missing warning/error for it` * `NUMBER: XMLWRN=MANDATORY/BRANCH/ATTRIBUTE/DATAFIELD/MISSING/NSPREFIX/ALL - Default to activate different warnings at XML parsing [NONE]` ** `MANDATORY - No error but warning if mandatory element not found` ** `BRANCH - Warning if a branch without column description in the XML document` ** `ATTRIBUTE - Warning if a attribute without column description in the XML document` ** `DATAFIELD - Warning if a data field without column description in the XML document` ** `MISSING - Warning if a branch, attribute or data field without column description in the XML document` ** `NSPREFIX - Warning if a tag name without matching namespace prefix in row definition` ** `ALL - Activate all additional warnings` * `NUMBER: XMLERR=BRANCH/ATTRIBUTE/DATAFIELD/MISSING/ALL - Default to activate different errors at XML parsing [NONE]` ** `BRANCH - Error if a branch without column description in the XML document` ** `ATTRIBUTE - Error if a attribute without column description in the XML document` ** `DATAFIELD - Error if a data field without column description in the XML document` ** `MISSING - Error if a branch, attribute or data field without column description in the XML document` ** `ALL - Activate all additional errors` * `STRING: VALUE='str' - Default value, if element not in structure formats ['0' for float and integer else '']` * `NUMBER: PADBYT=num - Default to remove this padding byte (mainly for fixed length formats)` * `NUMBER: ALIGN=num - Default alignment for data fields in flat formats [1 (no alignment)]` * `SWITCH: ALWTRC - Allow truncation of values [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-varfmt_329b.html",
"VARFMT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.VARFMT]] ==== VARFMT indexterm:[Parameter, VARFMT, CONV.READ.BINARY.TABLE.DEFAULTS.VARFMT] The format for variable length data allows to write the length and a pointer to the value instead of the value itself to your data stream/ structure. This is useful to reduce memory utilization for variable length data. The pointer is in native/usable format (incl. bit width) and valid up to the next read operation. When writing, the data the pointer points to is copied and the data needs to only be valid for the duration of this operation. On a 32 bit system, the pointer requires 4 bytes. On a 64 bit system, the pointer requires 8 bytes. The length is always a 32 bit unsigned integer in local endianness. It is mandatory to specify the field order of length and pointer and padding (if applicable). The field order can be set to length-pointer or pointer-length. It is also possible to pad the fields so that they can be directly written to C structs, which are stored unpacked by default (i.e. fields are aligned to offsets that are a multiple of the field's length). Both can be controlled by setting the METHOD to one of: * ALENPTR - order length-pointer; fields are aligned (4 bytes padding after length field on 64 bit systems) * APTRLEN - order pointer-length; fields are aligned (4 bytes padding after length field on 64 bit systems) * PLENPTR - order length-pointer; no padding (aka. packed) * PPTRLEN - order pointer-length; no padding (aka. packed) The example below shows a type definition in C for a few tables as union. To read from or write to them, the APTRLEN format must be used. When writing to memory, the space for the data is allocated and managed by FLAM. When reading from memory, the application must provide the pointer and is responsible for it. The length of a length-pointer pair is determined by the system's architecture (32/64 bit) and selected METHOD (8, 12 or 16 bytes). Therefore it does not have to be provided. For example, in COBOL the packed form (PLENPTR/PPTRLEN) and for C the aligned form (ALENPTR/APTRLEN) must be used to be in sync with the structures of these programming languages. If you need alignment of these length-pointer pairs in a complex structure, the normal alignment for the whole element can be used. To determine null/empty indication and other additional information, a flag, length and pointer format can be used. The 32 bit flag word, contains the null indication bit as least significant bit of the high order half word (FLMELM_TYPTAB_FLAG_NULLID). No other flag bits are defined, yet. * `PLENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; no padding (packed) (8/12 bytes on 32/64 bit systems)` * `ALENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; with memory alignment (unpacked) (8/16 bytes on 32/64 bit systems)` * `PPTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; no padding (packed) (8/12 bytes on 32/64 bit systems)` * `APTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; with memory alignment (unpacked) (8/12 bytes on 32/64 bit systems)` * `PFLGLENPTR - 32 bit flag word (system endian), buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length (12/16 bytes on 32/64 bit systems)` * `PPTRLENFLG - Pointer in architecture-specific length, buffer length as 32 bit (system endian) integer followed by 32 bit flag word (system endian) (12/16 bytes on 32/64 bit systems)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-ccsid_c90b.html",
"CCSID",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.CCSID]] ==== CCSID indexterm:[Parameter, CCSID, CONV.READ.BINARY.TABLE.DEFAULTS.CCSID] The CCSID defines the encoding string or CCSID for the input text stream. For read operations, the default value is usually known. If it is unknown, the local character set is derived from the environment variable LANG. If LANG is not set, the default ASCII or EBCDIC system-codepage is used, depending on the platform. To get a list of supported encoding strings, please use the command below: Depending on the platform, this function lists all known encoding strings. Some encodings may not be supported. To determine the supported CCSIDs and corresponding encoding strings and charsets please use: To define the CCSID, you can use one of the encoding strings or the decimal number for a CCSID displayed by the command above. Example: A numeric CCSID must start with a decimal digit. * `DEFAULT - Use default CCSID (environment)` * `ASCII - Use default ASCII CCSID (environment)` * `EBCDIC - Use default EBCDIC CCSID (environment)` * `SYSTEM - Use system character set (same as DEFAULT)` * `LOCAL - Use local character set (system/physical)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-casmod_8c6c.html",
"CASMOD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.CASMOD]] ==== CASMOD indexterm:[Parameter, CASMOD, CONV.READ.BINARY.TABLE.DEFAULTS.CASMOD] With the case modifier, you can perform conversion to upper or lower case as well as apply case folding and some special case conversions. Case folding converts all characters to lower case but is more compatible with language specific rules for doing so. For example, this may be useful for case-insensitive string comparison if the strings contain non-Latin characters (code point < 128). This mapping is done for each code point in front of substitution or transliteration. The respective case is accomplished on the basis of a separate Unicode conversion table in memory. This conversion can be manipulated if user mapping is activated and mapping definitions (`*`) are defined through the provided user table. The options UPPER and LOWER convert characters without expansion, i.e. returned strings will never grow in length. Note, however, that case folding and the special options (convert e.g. ß to SS) can result in an expansion of data. All these conversions are pre-calculated once at beginning of execution to reduce the required CPU time for the conversion. * `UPPER - Change character to upper case` * `LOWER - Change character to lower case` * `FOLD - Change character to folded case (for compare)` * `SUPPER - Change character to special upper case` * `SLOWER - Change character to special lower case` * `USRTAB - Change character according to user table` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-usrtab_ab42.html",
"USRTAB",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.USRTAB]] ==== USRTAB indexterm:[Parameter, USRTAB, CONV.READ.BINARY.TABLE.DEFAULTS.USRTAB] With this parameter, you can choose a predefined subset or standard manipulation for the system tables via keyword (see `flcl help 'xcnv.inp.sav.fil.cnv.chr.usrtab'` for available keywords). Alternatively, you can use a file containing a user-defined substitution table (USRTAB) or you can specify a string containing the user table definitions. To distinguish such a string from a file name, the user table string must start with a colon (:). A keyword definition results in a prefix with two colons (::CCUT). Please don't use two colons for a string definition. The definition of a string is mainly useful for short user tables or if the user table is generated by an application. For the user table file, all rules and replacements are valid which are described under 'FILENAME HANDLING' above. For example: A user defined substitution table has the syntax listed below: NOTE: In the description below '/' is used as code point separator. The optional signs in front of a code point (CP) have the following meaning: If no sign is used, then a transliteration for a valid code point is defined. Valid code points are accepted, invalid code points result in in an error. Error handling depends on the mode (STOP,IGNORE, SUBSTITUTE). Definition of `+` code points without code point list, thus without `=` is equal definition of valid code points. With an asterisk `*`, you can define an enforced mapping for this code point. For example, this can be used to delete this character if no code point list is provided or to translate this character always in another value. This can also be used to convert code points outside of a subset into this subset. In contrast to the transliteration (`+` is only done if a character doesn't exist in the target encoding), the mapping is always done for each character. Invalid (`-`) code points can be used to deactivate a code point. To activate (`+`) or deactivate (`-`) a range of code points you can use the minus mark (`-`) followed by one sub code point. The range goes from the smaller code point to the bigger one. For example: The range operator (`-`) with the optional plus sign (`+`) can also be used to activate code points. To define an own case mapping or folding (required for certain subsets) the caret sign (`^`) can be used. This mapping is only done if the user table is activated for case mapping (CASE=USRTAB). To define transliterations/substitutions/mappings an assignment (`=`) of a code point list is required. The code point list can contain a maximum of 8 code points. If no code point list is specified, then the character is ignored. A transliteration to itself simply activates this code point. The same is valid for mapping definitions. A code point is a hexadecimal number representing a 21 bit Unicode codepoint. If a code point is not defined in the substitution table (USRTAB and/or SYSTAB), the appropriate substitution character (SUBCHR) is used. If SUBCHR is not set, no substitution is performed. Depending on the MODE, character conversion stops with an error (STOP) or ignores the character (IGNORE). Text before and after brackets are comments. Between '(' and '=' or '/' or ')' you can define hex digits until the first non-hex digit. All non-hex digits up to the next separator are interpreted as comment. Leading whitespace is ignored. Leading zeros are allowed. If you don't supply a hex value, then 0x00 is used. WARNING: Don't use parentheses '()' or the operators in comments. To describe your own subsets, you can use a user table without a system table. The USRTAB can also be used to overwrite or add transliterations when a system substitution table (for example SYSTAB=ICONV) is used. The transliteration works recursively, that is if one of the substitution code points is not in the target set, this substitution will be used instead and so on. If you have a EURO sign in your text and convert it to 'Latin-1', the resulting byte string will be 'D6DF524F'. On the other hand, if you convert it to 'ASCII', the byte string will be '4F457373524F'. The mapping as described above is always done and is also done recursive including the transliteration result. For example, if you define a mapping `(*30=39)` then the target data won't have any zero in the resulting text. By replacing other code points recursively, you could easily cause infinite loops. To prevent this, the amount of replacements and the length of one replacement is limited to a maximum of 64. Note that this could still result in a large expansion of data. Therefore, be careful about defining recursive substitutions. You can also define mappings of more than one codepoint to other codepoints (multiple mapping). This can be used, e.g., to define 'tagging' mapping: and undo tagging: Another example for multiple mappings is to convert HTML entities to their respective characters: If multiple mappings are defined in a user table, it is important to know that character conversion (cnvchr) becomes much slower because finding multibyte sequences is a more expensive operation. An example of String.Latin subset (XOEF) normalisation mapping NFD (Normalization Form D) and NFC (Normalization Form C) is located in the SAMPLE directory under NPASNFD and NPASNFC. A sample user table for the ICONV system table to change the transliteration of German umlauts to AE, OE or UE is located in the SAMPLE directory under CCUTDEXL. Another sample user table called CCUTNPAS defines the 'string.latin' subset (XOEF) which is mainly used for statutory reporting. The order of definition is the order of processing the definitions. For exampel, if you define a mapping or a transliteration for code point X and later you make this code point invalid, then the code point is invalid. On the other hand, you can first deactivate all code points, then activate your subset and define your transliterations (best fit) or mappings. For example: To define a non-expansion best fit mapping a user table can be used to delete all combined characters for single byte code pages. For the ICONV system transliteration table, a sample user table can be found under the name CCUTBFM1. Some other subset user table definitions were added. For example: * currently valid SEPA characters (<128) for money transfers (CCUTSEPA) * characters valid in ISO-8859-15, CP1252 and IBM1142 (CCUTDELA) * characters valid in ISO-8859-15, CP1252, IBM1142 and XOEF (CCUTDLAX) All user table definitions are pre-calculated once at the beginning of execution to reduce the required CPU time for the conversion. So, the use of a user table increases the cost to open a file but has no effect on CPU utilization when converting the data. To minimize the effort and to simplify the usage of user table, the most common subsets can be selected by keyword. In this case, a pre-calculated load module (DLL) is used. The subset definition can be for UTF (21 Bit Unicode) or UCS (16 Bit Unicode). If it is a UCS subset, then no valid code point is greater than 0xFFFF and you must use UTF CCSIDS to ensure that no code point greater than 0xFFFF is accepted. If you have a working user table definition for a popular subset or system table manipulation, you can request a keyword for it. Please report this requirement over our issue tracking system https://www.flam.de/en/technology/support/issues/ Feel free to attach the corresponding user table definition. * `NPAS - UCS subset for statutory reporting (New passport, XOEF, String.Latin)` * `SEPA - UCS subset of valid SEPA character smaller than 128` * `DELA - UCS subset for German Latin of IBM1141, ISO8859-15 and CP1252` * `DLAX - UCS subset for German Latin of IBM1141, ISO8859-15, CP1252 and XOEF` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-onemap_6a95.html",
"ONEMAP",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.ONEMAP]] ==== ONEMAP indexterm:[Parameter, ONEMAP, CONV.READ.BINARY.TABLE.DEFAULTS.ONEMAP] Recursive mapping can be deactivated by using this switch. Otherwise, mapped output becomes mapping input and is mapped again, until no further replacements are possible. Example: If the following mapping rules are specified and the 'ONEMAP' switch is not used, a euro currency symbol is mapped to 'EUR', which is then mapped to 'CHF'. With the 'ONEMAP' switch set, the euro symbol is mapped to 'EUR' and is not mapped again. The order for character handling is to map first and then apply translitaration. So, if the switch 'ONEMAP' is set, the result of a consecutive translitaration is not mapped. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-cmbfrm_408a.html",
"CMBFRM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.CMBFRM]] ==== CMBFRM indexterm:[Parameter, CMBFRM, CONV.READ.BINARY.TABLE.DEFAULTS.CMBFRM] Combined character form parameter to manage combined character support. Some characters consist of more than one codepoint and some characters have multiple different codepoint sequences with the same meaning: *For example:* German small letter 'u' with diaeresis (u umlaut) has the codepoint: but you can write the same character with codepoint 'u' and combined character '..': So, the same character has two different representations. Comparison of two identical strings (to the human reader) in binary mode fails if the strings to be compared use different encoding schemes. *Normalization forms* To solve this problem, one of the Unicode normalization forms can be used: * NFD, Normalisation Form D (Canonical Decomposition) * NFC, Normalisation Form C (Canonical Decomposition, followed by Canonical Composition) To achieve *NFD*, the string is transformed by decomposing all characters by canonical equivalence and putting any combining characters in a well-defined order (sort on Canonical-Combining-Class 'CCC' value of combining characters). For *NFC*, characters are decomposed like in NFD and then recomposed by canonical equivalence. Example: For more information see: http://unicode.org/reports/tr15[unicode normalization forms] With the values *NFD*/*NFC*, the data is normalized, and is usually only useful in multi-byte character sets (UTF). It is not possible to use user-tables and normalization in one step. With the default parameter value 'AUTO', combined character detection is attempted on the first block. If deemed useful (conversion to single byte charset), combined character support is activated for character conversion. The parameter value 'ON' enforces character conversion with combined character support for any destination charset. In contrast to normalization, with combined character support, any character conversion feature (user-table, translitaration, case-mapping, ....) can be used. The parameter value 'OFF' deactivates combined character support, which results in a much faster character converion procedure being used. * `NFD - Normalization form D (Canonical Decomposition)` * `NFC - Normalization form C (Canonical Decomposition,followed by Canonical Composition)` * `AUTO - Detect combined character and compose this if useful` * `ON - Run with combined character support (slow)` * `OFF - Do not use combined character support` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-witspc_d03b.html",
"WITSPC",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.WITSPC]] ==== WITSPC indexterm:[Parameter, WITSPC, CONV.READ.BINARY.TABLE.DEFAULTS.WITSPC] With the whitespace modifier, you can specify how to handle whitespace in string data. Leading whitespace, trailing whitespace or both can be removed. Multiple consecutive whitespace characters can be collapsed to only one. Whitespace can also be removed completely. A special behavior is implemented for numbers which works like 'BOTH', but leading zeros (0) are also suppressed and if the number does not start (.3 -> 0.3) or end (3. ->3.0) with a digit, a 0 is put in front or afterwards. Replacement and removal of whitespace are pre-calculated once at the beginning of execution to optimize the required CPU time for the conversion. Whitespace handling is done based on Unicode code points and is independent of the character set used. * `PRESERVE - Don't touch any whitespace` * `REPLACE - Replace all control characters with whitespace characters` * `COLLAPSE - Remove leading/trailing whitespace and control characters and collapse multiple whitespaces into` * `REMOVE - Remove all whitespace  and control characters from the string` * `TRAILING - Remove trailing whitespace and control characters from the string` * `LEADING - Remove leading whitespace and control characters from the string` * `BOTH - Remove leading and trailing whitespace and control characters` * `NUMBER - Remove leading/trailing whitespace and control characters as well as leading zeros` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-defaults-xmlns_185b.html",
"XMLNS",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.DEFAULTS.XMLNS]] ==== XMLNS indexterm:[Object, XMLNS, CONV.READ.BINARY.TABLE.DEFAULTS.XMLNS] Defining XML namespaces activates namespace handling in XML-based tables. It is an array of pairs consisting of a prefix and a URI. The prefix is an abbreviation which can be used in path specifications (i.e. in `root` and `path` attributes when defining columns). If the prefix is not specified or an empty string, it is considered the default namespace which applies to all path elements which are not explicitly prefixed with one of the defined namespace prefixes. By defining a namespace without specifying prefix and URI (see below), the NULL namespace is used. This corresponds to an XML document without namespace definitions (using the NULL namespace for elements and attributes), but the namespace `xml` will be internally known and handled. Attribute names are always in the NULL namespace according to the XML specification unless it has a namespace prefix. If namespace handling is used when reading an XML document, the XML parser resolves all namespace prefixes in the document to the respective URIs and returns the namespace URI for each tag and attribute name. This URI is compared with the URI that is defined for path elements in the row specification of your table. The prefixes used in the XML document and the prefixes defined with the `prefix` attribute are consequently totally independent. The given namespace prefix is, however, used when writing tables as XML documents. The prefixes for all namespaces must be unique and are case sensitive. With namespace handling enabled, it no longer matters which prefixes are used inside the XML document since namespace are matched by URI. Therefore, the same `root` and `path` specifications can be used no matter if a tag is named `<ns1:svg>` or `<svg:svg>` in the XML document as long as both prefixes are mapped to the same URI. The namespace prefixes used in `root` and `path` strings must only match those defined via `xmlns(prefix=...)`. When writing XML documents, the namespace declarations are put in the root XML tag. Per-subtree namespace declarations can currently not be written. Please contact support if this is required. The defined prefix for a URI can be used in root and path strings: The prefix `ns0` can (but does not have to) be used in the root and path strings because the empty prefix (global namespace) has the same URI. The prefix 'ns1' must be used in the root and path strings where appropriate. If a path element in the `root` or `path` string contains a colon and the string before the colon is not a defined namespace prefix, the whole tag must match and the NULL namespace is used. When reading XML, this will yield an informational message or a warning (if enabled) to make you aware of possibly missing namespace declarations or typos. When writing XML, prefixes that are defined but not used in path or root strings are not written to the XML document. This could be used to read prefixed and unprefixed (i.e. with global namespace) XML documents and always write XML documents either with or without the prefix `ns0` in the example above, depending on whether or not you use the prefix in the `root` and `path` strings. With only the global namespace definiton it looks like: With only a prefixed namespace definiton it must look like this: Below is an XML example for namespaces and the corresponding row definition with an additional `xml:id` and `xml:lang` usage in the paragraphs to test the implicit `xml` prefix definition: The contents of the XML document are read into one row. The prefix `xml` is supported by default using the URI `http://www.w3.org/XML/1998/namespace` does not need to be defined. The URIs are stored in a literal cache to save memory, but the corresponding hash calculation can increase the CPU utilization at read if namespace handling active. * `STRING: PREFIX/PFX='str' - Prefix for XML namespace handling ['']` * `STRING: URI='str' - URI for XML namespace handling ['']` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row_94ac.html",
"ROW",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW]] ==== ROW indexterm:[Object, ROW, CONV.READ.BINARY.TABLE.ROW] Tables are read row-by-row. This object must be used to describe the structure of each row in a table. The maximum length of one row can be limited by specifying the MAXLEN parameter. This is especially important for unstructured data if more than one row specification is used because it may help to detect the correct row specification that applies to the currently processed row. If specifying a fixed or variable length format, by default, the 'MAXLEN' parameter is set to a reasonable value (sum of each length). For fixed length formats, the record length must be equal to the calculated length of this row and for variable formats, the record length must smaller than or equal to the defined maximal length. For structured formats like XML, the maximum length check is also available, but usually does not make much sense because the bytes occupied by one row needs is not known a priori for such data formats. To simplify the specification of columns, a format specifier and several default values can be specified. These settings will override the corresponding settings of the table object. Any conversions are performed per column. Data formats, character sets and various conversions can be mixed at will. If XML documents are parsed, the format for all columns must be XML. If the table processing method is RECORD, then you can activate switches to ignore empty records (record length = 0) or a remaining rest at the end of the line. This can be used to suppress columns at the end of the record. The table name is a logical qualifier which can later be used to address the table. Additionally, a path can be defined for different structured formats (like XML). This path is appended to the root path provided for the table and serves as prefix for the per-column path. If no path is provided, the logical table name is used. A row specification supports many powerful features which can be accessed with the parameters below. * `STRING: NAME='str' - Logical name for the row specification (table)` * `NUMBER: MAXLEN/FIXLEN=num - Maximum length of a row/record for format detection [no limit]` * `SWITCH: IGNRST - Ignore a remaining rest at the end of a record/row [FALSE] (only if record orientation)` * `SWITCH: IGNEMP - Ignore empty rows/records [FALSE] (only if record orientation)` * `STRING: PATH/ROOT='str' - Define path to row (root) in a structured format [name]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column_8147.html",
"COLUMN",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN]] ==== COLUMN indexterm:[Object, COLUMN, CONV.READ.BINARY.TABLE.ROW.COLUMN] This object is used to describe how to extract a specific column from each row. Optional pre-processing steps (e.g. decryption) can be applied separately before a conversion to a neutral data type is done as last step for every column. The neutral format of the extracted data can be validated using a regular expression. The column name is a logical qualifier which can later be used to address the column. For different supported structured formats, a path can be specified. This path is appended to the root path which may be specified in table and row objects. If no path is provided, the logical column name is used. To simplify the specification of formats, processes and types, several default values can be specified. These settings will override the corresponding settings of the row object. As part of the end of table handling you can define a logical table name over the keyword 'CHANGE' which activates monitoring of changes in this column, which will result in a EOT return code if a change is detected. In such a case the table name defined in this column specification is used in the EOT handling process. You can place a star character (*) in the change string. The first star in the string will be replaced by a string representation of the changed column value. For example: The CSV table can now be split in male and female, depending on the character in the column GENDER and the table names given after EOT are 'TABM' and TABF'. At write you can only request the name and the age and the EOT handling can be used to produce 2 tables one with all female and another with all male entries. This column change detection support was mainly introduced for users using only one row specification for different tables in XML. The first row will result in a table change, except if it is identical to the set default value for this column, because each use of a new row definition will start with this default as previously stored column values. If no default value is specified, for string and binary columns an empty string ('') and for integer and float the number zero ('0') is used. With this mechanism, you can control the EOT handling in the start phase of a table. You can ensure that the first EOT gives the first column with a defined change, if the default value is different to the value expected for this column or you can ensure to get the name of the row specification after the first EOT if all defaults match the expected values of the first row in the table. Later on, a row definition change will result in EOT and if you come back to a previous row definition, the old values are still used for compare. NOTE: If the first data block does not contain a complete row, you still get the table name of the first defined row specification. This mechanism only works in the expected manner if the block size is larger than the space required for the longest row. A column specification supports many powerful features which can be accessed with the parameters below. * `STRING: NAME='str' - Logical name of the column` * `NUMBER: MINLEN=num - Required minimal length to enforce data in external format [0 - no length check]` * `NUMBER: MAXLEN/FIXLEN=num - Required fixed length or maximum allowed length [0 - no length check]` * `STRING: PATH='str' - Define path to element in a structured data format [name]` * `STRING: ROOT='str' - Define root path to element in a structured data format` * `STRING: VALUE='str' - Optional default value, used for optional fields in structured data formats ['0' for float and integer else '']` * `STRING: CHANGE='str' - Logical table name and activation of change detection for this column` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format_8b57.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT] When reading a column of a row, it is important to know where the data for the column starts and ends. This overlay is intended to specify just that. It is used to either specify the length directly, or it specifies how to identify the data length and/or begin and/or end of the column. The currently supported data formats are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-fix_070f.html",
"FIX",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.FIX]] ==== FIX indexterm:[Object, FIX, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.FIX] This object is used to read a column containing fixed-length data where the length is not embedded into the data and where no column delimiter is present. The length parameter must be provided. Optionally, padding bytes can be removed and an alignment defined. * `NUMBER: LENGTH=num - Fixed length for the data field [0 = length from column specification is used]` * `SWITCH: REMPAD/ADDPAD - Remove padding bytes [FALSE]` * `NUMBER: PADBYT=num - Padding byte value for remove [0x00]` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-lfd_8eca.html",
"LFD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.LFD]] ==== LFD indexterm:[Object, LFD, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.LFD] This object is used to read a column with data that is prefixed with a length field. A limit for the maximum length and/or an alignment of this element can be set for better format detection. * `NUMBER: LENFMT=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Format of the length field [S2X (VARCHAR)]` ** `L4I - Parse binary 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse binary 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse binary 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse binary 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse binary 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse binary 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse binary 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse binary 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse binary 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse binary 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse binary 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse binary 4 byte length fields: System endian short (LLxx), length exclusive` ** `L2I - Parse binary 2 byte length fields: Little endian integer, length inclusive` ** `L2X - Parse binary 2 byte length fields: Little endian integer, length exclusive` ** `B2I - Parse binary 2 byte length fields: Big endian integer, length inclusive` ** `B2X - Parse binary 2 byte length fields: Big endian integer, length exclusive` ** `S2I - Parse binary 2 byte length fields: System endian integer, length inclusive` ** `S2X - Parse binary 2 byte length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Parse binary 1 byte length fields: Length inclusive` ** `S1X - Parse binary 1 byte length fields: Length exclusive` ** `D1I - Parse decimal 1 byte length fields: Length inclusive` ** `D2I - Parse decimal 2 byte length fields: Length inclusive` ** `D3I - Parse decimal 3 byte length fields: Length inclusive` ** `D4I - Parse decimal 4 byte length fields: Length inclusive` ** `D5I - Parse decimal 5 byte length fields: Length inclusive` ** `D6I - Parse decimal 6 byte length fields: Length inclusive` ** `D7I - Parse decimal 7 byte length fields: Length inclusive` ** `D8I - Parse decimal 8 byte length fields: Length inclusive` ** `D9I - Parse decimal 9 byte length fields: Length inclusive` ** `D0I - Parse decimal 10 byte length fields: Length inclusive` ** `D1X - Parse decimal 1 byte length fields: Length exclusive` ** `D2X - Parse decimal 2 byte length fields: Length exclusive` ** `D3X - Parse decimal 3 byte length fields: Length exclusive` ** `D4X - Parse decimal 4 byte length fields: Length exclusive` ** `D5X - Parse decimal 5 byte length fields: Length exclusive` ** `D6X - Parse decimal 6 byte length fields: Length exclusive` ** `D7X - Parse decimal 7 byte length fields: Length exclusive` ** `D8X - Parse decimal 8 byte length fields: Length exclusive` ** `D9X - Parse decimal 9 byte length fields: Length exclusive` ** `D0X - Parse decimal 10 byte length fields: Length exclusive` * `SWITCH: AWLEOD - Accept wrong length at the end of a row [OFF]` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-dlm_08fb.html",
"DLM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.DLM]] ==== DLM indexterm:[Object, DLM, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.DLM] This object is used to read a column with a trailing binary delimiter after the column data. A limit on the maximum length and/or an alignment of this element can be set for better format detection. * `STRING: DELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to find the end of an element [SYSTEM]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: ANDEOD - Accept no delimiter at the end of a row [OFF]` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-var_0cd5.html",
"VAR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.VAR]] ==== VAR indexterm:[Object, VAR, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.VAR] This object is used to read a column from memory based on a certain length pointer format. A limit on the maximum length of the value and/or an alignment of this element can be set for better format detection. * `NUMBER: METHOD=PLENPTR/ALENPTR/PPTRLEN/APTRLEN/PFLGLENPTR/PPTRLENFLG - Sets field order of buffer pointer and pointer length as well as padding [PFLGLENPTR]` ** `PLENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; no padding (packed) (8/12 bytes on 32/64 bit systems)` ** `ALENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; with memory alignment (unpacked) (8/16 bytes on 32/64 bit systems)` ** `PPTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; no padding (packed) (8/12 bytes on 32/64 bit systems)` ** `APTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; with memory alignment (unpacked) (8/12 bytes on 32/64 bit systems)` ** `PFLGLENPTR - 32 bit flag word (system endian), buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length (12/16 bytes on 32/64 bit systems)` ** `PPTRLENFLG - Pointer in architecture-specific length, buffer length as 32 bit (system endian) integer followed by 32 bit flag word (system endian) (12/16 bytes on 32/64 bit systems)` * `NUMBER: ALIGN=num - Align data in the buffers pointed at to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-csv_e90c.html",
"CSV",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.CSV]] ==== CSV indexterm:[Object, CSV, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.CSV] This object is used to read a column in CSV format, which exists in multiple variants. All that is necessary to parse CSV input is a list of column separators and optional field enclosing characters. A limit on the maximum length and/or an alignment can optionally be set for better format detection. All control characters (0x00-0x19) are regarded as row delimiters. If a padding byte is specified, it is also regarded as control character. The field enclosing characters cannot be a control or whitespace character. The defined column separators are excluded from the control characters. An additional list of code points can be specified which are excluded from the control character list. If a field is enclosed by field enclosing characters, any kind of control character and whitespace can be in the data. If the field enclosing character is also part of the actual data, it is expected to be escaped by doubling the character (i.e. two quotation marks for a quotation mark in the data). If a field consists of only two consecutive field enclosing characters, it is treated as an empty value. A special behavior is implemented for brackets. If one of the opening brackets '(<{[' is set as field enclosing character, then the corresponding closing bracket is expected for field termination. This allows to read CSV lines like:    (John Doe),(123),(42,23) If you need 0xC285 (UTF-8 NEL) as record delimiter or any other kind of binary delimiter, please use CNV.REC() for table formatting. * `STRING: COLNAM='str' - Column name to detect the headline [COLUMN-NAME]` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set of the CSV column [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - List of separator characters as Unicode codepoints [COMMA,SEMICOLON]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDCHR[num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS...] - List of field enclosing characters as Unicode codepoints [QUOTATION,APOSTROPHE,GRAVE]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: EXCCHR[num/TABULATOR...] - Exclude from control characters as Unicode codepoint list [NONE]` ** `TABULATOR - Apostrophe (Single quotation mark) as enclosing character` * `NUMBER: PADCHR=num - Binary padding character (is regarded as additional control character) [0x00]` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` * `SWITCH: CASEHL - Case-sensitive comparison of headline identifier [FALSE]` * `SWITCH: NONFLD - No field enclosing character [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-tvd_d152.html",
"TVD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.TVD]] ==== TVD indexterm:[Object, TVD, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.TVD] This object is used to read a column with data that is enclosed by a certain tag and a trailing delimiter. The format was mainly developed to parse SWIFT MT transaction data. The format can have an arbitrary hierarchical depth. This is expressed via a path specification with an opening tag and a closing delimiter, with each level separated by a slash. If TVD data from an underlying tag and delimiter are included, they can occur in any order. If this is not the case, the order must correspond to the information in the row specification. In such hierarchical formats, the beginning of the table is determined by the beginning of the repeating data. This beginning is indicated by the longest root path. The repeating data can itself be structured arbitrarily deep, which is indicated by a further path specification. The repeating data can be preceded by so-called headers or followed by trailer data. This header data is distinguished by a shorter root specification which must be placed before the repeating data as a template in the row specifications. The same applies to trailer data, except that it must follow after the repeating data. A short root in between will result in an error. A change in the header or trailer data, leads to an interruption of the table to output the changed header data. The complete or parts of the read delimiter can be pushed back to be matched again in the next column as the starting tag. This push back mechanism is also available for tags to include parts of these tag into the data portion. The push back defines the amount of characters (not bytes). Trailing whitespace (e.g. if `\\W` is used) is not included. For the tags and delimiters, the CCSID must be specified. Case sensitive comparison can be disabled with a switch. For each tag and delimiter, an unlimited amount of alternatives (separated by a | character) can be defined. This can be used for aliases or is required for different possible next tags as part of the previous delimiter in conjunction with the push back mechanism. For example, to parse an XML attribute lists, the delimiter list could look like this: `'\W>\W|'\B` The first alternative matches if the attribute list ends at the closing bracket of the starting tag `>`. The other alternative matches if another attribute follows, separated by a whitespace character. In this case, the order is important. If you have alternatives where one is a prefix of the other (e.g. 'abc' and 'abcdef'), the longest must come first to ensure it matches if it occurs in the data. If the minimum and/or maximum length of the data value is known, it is recommended to set these limits via the respective parameters as safety measure. For variable length data (i.e. only terminated by a delimiter) the default maximum length is 512. [[tvd.rootpath]] The component uses root and path variables to describe the format. The data format can have an unlimited hierarchical depth. The longest root defines the start of the repeating part of the table. A shorter root can be used to read values which are the same for every table row and therefore appear only once before the repeating structure in the input data begins (as a kind of 'header'). These (short root) values are copied to each table row. Example use case: A file containing banking transactions starting with the currency which is valid for all the following transactions so that it doesn't have to be stored repeatedly in each transaction record. When transforming this file to a table, the currency can be copied to each table row using the 'short root' approach to have the currency copied as a column to each row in the resulting table. NOTE: If a column is defined which is valid for more than one row, but this element was not defined with a short root, damaged data can be the result. In this case, the pointer into the input data can point to the next data read for upcoming rows and not to the previously read data. Be careful at this point in your design of row definitions. The character sequences below can be used in root and path specifications. [[tvd.characterclasses]] All character classes are determined by the supported Unicode standard. For example, if `\\u` refers to all uppercase letters, then this applies not only to the Latin A-Z but also to the Cyrillic, Greek and all other letters that are supported in Unicode. The upper case escape sequences to terminate a tag or delimiter in the above list match the corresponding character class (if found) but the internal reading position is not advanced by the number of characters matched. As a result, the push back operator (`>`) is not necessary. If defined more than once, all classes must match on this character. The special escape sequences `\\C`, `\\c` and `\\k` exist for formats like JSON where comma separators between arguments are used. The separator's character code point defaults to comma, but can be changed by setting the SEPCHR parameter. To separate the input, all closing parentheses are additionally supported here, whereby the read position remains in front of them, so that they can be read later as close delimiters. This makes it possible, among other things, to clearly recognize the end of numbers in JSON, which are not explicitly in quotes. When writing, `\\C` adds a newline character after the separator, `\\c` adds an additional space character after the separator and `\\k` only prints the separator if another element follows on the same hierarchical level. If no other element follows, separator and whitespace will not be printed. For `\\C` only the newline character is printed in this case. This special character sequences was defined to support comma separated lists, where the last item is not terminated by a certain separator. The special escape sequences `\\B`, `\\N` and `\\W` ignore whitespace and control characters when reading. When writing, `\\B` adds a whitespace character to the formatted output and `\\N` a newline character. To use any of the special characters or escape sequences as literal characters, they must be preceded by a backslash (e.g. `\\<` or `\\\\S`): We recommend to escape all punctuation characters. In the example above, the `>` does not have to be escaped because it does not have any special meaning, but this may change in a later version of FLAM. If the `*` separator is used, then the data is read until the delimiter is encountered. In this case a default limit of 512 is used unless a different maximum length is defined by setting the `MAXLEN` parameter of the column. This syntax can be used to parse quite complex text formats and transform the data into tables. Below is an example for a MT103 SWIFT transaction including the HSPF header and TSPF trailer. The complete definitions are provided together with other SWIFT-MT formats as example file in your FLAM installation. To convert a SWIFT-MT transaction into a corresponding SEPA XML transaction, the field CB-VDCUISA (`:32A:*\n`) must be split into three parts to get the date, the currency and the amount as separate columns. For such things, it is possible to define fixed-length fields without delimiter and also fixed or variable-length fields without a tag. If no tag is specified, then the next field must directly follow inside the data or a format error occurs. A special consideration is needed for `:71x:` fields. For example the field `:77:` could be at the end, is optional and can span multiple lines. In such a case the `\\n` delimiter is not sufficient since there are 2 possible tags which can follow. Either the optional tag `:77B:` or the closing tag (delimiter) `-}`. In this case, the 2 different alternatives must be defined and can be separated with the OR operator. If fields are enclosed by a root tag and delimiter, the order of the fields is arbitrary. If no enclosing tag and delimiter are found, the order must fit the order of the defined columns (optional fields may be missing). In SWIFT-MT messages, you can find repeating groups where a mandatory field signals that a new row begins. In such a case, the mandatory field (e.g. MT101 `:21:`) is the opening tag and the closing tag for the transaction, but these closing tags must be completely pushed back in order to be read as opening tag of the next transaction. See example SWFMT101 in your FLAM installation. Another special case in MT101 is the Message Index field. This is divided into the current index and the number of transactions. The separator between the two numbers is therefore a delimiter, which is followed by another number with \n as delimiter. Since this has no tag, the data must occur here in direct sequential order. In SWIFT-MT exist fields which have the same tag but different kinds of content. For example, there might be 3 options for the tag `:hugo:`: # The data starts with 6 digits followed by 2 upper case characters (A-Z). # 3 digits followed by 5 upper case characters (A-Z) # 4 upper case character followed by 4 digits In such a case, the path definition below can be used: If `:hugo:` a required field, then it must be defined as optional when reading (-) because only one of the 3 options can apply, which implies the other ones must be optional. The match of character classes must be unique in such a case. This means that in the example above a push back of 4 should be enough. The character class `\\z` can be used as wildcard which matches any character. This is useful if something can come in between. Below a sample to parse a XML message with the TVD support, where a corresponding sample message are add as comment to the the row definition. The attribute list in the XML tags are parsed as additional level, where the start tag (`<menu`) and start end tag (`>`) are used as tag and delimiter. The start tag (`<menu`) has also a corresponding end tag (`</menu>`) in the level below. For this to work, this start tag must be provided with a push back (`\\<menu\\W<*` (in full length (no digit behind `<`))), so that it can be read again in the next level for the attribute list. A special case is an 'end must list'. This is data behind a closing tag and this can also be parsed as a sequential list of data. If such data has a root definition on a higher level in the hierarchy (short root), its value is not available as column data for preceding rows (since it has not been read, yet). Such trailer data is handled as optional by default, otherwise an error will occur because the column was not found in the input data. See the extended XML sample below The last column specification is a trailer as must list delimited by `<` where the `<` will be push back to be read a begin of the delimiter for the XML root tag. All column definitions of the TVD format, which are not interrupted by any other format, are read as a tree containing the possible next items or fixed length fields or variable length fields for each item up to a defined delimiter. This means that the TVD format can be used in conjunction with the FIX, LFD and DLM formats. The main differences between TVD and explicit XML and JSON processors as part of the table support are: * The format definitions for XML or JSON in the TVD root and path syntax   are much more complex. * The TVD processor knows nothing about JSON or XML. Thats why no   plausibility checks are possible. * The explicit XML and JSON processors do not support mixed formats. The   whole data stream must be in JSON or XML format. The TVD format can   be mixed with any other format except XML and JSON. * Some validations (e.g. exist a required branch with only optional   fields) are not implemented with TVD. The format validation for XML   or JSON is higher. When reading records (no delimiter) using the CONV command and defining TVD format as default and block handling as method, then a record to block conversion using the default delimiter is done before format parsing. With XCNV, such a record to block conversion must be added manually. This is required to parse for delimiters and use the same row definition for flat files with delimiters and host datasets with record length instead of delimiters. * `STRING: ROOT='str' - Root to XML element [taken from table/row/column]` * `STRING: PATH='str' - Path to XML element [taken from column]` * `STRING: VALUE='str' - Optional default value, if element not in data structure ['0' for float and integer else '']` * `STRING: CCSID='str'/DEFAULT/ASCII/EBCDIC/SYSTEM/LOCAL - Conversion from this CCSID to UTF-8 [system]` ** `DEFAULT - Use default CCSID (environment)` ** `ASCII - Use default ASCII CCSID (environment)` ** `EBCDIC - Use default EBCDIC CCSID (environment)` ** `SYSTEM - Use system character set (same as DEFAULT)` ** `LOCAL - Use local character set (system/physical)` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - List of separator characters as Unicode codepoints [COMMA]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `SWITCH: NOCASE - Case sensitive or not [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-xml_a045.html",
"XML",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.XML]] ==== XML indexterm:[Object, XML, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.XML] This object is used to transform an XML document into table format (i.e. rows and columns). If one column format is set to XML, then all column formats of all row specifications must be set to XML because the FMT.XML() object is used to build an XML element list for the provided XML document. This XML element is transformed to table entries based on the paths specified for each column. The XML data is required to be in UTF-8. All formatting, comments, processing instructions and document type definitions (DTD) from the XML document are ignored when reading. Only data contained within XML tags or attributes can be accessed. The maximum data length for a column is 1024 bytes by default. If there is a column that may contain more than 1024 bytes of data, the MAXLEN parameter must be set accordingly. Since version 5.1.25 of FLAM (namespace support) tag and attribute names are stored in a literal cache only once and used over and over again. This saves memory and processing time, but only if the hashtable is not too small. The default is 12 for 4096 entries. With the environment variable FL_LITERAL_CACHE_SIZE this can be adjusted between 256 (=8) and 1,048,576 (=20). For processing large XML documents we recommend to work with FL_LITERAL_CACHE_SIZE=16. To address XML elements which are to be transformed to table columns, there is a path notation to describe the location of a data field within the XML document. There are two kinds of path: the root path (the branch in the XML tree where all data supposed to go into the table is located under) and the column-specific path (which locates an attribute or data node within the sub-tree under the root). The syntax is described in detail further below. There are two supported schemes of operation. The default scheme is the structured scheme. In this mode, each table row is enclosed by an XML tag. This is required to support default values for missing entries, header data, optional branch checking and other features. The second supported scheme is the unstructured one. In this variant, table rows do not need to be enclosed in XML tags. Instead, it is considered a new row when a defined column is encountered in the XML data which has already been read before for the current row. As a consequence, the order of columns within a row is arbitrary. There are, however, no optional columns in this mode. Each column must be present in the XML data for every row. Since version 5.1.25 of FLAM the structured format supports also XML formats with only one level, but in this case such a format as only one root level and one or more path level and the whole format is only a table with one row. See example below: Formats containing only the root level and native data like below are not yet supported: Let's continue with examples for both schemes: Below is a simple XML example which is suitable for the structured mode: A table object that to read this XML documentation into a table can be found below. Since no path information is specified, the row and column names are used for the path. An XML document suitable for the unstructured variant may look like the following example: The tags 'col1' and 'col2' appear repeatedly, but with changing order. The XML could also be encoded in one line without any whitespace. The form of the XML document is completely independent for the parsing process. To turn this document into a table with three rows and two columns, the following table object can be used: The XML document must contain all columns for each specified row. The order of columns per row is arbitrary. If one column is missing, the row specification does not match and another row specification is tried. If no matching row specification is found, an error occurs. A row specification must not contain all possible data fields and attributes in a XML document. You can only ready what you need. Beside the scheme, a 'root' and a 'path' can be specified to locate elements in the XML document. In the structured scheme, 'root' is the path to a row and 'path' is a path within a row. In the unstructured scheme, 'root' is the path to a table and 'path' is a path within that table. The root and path must be specified in the syntax described below and can have any hierarchical depth up to 64 levels. The structured example above could also be read like this: The parameters 'path' and 'root' must be enclosed in angle brackets (<...>) for XML. To reduce redundancies in path specifications, the 'path' attributes on table, row and columns level can be used. All paths are case sensitive. Don't use diacritical characters in tag names. If your UTF-8 encoded XML data contains decomposed combined characters, you must perform conversion to UTF-8 NFC before using table formatting. To locate an attribute value in the XML, the last path element must be prefixed with the character '@'. The character '&' can be used as a code page independent alternative and is mainly intended for EBCDIC systems. The last element in a path can also be prefixed with the '%' character. It is only valid for non-attributes (i.e. '%' and '@'/'&' cannot be used at the same time). It is only relevant when writing and encloses the data in a CDATA section. When reading, prefixing a non-attribute with '%' is valid syntax, but has no effect. This allows using the same paths without modification for reading and writing. By default, all columns are mandatory, requiring them to be present in the XML document for every single row. To make a branch, a data value or an attribute value optional, the respective path element must be prefixed with a question mark (?). To use the same row specification for reading and writing, the minus (-) character can be used to make a branch optional only when reading and plus (+) when writing. This is useful, for example, if you have different tables in one XML document with a global required file header. This header must be optional when reading because you don't know which transaction type (table format) will be the first. The file header is required when writing so that it is written before each table. In such a case, the minus (-) would be the right choice. In the example below, the attribute value 'att2' for <col> is optional, but the tag itself is mandatory. If a default value is specified for a column ('value' parameter) and no optional mark exists anywhere within the path to this column, this parameter has no effect. If no default value is set, but a column is marked optional, a zero-length value for strings and binary columns and the number zero is used for integer and float data types. In the example below, both values are optional, but the <row> tag must be present: The example below reads data from XML attributes and shows the different possibilities to define a default value (alternative as line comment): An example XML file which can be read by this table definition is presented below. For missing data within <col> tags, 'DataXX' is put into the table. Missing attributes result in the value 'DataYY' in the table. To get an error or a warning for an empty data field or attribute value the exclamation mark ('!' or '|') can be used at the last path component (leaf). The same character is used at write for path entries of header elements but is ignored at a leaf, so that the same row definition can be used for read and write. The next example shows an optional branch with mandatory fields and some changed default values if the complete optional branch is missing. In this example the column 'col0' is required. If the optional <optbr> branch is missing from the row in the XML document, 'col1' is set to its default value 'DataXX', 'col2' and 'col3' are set to an empty string and 'col4' is set to 'DataYY'. If the <optbr> branch exists, it must contain tags <req1> (col1) and <req2> (col2), the tags <opt3> (col3) and <opt4> (col4) are optional and, if missing, are set to an empty string or 'DataYY', respectively. To prevent an error for 'col2' in the 4th row you can deactivate the check of optional branches for mandatory fields (NOCHECK). If the switch is activated then the corresponding default values are used in the table and no error occurs. Otherwise you can activate a warning for missing mandatory fields in optional branches. If neither the field or attribute nor its containing XML branch is marked as optional, it must be present, otherwise an error occurs. If the optional mark is used on a branch (i.e. non-leaf XML node), the whole branch is optional. If a field in this branch is mandatory (no optional mark) then this field must be present if the branch is present, but if the complete optional branch does not exist in the XML document, a mandatory part will result in an error by default. Checking for mandatory parts in an optional branch and the reset to the original default values at the begin of each branch is CPU-expensive and in this case often the last determined value are required in the table. Therefore, this kind of XML validation can be deactivated through the NOCHECK switch, if necessary. Effectively, every column is treated as if it was marked as optional and the last parsed value are still valid. If an XML branch is marked as optional in one column description, then this branch is implicitly also optional for all other column descriptions that refer to children of the same branch. In consequence, a branch must only be mark as optional in one column description to make it optional for all columns of the same branch. Please note that this does NOT imply that the columns itself become optional, but only the marked branch. All other paths, attributes or values which do not match the provided column specifications are ignored by default. With the selection WARN you can activate several warnings to be sure you don't forget a column specification. The example below will still result in the same logical table as the samples above: There is no support for reading nested tables. The root path of different row definitions must be unique. Otherwise, undefined behavior and/or unpredictable errors are the result. Here is an example for this kind of XML: The root path (<root/row1>) must be unique. The second root path for this XML document would be <root/row1/other/row2>. However, this latter path is within a subtree of the first root path, which is not supported. The corresponding table object would look as follows, but such a specification will not work properly: Only the first row specification is valid and can be used to read the XML document. You can extend this to a valid specification to read the document as a table with 4 columns: The maximum hierarchical depth of the XML document is currently limited to 64 levels including the root tag for performance reasons. This limit can be extended if required. Please open an issue on 'www.flam.de' if you need support for more levels. Since XML is a hierarchical format, there might be information on the same or higher level of the XML document tree that is relevant for every single row of a table. This information typically occurs only once in XML before the repetitive data that constitutes the actual table data. We call this type of data 'header data'. By converting the XML document to a two-dimensional table, we want to copy the mentioned header data into every row of the resulting table. Header data may exist on the same or a higher level in the document tree and must occur before the table data. To specify a column that carries header data, the column MUST have the root parameter set to a path that is shorter than the containing row. For example, if the path to a row is <root/table/row>, then a column containing a header value must have a root parameter with either <root/table> or <root> as path. The path to locate the header field within this new root path may be arbitrarily complex. Specifying multiple columns with multiple different root paths is also supported. The root path of a header column also defines the scope at which a header data value remains valid during parsing of the XML document. Whenever a header columns's root path is left, i.e. a closing XML tag occurs that causes the current path to be shorter than the header's root path, the header column's data is reset to it's default value (either explicitly specified by the 'value' parameter or implicitly set to an empty string or zero, depending on the data type). If a header column is not marked as optional (?/-), the header element must be found in the XML document, otherwise an error occurs. You can use the column change detection functionality in your custom application to be notified about header changes. Below is an example XML document with a list of customers, which own a specific product, grouped by country. For every country, the sales tax and a reduced tax is stored: To goal is to create a customer table from this document with product, country name and the tax rates that apply to each customer. There are multiple ways to specify the columns: Result: When writing using the same column specifications, header attributes and header data fields are written only once in front of the table, resulting in the original XML document. A simple XML document with a complex header structure could look like in the example below: For this document, it make sense to define a row specification for the dedicated header, one for the <table> subtree and a third one for the dedicated trailer. The corresponding table object for the example above could look like this: For XML documents which are structured like in the example above, but without the dedicated trailer, it may be desirable to create only one table with more columns. To achieve this, the dedicated header can be added as short roots (header columns) to the row specification of the table. The trailer could also be added to this row specification. In this case, a last record is produced containing the trailer elements, but table (the row tag) and header elements must be optional. Header elements are only supported when using the structured scheme of XML parsing, because the end of a row must be known. In the unstructured version, there is no capability to store such header information in the columns. Data fields which are not in leafs of the XML tree, but somewhere on the path (<root><table>data<row>...</row>other data</...) can also be addressed except data on root tag level. If more than one data element is present and only one column are defined, the last value is used. Example: When addressing '<root><?table>' as one of your table columns, then the first four rows contain 'SomeData1' and the following four rows contain 'SomeData2' in this column. For 'SomeData3', an additional row with default values for missing items is created except if there is a mandatory field in the row. So, when specifying a column with a path which addresses non-leaf data, the column will always contain the last chunk of data encountered within that non-leaf XML node. It is also possible to address data and attributes of multiple consecutive XML tags with the same name one the same level by simply specifying multiple columns consecutively with the same path. If the XML data contains more consecutive tags than columns with identical paths are specified, the data of these additional tags is lost (ignored). For this case, a warning can be activated. Example: Using multiple columns with identical paths, this XML document can be read as follows: XML name spaces must normally be handled by the application. Since version 5.1.24 with the selection 'PREFIX' the name space abbreviations can be excluded from tag comparisons. At write this requires, that only tree wide name space definitions are possible and must be defined as attribute for this tree by the application. In a later version the name space object can be used to define the name space URI for each column. At read this URI will be validated unless the prefix selection is defined. At write the name space will be defined if possible per tree and only for elements where a local name space is required a name space abbreviation is used. When using the structured scheme (default), a default value can be specified (see one of the examples above), which is used if an element marked as optional ('/?' or '/-') is not found in the row. Sometimes it may be useful to get a warning instead of an error if a mandatory field is missing. For this purpose, the selection WARN with keyword MANDATORY exists. If the selection is activated, a warning is written to the log for each mandatory column that is not found in the document. Additionally, it is possible to activate warnings or errors for missing branches, data fields or attributes in the column specifications. To implement/validate choices (this or this branch) you have two possibilities. First you can work with different row specification matching the different XML formats. Or you make such branches optional and validate correctness within your application. Using different row specification you can define different tables in the same XML document. For example, a certain header and/or trailer could be a table with one row. In between, there could be different table formats with many rows for the different transaction types. In an extreme case, the whole document could be a single row with lots of columns. With the parameter PREFIX the handling of XML prefixes in front of a colon can be defined. There are currently 3 methods implemented to ignore such prefixes at tag comparison. The first method ignores all prefixes if a colon found in the tag and compares only the remaining tag behind the colon. The second ignores anything except prefixes starting with 'xml' and the third method works like the second one, but only for 'xmlns:' and it also disables the missing warning or error for name space definitions. To be backward compatible with existing row definitions the ignore methods are only used if the tag does not match. If you specify a XML prefix in a column definition then the tag must still match, but with one of the supported ignore method the prefix must not defined anymore. Be aware that these prefix handling are only relevant at read and you must ensure at write, that required XML prefix definitions are done. For name space handling the better approach is to use the name space support introduced with FLAM version 5.1.25. There is no possibility to mix XML data with other supported table formats. An error will occur if you define an XML column and another type of column format. If you need such mixed formats, then the tag value delimiter (TVD) support can be used to define sections of XML or JSON within a record or data structure. * `STRING: ROOT='str' - Root to XML element [taken from table/row/column]` * `STRING: PATH='str' - Path to XML element [taken from column]` * `STRING: VALUE='str' - Optional default value, if element not in data structure ['0' for float and integer else '']` * `NUMBER: SCHEME=STRUCTURED/UNSTRUCTURED - Scheme for XML parsing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `NUMBER: PREFIX=IGNOREALL/IGNEXCXML/IGNXMLNS - Ignore prefix (pfx:tag) at tag compare [NONE]` ** `IGNOREALL - Ignore each prefix` ** `IGNEXCXML - Ignore each prefix except starting with 'xml'` ** `IGNXMLNS - Ignore each prefix except starting with 'xmlns' and prevent missing warning/error for it` * `NUMBER: WARN=MANDATORY/BRANCH/ATTRIBUTE/DATAFIELD/MISSING/NSPREFIX/ALL - Activates different warnings [NONE]` ** `MANDATORY - No error but warning if mandatory element not found` ** `BRANCH - Warning if a branch without column description in the XML document` ** `ATTRIBUTE - Warning if a attribute without column description in the XML document` ** `DATAFIELD - Warning if a data field without column description in the XML document` ** `MISSING - Warning if a branch, attribute or data field without column description in the XML document` ** `NSPREFIX - Warning if a tag name without matching namespace prefix in row definition` ** `ALL - Activate all additional warnings` * `NUMBER: ERROR=BRANCH/ATTRIBUTE/DATAFIELD/MISSING/ALL - Activates different errors [NONE]` ** `BRANCH - Error if a branch without column description in the XML document` ** `ATTRIBUTE - Error if a attribute without column description in the XML document` ** `DATAFIELD - Error if a data field without column description in the XML document` ** `MISSING - Error if a branch, attribute or data field without column description in the XML document` ** `ALL - Activate all additional errors` * `SWITCH: NOCHECK/NOCHEK/NOCHK - Deactivate check of optional branches for mandatory fields (increase performance but incomplete XML validation)[FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-format-rst_1165.html",
"RST",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.RST]] ==== RST indexterm:[Object, RST, CONV.READ.BINARY.TABLE.ROW.COLUMN.FORMAT.RST] This object is used to read the remaining rest of a record/block (OFFSET=0) or up to a certain offset as a column. This is useful if there some variable parts in the record starting at fix offsets. * `NUMBER: OFFSET=num - Absolute offset in a record or block to read a rest [0 = read up to the end]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process_9419.html",
"PROCESS",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS]] ==== PROCESS indexterm:[Overlay, PROCESS, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS] This array of overlays allows to run certain pre-processings on the column data after parsing. The result of these pre-processings must result in a external representation of the given data type. The supported pre-processings are explained in dedicated chapters below. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-binary_bb6f.html",
"BINARY",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY]] ==== BINARY indexterm:[Object, BINARY, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY] The conversion object for a binary data type allows to convert from an external data representation to another external data representation of binary blob. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-binary-from_0df4.html",
"FROM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY.FROM]] ==== FROM indexterm:[Object, FROM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY.FROM] This object can be used to convert several external representations of binary data (e.g. Base64/32 or hexadecimal) into a neutral internal binary data type (length and data). * `NUMBER: DECODE/ENCODE=OFF/BASE16/BASE32/BASE64 - Base decoding selector [NONE]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set for base decoding [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `SWITCH: IGNSPC - Ignore whitespace characters during base decoding [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-binary-to_5825.html",
"TO",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY.TO]] ==== TO indexterm:[Object, TO, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.BINARY.TO] This object can be used to convert the internal data type binary (length and data) into different external data representations (hex, Base64, ...). * `NUMBER: ENCODE/DECODE=OFF/BASE16/BASE32/BASE64 - Base encoding selector [NONE]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set for base encoding [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: OFFSET=num - Starting offset in the binary blob [0]` * `NUMBER: LENGTH=num - Partial length starting at offset [0 = up to the end]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string_72c7.html",
"STRING",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING]] ==== STRING indexterm:[Object, STRING, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING] The conversion object for a string data type allows to convert from an external data representation to another external data representation of a string. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-from_f24c.html",
"FROM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM]] ==== FROM indexterm:[Object, FROM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM] This object can be used to convert several representations of a string into a neutral FL5-internal string data type. Such a string can optionally be validated using a regular expression. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-from-chrset_433c.html",
"CHRSET",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM.CHRSET]] ==== CHRSET indexterm:[Object, CHRSET, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM.CHRSET] This object can be used to activate the character conversion from a external code page to the neutral internal representation in UTF-8. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-from-regexp_3058.html",
"REGEXP",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM.REGEXP]] ==== REGEXP indexterm:[Object, REGEXP, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.FROM.REGEXP] This object can be used to activate the validation of the content of a string. For this a Perl-compatible regular expression can be defined. Writing regular expressions may seem like a daunting task if you never did so before. You can find a tutorial that will get you started quickly here:    https://www.regular-expressions.info/quickstart.html Countless other tutorials and documentation for regular expressions can be found on the web. We recommend to consult these resources to familiarize yourself with regular expressions. Advanced users can find the complete syntax documentation for writing regular expression patterns by following this URL:    https://www.pcre.org/current/doc/html/pcre2pattern.html At read you can enforce an format error for better format detection. This could be useful for example in table support to define a row definition for all German transactions where the IBAN starts with 'DE' and the same for all transaction with 'UK' and so on, to separate the content in different tables per country. Additional you can ignore all records without a successful match of the regular expression. In this case the unmatching lines will be skipped. By default a mismatch will result in a validation error. Several flags are supported to control the behavior of the validation process. * `STRING: PATTERN='str' - Pattern of regular expression for validation` * `SWITCH: NOCASE - Case insensitive matching` * `SWITCH: MULTILINE - '^' and '$' match start/end of line instead of start/end of whole string` * `SWITCH: DOT4ALL - Change '.' to match any character whatsoever, even a newline, which normally it would not match` * `SWITCH: EXTENDED - Makes parser ignore whitespace and '#' comments within the pattern (can be used for readability)` * `SWITCH: FMTERR - Return a format error if no match (improve auto detection)` * `SWITCH: IGNREC - Remove every record that the regex does not match` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to_4fcd.html",
"TO",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO]] ==== TO indexterm:[Object, TO, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO] This object can be used to convert an FL5-internal string data type into one of several supported string representations (ASCII, EBCDIC, Unicode strings and numbers). The string can be validated or manipulated using regular expressions. The NUMBER object can be used for string-based sanitizing/cleanup of numbers and only works with the local character set. If only NUMBER is specified, then a CHRSET definition with CCSID=DEFAULT (local charset) and WHITESPACE=NUMBER is activated. The returned string containing the number is always in the local ASCII or EBCDIC representation. If you need character set independent conversion of number strings, including conversion to various number formats (e.g. BCD, binary, ...), you should use the INTEGER or FLOAT number converters which can also read and write strings. The string can be specified as a fixed-length string by setting the length parameter. The string is then padded with whitespace on the right side by default. The padding sequence can by set as (hex) string. If no length parameter is provided and padding is activated, the strings are padded to fill all of the provided space in memory. Additionally, you can activate null termination for the string. The returned output length does not include the null termination character. * `NUMBER: MODE=STOP/CUT - Mode if the string does not fit into the provided space [STOP]` ** `STOP - Stop if string longer then provided space` ** `CUT - Cut the string to fit in the provided space` * `NUMBER: FIXEDLENGTH=num - Pad string to this fixed length in bytes using PADCHAR [variable]` * `NUMBER: PADDING=NONE/RIGHT/LEFT - Choose padding for variable or fixed-length strings [NONE if variable or RIGHT if fixed-length]` ** `NONE - No padding` ** `RIGHT - Pad on the right` ** `LEFT - Pad on the left` * `STRING: PADCHAR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Byte array to pad string to a fixed or provided length [system]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `SWITCH: NULLTERM - Ensure null termination of string [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-regexp_63f7.html",
"REGEXP",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.REGEXP]] ==== REGEXP indexterm:[Object, REGEXP, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.REGEXP] This object can be used to activate the validation and/or replacement of the content of a string. For this a Perl-compatible regular expression and optional a corresponding replacement string can be defined. Writing regular expressions may seem like a daunting task if you never did so before. You can find a tutorial that will get you started quickly here:    https://www.regular-expressions.info/quickstart.html Countless other tutorials and documentation for regular expressions can be found on the web. We recommend to consult these resources to familiarize yourself with regular expressions. Advanced users can find the complete syntax documentation for writing regular expression patterns by following this URL:    https://www.pcre.org/current/doc/html/pcre2pattern.html At write you can ignore all records without a successful match of the regular expression. In this case the unmatching lines will be skipped. By default a mismatch will result in a validation error. If the replace string defined, then the default will keep the data if no match found. In this case the IGNREC switch will skip all lines where no replacement are done. With the FMTERR switch you can enforce an error if no replacement done but a replacement string provided. Several flags are supported to control the behavior of the validation or substitution process. * `STRING: PATTERN='str' - Pattern of regular expression for matching` * `STRING: REPLACE='str' - Replacement string for substitution` * `SWITCH: NOCASE - Case insensitive matching` * `SWITCH: MULTILINE - '^' and '$' match start/end of line instead of start/end of whole string` * `SWITCH: DOT4ALL - Change '.' to match any character whatsoever, even a newline, which normally it would not match` * `SWITCH: EXTENDED - Makes parser ignore whitespace and '#' comments within the pattern (can be used for readability)` * `SWITCH: NOCAPTURE - Prevent the grouping metacharacters '()' from capturing` * `SWITCH: SUBALL - Match and replace repeatedly until all occurrences are replaced` * `SWITCH: RPLONLY - Only returns the replacement substrings` * `SWITCH: FMTERR - Return a format error if no match (stop if no replacement)` * `SWITCH: IGNREC - Remove every record that the regex does not match` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset_5f2f.html",
"CHRSET",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET]] ==== CHRSET indexterm:[Object, CHRSET, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET] This object can be used to activate the character conversion from the neutral internal representation in UTF-8 to an external code page. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode_f70f.html",
"MODE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE]] ==== MODE indexterm:[Parameter, MODE, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE] With the MODE selection you can define how an invalid or incomplete character is handled inside of a unit by this component. All possible modes are listed at the end of this chapter. This MODE is valid for the content of each unit (block or record). At the end of a unit there can be an incomplete character. Such a rest will be handled dependent on the METHOD you choose. The rest of the last unit of a data field will be concatenated to the first unit of the next data field. For all other records in a data field the handling of such a rest will be defined by the respective METHOD. The SKIP case for METHOD is only relevant for incomplete byte sequences at the end of a unit. The ignore and substitution mode is only effective for all characters in the middle of the unit, besides an incomplete byte sequence occurs in the last unit. Please don't mix up the IGNORE case for MODE with the SKIP case of METHOD. If a system or user substitution table is used the stop, ignore or substitute are only relevant for characters not managed by the CCSIDs and the substitution tables. This means that the USRTAB and SYSTAB are added to the capabilities of character conversion and only for the rest the chosen MODE is used. If the modes identity (only for single to single byte conversions (ASCII to EBCDIC and vice versa)), substitution or transliteration as error handling for none convertible characters activated, no reporting requested and all conversions result in the same length (for ASCII/ EBCDIC/UTF-8 always 1 byte, for UTF-16 always 2 byte and for UTF-32 always 4 byte) then the character conversion will be factor 2 to 4 faster, but in this case the none reversible character conversions are not counted anymore. A character conversion with different length (IGNORE, TRANSLIT, USRTAB) or an error (STOP) if a invalid character encountered needs needs a character by character handling which result in less performance. To be fast (like the old translate parameter of FLAMv4) we recommend to use the substitution mode for character conversion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode-stop_51c4.html",
"STOP",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.STOP]] ===== STOP indexterm:[Constant, STOP, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.STOP] Stops conversion at the first incomplete or invalid character which cannot be converted. An error message is given with the position of abortion and the value in the input stream. An entry will be (STP()) written to the report file to log this event. To be compatible with other conversion tools, this is the default case, but we recommend to use IGNORE or SUBSTITUTE to prevent any abortion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode-ignore_723e.html",
"IGNORE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.IGNORE]] ===== IGNORE indexterm:[Constant, IGNORE, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.IGNORE] Ignores incomplete or invalid characters and writes a report entry for each character. IGNORE is a substitution by no corresponding character that means no substitution table is required. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode-substitute_b148.html",
"SUBSTITUTE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.SUBSTITUTE]] ===== SUBSTITUTE indexterm:[Constant, SUBSTITUTE, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.SUBSTITUTE] Substitutes incomplete or invalid character and writes a report entry for each character. For SUBSTITUTE you can define a substitution character list (SUBCHR). If no SUBCHR is provided then this option substitutes invalid or incomplete characters with code point 0x00001A. If a SUBCHR is defined all invalid or incomplete characters will be substituted by the defined list of code points that can be up to 8. If you specify a SUBCHR the substitution mode will be enabled. If no reporting requested and the substitution character is only one code point this mode will significant improve performance of character conversion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode-identity_1e46.html",
"IDENTITY",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.IDENTITY]] ===== IDENTITY indexterm:[Constant, IDENTITY, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.IDENTITY] Copies invalid characters from input to output and writes a report entry for each character. Resulting output could be not printable. This kind of error handling can only be used for single byte to single byte character conversion (ASCII<->EBCDIC). If no reporting requested this mode will significant improve performance of character conversion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-mode-translit_41ab.html",
"TRANSLIT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.TRANSLIT]] ===== TRANSLIT indexterm:[Constant, TRANSLIT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.MODE.TRANSLIT] Activates ICONV transliteration for non-convertible character, ignores incomplete or invalid character and writes a report entry for each manipulated character. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-systable_8df7.html",
"SYSTABLE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.SYSTABLE]] ==== SYSTABLE indexterm:[Parameter, SYSTABLE, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.SYSTABLE] With the system table (SYSTAB) you can load a substitution table with a predefined transliteration schema. Entries in the USRTAB can be used to override predefined transliteration entries or add missing transliteration code points. The options listed at the end of this chapter are available. If a substitution table is used then the MODE option (STOP/IGNORE/SUBSTITUTE) is only relevant for characters that cannot be converted or substituted. This conversion is pre-calculated once at beginning of execution to reduce the required CPU time for the conversion. * `ICONV - Preload with ICONV//TRANSLIT substitution table` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-chrset-subchar_c712.html",
"SUBCHAR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.SUBCHAR]] ==== SUBCHAR indexterm:[Parameter, SUBCHAR, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.CHRSET.SUBCHAR] A substitution character (SUBCHR) is a list with up to 8 Unicode codepoints which are used for the substitution of invalid or incomplete characters if the corresponding codepoint is not defined in the substitution table (SUBTAB). Assigning the keyword SYSTEM is equivalent to value 0x1A. If substitution is activated and no substatition character is defined, unsupported characters will be replaced with the codepoint 0x00001A. SUBCHR results in replacement of every undefined code point in the substitution table. This is equivalent to using a USRTAB with corresponding SUBCHR values for every possible codepoint (000000-200000). If SUBCHR is used and no MODE is specified, the substitution mode is activated. This conversion is pre-calculated once at the beginning of execution to reduce the required CPU time for the conversion. * `SYSTEM - Use system specific substitution char (0x1A for ASCII/UTF, 0x3F for EBCDIC)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-number_33bf.html",
"NUMBER",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER]] ==== NUMBER indexterm:[Object, NUMBER, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER] This object activates number conversion for a string. If string data containing a number is written to the application memory, it can be transformed to a different representation supported by the runtime environment. Allowed minimum and maximum values (range check) and the target string format can be specified. The number conversion requires the string to be in the local character set. Character conversion is activated for it. The string may contain leading whitespace. Trailing whitespace or non-convertible characters result in an error unless the IGNREST flag is set. You can use the whitespace handling (WHITESPACE=NUMBER) of the character conversion object as preparation for this conversion. The format string of the object can, for example, be used to ensure that a number starts with a digit, has two fractional digits, has a sign and so on. The object was mainly designed to convert numbers from XML elements to a display representation for COBOL on mainframe systems. If you need the numbers in a different representation (BCD or two's complement number) for calculations, then you must use the integer or float converter. The use of this object can result in a loss of accuracy. The integer and float converters use an internal number representation without any loss of accuracy. For integers (u,i,d,x,X), you can specify the base for parsing the data. Default is base 10 for decimal. Floating point numbers (f,g,G,e,E) are always parsed with base 10 and the parameter is ignored. The range check is based on decimal string values for the maximum and the minimum. The conversion is identical with the data using IGNREST and a base of 10, to make it comparable for integers and floating point numbers. * `STRING: MINIMUM='str' - Minimum accepted value in decimal digits [no limit]` * `STRING: MAXIMUM='str' - Maximum accepted value in decimal digits [no limit]` * `SWITCH: MININCL - Check range inclusive the given minimum values [FALSE]` * `SWITCH: MAXINCL - Check range inclusive the given maximum values [FALSE]` * `SWITCH: IGNREST - Ignore rest after a number was parsed [FALSE]` * `NUMBER: BASE=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Define the base to parse integer values [10]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-number-format_5b0f.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER.FORMAT]] ==== FORMAT indexterm:[Parameter, FORMAT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER.FORMAT] Provides formatting of strings containing decimal numbers to another string matching the specified format string. When converting a floating point number, conversion depends on the locale. For the conversion to be successful, the in-memory representation must be in the local character set. Use CCSID=DEFAULT to ensure this. If no character conversion is requested, the local character set will be assumed. Other kinds of character conversions mainly result in an error or strange data. The resulting formatted string is truncated if the output buffer is too small. The format string specifies the format of the number in the output string. Numbers may be decimal integers or real numbers, signed or unsigned. The conversion ignores leading whitespace and parses the number up to the first character not part of the number. If this is not the last character, an error will occur unless the 'IGNREST' switch is set (may be used e.g. to ignore currency signs). The input numbers must match one of the following regular expressions in order to be processed successfully. Internally, the numbers are converted to a 64 bit integer or floating point value. A format string must start with the % character, otherwise the format string is ignored. The percent character is followed by optional flags, an optional width, an optional precision and a format specifier. Precision and width are separated by a period: The specifier is the type of the output number and tells the string converter how to parse the input. A real number is parsed and stored in a 64 bit floating point value. An integer is stored in a 64 bit integer value. * u  Unsigned decimal integer * d or i   Signed decimal integer * x  Unsigned hexadecimal integer * X  Unsigned hexadecimal integer (capital letters) * e  Scientific notation (mantissa/exponent) using e character * E  Scientific notation (mantissa/exponent) using E character * f  Decimal floating point * g  Uses the shorter of %e or %f. * G  Uses the shorter of %E or %f * -     Left-justify within the given field width; Right justification is the default (see width sub-specifier). * +     Forces to precede the result with a plus or minus sign (+ or -) even for positive numbers (not valid for unsigned).         By default, only negative numbers are preceded with a '-' sign. * SPACE If no sign is going to be written, a blank space is inserted before the value. * 0     Left-pads the number with zeros (0) instead of whitespace, where padding is specified (see width sub-specifier). Minimum number of characters to be printed. If the value to be printed is shorter than this number, the result is padded with whitespace. The value is not truncated even if the result is larger. For integer specifiers (d, i, u, x), precision specifies the minimum number of digits to be written. If the value to be written is shorter than this number, the result is padded with leading zeros. The value is not truncated even if the result is longer. A precision of 0 means that no character is written for the value 0. For e, E and f specifiers, this is the number of digits to be printed after the decimal point. For g and G specifiers, this is the maximum number of significant digits to be printed. When no precision is specified, the default is 1. If the period is specified without an explicit value for precision, 0 is assumed. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-string-to-number-locale_2ea6.html",
"LOCALE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER.LOCALE]] ==== LOCALE indexterm:[Parameter, LOCALE, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.STRING.TO.NUMBER.LOCALE] The format of numbers depends on the system locale for numerical values. Depending on the environment variable LC_NUMERIC, the decimal mark is either a point or comma. The locale for processing numbers can be overridden temporarily through the 'locale' parameter for correct interpretation of the decimal mark. The default decimal mark is system-dependent. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer_dd20.html",
"INTEGER",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER]] ==== INTEGER indexterm:[Object, INTEGER, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER] The conversion object of an integer data type allows to convert from an external data representation to another external data representation of this certain number. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from_8ac9.html",
"FROM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM]] ==== FROM indexterm:[Object, FROM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM] This object can be used to convert several representations of an integral number into a neutral FL5-internal integer data type. * `STRING: MINIMUM='str' - Minimum allowed value as decimal number [none]` * `STRING: MAXIMUM='str' - Maximum allowed value as decimal number [none]` * `SWITCH: MINEXCL - MINIMUM limit is exclusive the specified number [FALSE]` * `SWITCH: MAXEXCL - MAXIMUM limit is exclusive the specified number [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format_adf5.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT] The overlay 'format' allows you to choose a binary representation for integer values. Depending on the format selected, different parameters can be set. See below for the options. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format-bin_57e7.html",
"BIN",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.BIN]] ==== BIN indexterm:[Object, BIN, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.BIN] Reads a binary representation of an integer number. The result is an FL5-internal neutral integer representation which can be converted to any of the supported target integer representations by a corresponding write converter. This converter supports the most common binary number sizes: 8, 16, 32 and 64 bit. Hence, the input to this converter must be either 1, 2, 4 or 8 bytes long. If the SIGNED flag is set, the binary number is interpreted as a two's complement binary number, which can be negative. Otherwise, the input bytes are interpreted as an unsigned number. With the ENDIAN parameter, the endianness (byte order) of the binary number can be specified. By default, the system's endianness is assumed. * `SWITCH: SIGNED - Enable for signed integer [FALSE]` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order of the integer [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format-bcd_4d0f.html",
"BCD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.BCD]] ==== BCD indexterm:[Object, BCD, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.BCD] Reads a binary-coded decimal (BCD) representation of an integer number, where each decimal (base 10) digit is encoded in a 4 or 8 bit value. The result is an FL5-internal neutral integer representation which can be converted to any of the supported target integer representations by a corresponding write converter. This converter supports multiple formats of BCD numbers. The parameter TYPE must be set to the correct BCD format of the input number. The following formats are supported: * UNPACKED: Each decimal digit is stored in one byte. Only the lower nibble (4 bits) of each byte is used, the upper nibble is ignored. * PACKED: Each decimal digit is stored in one nibble, so one byte contains two decimal digits. * ZONED: Each decimal digit is stored in one byte. The upper nibble contains the zone bits. They are usually set to a fixed value so that the byte holds a character value corresponding to the digit. BCD numbers can be signed or unsigned. If the SIGNED flag is specified, read numbers are treated as signed. Without the flag, numbers are treated as unsigned BCD. Unsigned BCD numbers can only have positive values. The sign is part of the BCD number. Its specific representation depends on the BCD type: * UNPACKED: The sign is stored in the right-most byte * PACKED: The sign is stored in the right-most nibble * ZONED: The sign is stored in the upper nibble of the right-most byte, replacing the zone bits with the sign value The hexadecimal values 0xB and 0xD indicate a negative sign. 0xA, 0xC, 0xE and 0xF sign values are treated as positive numbers. Sign values of 0x0 through 0x9 are illegal. For type ZONED, these sign values only apply for BCD numbers in EBCDIC zone format, i.e. the upper zone nibble is set to 0xF. If the zone is in ASCII format (0x3), the positive sign value is 0x3, the negative sign value is 0x7 and all other values are illegal. So, the decimal number -123 in zoned BCD with an EBCDIC zone is 0xF1F2D3. With an ASCII zone, the same number is stored as 0x313273. The parameter ZONE is relevant only if TYPE=ZONED and specifies whether the zone is in ASCII or EBCDIC format. This is mainly relavant for interpreting the sign correctly as described in the paragraph above. If not specified, the zone is system-dependent (i.e. EBCDIC on EBCDIC machines, ASCII otherwise). * `SWITCH: SIGNED - Enable for signed BCD [FALSE]` * `NUMBER: TYPE=UNPACKED/PACKED/ZONED - BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: ZONE=ANY/ASCII/EBCDIC - Character set (only for type ZONED) [ANY]` ** `ANY - Any kind of zone format (ASCII and EBCDIC accepted)` ** `ASCII - ASCII character set (0x30-0x39)` ** `EBCDIC - EBCDIC character set (0xF0-0xF9)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format-str_372d.html",
"STR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.STR]] ==== STR indexterm:[Object, STR, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.STR] Reads a string representation of an integer number. The result is an FL5-internal neutral integer representation which can be converted to any of the supported target integer representations by a corresponding write converter. The string can be in decimal (base 10), hexadecimal (base 16), binary (base 2) or octal (base 8) format. The BASE parameter must be set accordingly. The default base is decimal. Decimal numbers may be positive or negative. For all other bases, only positive numbers without a sign character are supported. The CHRSET parameter must match the character set of the string. If no character set is specified, the system's default character set is assumed. All character sets supported by the character conversion module can be used, including multi-byte charsets. If the string has some leading or trailing whitespace characters, they are ignored. The VALUE parameter can be used to specify a default integer value in local character set and decimal base. An empty string will be replaced by the default value and will not result in an error anymore. * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: BASE=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Base / Radix [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: GROUPSEPARATOR/MARKER=num/NON/OFF/SYSTEM/PERIOD/COMMA/SPACE/APOSTROPHE - Decimal marker [SYSTEM]` ** `NON - Decimal marker are not set` ** `OFF - Decimal marker are not allowed` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `SPACE - Use space ( ) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `STRING: VALUE='str' - Default value (decimal) used, if string format is empty [ERROR]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format-enum_6d6b.html",
"ENUM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.ENUM]] ==== ENUM indexterm:[Object, ENUM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.ENUM] This object can be used to read enumerations, i.e. fields with a limited number of allowed string values. An enumeration contains one or more items. There must be one item for each accepted string. Additionally, the charset of the input data may optionally be set. The first item 'EUR' is assigned the number 1. The following items are automatically numbered 2 and 3, respectively. Only integers values, which are defined, are converted to the respective strings. If there is an integer in the data for which no string is defined, an error occurs. Strings in the input data must be encoded in CCSID 1141. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-from-format-enum-item_7ccf.html",
"ITEM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.ENUM.ITEM]] ==== ITEM indexterm:[Object, ITEM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.FROM.FORMAT.ENUM.ITEM] An enumeration item is used to define an allowed value of an enumeration. Each enumeration must have one or more items. A string value must be assigned to each enumeration item. This string value must be unique among all enumeration items in the same enumeration. Each enumeration item is mapped to an integer number. The mapped number may optionally be specified. If no number is specified for an item, it is auto-assigned to the number of the predecessor item plus one. If no number is assigned to the first item, its number is 0. So, if the mapped numbers are not important, they can be ommitted. For a start value other than 0, it is sufficient to assign a number to first item. All other items are numbered sequentially. When reading enumerations, the input data contains strings which are mapped to the corresponding integer number. If there is a string in the data for which no item is defined, an error occurs. * `STRING: VALUE='str' - String value of the enum item` * `NUMBER: NUMERICAL=num - Numerical value this item is mapped to (optional)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-to_3d90.html",
"TO",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO]] ==== TO indexterm:[Object, TO, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO] This object can be used to convert an FL5-internal integer data type to one of the supported integer representations. * `STRING: MINIMUM='str' - Minimum allowed value as decimal number [none]` * `STRING: MAXIMUM='str' - Maximum allowed value as decimal number [none]` * `SWITCH: MINEXCL - MINIMUM limit is exclusive the specified number [FALSE]` * `SWITCH: MAXEXCL - MAXIMUM limit is exclusive the specified number [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-to-format-bin_f35c.html",
"BIN",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.BIN]] ==== BIN indexterm:[Object, BIN, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.BIN] Writes a binary representation of an integer number, taking an FL5-internal neutral integer representation (produced by the reading counterpart) as input. This converter supports the most common binary number sizes: 8, 16, 32 and 64 bit. Hence, the output of this converter is either 1, 2, 4 or 8 bytes long. The desired binary integer width can be specified in two ways:   results in binary integers of the specified width. If the number cannot   be represented as a binary integer of this width, a range error occurs.   must be 1, 2, 4 or 8 bytes long and is filled with a binary integer of   the corresponding width. This allows using one converter handle to   convert to binary of different bit widths, when using the byte interface   (fcbconv()), by simply passing output buffers of different sizes. If the   number cannot be represented as binary integer of the given width, a   range error occurs. If the SIGNED flag is set, the binary number is written as a two's complement binary number, which can be negative. Otherwise, the output is an unsigned number. Attempting to convert a negative number to an unsigned binary integer results in a range error. With the ENDIAN parameter, the endianness (byte order) of the binary number can be specified. By default, the system's endianness is used. * `SWITCH: SIGNED - Enable for signed integer [FALSE]` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order of the integer [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: WIDTH=num/W08/W16/W32/W64 - Width of integer in bits [dynamic]` ** `W08 - 8 bit integer` ** `W16 - 16 bit integer` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-to-format-bcd_f7e8.html",
"BCD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.BCD]] ==== BCD indexterm:[Object, BCD, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.BCD] Writes a binary-coded decimal (BCD) representation of an integer number, taking an FL5-internal neutral integer representation (produced by a reading counterpart) as input. This converter supports multiple formats of BCD numbers. The parameter TYPE must be set to the correct BCD format of the input number. The following formats are supported: * UNPACKED: Each decimal digit is stored in one byte. Only the lower             nibble (4 bits) are used, the upper nibble is ignored * PACKED: Each decimal digit is stored in one nibble, so one byte contains           two decimal digits. * ZONED: Each decimal digit is stored in one byte. The upper nibble contains          the zone bits. They are usually set to a fixed value so that the          byte holds a character value corresponding to the digit. BCD numbers can be signed or unsigned. If the SIGNED flag is specified, numbers are written with a positive or negative sign. Without the flag, output numbers are unsigned. Unsigned BCD numbers can only have positive values. When attempting to convert a negative number to an unsigned BCD, an error occurs. In the signed case, the sign is part of the BCD number. Its specific representation depends on the BCD type: * UNPACKED: The sign is stored in the right-most byte * PACKED: The sign is stored in the right-most nibble * ZONED: The sign is stored in the upper nibble of the right-most byte,          replacing the zone bits with the sign value The hexadecimal value 0xD is used for a negative sign. A positive number uses 0xC for the sign. For type ZONED, these sign values only apply for BCD numbers in EBCDIC zone format, i.e. the upper zone nibble is set to 0xF. If the zone is in ASCII format (0x3), the positive sign value is 0x3, the negative sign value is 0x7. So, the decimal number -123 in zoned BCD with an EBCDIC zone is 0xF1F2D3. With an ASCII zone, the same number is stored as 0x313273. The parameter ZONE is relevant only if TYPE=ZONED and specifies whether the zone is in ASCII (0x3) or EBCDIC (0xF) format and also specifies the values used for the sign nibble as described in the paragraph above. If not specified, the zone is system-dependent (i.e. EBCDIC on EBCDIC machines, ASCII otherwise). The length of the written BCD number can be specified in three ways:   to always write exactly the specified number of decimal digits. The number   is padded with leading zeros if necessary. If the BCD representation is   longer than the specified amount of digits, a range error occurs. Please   note that the digits count does not include a sign (if present) and that   the byte length of the resulting BCD number is roughly half of the   digits count when writing packed BCD numbers.   will result in a calculated amount of digits to fit within the requested   space. This simplifies the type and sign dependent amount of integral   digits if the number must fit in a fix structure. The rest works like   if this amount of DIGITS is given.   writer is always filled completely. This allows using one converter handle   to convert to BCD numbers of different lengths, when using the byte   interface (fcbconv()), by simply passing output buffers of different   sizes. Numbers are padded with zero, if necessary. If the output buffer   is too short, a range error occurs. * `SWITCH: SIGNED - Enable for signed BCD [FALSE]` * `NUMBER: TYPE=UNPACKED/PACKED/ZONED - BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: ZONE=SYSTEM/ASCII/EBCDIC - Character set (only for type ZONED) [SYSTEM]` ** `SYSTEM - System character set (ASCII or EBCDIC)` ** `ASCII - ASCII character set (0x30-0x39)` ** `EBCDIC - EBCDIC character set (0xF0-0xF9)` * `NUMBER: DIGITS=num - Print exactly this amount of digits (excl. sign) [variable]` * `NUMBER: BYTES=num - Calculate digits to produce fixed length data type [variable]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-to-format-str_7af6.html",
"STR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.STR]] ==== STR indexterm:[Object, STR, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.STR] Writes a string representation of an integer number, taking an FL5-internal neutral integer representation (produced by a reading counterpart) as input. The parameter BASE determines the base/radix of the output string. The following numeral systems are supported by the integer converter: * binary (base 2) * octal (base 8) * decimal (base 10) * hexadecimal (base 16) The default base is decimal. Decimal numbers may be positive or negative. For all other bases, only positive numbers are supported. Converting a negative integer number to binary, octal or hexadecimal string results in an error. When BASE is set to hexadecimal, the parameter CASE can be used to control whether upper (A-F) or lower case (a-f) characters are written. By default, the string is written with the minimum number of characters possible to represent the integer's value in the given base. If the DIGITS parameter is set to a non-zero value, the string will always contain exactly the specified number of digits in the specified base, even if the integer could be represented with fewer digits. The number is padded with leading zeros as necessary. If the number to convert requires more digits to be representable as string, an error occurs. This consequently results in a limitation of the range of valid integer values, which depends on the specified base. Please note, that a potential sign character is not included in the digits count. So if DIGITS=5, then the number -123 gets converted to the string '-00123'. With the SIGN parameter, it is possible to specify if and how a sign character for positive and negative integers is printed, when converting an integer to a decimal string. The following options are available: * A '-' character is written for negative numbers * A '-' character is written for negative numbers, a space character for positive numbers * A '-' character is written for negative numbers, a '+' character for positive numbers If the output string must have a specific length (e.g. to store it in a fixed-length data field), the FIXEDLENGTH field can be set to the desired number of bytes (not characters!). If the integer string is too short, the string is padded with whitespace characters on the left, by default. The PADDING parameter determines on which side the string is padded. It can be padded at the start or end of the string. With PADCHAR, the padding character can be changed. The default padding character is the space character in the specified CHRSET. If you specify a custom padding character, the value must be a byte sequence of the padding character in the specified target CHRSET. So, for example, if CHRSET=UTF16BE and the integer string is supposed to be padded with '.' characters, PADCHAR must be set to the two bytes sequence of the period character in big endian UTF16. Specified in hex notation, this would be x'002E' (note the x before the quotation marks, which is the marker for hexadecimal notation of a sequence of byte values). The CHRSET parameter determines the character set of the written string. If no character set is specified, the system's default character set is used. All character sets supported by the character conversion module can be used, including multi-byte charsets. When using the byte interface (fcbconv()) to convert integers to strings, you have to make sure that the output buffer you provide is of sufficient size to hold the output string. If the buffer is too short, the return code is FLMRTC_LEN and the output buffer size is set to the minimum number of bytes required, allowing you to provide a larger buffer and retry the conversion. You can also activate null termination of the string by activating the NULLTERM switch. The output length returned by the byte interface does not include the null termination character. The parameter VALUE specifies the default value of an integer. It is always in local character set and decimal base. If the integer value is equal to the default value, an empty string will be written. Additionally, you can activate the parameter USEEID (use empty indication). If read integer was an empty string which has now default float value, with USEEID will also write an empty string, instead of default value. If also write default value is set, empty string will only written, is integer value is equal to write default value and read integer was an empty string. * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: BASE=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Base / Radix [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: CASE=UPPER/LOWER - Print letters in upper or lower case (for hexadecimal) [UPPER]` ** `UPPER - Change character to upper case` ** `LOWER - Change character to lower case` * `NUMBER: SIGN=IFNEGATIVE/SPACEIFPOSITIVE/PLUSIFPOSITIVE - When/How to print the sign [IFNEGATIVE]` ** `IFNEGATIVE - Minus for negative values only, no sign if positive` ** `SPACEIFPOSITIVE - Minus for negative, space for positive values` ** `PLUSIFPOSITIVE - Minus for negative, plus for positive values` * `NUMBER: DIGITS=num - Fixed number of digits with preceding zeros` * `NUMBER: FIXEDLENGTH=num - Pad string to this fixed length in bytes using PADCHAR [variable]` * `NUMBER: PADDING=NONE/RIGHT/LEFT - Choose  padding for variable or fixed-length strings [NONE if variable or LEFT if fixed-length]` ** `NONE - No padding` ** `RIGHT - Pad on the right` ** `LEFT - Pad on the left` * `STRING: PADCHAR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Byte array to pad string to a fixed or provided length [system]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `NUMBER: GROUPSEPARATOR/MARKER=num/NON/OFF/SYSTEM/PERIOD/COMMA/SPACE/APOSTROPHE - Thousand separator [NON]` ** `NON - Decimal marker are not set` ** `OFF - Decimal marker are not allowed` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `SPACE - Use space ( ) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `STRING: VALUE='str' - Default value (decimal) used, to produce an empty string [NONE]` * `SWITCH: USEEID - Use empty indication, don't print default value if read integer was an empty string [FALSE]` * `SWITCH: NULLTERM - Ensure null termination of string [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-integer-to-format-enum-item_1660.html",
"ITEM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.ENUM.ITEM]] ==== ITEM indexterm:[Object, ITEM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.INTEGER.TO.FORMAT.ENUM.ITEM] An enumeration item is used to define an allowed value of an enumeration. Each enumeration must have one or more items. A string value must be assigned to each enumeration item. This string value must be unique among all enumeration items in the same enumeration. Each enumeration item is mapped to an integer number. The mapped number may optionally be specified. If no number is specified for an item, it is auto-assigned to the number of the predecessor item plus one. If no number is assigned to the first item, its number is 0. So, if the mapped numbers are not important, they can be ommitted. For a start value other than 0, it is sufficient to assign a number to first item. All other items are numbered sequentially. When writing enumerations, the input data contains integers which are mapped to the corresponding string. If there is no mapping between an integer value and a string, an error occurs. * `STRING: VALUE='str' - String value of the enum item` * `NUMBER: NUMERICAL=num - Numerical value this item is mapped to (optional)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float_db1c.html",
"FLOAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT]] ==== FLOAT indexterm:[Object, FLOAT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT] The conversion object of a floating point data type allows to convert from an external data representation to another external data representation. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-from_f4c5.html",
"FROM",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM]] ==== FROM indexterm:[Object, FROM, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM] This object can be used to convert several representations of a floating point number into a neutral FL5-internal floating point data type. * `STRING: MINIMUM='str' - Minimum allowed value as decimal number [none]` * `STRING: MAXIMUM='str' - Maximum allowed value as decimal number [none]` * `SWITCH: MINEXCL - Check range inclusive the given minimum value [FALSE]` * `SWITCH: MAXEXCL - Check range inclusive the given maximum value [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-from-format_5b29.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT] The overlay 'format' allows you to choose a binary representation for floating point value. Depending on the format selected, different parameters can be set. See below for the options. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-from-format-bin_6783.html",
"BIN",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.BIN]] ==== BIN indexterm:[Object, BIN, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.BIN] Reads a binary representation of a floating point number. The result is an FL5-internal neutral real number representation which can be converted to any of the supported target real number representations by a corresponding write converter. This converter supports the most common binary number sizes: 32 and 64 bit. Hence, the input to this converter must be either 4 or 8 bytes long. The binary representation depends on the system, e.g. IEEE 754 on x86, hexadecimal floating-point on IBM mainframe. Floating point numbers are always signed. With the ENDIAN parameter, the endianness (byte order) of the binary number can be specified. By default, the system's endianness is assumed. * `NUMBER: TYPE=SYSTEM - Type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order of the floating point number [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-from-format-bcd_75db.html",
"BCD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.BCD]] ==== BCD indexterm:[Object, BCD, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.BCD] Reads a binary-coded decimal (BCD) representation of a fixed-point number, where each decimal (base 10) digit is encoded in a 4 or 8 bit value. The result is an FL5-internal neutral real number representation which can be converted to any of the supported target real number representations by a corresponding write converter. This converter supports multiple formats of BCD numbers. The parameter TYPE must be set to the correct BCD format of the input number. The following formats are supported: * UNPACKED: Each decimal digit is stored in one byte. Only the lower nibble (4 bits) of each byte is used, the upper nibble is ignored. * PACKED: Each decimal digit is stored in one nibble, so one byte contains two decimal digits. * ZONED: Each decimal digit is stored in one byte. The upper nibble contains the zone bits. They are usually set to a fixed value so that the byte holds a character value corresponding to the digit. BCD numbers can be signed or unsigned. If the SIGNED flag is specified, read numbers are treated as signed. Without the flag, numbers are treated as unsigned BCD. Unsigned BCD numbers can only have positive values. The sign is part of the BCD number. Its specific representation depends on the BCD type: * UNPACKED: The sign is stored in the right-most byte * PACKED: The sign is stored in the right-most nibble * ZONED: The sign is stored in the upper nibble of the right-most byte, replacing the zone bits with the sign value The hexadecimal values 0xB and 0xD indicate a negative sign. 0xA, 0xC, 0xE and 0xF sign values are treated as positive numbers. Sign values of 0x0 through 0x9 are illegal. For type ZONED, these sign values only apply for BCD numbers in EBCDIC zone format, i.e. the upper zone nibble is set to 0xF. If the zone is in ASCII format (0x3), the positive sign value is 0x3, the negative sign value is 0x7 and all other values are illegal. So, the decimal number -123.45 in zoned BCD with two fraction digits and an EBCDIC zone is 0xF1F2F3F4D5. With an ASCII zone, the same number is stored as 0x3132333475. The FRACDIGITS parameter greatly influences how the BCD value is interpreted. It specifies the number of digits which form the fractional part of the fixed-point number. Fractional digits are always located at the end of the BCD number. In the example above, FRACDIGITS must be set to 2 to interpret the fixed-point BCD number as decimal number -123.45. If the parameter is not specified, it is equivalent to FRACDIGITS=0, i.e. there are no fractional digits. The parameter ZONE is relevant only if TYPE=ZONED and specifies whether the zone is in ASCII or EBCDIC format. This is mainly relavant for interpreting the sign correctly as described in the paragraph above. If not specified, the zone is system-dependent (i.e. EBCDIC on EBCDIC machines, ASCII otherwise). * `SWITCH: SIGNED - Enable for signed float [FALSE]` * `NUMBER: TYPE=UNPACKED/PACKED/ZONED - BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: ZONE=ANY/ASCII/EBCDIC - Character set (only for type zoned) [ANY]` ** `ANY - Any kind of zone format (ASCII and EBCDIC accepted)` ** `ASCII - ASCII character set (0x30-0x39)` ** `EBCDIC - EBCDIC character set (0xF0-0xF9)` * `NUMBER: FRACDIGITS=num - Number of fractional digits (after comma) [0 - integer]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-from-format-str_6329.html",
"STR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.STR]] ==== STR indexterm:[Object, STR, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.FROM.FORMAT.STR] Reads a string representation of an real number. The result is an FL5-internal neutral real number representation which can be converted to any of the supported target real number representations by a corresponding write converter. The string must be in decimal (base 10) format. The CHRSET parameter must match the character set of the string. If no character set is specified, the system's default character set is assumed. All character sets supported by the character conversion module can be used, including multi-byte charsets. If the string has some leading or trailing whitespace characters, they are ignored. The SEPARATOR parameter specifies the character that separates integral and fractional portions of the number (i.e. period or comma). If not specified, the read numbers are expected to be in the locale-dependent default number format (e.g. environment variable LC_NUMERIC on Linux). The VALUE parameter, defines a default float in local char set and decimal base and period as floating point separator. An empty string will be replaced by default value and don't result in an error anymore. * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: SEPARATOR=SYSTEM/PERIOD/COMMA/APOSTROPHE - Floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `NUMBER: GROUPSEPARATOR/MARKER=num/NON/OFF/SYSTEM/PERIOD/COMMA/SPACE/APOSTROPHE - Decimal marker [SYSTEM]` ** `NON - Decimal marker are not set` ** `OFF - Decimal marker are not allowed` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `SPACE - Use space ( ) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `STRING: VALUE='str' - Default value (period) used, if string format is empty [ERROR]` * `SWITCH: ALLOWTRUNC - Allow truncated values [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-to_c1b4.html",
"TO",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO]] ==== TO indexterm:[Object, TO, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO] This object can be used to convert an FL5-internal floating point data type to one of the supported floating point representations. * `STRING: MINIMUM='str' - Minimum allowed value as decimal number [none]` * `STRING: MAXIMUM='str' - Maximum allowed value as decimal number [none]` * `SWITCH: MINEXCL - Check range inclusive the given minimum value [FALSE]` * `SWITCH: MAXEXCL - Check range inclusive the given maximum value [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-to-format-bin_d7c0.html",
"BIN",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.BIN]] ==== BIN indexterm:[Object, BIN, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.BIN] Writes a binary floating point representation of a real number, taking an FL5-internal neutral real number representation (produced by the reading counterpart) as input. This converter supports the most common binary floating point sizes: 32 and 64 bit. Hence, the output of this converter is either 4 or 8 bytes long. The binary representation depends on the system, e.g. IEEE 754 on x86, hexadecimal floating-point on IBM mainframe. Floating point numbers are always signed. The desired binary floating point width can be specified in two ways:   results in binary floats of the specified width. If the number cannot   be represented as a binary float of this width, a range error occurs.   must be 4 or 8 bytes long and is filled with a binary float of the   corresponding width. This allows using one converter handle to convert   to binary of different bit widths, when using the byte interface   (fcbconv()), by simply passing output buffers of different sizes. If   the number cannot be represented as binary float of the given width, a   range error occurs. With the ENDIAN parameter, the endianness (byte order) of the binary number can be specified. By default, the system's endianness is used. * `NUMBER: TYPE=SYSTEM - Type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order of the floating point number [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: WIDTH=num/W32/W64 - Width of floating point number in bits [64]` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-to-format-bcd_627c.html",
"BCD",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.BCD]] ==== BCD indexterm:[Object, BCD, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.BCD] Writes a binary-coded decimal (BCD) representation of a real number, taking an FL5-internal neutral real number representation (produced by a reading counterpart) as input. This converter supports multiple formats of BCD numbers. The parameter TYPE must be set to the correct BCD format of the input number. The following formats are supported: * UNPACKED: Each decimal digit is stored in one byte. Only the lower nibble (4 bits) are used, the upper nibble is ignored * PACKED: Each decimal digit is stored in one nibble, so one byte contains two decimal digits. * ZONED: Each decimal digit is stored in one byte. The upper nibble contains the zone bits. They are usually set to a fixed value so that the byte holds a character value corresponding to the digit. BCD numbers can be signed or unsigned. If the SIGNED flag is specified, numbers are written with a positive or negative sign. Without the flag, output numbers are unsigned. Unsigned BCD numbers can only have positive values. When attempting to convert a negative number to an unsigned BCD, an error occurs. In the signed case, the sign is part of the BCD number. Its specific representation depends on the BCD type: * UNPACKED: The sign is stored in the right-most byte * PACKED: The sign is stored in the right-most nibble * ZONED: The sign is stored in the upper nibble of the right-most byte, replacing the zone bits with the sign value BCD representations of real numbers are always fixed-point numbers, with an implied decimal (i.e. not stored) point. Therefore, the number of fractional digits must be specified via the FRACDIGITS parameter. If it is omitted, the resulting BCD number consists of only the integral part of the real number, with no fractional digits (i.e. FRACDIGITS=0). If the real number contains more fractional digits than are representable, remaining fractional digits are cut off by default. For a different rounding method or for gerating an error when truncation would occur, set the ROUNDING parameter accordingly. If the INTDIGITS parameter is specified, the string will always contain exactly the specified number of digits in the integral portion of the BCD number. The integer portion is padded with leading zero digits as necessary. If the number to convert requires more integral digits to be representable as BCD number, an error occurs. If the INTDIGITS parameter is omitted, the buffer passed to this number converter is always filled completely (which is relevant when using the byte interface). As an alternative to INTDIGITS, you can specify the BYTES parameter. This may be useful for fixed-length data types. By specifying the BYTES and FRACDIGITS parameters, the number of integer digits that fit into the specified number of bytes is calculated depending on the other BCD parameters. If both, INTDIGITS and BYTES, is specified, the BYTES parameter is ignored. The hexadecimal value 0xD is used for a negative sign. A positive number uses 0xC for the sign. For type ZONED, these sign values only apply for BCD numbers in EBCDIC zone format, i.e. the upper zone nibble is set to 0xF. If the zone is in ASCII format (0x3), the positive sign value is 0x3, the negative sign value is 0x7. So, the decimal number -123 in zoned BCD with an EBCDIC zone is 0xF1F2D3. With an ASCII zone, the same number is stored as 0x313273. The parameter ZONE is relevant only if TYPE=ZONED and specifies whether the zone is in ASCII (0x3) or EBCDIC (0xF) format and also specifies the values used for the sign nibble as described in the paragraph above. If not specified, the zone is system-dependent (i.e. EBCDIC on EBCDIC machines, ASCII otherwise). * `SWITCH: SIGNED - Enable for signed float [FALSE]` * `NUMBER: TYPE=UNPACKED/PACKED/ZONED - BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: ZONE=SYSTEM/ASCII/EBCDIC - Character set (only for type zoned) [SYSTEM]` ** `SYSTEM - System character set (ASCII or EBCDIC)` ** `ASCII - ASCII character set (0x30-0x39)` ** `EBCDIC - EBCDIC character set (0xF0-0xF9)` * `NUMBER: INTDIGITS=num - Number of integral digits (before comma) [variable]` * `NUMBER: FRACDIGITS=num - Number of fractional digits (after comma) [0 - only integral part]` * `NUMBER: ROUNDING=AWAYFROMZERO/NEAREST/TOWARDZERO/ERROR - Rounding method if fractional digits don't fit [TOWARDZERO(=cut off)]` ** `AWAYFROMZERO - Round fractional part away from zero (0.1 => 1; -0.1 => -1)` ** `NEAREST - Round fractional part toward nearest integer (0.1=>0; 0.5=>1; -0.5=>-1)` ** `TOWARDZERO - Round fractional part toward zero (=cut off) (0.9 => 0; -0.9 => 0)` ** `ERROR - Return an error instead of rounding a too long number` * `NUMBER: BYTES=num - Calculate integral digits to produce fixed length data type [variable]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-float-to-format-str_77ba.html",
"STR",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.STR]] ==== STR indexterm:[Object, STR, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.FLOAT.TO.FORMAT.STR] Writes a string representation of a real number, taking an FL5-internal neutral real number representation (produced by a reading counterpart) as input. The resulting string is in decimal format. By default, the string is written with the minimum number of characters possible to represent the number's value. If the INTDIGITS parameter is set to a non-zero value, the string will always contain exactly the specified number of digits in the integral portion of the number string, even if the integer part could be represented with fewer digits. The integer portion is padded with leading zeros as necessary. If the number to convert requires more integral digits to be representable as string, an error occurs. Accordingly, the FRACDIGITS parameter sets the length of the fractional portion to a fixed value. It is padded with zeros on the right as necessary. If there are more than FRACDIGITS fractional digits in the number to be converted, the remaining digits are cut off. With SEPARATOR, the character separating intral and fractional part can be set to either period or comma. The default depends on the system's locale (e.g. environment variable LC_NUMERIC on Linux). With the SIGN parameter, it is possible to specify if and how a sign character for positive and negative numbers is printed, when converting a real number to a decimal string. The following options are available: * A '-' character is written for negative numbers * A '-' character is written for negative numbers, a space character for positive numbers * A '-' character is written for negative numbers, a '+' character for positive numbers If the output string must have a specific length (e.g. to store it in a fixed-length data field), the FIXEDLENGTH field can be set to the desired number of bytes (not characters!). If the number string is too short, the string is padded with whitespace characters on the left, by default. The PADDING parameter determines on which side the string is padded. It can be padded at the start or end of the string. With PADCHAR, the padding character can be changed. The default padding character is the space character in the specified CHRSET. If you specify a custom padding character, the value must be a byte sequence of the padding character in the specified target CHRSET. So, for example, if CHRSET=UTF16BE and the integer string is supposed to be padded with '.' characters, PADCHAR must be set to the two bytes sequence of the period character in big endian UTF16. Specified in hex notation, this would be x'002E' (note the x before the quotation marks, which is the marker for hexadecimal notation of a sequence of byte values). The CHRSET parameter determines the character set of the written string. If no character set is specified, the system's default character set is used. All character sets supported by the character conversion module can be used, including multi-byte charsets. When using the byte interface (fcbconv()) to convert real numbers to strings, you have to make sure that the output buffer you provide is of sufficient size to hold the output string. If the buffer is too short, the return code is FLMRTC_LEN and the output buffer size is set to the minimum number of bytes required, allowing you to provide a larger buffer and retry the conversion. You can also activate null termination of the string by activating the NULLTERM switch. The output length returned by the byte interface does not include the null termination character. The parameter VALUE specifies the default value of a real number. This is always in local charset, decimal base and period is the decimal separator. If the the default value is encountered in the data, an empty string is written. Additionally, you can activate the parameter USEEID (use empty indication). If a float value in the read data is an empty string, it is written out with the default value. With USEEID, an empty string is written instead of default value. If a default write value is also set, empty string is only written, if the float value is equal to default write value and the read float was an empty string. * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: SIGN=IFNEGATIVE/SPACEIFPOSITIVE/PLUSIFPOSITIVE - Define handling of leading sign [IFNEGATIVE]` ** `IFNEGATIVE - Sign only if a negative value` ** `SPACEIFPOSITIVE - Use space if a positive value` ** `PLUSIFPOSITIVE - Use plus if a positive value` * `NUMBER: INTDIGITS=num - Number of integral digits (before comma)` * `NUMBER: SEPARATOR=SYSTEM/PERIOD/COMMA/APOSTROPHE - Floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `NUMBER: FRACDIGITS=num - Number of fractional digits (after comma) [all digits]` * `NUMBER: ROUNDING=AWAYFROMZERO/NEAREST/TOWARDZERO/ERROR - Rounding method if fractional digits don't fit [TOWARDZERO]` ** `AWAYFROMZERO - Round fractional part away from zero (0.1 => 1; -0.1 => -1)` ** `NEAREST - Round fractional part toward nearest integer (0.1=>0; 0.5=>1; -0.5=>-1)` ** `TOWARDZERO - Round fractional part toward zero (=cut off) (0.9 => 0; -0.9 => 0)` ** `ERROR - Return an error instead of rounding a too long number` * `NUMBER: FIXEDLENGTH=num - Pad string to this fixed length in bytes using PADCHAR [variable]` * `NUMBER: PADDING=NONE/RIGHT/LEFT - Choose  padding for variable or fixed-length strings [NONE if variable or LEFT if fixed-length]` ** `NONE - No padding` ** `RIGHT - Pad on the right` ** `LEFT - Pad on the left` * `STRING: PADCHAR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Character to pad string to a fixed or provided length [system]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `STRING: VALUE='str' - Default value (period) used, to produce an empty string [NONE]` * `SWITCH: NULLTERM - Ensure null termination of string [FALSE]` * `SWITCH: USEEID - Use empty indication, don't print default value if read float was an empty string [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-mask_6a06.html",
"MASK",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.MASK]] ==== MASK indexterm:[Object, MASK, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.MASK] This object can be used to mask strings as pre-processing step. For this you can define the masking character (default is '*'), the character set, the start (6) and end points (4) and if the replacement is done for the inner or outer part. The masking is not invertible. A post-processing step while writing cannot reproduce the original data. * `NUMBER: CHAR=ASTERISK/MINUS/DOT/X - Masking character [ASTERISK]` ** `ASTERISK - Asterisk also known as star (0x2A for ASCII/UTF, 0x5C for EBCDIC)` ** `MINUS - Minus sign (0x2D for ASCII/UTF, 0x60 for EBCDIC)` ** `DOT - Dot sign (0x2E for ASCII/UTF, 0x4B for EBCDIC)` ** `X - Small x sign (0x2E for ASCII/UTF, 0xA7 for EBCDIC)` * `STRING: CCSID='str' - CCSID / Character encoding [auto]` * `NUMBER: HEAD=num - Number of characters at the beginning [if TAIL then 0 else 6]` * `NUMBER: TAIL=num - Number of characters at the end [if HEAD then 0 else 4]` * `NUMBER: CHANGE=INNER/OUTER - Mask inner or outer part [INNER]` ** `INNER - Mask inner part` ** `OUTER - Mask outer part` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-process-exit_7cbe.html",
"EXIT",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.EXIT]] ==== EXIT indexterm:[Object, EXIT, CONV.READ.BINARY.TABLE.ROW.COLUMN.PROCESS.EXIT] This object can be used to call a customer exit for column pre- processing. You can set the filename of the library (libfcpe) which implements the different column processing functions. On mainframe systems, the library name can be an empty string to fetch load modules from the STEPLIB concatenation. Beside library and function name you can provide function-specific parameters. Please refer to the corresponding FCPE documentation to find out how these strings are to be specified. To write your own FLAM column processing exit (FCPE), you must implement the interface specified in 'FCPE.h' header file. It is independent of the platform and programming language. You must simply provide a DLL/SO or load module which implements one main entry. The interface specifies an open, run and close function. The parameter string is given to the open function, which returns a handle. The run function uses the handle to transform input data to the output data and the close function can be used to release resources allocated by the handle. The interface specification can be found under the link below: https://flam.de/ftp/FL5/doxygen/FCPE/ The processing component, which drives this exit, sets each attribute about the data to unknown except the CCSID. If you use an exit, you must define the complete data representation for the next processor or the type. This exit can be used to implement several validation, tokenization, anonymization or masking services. To be PCIDSS compliant, it can be used for individual column encryption or to build summaries over the column data. * `STRING: LIBRARY='str' - Exit library name` * `STRING: FUNCTION='str' - Exit function name` * `STRING: PARAMETER='str' - Exit function parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-column-type_3a6c.html",
"TYPE",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.COLUMN.TYPE]] ==== TYPE indexterm:[Overlay, TYPE, CONV.READ.BINARY.TABLE.ROW.COLUMN.TYPE] The READ overlay for an element data conversion allows to choose a type specific conversion. It specifies how the data is read from an external representation and converted into a neutral FLAM5 data type. The currently supported data types and conversions are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-table-row-defaults_3177.html",
"DEFAULTS",
"[[CLEP.COMMAND.CONV.READ.BINARY.TABLE.ROW.DEFAULTS]] ==== DEFAULTS indexterm:[Object, DEFAULTS, CONV.READ.BINARY.TABLE.ROW.DEFAULTS] Default values can be set for many values that would otherwise need to be specified for every single column. By setting defaults via this object, the values set here apply to all columns which are defined within the same row object. The defaults set here can be overridden by specifying other values for the respective columns parameters. * `NUMBER: TYPE=BINARY/STRING/INTEGER/FLOAT - Default data type used for conversion [NONE]` ** `BINARY - Read binary data` ** `STRING - Read a string data type` ** `INTEGER - Read a integer value` ** `FLOAT - Read a fractional numbers` * `SWITCH: NOCASE - No case-sensitive comparison of tags and delimiter [FALSE]` * `SWITCH: CASEHL - Activate case sensitive comparison of headline identifier [FALSE]` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Default list of separator characters as Unicode codepoints for CSV files [COMMA,SEMICOLON]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDCHR[num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS...] - Default list of field enclosing characters as Unicode codepoints for CSV files [QUOTATION,APOSTROPHE,GRAVE]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: LENFLD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Default format of the length field [S2X (VARCHAR)]` ** `L4I - Parse binary 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse binary 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse binary 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse binary 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse binary 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse binary 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse binary 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse binary 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse binary 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse binary 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse binary 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse binary 4 byte length fields: System endian short (LLxx), length exclusive` ** `L2I - Parse binary 2 byte length fields: Little endian integer, length inclusive` ** `L2X - Parse binary 2 byte length fields: Little endian integer, length exclusive` ** `B2I - Parse binary 2 byte length fields: Big endian integer, length inclusive` ** `B2X - Parse binary 2 byte length fields: Big endian integer, length exclusive` ** `S2I - Parse binary 2 byte length fields: System endian integer, length inclusive` ** `S2X - Parse binary 2 byte length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Parse binary 1 byte length fields: Length inclusive` ** `S1X - Parse binary 1 byte length fields: Length exclusive` ** `D1I - Parse decimal 1 byte length fields: Length inclusive` ** `D2I - Parse decimal 2 byte length fields: Length inclusive` ** `D3I - Parse decimal 3 byte length fields: Length inclusive` ** `D4I - Parse decimal 4 byte length fields: Length inclusive` ** `D5I - Parse decimal 5 byte length fields: Length inclusive` ** `D6I - Parse decimal 6 byte length fields: Length inclusive` ** `D7I - Parse decimal 7 byte length fields: Length inclusive` ** `D8I - Parse decimal 8 byte length fields: Length inclusive` ** `D9I - Parse decimal 9 byte length fields: Length inclusive` ** `D0I - Parse decimal 10 byte length fields: Length inclusive` ** `D1X - Parse decimal 1 byte length fields: Length exclusive` ** `D2X - Parse decimal 2 byte length fields: Length exclusive` ** `D3X - Parse decimal 3 byte length fields: Length exclusive` ** `D4X - Parse decimal 4 byte length fields: Length exclusive` ** `D5X - Parse decimal 5 byte length fields: Length exclusive` ** `D6X - Parse decimal 6 byte length fields: Length exclusive` ** `D7X - Parse decimal 7 byte length fields: Length exclusive` ** `D8X - Parse decimal 8 byte length fields: Length exclusive` ** `D9X - Parse decimal 9 byte length fields: Length exclusive` ** `D0X - Parse decimal 10 byte length fields: Length exclusive` * `STRING: ELMDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter written after a data element [original]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: ANDEOD - Don't accept a delimiter at the end of a row [OFF]` * `NUMBER: INTFMT=BIN/BCD/STR - Default format for integer values [auto]` ** `BIN - Integer in binary format (two's complement)` ** `BCD - Binary coded decimal (BCD) number` ** `STR - String representation of an integer` * `NUMBER: FLTFMT=BIN/BCD/STR - Default format for floating point values [auto]` ** `BIN - Floating point number in binary format` ** `BCD - Binary coded decimal (BCD) floating point number` ** `STR - String representation of an floating point number` * `STRING: INTVAL='str' - Default value used, to produce an empty integer string [NONE]` * `STRING: FLTVAL='str' - Default value (period) used, to produce an empty float string [NONE]` * `NUMBER: DECODE/ENCODE=OFF/BASE16/BASE32/BASE64 - Default base decoding for binary data [BASE16(text input), NONE(binary input)]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `SWITCH: IGNSPC - Ignore whitespace characters during base decoding [FALSE]` * `NUMBER: INTBAS=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Default base / radix for integers [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: FLTTYP=SYSTEM - Default type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `SWITCH: FLTSIG - Default: floating point numbers are signed [FALSE]` * `SWITCH: INTSIG - Default: integers are signed [FALSE]` * `NUMBER: BCDTYP=UNPACKED/PACKED/ZONED - Default BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: FRADIG=num - Default number of fractional digits (after comma)` * `NUMBER: FRASEP=SYSTEM/PERIOD/COMMA/APOSTROPHE - Default floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Default byte order for binary numbers [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: XMLSCM=STRUCTURED/UNSTRUCTURED - Default scheme for XML parsing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `SWITCH: XMLNOC - Default if no check of optional branches for mandatory fields (increase performance) [FALSE]` * `NUMBER: XMLPFX=IGNOREALL/IGNEXCXML/IGNXMLNS - Ignore prefix (pfx:tag) at tag compare [NONE]` ** `IGNOREALL - Ignore each prefix` ** `IGNEXCXML - Ignore each prefix except starting with 'xml'` ** `IGNXMLNS - Ignore each prefix except starting with 'xmlns' and prevent missing warning/error for it` * `NUMBER: XMLWRN=MANDATORY/BRANCH/ATTRIBUTE/DATAFIELD/MISSING/NSPREFIX/ALL - Default to activate different warnings at XML parsing [NONE]` ** `MANDATORY - No error but warning if mandatory element not found` ** `BRANCH - Warning if a branch without column description in the XML document` ** `ATTRIBUTE - Warning if a attribute without column description in the XML document` ** `DATAFIELD - Warning if a data field without column description in the XML document` ** `MISSING - Warning if a branch, attribute or data field without column description in the XML document` ** `NSPREFIX - Warning if a tag name without matching namespace prefix in row definition` ** `ALL - Activate all additional warnings` * `NUMBER: XMLERR=BRANCH/ATTRIBUTE/DATAFIELD/MISSING/ALL - Default to activate different errors at XML parsing [NONE]` ** `BRANCH - Error if a branch without column description in the XML document` ** `ATTRIBUTE - Error if a attribute without column description in the XML document` ** `DATAFIELD - Error if a data field without column description in the XML document` ** `MISSING - Error if a branch, attribute or data field without column description in the XML document` ** `ALL - Activate all additional errors` * `STRING: VALUE='str' - Default value, if element not in structure formats ['0' for float and integer else '']` * `NUMBER: PADBYT=num - Default to remove this padding byte (mainly for fixed length formats)` * `NUMBER: ALIGN=num - Default alignment for data fields in flat formats [1 (no alignment)]` * `SWITCH: ALWTRC - Allow truncation of values [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-avscan_b22f.html",
"AVSCAN",
"[[CLEP.COMMAND.CONV.READ.BINARY.AVSCAN]] ==== AVSCAN indexterm:[Object, AVSCAN, CONV.READ.BINARY.AVSCAN] The anti virus component can be used when reading or writing to scan the data stream for malware. The handling of found malware is configurable. By default, processing is aborted with an error. By activating the REMOVE switch of the corresponding I/O component, the written part of the affected file can be deleted. The whole component was implemented as an exit driver to integrate FLAM with any kind of AV technology. To address a certain implementation, you can define the library and function name and you can provide a specific parameter string for this implementation. You can also define these values through the environment variables below: * FL_FAVE_LIBRARY     - Set default library for anti virus scanning (default is 'libfave') * FL_FAVE_FUNCTION    - Set default function for anti virus scanning (default is 'CLAMAVC') * FL_FAVE_PARAMETER   - Set default parameter for anti virus scanning (default is 'clamav.daemon:3310:10') If none of these variables are set, then the FLAM default implementation is used, which utilizes the ClamAV daemon (clamav.daemon:3310:10) if the AVS converter is activated (see www.clamav.net for more information). The parameter string contains up to 3 optional parts separated by colon: * Server address      - Default: clamav.daemon * Server port         - Default: 3310 * Timeout in seconds  - Default: 10 The environment variable below can be used to change this string: * FL_CLAMAV_DAEMON    - Set default communication parameter for ClamAV client (default is 'clamav.daemon:3310:10') The quality and security of the malware detection depends on the quality of the signature database and configuration of the ClamAV daemon. If anti virus scanning is configured correctly, the corresponding objects in the read/input or write/output parameter strings must be activated. You can also activate the AVS component with one of the environment variables below: * FL_AVSCAN_READ     - If defined, then anti virus scanning on read data is activated (corresponding default values must be defined) * FL_AVSCAN_WRITE    - If defined, then anti virus scanning on written data is activated (corresponding default values must be defined) The component supports standard GZIP compression for the data stream. This is useful to save bandwidth if a network service (clamd) is used to scan for malware. The function should only be used if the service provider supports GZIP data streams. The service provider must indicate this. If the service provider does not support GZIP data streams, then the compression switch has no effect, to ensure anti virus scanning. The environment variable below can be used to activate GZIP compression: * FL_AVSCAN_COMPRESS - If defined, then anti virus scanning is done on a compressed GZIP data stream To write your own service provider, the SPI documentation is published as 'FLAM Anti Virus Exit (FAVE) Service provider Interface' under the link below. https://flam.de/ftp/FL5/doxygen/FAVE/ The interface is specified in the 'FAVE.h' header file and is independent of the platform and programming language. You must simply provide a DLL/SO or load module which implements one main entry. The interface specifies an open, run and close function. The parameter string is given to the open function, which returns a handle. The run function uses the handle to scan the input data and the close function can be used to release resources allocated by the handle. The run and close function can return a code, which indicates whether malware was found (FLMRTC_VRS). A trace flag can be activated through the exit driver to request additional trace information in error situations. A statistics flag indicates the service provider to produce additional statistics information. A re-open flag is set by the exit driver when opening an additional stream to be scanned which happens if more than one file must be scanned. It allows the service provider to implement a fast open function. * `NUMBER: METHOD=WARNING/ERROR - Defines handling if a virus was found [ERROR]` ** `WARNING - Warning if virus found` ** `ERROR - Error if virus found` * `SWITCH: COMPRESS - Activate GZIP compression (if service provider support it) [FALSE]` * `SWITCH: TRACE - Activate tracing (if service provider support it) [FALSE]` * `SWITCH: STATISTICS - Activate statistics on close (if service provider supports it) [FALSE]` * `STRING: LIBRARY='str' - Library name for FAVE ['libfave']` * `STRING: FUNCTION='str' - Function name of FAVE ['CLAMAVC']` * `STRING: PARAMETER='str' - Parameter for the open call of FAVE ['clamav.daemon:3310:10']` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-preprocess_8387.html",
"PREPROCESS",
"[[CLEP.COMMAND.CONV.READ.BINARY.PREPROCESS]] ==== PREPROCESS indexterm:[Object, PREPROCESS, CONV.READ.BINARY.PREPROCESS] The global pre command object can be used to execute commands before processing of any files starts. With the NET overlay, commands can be executed on remote systems. If no connection information is provided, the command is executed locally. If a command is specified, it is executed on the target (local or remote) in an operating system dependent manner. An optional timeout can be specified, which limits the maximum execution time. Timeouts are not supported on all platforms. The following paragraphs describe the differences between the supported execution environments: *POSIX (Linux/Solaris/AIX/USS):* The command is executed by the default system shell as if run via `/bin/sh -c 'command'`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *Windows:* The command is executed by the Windows command line interpreter as if run via `cmd.exe /C command`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *z/OS:* The command is executed through the `system()` function which allows you to call commands, EXECs, CLISTs or executable modules under MVS and TSO/E. For more information on how to build the command string, please refer to the documentation of the `system()` function (ANSI variant) in IBM's 'z/OS XL C/C++ Runtime Library Reference'. Timeouts are not supported. Therefore, specifying a timeout value has no effect. The command's termination is always waited for before processing by FLAM continues. *SSH:* The command is executed on the remote host through the command execution feature in SSH as described in RFC4254. To be able to execute commands on a remote SSH host, the server must support this feature and the login user must have sufficient privileges to run commands. How the command is executed is server-specific. OpenSSH on a Linux host usually runs the command via `/bin/sh -c 'command'` and sends the standard output and standard error streams through the SSH channel back to the client. If a non-zero timeout is specified and the execution time exceeds the timeout value, a timeout error occurs. No attempt is made to terminate the process on the remote host because this not supported by the SSH protocol and is highly specific to the (unknown) operating system on the remote host. Therefore, the remote process may or may terminate successfully after the timeout was reached. The exit code is logged if the command terminates normally. It is possible to provide a list of acceptable exit codes. When the command terminates with an acceptable exit codes, it is considered successful and file processing continues. All other exit codes are considered a failure. The only default acceptable exit code is 0. The action taken when a command fails depends on whether it is a pre or post command. If a pre command fails, an error is logged and the conversion of the file (for per-file pre commands) or the whole conversion (for global pre commands) is not performed. If a post command fails, an error is logged and processing of the next file (for per-file post commands) continues. For failed commands, the beginning of the standard error stream is printed as part of the error trace if the STDERR parameter has not been assigned to help you debug the issue. The standard output and standard error streams of the executed command are ignored by default. By specifying a file URL for the STDOUT or STDERR parameter, the respective output stream can be written to the log (STDOUT=:LOG), to the respective output streams of the current process (STDOUT=:STDOUT / STDERR=:STDERR) or to a file at the given path (can be remote). By setting STDOUT=:STDERR or STDERR=:STDOUT, the respective streams output can also be redirected to the location of the respective other stream's output. For example, by setting STDOUT=/any/path and STDERR=:STDOUT both output streams can be redirected to the same file without having to specify the path twice. Please note that by multiplexing both output streams into one file, the order of lines might not accurately reflect the order in which they were written by the executed application if it alternates between writing to stdout and stderr. If command output is written to the log, character conversion to the local character set is performed automatically (relevant for remote execution). The CCSID parameter can be used to set the character set that the output from the remote system is encoded in. If not specified, FLAM uses UTF-8 as default and falls back to Latin-1 for remote command execution and the local character set for local command execution. This works well if the output is text. Please note that lines longer than 1023 bytes are truncated. As a result, a warning is written to the log (this will result in completion code 1). Non-convertible characters are transliterated. If this is not possible, they are ignored (like CHRMODE=TRANSLIT). When writing the output to a file (local or remote) by specifying a file URL, character conversion can be activated by setting the parameter CCSID and/or by appending the target CCSID to the URL (e.g. ssh://user@host/myfile/&UTF-8). Otherwise, the binary output is written as-is. Using the CCSID parameter activates text mode processing. If the target CCSID is defined via the URL, a binary transfer of the character converted data stream is performed. An error occurs if character conversion or the write operation fails. The CHRMODE parameter can be used to change the handling of non-convertible or damaged characters. This parameter also enforces character conversion. By default, character conversion between identical CCSIDs are skipped. * `STRING: COMMAND='str' - Command(s) to be executed` * `NUMBER: TIMEOUT=num - Timeout for the command in seconds (not for local z/OS commands) [0=infinite]` * `NUMBER: ACCEPT[num...] - List of exit codes that are considered as successful execution [0]` * `STRING: STDOUT='str'/LOG/STREAM/STDERR - Where to write standard output of the command [IGNORE]` ** `LOG - Write standard output to the log` ** `STREAM - Write standard output to local stdout stream` ** `STDERR - Write standard output defined by STDERR parameter` * `STRING: STDERR='str'/LOG/STREAM/STDOUT - Where to write standard error of the command [IGNORE]` ** `LOG - Write standard error output to the log` ** `STREAM - Write standard error output to local stderr stream` ** `STDOUT - Write standard error output defined by STDOUT parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-preprocess-net_770f.html",
"NET",
"[[CLEP.COMMAND.CONV.READ.BINARY.PREPROCESS.NET]] ==== NET indexterm:[Overlay, NET, CONV.READ.BINARY.PREPROCESS.NET] With the overlay NET, the protocol for remote file access can be selected and configured. Below, you can find the currently supported protocols and the corresponding parameters explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-preprocess-ccsid_ff5e.html",
"CCSID",
"[[CLEP.COMMAND.CONV.READ.BINARY.PREPROCESS.CCSID]] ==== CCSID indexterm:[Parameter, CCSID, CONV.READ.BINARY.PREPROCESS.CCSID] The FROM code defines the encoding string or CCSID (Coded Character Set Identifier) for the input text stream. If no CCSID is provided, the default handling (DEFAULT) is used. When reading, the input data's charset is auto-detected. The charsets below can currently be detected: * ASCII (the finally used code page depends on the language code) * EBCDIC (the finally used code page depends on the language code) * UTF-8    == US-ASCII * UTF-16LE == UCS-2LE (little-endian) * UTF-16BE == UCS-2BE (big-endian) * UTF-32LE == UCS-4LE (little-endian) * UTF-32BE == UCS-4BE (big-endian) If the data is encoded in ASCII or EBCDIC, the corresponding CCSID will be derived from the appropriate environment variable LANG. On non-ASCII systems, the ASCII-CCSID is derived from the language identifier (e.g. en, de, ...). The same holds true for non-EBCDIC systems if EBCDIC is detected. When ASCII is detected on an ASCII system, the CCSID from the LANG environment variable is used (e.g. de_DE.UTF-8 => UTF-8), if present. If the LANG variable contains no CCSID, then the language identifier is used (e.g. de_DE => ISO-8859-1). The same holds true for EBCDIC systems if EBCDIC is detected. On modern platforms, the CCSID for a resource may be saved in the file system and can also be given by the FIO module. In general, however, it is recommended to set this parameter to its correct value. For default handling, the keywords DEFAULT, ASCII and EBCDIC as well as (for multibyte characters) the BOM keywords stated below can be used to help finding the correct CCSID on read operations. The SYSTEM keyword selects the system specific CCSID (on EBCDIC systems the default EBCDIC and on ASCII the default ASCII CCSID). The keyword LOCAL works like DEFAULT but it prefers the real local character set if the same kind of character set (ASCII or EBCDIC) is detected. Character conversions at write operation are also possible, but in this case, the BOM keywords are not supported. When writing, the FROM CCSID is usually known and does not need to be specified. In order to use the BOM keywords, a BOM sign must be part of the input data. All unique BOM characters are supported in principle, but for UTF-16/USC-2 and UTF-32/UCS-4 the same BOM sign is used. You can define by yourself which family is used. To get a list of supported encoding strings, please use the command below: Depending on the platform, this function lists all known encoding strings. Some encodings may not be supported. To determine the supported CCSIDs and corresponding encoding strings and charsets please use: To define the CCSID, you can use one of the encoding strings or the decimal number for a CCSID displayed by the command above. Example: A numeric CCSID must start with a decimal digit. * `DEFAULT - Use default CCSID (environment)` * `ASCII - Use default ASCII CCSID (environment)` * `EBCDIC - Use default EBCDIC CCSID (environment)` * `SYSTEM - Use system character set (same as DEFAULT)` * `LOCAL - Use local character set (system/physical)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-binary-postprocess_64d0.html",
"POSTPROCESS",
"[[CLEP.COMMAND.CONV.READ.BINARY.POSTPROCESS]] ==== POSTPROCESS indexterm:[Object, POSTPROCESS, CONV.READ.BINARY.POSTPROCESS] The global post command object can be used to execute commands after processing of all files ended. With the NET overlay, commands can be executed on remote systems. The command can be executed or not depending on whether processing of all files was successful. It can be executed on success, on error or both. If one or more file conversions or their per-file pre/post commands fail, the command is only executed when it is set to execute on error or both. If no connection information is provided, the command is executed locally. If a command is specified, it is executed on the target (local or remote) in an operating system dependent manner. An optional timeout can be specified, which limits the maximum execution time. Timeouts are not supported on all platforms. The following paragraphs describe the differences between the supported execution environments: *POSIX (Linux/Solaris/AIX/USS):* The command is executed by the default system shell as if run via `/bin/sh -c 'command'`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *Windows:* The command is executed by the Windows command line interpreter as if run via `cmd.exe /C command`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *z/OS:* The command is executed through the `system()` function which allows you to call commands, EXECs, CLISTs or executable modules under MVS and TSO/E. For more information on how to build the command string, please refer to the documentation of the `system()` function (ANSI variant) in IBM's 'z/OS XL C/C++ Runtime Library Reference'. Timeouts are not supported. Therefore, specifying a timeout value has no effect. The command's termination is always waited for before processing by FLAM continues. *SSH:* The command is executed on the remote host through the command execution feature in SSH as described in RFC4254. To be able to execute commands on a remote SSH host, the server must support this feature and the login user must have sufficient privileges to run commands. How the command is executed is server-specific. OpenSSH on a Linux host usually runs the command via `/bin/sh -c 'command'` and sends the standard output and standard error streams through the SSH channel back to the client. If a non-zero timeout is specified and the execution time exceeds the timeout value, a timeout error occurs. No attempt is made to terminate the process on the remote host because this not supported by the SSH protocol and is highly specific to the (unknown) operating system on the remote host. Therefore, the remote process may or may terminate successfully after the timeout was reached. The exit code is logged if the command terminates normally. It is possible to provide a list of acceptable exit codes. When the command terminates with an acceptable exit codes, it is considered successful and file processing continues. All other exit codes are considered a failure. The only default acceptable exit code is 0. The action taken when a command fails depends on whether it is a pre or post command. If a pre command fails, an error is logged and the conversion of the file (for per-file pre commands) or the whole conversion (for global pre commands) is not performed. If a post command fails, an error is logged and processing of the next file (for per-file post commands) continues. For failed commands, the beginning of the standard error stream is printed as part of the error trace if the STDERR parameter has not been assigned to help you debug the issue. The standard output and standard error streams of the executed command are ignored by default. By specifying a file URL for the STDOUT or STDERR parameter, the respective output stream can be written to the log (STDOUT=:LOG), to the respective output streams of the current process (STDOUT=:STDOUT / STDERR=:STDERR) or to a file at the given path (can be remote). By setting STDOUT=:STDERR or STDERR=:STDOUT, the respective streams output can also be redirected to the location of the respective other stream's output. For example, by setting STDOUT=/any/path and STDERR=:STDOUT both output streams can be redirected to the same file without having to specify the path twice. Please note that by multiplexing both output streams into one file, the order of lines might not accurately reflect the order in which they were written by the executed application if it alternates between writing to stdout and stderr. If command output is written to the log, character conversion to the local character set is performed automatically (relevant for remote execution). The CCSID parameter can be used to set the character set that the output from the remote system is encoded in. If not specified, FLAM uses UTF-8 as default and falls back to Latin-1 for remote command execution and the local character set for local command execution. This works well if the output is text. Please note that lines longer than 1023 bytes are truncated. As a result, a warning is written to the log (this will result in completion code 1). Non-convertible characters are transliterated. If this is not possible, they are ignored (like CHRMODE=TRANSLIT). When writing the output to a file (local or remote) by specifying a file URL, character conversion can be activated by setting the parameter CCSID and/or by appending the target CCSID to the URL (e.g. ssh://user@host/myfile/&UTF-8). Otherwise, the binary output is written as-is. Using the CCSID parameter activates text mode processing. If the target CCSID is defined via the URL, a binary transfer of the character converted data stream is performed. An error occurs if character conversion or the write operation fails. The CHRMODE parameter can be used to change the handling of non-convertible or damaged characters. This parameter also enforces character conversion. By default, character conversion between identical CCSIDs are skipped. * `STRING: COMMAND='str' - Command(s) to be executed` * `NUMBER: TIMEOUT=num - Timeout for the command in seconds (not for local z/OS commands) [0=infinite]` * `NUMBER: ACCEPT[num...] - List of exit codes that are considered as successful execution [0]` * `STRING: STDOUT='str'/LOG/STREAM/STDERR - Where to write standard output of the command [IGNORE]` ** `LOG - Write standard output to the log` ** `STREAM - Write standard output to local stdout stream` ** `STDERR - Write standard output defined by STDERR parameter` * `STRING: STDERR='str'/LOG/STREAM/STDOUT - Where to write standard error of the command [IGNORE]` ** `LOG - Write standard error output to the log` ** `STREAM - Write standard error output to local stderr stream` ** `STDOUT - Write standard error output defined by STDOUT parameter` * `NUMBER: ON=SUCCESS/FAILURE - Condition under which the command is executed [ALWAYS]` ** `SUCCESS - Execute command on success` ** `FAILURE - Execute command on failure` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-character_6b1c.html",
"CHARACTER",
"[[CLEP.COMMAND.CONV.READ.CHARACTER]] ==== CHARACTER indexterm:[Object, CHARACTER, CONV.READ.CHARACTER] Read char operates on blocks of text data. If the input data is encoded (e.g. Base64), encrypted or compressed, it is automatically decoded, decrypted and/or decompressed. Through the 'decode' parameter, you can extend or limit the number of encoding layers to remove. For example, to retrieve a Base64-encoded text from a GZIP file instead of the decoded version of this text you can set DECODE=CRYDEC. To decode encoded XML data after decompression you must define DECODE=CMPDEC. This is the default. The base decoding of text can result in valid but nonsensical text. There is no uniqueness for a clear decision in this case. To enforce decoding of possible base encodings where the result is still a character or text stream, you must set DECODE=ALWAYS. If a 4 byte record length format is detected, the record lengths are removed to build a valid character block with a certain number of records. For decryption, you must provide the required decryption parameters, e.g. a key reference or passphrase. Several decryption methods can be enabled at once with the corresponding parameters and will be used to transparently read the data. Decompression is done automatically because a compressed data stream is binary and contains no valid characters. If you provide a record length, the character stream is wrapped into fixed-length records. This is useful to exchange fixed-length text records with open standards like PGP or GZIP. If you provide a binary delimiter, the data stream is wrapped into variable-length text records. The character data is converted from the provided CCSID to UTF-8. If no CCSID is provided or auto detection fails, the default CCSID is determined in a system-dependent way in the following order: * Stored CCSID from the file system (if available) * From the environment variable LANG * ISO-8859-1 (Latin-1) on ASCII and IBM-1047 (Open Systems Latin-1) on EBCDIC systems The character data blocks can be converted to any code page on write. If you don't need character conversion, the binary version of reading files might be more suitable. In contrast to the read text method, the read char method does not scan for line delimiters to build valid records. This means that the data will remain a chunk of character data. If you provide row specifications through the table object, the character blob is split into neutral FL5 table elements (rows and columns). * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECLENGTH=num - Length to activate fixed length record wrapping [0-OFF]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `NUMBER: DECODE=NONE/FIODEC/CRYDEC/CMPDEC/ALWAYS - Decode encoded data first (remove base encodings)` ** `NONE - No automated decoding` ** `FIODEC - Base decoding after file IO, before decryption` ** `CRYDEC - Base decoding after decryption, before decompression` ** `CMPDEC - Base decoding after decompression, before formatting if XML` ** `ALWAYS - Always decode encoded data (like CMPDEC but also if CHAR or TEXT)` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to parse end of record [NONE]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: SUPPADDING - Suppress trailing padding/equal characters` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCBLK - Enforce block orientation on record oriented devices [FALSE]` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-character-bom_5299.html",
"BOM",
"[[CLEP.COMMAND.CONV.READ.CHARACTER.BOM]] ==== BOM indexterm:[Parameter, BOM, CONV.READ.CHARACTER.BOM] If the handle byte order mark (BOM) keyword is specified, a byte order change is handled by the character conversion module. This means that a change of the byte order will not result in an error and the new byte order is used to read the next characters. This can be useful for concatenated files with different byte orders. But in such case each file needs a BOM sign and the bit width must still be the same. As default the handle BOM keyword is set to OFF. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-character-enl2lf_e996.html",
"ENL2LF",
"[[CLEP.COMMAND.CONV.READ.CHARACTER.ENL2LF]] ==== ENL2LF indexterm:[Parameter, ENL2LF, CONV.READ.CHARACTER.ENL2LF] This option only has an effect if the input CCSID is an EDCDIC charset. If enabled on ASCII systems, EBCDIC new line control characters (0x15) will be replaced by line feed characters (0x25) when character conversion takes place. When converting from an EBCDIC to a single-byte ASCII charset, then this option is enabled on EBCDIC system and can be disabled over this switch. This is required because a standard conform conversion converts 0x15 (EBCDIC NL) to 0x85 (ISO-8859-1/Latin-1) instead of 0x0A. When converting to a UTF charset, 0x15 gets converted to 0xC285 (NEL) by default. Enabling this internal option will result in line feeds (0x0A) instead. For the normal transfer of text data between ASCII and EBCDIC systems the internal adjustment of the translation table is done by FLAM automatically. This means that normally you don't need to activate this switch, only in exceptional situations this option can be useful to achieve the opposite of the expected behavior. This conversion is pre-calculated once at beginning of execution to reduce the required CPU time for the conversion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-text_d72a.html",
"TEXT",
"[[CLEP.COMMAND.CONV.READ.TEXT]] ==== TEXT indexterm:[Object, TEXT, CONV.READ.TEXT] Read text works on blocks of text data or records. First, the text data is converted to the UTF-8 character set. Then the text data is split into record and rest elements based on text delimiters or record length. The data must contain a valid text delimiter within the provided record/ line length. If the data contains 4 byte length fields, the length fields are used to build a block as list of records. If no delimiter is found, the record length are used to form the text records. If the data is block-oriented (no record length) and neither delimiters nor 4 byte length fields are found, the data will be wrapped into UTF-8 records of the provided record length. The wrapping of UTF-8 character streams in records can result in incomplete multibyte sequences at the end and the rest of a multibyte character at the beginning of an record. A text record contains all text between two delimiters, but without trailing whitespace if SUPTWS used. Trailing whitespace, the delimiter and possibly some padding characters make up the rest element. Taken together, the record and the rest elements represent the original data. The net text record (without the rest element) can be validated using Perl-compatible regular expressions. The reaction to records that don't match the regular expression can be configured to result in validation error (default), a FMTERR for better detection or to ignore the non-matching records, removing the from output. List of valid text delimiters (Unicode codepoints): * 0x00 (padding character (can be changed)) * 0x0A (carriage return (EBCDIC 0x25)) * 0x0D (line feed (EBCDIC(0x0D))) * 0x0A, 0x0D (carriage return line feed) * 0x0A, ..., 0x0A, 0x0D (dirty delimiters) * 0x0A, 0x0D, ..., 0x0D (dirty delimiters) * 0x0C (form feed (EBCDIC 0x0C)) * 0x85 (new/next line (EBCDIC 0x15, optional if single byte ASCII)) 0x85 are used for UTF-8 (C285) and EBCDIC (0x15) but in single byte ASCII code pages the NELDLM flag must be defined to scan for 0x85, because 0x85 normally used as currency sign accept for ISO code pages. To prevent EBCDIC(0x15) to UNICODE(0x85) at character conversion FLAM supports the ENL2LF and ELF2NL switches. If the text data is detected as being compressed, it is decompressed automatically. For encodings like Base64, automated decoding is useful in most cases. However, if you want to read the base encoded data as text, you must set the 'decode' parameter to the number of automatic decodings to perform. You can extent or limit the number of encoding layers. For example, to retrieve a Base64-encoded text from a GZIP file instead of the decoded version of this text you can set DECODE=CRYDEC. To decode encoded XML data after decompression you must define DECODE=CMPDEC. This is the default. The base decoding of text can result in valid but nonsensical text. There is no uniqueness for a clear decision in this case. To enforce decoding of possible base encodings where the result is still a text stream, you must set DECODE=ALWAYS. This is the default because base decoding of text can result in valid but nonsensical text. There is no uniqueness for a clear decision in this case. To decode base encoded data after decompression, you must specify DECODE=CMPDEC or DECODE=ALWAYS. If the decompressed text is, for example, Base64 encoded XML, this must be explicitly activated to process the XML. For a transparent decryption, you must provide the required parameters. Decryption requires at least a key reference as parameter. Several decryption methods can be enabled at once with the corresponding parameters. 4 byte length fields in the data are detected and cannot be part of valid text data. Therefore, these length fields are used automatically to build a list of records. The character data is converted from the provided CCSID to UTF-8. If no CCSID is provided, auto detection is applied. If this not successful, a system dependent default CCSID is used: If available, the CCSID stored in the file system is used. If this is unset or not supported, the environment variable LANG is used. If this is also not set to a valid value, ISO-8859-1 (Latin-1) is used on ASCII and IBM-1047 (Open Systems Latin-1) on EBCDIC systems. While text formatting, form feed characters may optionally be replaced by empty records. A padding character may be defined which is regarded as a special delimiter. Consecutive occurrences of this padding character are regarded as one delimiter, i.e. the text 'some text_____more text' will become two records 'some text' and 'more text'. Not being a part of the original data, padding characters are simply dropped and are not part of the rest element. With read.text() you can transparent read normal text files with delimiter in clear, compressed (GZIP, BZIP2, XZ(LZMA)), encrypted (FLAM, PGP) or encoded (Base64/32/16) form, normal record oriented data sets (FB(A/M)/VB(A/M)/VSAM/...), FLAMFILEs, ZIP or other archive formats from local or remote (SSH) locations. If you provide row specifications through the table object, each text record is split into neutral FL5 table elements. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECLENGTH=num - Maximum record length (Host) / line length (Unix/Win) for text parsing [512]` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `SWITCH: NELDLM - Activate NEL (0x85) as delimiter for ASCII character sets [FALSE]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `SWITCH: CONVBIN - Don't skip character conversion if binary data is detected [FALSE]` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `NUMBER: PADCHAR=num - Padding character to be regarded as additional delimiter [0x00]` * `NUMBER: DECODE=NONE/FIODEC/CRYDEC/CMPDEC/ALWAYS - Decode encoded data first (remove base encodings)` ** `NONE - No automated decoding` ** `FIODEC - Base decoding after file IO, before decryption` ** `CRYDEC - Base decoding after decryption, before decompression` ** `CMPDEC - Base decoding after decompression, before formatting if XML` ** `ALWAYS - Always decode encoded data (like CMPDEC but also if TEXT)` * `SWITCH: FRCBLK - Enforce block orientation on record oriented devices [FALSE]` * `SWITCH: BINERROR - Enforce an error if binary data detected [FALSE]` * `SWITCH: CHRERROR - Enforce an error if character data without delimiter detected [FALSE]` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-xml_1632.html",
"XML",
"[[CLEP.COMMAND.CONV.READ.XML]] ==== XML indexterm:[Object, XML, CONV.READ.XML] Read XML works on blocks of binary or text data. Character conversion takes place before processing the XML data. If no CCSID is provided, then auto detection is used. If UTF-8 is detected, character conversion is skipped. Line delimiters must be one of 0x0A, 0x0D or 0x0D0A (after conversion to UTF-8). If a CCSID is supplied, the character data is converted from the provided CCSID to UTF-8 before performing XML processing, using the supplied CCSID as source encoding. If the input data is encoded (e.g. Base64), encrypted, compressed or contains 4 byte length fields, it is automatically decoded, decrypted, and/or decompressed to build a valid XML data block. During parsing, all line delimiters are normalized to line feed characters (0xA) as defined by the XML specification. The XML data is parsed using the Expat library and transformed into FLAM elements, which allows various formatting options when writing, including minimizing, pretty printing XML data and restoring an equivalent of the original document. There are several switches available to exclude certain types of XML elements from the parsed element list. When reading XML documents through the byte or record interface using the element formatter (format.element()), the character data between starting and closing tags may be split into multiple XML data elements as the data can be of an arbitrary length. The DATLEN parameter controls the minimum length of a data element before being split (default is 1024). Note that this a minimum, so the data elements returned may be actually much larger. As a rule of thumb, the maximum length of data elements is close to the input buffer size (but may exceed it). If you want to get all data between any pair of starting and closing tags as a single data element, simply set the DATLEN parameter to a large number. You must be aware, however, that this might require considerable amounts of memory, depending the maximum data length in tag bodies. With the LENERR parameter, an error occurs if a data element exceeds the specified length. If the ignore empty data (NOEMPD) switch is set, data elements containing only whitespace are suppressed. Additional with the switch ADDEMP switch you can insert a empty data element to the element list if a end tag follows direct after a start tag. On some EBCDIC machines, if character conversion from an EBCDIC charset is used, the new line character (0x15) is not properly converted, causing the XML parser to fail. In this case, turn on the enl2lf to enable proper conversion of new lines (0x15) to line feeds (0xA). If reading XML, the semantics of write modes (write.*()) change as follows: * BINARY:     The FLAM elements produced by this read mode are used to  restore the original XML file as close as possible  (standard formatting).  The XML will be in UTF-8 and lines are delimited by line feed (0xA). * CHARACTER:  The FLAM elements are used to produce a minimized version  of the XML data. Line breaks and whitespace are removed unless they are  part of actual character data. * TEXT:       Human readable XML data with proper indentation is  produced (pretty printing). Linebreaks are converted to a  system-specific representation. * XML:        Produces XML data using the specified formatting method.  The XML data will be in UTF-8 and lines are delimited by line feed  (0xA) unless explicit character conversion is enabled. * RECORD:     Human readable XML data with proper indentation is  produced (pretty printing). The produced XML data is separated into  records, each record containing one line of XML. * FLAM4:      Same as RECORD, but stored in a FLAM4 file. Known limitations: * If the attributes inside an XML tag are separated by more than one  space character, the additional space characters are dropped (as per  XML specification). * Due to a parser limitation, declared entities that appear inside  attributes will be output in its substituted form. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: NOCMNT - Ignore XML comments [FALSE]` * `SWITCH: NODFLT - Ignore XML default elements (i.e. whitespace before/after root tag) [FALSE]` * `SWITCH: NOEMPD - Ignore XML empty/whitespace data elements (not in CDATA section) [FALSE]` * `SWITCH: ADDEMP - Add an empty XML data element if end tag follows direct a start tag [FALSE]` * `SWITCH: NOPINS - Ignore XML processing instructions [FALSE]` * `SWITCH: NODTD - Ignore XML document type definitions[FALSE]` * `SWITCH: CCDATA - Collect CDATA to simple data elements [FALSE]` * `NUMBER: DATLEN=num - Minimum length to collect data elements in one element [1024]` * `SWITCH: LENERR - Return an error if minimum data element length exceeded [FALSE]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `SWITCH: FRCBLK - Enforce block orientation on record oriented devices [FALSE]` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record_5b98.html",
"RECORD",
"[[CLEP.COMMAND.CONV.READ.RECORD]] ==== RECORD indexterm:[Object, RECORD, CONV.READ.RECORD] Read record provides a list of records from a host-like data set format or from a member in an archive file. If a record contains text data, you can mark it by defining the correct CCSID. This will result in character set conversion from the provided CCSID to UTF-8 for each record. If the CCSID is not provided, the record is handled as binary data. The following options are supported: * Stop, cut or wrap if a record is longer then provided record length * Print control character handling as attributes * Padding of fixed-length record formats at write operations * Suppress trailing padding characters for fixed-length record formats at read * Suppress trailing padding characters for variable record formats at   write * All kind of record formats and length including entry, index, keyed   and relative data sets, including management of slot numbers * Support of various file allocation, space parameters and subsystems * Validation of records using regular expressions If decryption parameters or a member name are specified, transparent reading of FLAM4FILEs is activated automatically. You can enforce or prevent this by setting the DECODE parameter accordingly. Archives, decryption and decompression are supported for different types of files when writing. FLAM4 archives support storing records, but you can also use ZIP archives, GZIP or ASCII armored files to archive host record datasets. This solution uses FLAM specific extensions of the respective formats. Therefore, you must use FLCL to recreate the correct host data set by activating the decode switch. This works for all kinds of datasets (PS, PO, VSAM) except load libraries, which cannot be recreated with loadable modules. Decoding of FLAMFILEs or other supported formats can be enforced with the keyword 'DECODE' (default is the level 'RECORD'). If the DECODE parameter is not specified, the raw record will be processed. The DECODE switch also enables support for reading different archive formats, automatic decryption and decompression, followed by a final record conversion based on length fields or a binary delimiter, if one was used to store the record-oriented dataset. Auto-decoding capabilities can be limited by assigning one of the defined levels to the DECODE parameter. If DECODE is not specified (read records from dataset), but a binary record delimiter is set, the default record format is DLM and does not have to be assigned explicitly. If no length fields or binary delimiters are detected and the original record length is known, the data is wrapped into records of this length by default, which is useful if fixed record length dataset formats are exchanged. For not cataloged data sets or record-oriented file formats on non record-oriented platforms (WIN, UNIX, ...), you can define file organization, block size, record format and record length. If you work with cataloged files or FLAMFILEs, these parameters are not required. For non-record-oriented platforms, you can define a lot of different length formats. If you don't specify a length format at read and a 4 byte record length format is detected (a FILEDATA=RECORD file is allocated with FILEDATA=BINARY), the length fields in the data are used to build the records. If you provide row specifications through the table object, each record is split into neutral FL5 table elements. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECMODE=STOP/CUT/WRAP/SKIP - Mode used to read records [STOP]` ** `STOP - Stop if record too long` ** `CUT - Cut if record too long` ** `WRAP - Wrap if record too long` ** `SKIP - Skip if record too long` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: SUPPADDING - Suppress trailing padding characters (useful for fixed-length records)` * `STRING: PADCHARACTER='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Define padding character for suppression [automatic]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `NUMBER: ORGANIZATION=SEQ/PS/LIB/PDS/USS/EDS/ESDS/KDS/KSDS/RDS/RRDS - File organization [catalog/SEQ]` ** `SEQ - Sequential data set [DEFAULT]` ** `PS - Sequential data set [DEFAULT]` ** `LIB - Library (ZOS-PDSE)` ** `PDS - Partitioned data set (ZOS-PDS)` ** `USS - UNIX files (path based)` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` * `NUMBER: RECFORMAT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format for read operation [catalog/VAR]` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLENGTH=num - Maximum record length for read operation [catalog/512]` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record (if RECF=DLM used)` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: RECCOUNT=num - Amount of records handled in one read operation [catalog/128]` * `NUMBER: KEYPOSITION=num - Key position (>=1) for index/key sequential data sets [0=NONE]` * `NUMBER: KEYLENGTH=num - Key length (>=1) for index/key sequential data sets [if KEYPOS>0 then 8]` * `SWITCH: NOSPANNED - Deactivate read of large spanned records from V(B)S datasets [FALSE]` * `NUMBER: DECODE=NONE/ARCHIVE/DECOMP/RECORD/CMPDEC/ALWAYS - Decode encoded, encrypted or compressed data [0=NONE]` ** `NONE - No automated decoding` ** `ARCHIVE - Transparently read archives` ** `DECOMP - Decryption and decompression of encrypted and/or compressed data` ** `RECORD - Decode record length fields or delimiter (is default) after decompression` ** `CMPDEC - Additional base decoding after decompression, before formatting` ** `ALWAYS - Always decode encoded data (causes the same as CMPDEC)` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-lenformat_bce3.html",
"LENFORMAT",
"[[CLEP.COMMAND.CONV.READ.RECORD.LENFORMAT]] ==== LENFORMAT indexterm:[Overlay, LENFORMAT, CONV.READ.RECORD.LENFORMAT] The overlay can be used to define the format of the length field on open platforms which don't support record formats by the data management system. For example: If you read records on a mainframe and you want to write the records as records (not as binary or text data) on WINDOWS or UNIX then the data will be prefixed with the record length. The format of this length field can be changed over this union. This length specification will be only used for variable length records. The default mapping method between record formats will be map each host record format the corresponding open variable format. If the length format not defined the length field will be written as 32 bit integer in platform dependent byte order. This behavior corresponds to the FILEDATA=RECORD parameter for USS files on z/OS. This means that if you write a record oriented file to USS without any format changed over this overlay then you can read the record with another MVS application using FILEDATA=RECORD. If you choose record format text or binary then this will correspond to FILEDATA=TEXT or FILEDATA=BINARY and the length format specification will be ignored. To enable record format mapping based on the data type you can set the environment variable below: If this environment variable set, then the length format is only used if you explicitly set a variable record format of the open systems. Since version 5.1.8, FLAM can detect the 4 byte length fields (integer or host) inside a data stream. We recommend to use one of these formats to have more comfort when reading. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-lenformat-integer_76c2.html",
"INTEGER",
"[[CLEP.COMMAND.CONV.READ.RECORD.LENFORMAT.INTEGER]] ==== INTEGER indexterm:[Object, INTEGER, CONV.READ.RECORD.LENFORMAT.INTEGER] The object defines the binary representation of the length field in integer format. You can define the byte order, the bit width and if the length field will be part of the length value or not. * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: WIDTH=num/U16/U32/U64 - Bit width/rate [B32]` ** `U16 - 16 bit unsigned integer` ** `U32 - 32 bit unsigned integer` ** `U64 - 64 bit unsigned integer` * `SWITCH: INCLUDE - Include length field in length value [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-lenformat-string_e001.html",
"STRING",
"[[CLEP.COMMAND.CONV.READ.RECORD.LENFORMAT.STRING]] ==== STRING indexterm:[Object, STRING, CONV.READ.RECORD.LENFORMAT.STRING] The object defines the binary representation of the length field in string format (a character per digit). You can define the character set, the character count, the base and if the length field will be part of the length value or not. * `NUMBER: CHRSET=SYSTEM/ASCII/EBCDIC/LOCAL - Character set [SYSTEM]` ** `SYSTEM - Use default system code page` ** `ASCII - Use ASCII (UTF-8) code page` ** `EBCDIC - Use EBCDIC code page` ** `LOCAL - Use real local code page` * `NUMBER: COUNT=num/C04/C05/C06 - Character count [C06]` ** `C04 - 4 character/digits` ** `C05 - 5 character/digits` ** `C06 - 6 character/digits` * `NUMBER: BASE=num/DEC/B10 - String base [B10]` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` * `SWITCH: INCLUDE - Include length field in length value [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-lenformat-bcd_5b09.html",
"BCD",
"[[CLEP.COMMAND.CONV.READ.RECORD.LENFORMAT.BCD]] ==== BCD indexterm:[Object, BCD, CONV.READ.RECORD.LENFORMAT.BCD] The object defines the binary representation of the length field in BCD format (4 Bit are one decimal digit). You can define the bit width and if the length field will be part of the length value or not. * `NUMBER: WIDTH=num/U16/U24/U32 - Bit width/rate [B32]` ** `U16 - 16 bit unsigned BCD (POV with 4 digits)` ** `U24 - 24 bit unsigned BCD (POV with 6 digits)` ** `U32 - 32 bit unsigned BCD (POV with 8 digits)` * `SWITCH: INCLUDE - Include length field in length value [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-lenformat-host_8faa.html",
"HOST",
"[[CLEP.COMMAND.CONV.READ.RECORD.LENFORMAT.HOST]] ==== HOST indexterm:[Object, HOST, CONV.READ.RECORD.LENFORMAT.HOST] The object defines the 4 byte host specific format (LLxx) of the length field. This format uses the first 16 bits as integer in big endian or little endian byte order to represent the record length including or excluding the record length field itself and the last 16 bits are set to zero when writing and ignored when reading. For example, a record with 136 bytes content has a default length field (big endian, inclusive) of: The default conforms to the length fields used by the data management system of MVS. * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Byte order [BIG ENDIAN] for first 16 Bit` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `SWITCH: EXCLUDE - Record length field not part of the length value [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-record-fdecode_5f97.html",
"FDECODE",
"[[CLEP.COMMAND.CONV.READ.RECORD.FDECODE]] ==== FDECODE indexterm:[Overlay, FDECODE, CONV.READ.RECORD.FDECODE] The overlay 'fdecode' allows you to enforce an additional decoding of the data after the auto decoding ('decode' parameter defined) was done. This is useful if the resulting data is still encoded. This may happen if a record was decoded from a FLAMFILE (read.record()) and the record is, for example, base encoded. The forced decoding works on records and gives you the possibility to read files, which (for example) were encoded with:    'write.record(encode.base64())' The enforcement of base decoding can even be used if no auto decoding is activated. See below for the decoding possibilities. * `SWITCH: BASE64/ARMOR/PGP - Base64 decoding (RFC4648)` * `SWITCH: BASE32 - Base32 decoding (RFC4648)` * `SWITCH: BASE16 - Base16 decoding (RFC4648)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-flam4_db5f.html",
"FLAM4",
"[[CLEP.COMMAND.CONV.READ.FLAM4]] ==== FLAM4 indexterm:[Object, FLAM4, CONV.READ.FLAM4] Read FLAM4 works with a list of records from a FLAMFILE of version 4 or older. If such a record is text data, you can mark this by defining the correct CCSID. Such a definition will result in character set conversion from the provided CCSID to UTF-8 for each record. If no CCSID is provided, the record will be handled as binary data. For FLAMFILE archives, these features are supported: * Read all members or a dedicated member of the archive * Print control character handling defined by a dedicated mode * Pass phrase based or FKME based decryption technology * Free definition of the amount of records handled as one chunk User I/O, pre- and post-processing exits are not supported. If these features are required, please use the extended variant (XCMP/XCNV) of this command. If you need, for example, Base64 decoding for records of a FLAMFILE, please use read.record(fdecode.base64). Read.record() can transparently read FLAMFILEs, supports base decoding and other useful features for record handling. If you provide row specifications through the table object, each record is split into neutral FL5 table elements. * `STRING: FILE['str'...] - Name/URL of the FLAMFILE to read [required]` * `STRING: MEMBER='str' - Name or Index of the member in the FLAMFILE to read` * `NUMBER: RECCOUNT=num - Amount of records handled in one read operation [4<128<1024]` * `NUMBER: RECLENGTH=num - Maximum record length for read operation [512]` * `SWITCH: TRUNCATE - Allow truncation of records [FALSE]` * `STRING: PASSWORD/CRYPTOKEY='bin'/DEFAULT - Passphrase to decrypt the FLAMFILE ['']` ** `DEFAULT - FLAM4 default password` * `STRING: KMLIBRARY='str' - Library name for FKME ['']` * `STRING: KMFUNCTION='str' - Function name of FKME ['']` * `STRING: KMPARAMETER='bin' - Parameter for the call of FKME ['']` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-flam4-larger_f17b.html",
"LARGER",
"[[CLEP.COMMAND.CONV.READ.FLAM4.LARGER]] ==== LARGER indexterm:[Parameter, LARGER, CONV.READ.FLAM4.LARGER] The LARGER switch will activate the block/record conversion with the B4X method. see: <<flcl.handling.spanned.records,Handling of Spanned Records>> To write large records to the old FLAMFILE, they must be converted. The FLAM4 components will handle this as an undefined byte stream. When reading, the inverse conversion must be requested to restore the original records. NOTE: Automatic record length detection will not work with large records (>=32768). This requires to set the record formatting method when reading such a FLAMFILE. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-auto_e622.html",
"AUTO",
"[[CLEP.COMMAND.CONV.READ.AUTO]] ==== AUTO indexterm:[Object, AUTO, CONV.READ.AUTO] Read 'auto' attempts to identify the file format automatically and reads the file with the most appropriate parameters. Detection works on a best effort basis and should not be relied on. For example, 'read.auto() write.record()' can convert every supported file format to records on mainframe systems. This is utilized in the FLVIEW and FLVEDIT ISPF command. With read.auto(), you can transparently read normal XML or text files with delimiters, encoded (BASE16/32/64), encrypted (FLAMFILE) or compressed (GZIP, BZIP2, XZ(LZMA)) files (even nested!), normal record-oriented data sets (FB(A/M)/VB(A/M)/VSAM/...), FLAMFILEs or binary data. If the data contains 4 byte length fields after I/O, decryption, decompression then a list of records is built to form one block. This allows you for example to read a file transparently from USS which was created with FILEDATA=RECORD and now allocated with FILEDATA=BINARY or a record length based format from a ZIP archive. The read.auto() function was mainly implemented to display (FLVIEW) the content of a file. The detection may fail on some files, especially for very small files. Additionally, you can provide a list of row specifications through the table object. If the file matches a row specification, table formatting is used. If the data does not fit with the provided row specification, the normal auto processing is performed. Generally: If you know the type of data (binary, char, text, xml, flam, charset/ccsid), it is recommended to use the corresponding read method and set the known parameters to prevent false detections. On the other side, if you know nothing about your data or you get data from different sources, read.auto() might be very helpful. To simplify the use of the read.auto() function, the mechanisms below are implemented: * The EBCDIC new line to ASCII line feed management is activated.   This means that, for methods that support it, the ENL2LF flag is set   for read methods and the ELF2NL flag is set for the write methods. * Suppression of trailing whitespace is activated for text records. * The print control character handling is set to erase print control   characters from records. * Subsystem specifications are not supported * Base encodings are always decoded, if the decoding results in useful   data. (i.e. text files in an a Base64 encoded Gzip file are decoded   and uncompressed automatically). Optional CRC verification and   verification of the trailer (if ASCII armor) is done if the CHECK   switch is enabled. * Record length format detection is enabled and used after I/O (a wrong   static file allocation on z/OS was done (FILEDATA=BINARY instead of   FILEDATA=RECORD) or a file with variable record length was read on   Windows or UNIX platforms), after decryption (data containing record   length fields were encrypted), after decompression (data with   record length fields was compressed (ZIP)) and after base decoding (if   data with length fields was encode). To read ASCII text files with NEL delimiter or to use specific formatting options, please use read.text(). To keep and manage record attributes, please use read.record(). The read.auto() function is designed to be very powerful, using the procedures suited best and, at the same time, to keep it as simple as possible. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [''==stdin]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECLENGTH=num - Maximum record length (Host) / line length (Unix/Win) for text parsing [512]` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `SWITCH: NOARCH - Disable the attempt to read archives (prevent multiple opens to the same file) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-read-file_e60f.html",
"FILE",
"[[CLEP.COMMAND.CONV.READ.FILE]] ==== FILE indexterm:[Parameter, FILE, CONV.READ.FILE] `read.file='name.txt'` is an abbreviation for `read.auto(file='name.txt')` without any further parameters. Please have a look at read.auto() for more information. `read.file` use all data format detection capabilities of FLAM to read transparent byte streams or records form a data source, which can be an encoded (e.g. Base64), encrypted (e.g. PGP) and/or compressed (GZIP/BZIP2/XZ) file, a FLAMFILE, other archive or a normal clear data set. The data stream after I/O and after each conversion can contain several kinds of 4 byte length field formats. This is also detected and the data is interpreted as blocks containing various records for the next layer. * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write_0053.html",
"WRITE",
"[[CLEP.COMMAND.CONV.WRITE]] ==== WRITE indexterm:[Overlay, WRITE, CONV.WRITE] Over the overlay WRITE you can choose the target format (binary, text, character, record, FLAM4FILE, table, ...) which will be written. Depending of this target a dedicated behavior is implemented and the corresponding parameter can be used to detail the procedure. Based on the knowledge about the kind of data You have read and the format you want to write, we have simplify the way to do automatically the right conversions for You. Additionally you can calculate or verify checksums on the binary data stream direct in front of the write operation. Below You can find the currently supported targets explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary_455d.html",
"BINARY",
"[[CLEP.COMMAND.CONV.WRITE.BINARY]] ==== BINARY indexterm:[Object, BINARY, CONV.WRITE.BINARY] Write binary formats all elements to one block, this binary block can then optionally compressed, encrypted and encoded and is written or appended to the specified file or archive on a local or remote system. For compression, encryption, encoding and archiving, one of the supported methods can be used. For each of these methods, specific parameters can be set to control the outbound conversions. If the data to be written consists of table elements and the 'TABLE' object is not specified or with no further formatting (i.e. TABLE()), then the original form of the table is written. Use the 'TABLE' object to reformat the table. * `STRING: FILE='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append data to this file or add member to archive [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: METHOD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method to convert records in blocks [NONE]` ** `L4I - Adds 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte length fields: System endian short (LL00), length exclusive` ** `DLM - Adds provided binary record delimiter` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record [system]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: SUPPADDING - Suppress trailing padding/equal characters` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCREC - Enforce record orientation on record oriented devices [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-falloc_ac71.html",
"FALLOC",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.FALLOC]] ==== FALLOC indexterm:[Object, FALLOC, CONV.WRITE.BINARY.FALLOC] The file allocation object collects several parameters for platforms which are record oriented based on a catalog system like z/OS(R) and where the space, volume and other things must be predefined. The supported parameters are platform dependent. Only parameters relevant for a certain platform are used. This way its possible to store files on special volumes, units, and with SMS-classes without any JCL usage on z/OS(R). But also on distributed platforms like (WIN, UNIX, MAC, ...) FLAM supports record oriented file types to keep the record information on such platforms. For this case the different record format for the open world can be defined. To read such a special file format on an open platform the correct record format must also be defined. On a catalog based system, this is not required. If the record format in the catalog are not the same as specified an error will occur. * `NUMBER: ORGANIZATION=SEQ/PS/LIB/PDS/USS/EDS/ESDS/KDS/KSDS/RDS/RRDS - File organization [SEQ]` ** `SEQ - Sequential data set [DEFAULT]` ** `PS - Sequential data set [DEFAULT]` ** `LIB - Library (ZOS-PDSE)` ** `PDS - Partitioned data set (ZOS-PDS)` ** `USS - UNIX files (path based)` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` * `NUMBER: BLKSIZE=num - Block size [system]` * `NUMBER: RECFORMAT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format [auto]` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLENGTH=num - Record length (data only, no print control and length fields)` * `NUMBER: KEYDISP=OLD/NEW/DEL - Key disposition for index/key sequential data sets [OLD]` ** `OLD - Key disposition OLD (keep the existing key)` ** `NEW - Key disposition NEW (insert record number as key)` ** `DEL - Key disposition DEL (delete key from record)` * `NUMBER: KEYPOSITION=num - Key position (>=1) for index/key sequential data sets [1]` * `NUMBER: KEYLENGTH=num - Key length (>=1) for index/key sequential data sets [8]` * `STRING: LIKE='str' - Specifies the name of the model data set from which the attributes are to be copied` * `SWITCH: RENEW - Enforce new allocation by a remove of an existing file` * `SWITCH: PERFILE - Enforce processing per file in directory walk [OFF] (prevent append handling)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-falloc-sysout_2f7d.html",
"SYSOUT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.FALLOC.SYSOUT]] ==== SYSOUT indexterm:[Object, SYSOUT, CONV.WRITE.BINARY.FALLOC.SYSOUT] The SYSOUT specification object can be used to allocate a SYSOUT class (only one character) and (if required) a SYSOUT program (at most 8 characters) on platforms like z/OS(R). The default value for SYSOUT is class '*' and no writer. If SYSOUT is specified, other allocation parameters (filename, DCBs) are ignored. Depending on the format, the default class and writer could be different. The remaining parameter supports text units to re-direct the SYSOUT to other LPARs or to the hold queue. * `STRING: CLASS='str' - The class of the system output data set [DEFAULT]` * `STRING: WRITER='str' - Program name for the system output data set [auto]` * `STRING: DSTRWS='str' - Remote work station specification [NONE]` * `STRING: DSTUID='str' - Destination user ID for redirection [NONE]` * `SWITCH: HLDQUE - Redirection to hold queue [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-falloc-sysout-format_2ce1.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.FALLOC.SYSOUT.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.WRITE.BINARY.FALLOC.SYSOUT.FORMAT] The FORMAT overlay offers conversions that produce output in a format that is appropriate for the designated SYSOUT program (e.g. emails). * `SWITCH: NONE - No special formatting` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-falloc-sysout-format-mail_a0bd.html",
"MAIL",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.FALLOC.SYSOUT.FORMAT.MAIL]] ==== MAIL indexterm:[Object, MAIL, CONV.WRITE.BINARY.FALLOC.SYSOUT.FORMAT.MAIL] The `MAIL` object can be used to write each file as a Base64 encoded email attachment. A sender email address should and one or more receipient email addresses must be specified (TO, CC and BCC supported). The subject header, email body text and a filename for the attachment can also be set. The environment variables `MAILADDR` can be set to a default sender email address, so that it does not need to be specified every time. The 'CSSMTP' writer with class 'A' is allocated by default for SYSOUT if this formatter is selected. The environment variable below can be used to change these defaults. * `FL_SYSOUT_MAIL_CLASS` Default class for SYSOUT allocation * `FL_SYSOUT_MAIL_WRITER` Default program for SYSOUT allocation See the chapter <<clep.main.usedenv, Used Environment Variables>> for documentation about how to set environment variables. Mails are generated in CCSID 1047 by default, which can changed with the corresponding parameter, if necessary. If `SYSOUT` is used for sending files as emails, one email is sent for each written file. If processing multiple files and a fixed filename is specified in the writing part of the command, then all these files are concatenated into one attachment. It essentially works as if writing to disk: If one file would be written locally, one email is sent. If multiple files would be written to disk, multiple emails are sent. With the `ATTACHMENT` parameter, an attachment name can be specified. By default, the given filename is used. The attachment parameter has no impact on the file handling. It only sets the attachment filename in the email header. Below a example jobstep: For the subject and the attachment name <<flcl.input.output.name.mapping,Input to Output Name Mapping>> is supported. * `STRING: SYSTEM='str' - The system name used in SMTP's HELO command [SYSNAME]` * `STRING: CCSID='str' - CCSID for the mail writer [1047]` * `STRING: FROM='str' - Mail address of the sender [MAILADDR]` * `STRING: TO['str'...] - Mail addresses of receivers` * `STRING: CC['str'...] - Mail addresses of receivers on carbon copy (optional)` * `STRING: BCC['str'...] - Mail addresses of receivers on blind carbon copy (optional)` * `STRING: SUBJECT='str' - Mail subject [Mail send by FLAM]` * `STRING: BODY='str' - Mail body (optional)` * `STRING: ATTACHMENT='str' - Name of the attachment [filename]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-falloc-space_86f8.html",
"SPACE",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.FALLOC.SPACE]] ==== SPACE indexterm:[Object, SPACE, CONV.WRITE.BINARY.FALLOC.SPACE] The space definition object collects several parameters for platforms where data sets are preallocated like z/OS(R) and where cylinders or tracks must be predefined for a file allocation. The supported parameters are platform dependent. Only parameters relevant for a certain platform are used. This way it is possible to store files on special volumes, units, and with SMS-classes without any JCL usage on z/OS(R). All sizes must be specified in megabytes (MiB). The conversion into platform-dependent units (tracks, cylinders, ...) is done internally. NOTE: 1 MiB = 1024 KiB = 1024*1024 Bytes (21 tracks on z/OS (3390)) If the sum of primary and secondary space is larger than the basic file limits, large files or extended attribute files are allocated automatically. To allocate smaller files as large files, the corresponding switch must be specified. If a data class is specified, default values for data set organization record format, record length, block size, etc. are no longer used since version 5.1.22. Only the internally calculated file size (if known) overrides the values defined by the data class. When using a data class, the values defined by the data class can be overridden by providing them as parameters of this object. By specifying one of the space parameters, the default and not the data class value for the other parameters will be used. We recommend to use our intelligent defaults and no data class definitions. For example, for fixed length record datasets we increase the the primary and secondary space depending on the record format and the record length of the origin dataset and the target record length to include the potential/required space for padding. * `NUMBER: PRIMARY=num - Primary size in megabytes` * `NUMBER: SECONDARY=num - Secondary size in megabytes` * `NUMBER: DIRBLOCKS=num - Directory blocks for partitioned data sets` * `STRING: VOLSER='str' - Volume serial number` * `STRING: VOLUNIT='str' - Volume unit` * `STRING: DATACLASS='str' - Data class` * `STRING: MGMTCLASS='str' - Management class` * `STRING: STORCLASS='str' - Storage class` * `NUMBER: NORMALDISP=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for normal end [CATALOG]` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` * `NUMBER: ABORTDISP=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for abnormal end [KEEP]` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` * `NUMBER: RELEASE=YES/NO - Release unused space when file is closed [SEQ=YES, PDS=NO]` ** `YES - Yes, do it` ** `NO - No, don't do it` * `SWITCH: LARGEFILE - Enforce the allocation of a large file [FALSE]` * `SWITCH: UNMOVABLE - Allocate space unmovable [FALSE]` * `SWITCH: CONTIG - Allocate space contiguously [FALSE]` * `SWITCH: PERMANENT - Allocate space permanently [FALSE]` * `NUMBER: RLS=NRI/CR/CRE - Specifies the type of record level sharing (RLS) being done for a specific data set [NONE]` ** `NRI - No Read Integrity` ** `CR - Consistent Read` ** `CRE - Consistent Read Explicit` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-prncontrol_2e6b.html",
"PRNCONTROL",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.PRNCONTROL]] ==== PRNCONTROL indexterm:[Parameter, PRNCONTROL, CONV.WRITE.BINARY.PRNCONTROL] Print control character handling is a special feature for record oriented files of mainframe system. For print control, the ASA or machine control characters are encoded in the first byte of the record. If an attribute with such a control character is known on write operation, you can decide whether it will be part of the output (RETAIN), written to the output if required (DETACH) or never written (ERASE). At record I/O an additional replacement by certain empty records to produce a print like output (REPLACE) is supported. The replacement is only done if the target record format don't support ASA or MCC. In this case a default line per page of 60 is used. This default can change over the parameter replace form feed (RPLFFD). If RPLFFD is 0 then 60 is assumed, if it 1 then form feeds are ignored and in each other case the missing records to fill up one page are added. * `DETACH - Manage print control character as record attribute` * `RETAIN - Leave print control character as part of the data record` * `ERASE - Erase the print control character from the record` * `REPLACE - Replace print control characters by additional records like printed` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-compress_e0e2.html",
"COMPRESS",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.COMPRESS]] ==== COMPRESS indexterm:[Overlay, COMPRESS, CONV.WRITE.BINARY.COMPRESS] With the overlay 'compress', you can choose which kind of compression method is used for the data. Depending on the compression method different parameters can be provided to define the behavior in more detail. If no compression method is selected, no data compression is performed. Example: Read a host data set and write it as GZIP file for Windows The example uses SUPPAD to eliminate trailing whitespace from the MVS dataset. The ASA control character is detached by default, the character set is changed from IBM1141 to CP1252, 0x0D0A is used as delimiter for each record and a GZIP file is written to USS. If you want to read such a GZIP text file, use 'read.text()' and the decompression is done transparently and automatically. See below for the different compression options. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-compress-gzip_8d7b.html",
"GZIP",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.COMPRESS.GZIP]] ==== GZIP indexterm:[Object, GZIP, CONV.WRITE.BINARY.COMPRESS.GZIP] The GZIP compression conforms to RCF1951/52. The compression level can be set to values from 0 to 9 (0=copy, 1=fastest, 9=best). Additionally, it is possible to set a comment and to enforce checksum calculation of the file header. The checksum calculation is not recommended because only the newer versions of Zlib can handle this checksum technique. With older versions of Zlib this can cause problems. Therefore, checksum calculation is turned off by default. The decompressor also accepts the older Zlib wrapping format specified in RFC1950. It is not possible to enforce RFC1950 at compression because most standards require RFC1952 for the deflate algorithms. If no compression level is defined and the data is marked is being without redundancy, level 0 (copy) is used. In all other cases the default level 6 is used. Decompression of concatenated GZIP files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: If GZIP compression is used with write.record(), all file attributes are stored in the GZIP header. The record attributes can be added in front of the record (PRNCTR=RETAIN). By default, a 4 byte length field in little endian is written in front of the data. Such a GZIP file can be used on record-oriented platforms to recreate datasets. * `NUMBER: LEVEL=num/COPY/FAST/LEV1/LEV2/LEV3/LEV4/LEV5/LEV6/LEV7/LEV8/LEV9/BEST/AUTO - Compression level [AUTO==6]` ** `COPY - No compression = copy of data (0)` ** `FAST - Fastest compression (level 1)` ** `LEV1 - Compression level 1` ** `LEV2 - Compression level 2` ** `LEV3 - Compression level 3` ** `LEV4 - Compression level 4` ** `LEV5 - Compression level 5` ** `LEV6 - Compression level 6` ** `LEV7 - Compression level 7` ** `LEV8 - Compression level 8` ** `LEV9 - Compression level 9` ** `BEST - Best compression (level 9)` ** `AUTO - Automatic compression (level 6)` * `STRING: MEMBER='str' - File name for header [from origin]` * `STRING: COMMENT='str' - Comment for header [default]` * `SWITCH: CHECK - Calculate checksum over GZIP header [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-compress-bzip2_a068.html",
"BZIP2",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.COMPRESS.BZIP2]] ==== BZIP2 indexterm:[Object, BZIP2, CONV.WRITE.BINARY.COMPRESS.BZIP2] The BZIP2 algorithm compresses chunks of data. Such a chunk can be up to 100KB, 200KB, ..., 900KB. The chunk size is selected automatically based on the internal block size (block size in KB rounded up to the next possible chunk size). The chunk size directly correlates with the compression level. Compression levels range from 1 (fastest) to 9 (best, but slowest). Level 1 results in 100KB chunk size, level 9 in 900KB chunk size (i.e. chunk size = level*100KB). Hence, a lower level also reduces the required memory resources during compression and decompression. Decompression of concatenated BZIP2 files is also possible. All concatenated files will be decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: If BZIP compression is used with write.record(), the file attributes cannot be stored in the BZIP2 file. The record attributes can be added in front of the record (PRNCTR=RETAIN). By default, a 4 byte length field in little endian is written in front of the data. Such a BZIP2 file can be used on record-oriented platforms to recreate the original datasets as PS-VB. You may want to use a ZIP archive or ARMOR encoding to store the file attributes (DCB) to recreate the correct record format and length. * `NUMBER: LEVEL=num/FAST/LEV1/LEV2/LEV3/LEV4/LEV5/LEV6/LEV7/LEV8/LEV9/BEST/AUTO - Compression level (defines block size) [AUTO]` ** `FAST - Fastest compression (Block size = 100kb)` ** `LEV1 - Compression level 1 (Block size = 100kb)` ** `LEV2 - Compression level 2 (Block size = 200kb)` ** `LEV3 - Compression level 3 (Block size = 300kb)` ** `LEV4 - Compression level 4 (Block size = 400kb)` ** `LEV5 - Compression level 5 (Block size = 500kb)` ** `LEV6 - Compression level 6 (Block size = 600kb)` ** `LEV7 - Compression level 7 (Block size = 700kb)` ** `LEV8 - Compression level 8 (Block size = 800kb)` ** `LEV9 - Compression level 9 (Block size = 900kb)` ** `BEST - Best compression (Block size = 900kb)` ** `AUTO - Automatic compression (depending on the real block size)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-compress-xz_b349.html",
"XZ",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.COMPRESS.XZ]] ==== XZ indexterm:[Object, XZ, CONV.WRITE.BINARY.COMPRESS.XZ] The XZ compression conforms to the XZ-compression tool on UNIX-systems. The compression level can be set to values from 0 to 9 (0=fastest, 9=best). The default level is 6 when no level is specified. Decompression of concatenated XZ files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: If XZ compression is used with write.record(), the file attributes cannot be stored in the XZ file. The record attributes can be added in front of the record (PRNCTR=RETAIN). By default, a 4 byte length field in little endian is written in front of the data. Such an XZ file can be used on record-oriented platforms to recreate the original datasets as PS-VB. You may want to use a ZIP archive or ARMOR encoding to store the file attributes (DCB) to recreate the correct record format and length. * `NUMBER: LEVEL=num/FAST/LEV0/LEV1/LEV2/LEV3/LEV4/LEV5/LEV6/LEV7/LEV8/LEV9/BEST/AUTO - Compression level [AUTO==6]` ** `FAST - Fastest compression (level 0)` ** `LEV0 - Compression level 0` ** `LEV1 - Compression level 1` ** `LEV2 - Compression level 2` ** `LEV3 - Compression level 3` ** `LEV4 - Compression level 4` ** `LEV5 - Compression level 5` ** `LEV6 - Compression level 6` ** `LEV7 - Compression level 7` ** `LEV8 - Compression level 8` ** `LEV9 - Compression level 9` ** `BEST - Best compression (level 10)` ** `AUTO - Automatic compression (level 6)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-compress-zstd_60f8.html",
"ZSTD",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.COMPRESS.ZSTD]] ==== ZSTD indexterm:[Object, ZSTD, CONV.WRITE.BINARY.COMPRESS.ZSTD] The ZSTD compression conforms to the ZSTD-compression tool on UNIX-systems. The compression level can be set to values from 0 to 9 (0=fastest, 9=best). The default level is 6 when no level is specified. Decompression of concatenated ZSTD files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: If ZSTD compression is used with write.record(), the file attributes cannot be stored in the ZSTD file. The record attributes can be added in front of the record (PRNCTR=RETAIN). By default, a 4 byte length field in little endian is written in front of the data. Such an ZSTD file can be used on record-oriented platforms to recreate the original datasets as PS-VB. You may want to use a ZIP archive or ARMOR encoding to store the file attributes (DCB) to recreate the correct record format and length. * `NUMBER: LEVEL=num/FAST/LEV1/LEV2/LEV3/LEV4/LEV5/LEV6/LEV7/LEV8/LEV9/LEV10/LEV11/LEV12/LEV13/LEV14/LEV15/LEV16/LEV17/LEV18/LEV19/BEST/AUTO - Compression level [AUTO==9]` ** `FAST - Fastest compression (ZSTD_minCLevel())` ** `LEV1 - Compression level 1` ** `LEV2 - Compression level 2` ** `LEV3 - Compression level 3` ** `LEV4 - Compression level 4` ** `LEV5 - Compression level 5` ** `LEV6 - Compression level 6` ** `LEV7 - Compression level 7` ** `LEV8 - Compression level 8` ** `LEV9 - Compression level 9` ** `LEV10 - Compression level 10` ** `LEV11 - Compression level 11` ** `LEV12 - Compression level 12` ** `LEV13 - Compression level 13` ** `LEV14 - Compression level 14` ** `LEV15 - Compression level 15` ** `LEV16 - Compression level 16` ** `LEV17 - Compression level 17` ** `LEV18 - Compression level 18` ** `LEV19 - Compression level 19` ** `BEST - Best compression (ZSTD_maxCLevel())` ** `AUTO - Automatic compression (level 9)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encrypt_523b.html",
"ENCRYPT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCRYPT]] ==== ENCRYPT indexterm:[Overlay, ENCRYPT, CONV.WRITE.BINARY.ENCRYPT] The overlay 'encrypt' allows you to choose which kind of encryption method is used for the data. Depending on the encryption method, different parameters can be set. If no encryption method is selected, then no data encryption will be done. Example: ASCII armor encoding (using the system character set) for encrypted OpenPGP file, previously deflated and prepared for usage on a CP1252-based Windows system. See below for the encryption possibilities. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encrypt-pgp_1fcf.html",
"PGP",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCRYPT.PGP]] ==== PGP indexterm:[Object, PGP, CONV.WRITE.BINARY.ENCRYPT.PGP] Activates OpenPGP encryption based on passwords or the FLAM5 key management extension (FKM5). To protect the PGP session (data) key with a FKM5 module the library name, function name and corresponding parameter list must be provided. On mainframe systems, the library name can be empty to choose a load module through the function name from the STEPLIB concatenation. The default library name is 'LIBFKM5' on mainframes and 'libfkm5' on other platforms. The default function name is 'PGPCCA' on IBM and PGPRING on all other systems. Also you can use PGPP11 function if PKCS#11 HSM is available. For more information see FKM5BOOK manual. Beside the connection parameters to your cryptographic infrastructure you must provide at least one user ID to address the receiver and/or one password. With the user ID specification, the session (data) key is encrypted with public key of this user (if this is found). With the password specification, the session (data) key is encrypted symmetric with derived password. The recipient must know the password. You can change the key label templates for encryption and signature generation. If signature generation is activated, the owner for signing (and optionally the corresponding template) must be defined. If you provide more than one passphrase or user ID then additional encrypted session key packets are added to the PGP file to encrypt for different recipients. The session (data) key will be encrypted with each password and can be decrypted with one of this: The session (data) key will be encrypted for each user (public key) and can be decrypted of one of them: Mix of user ID and password is also possible: Passwords can be provided in four different ways: * In ASCII format: `password=a'ascii'` * In EBCDIC format: `password=e'ebcdic'` * In hexadecimal format: `password=x'hex'` * In local charset: `password='system'` NOTE: Don't use the local charset variant if you wish to open the file on different platforms. To prevent passwords from being logged and for a better protection, we recommend to store passwords in files and use that password file instead passing the password directly. NOTE: In a password file, you can define the password in one of the variants described above. You can choose the compression mode. The default and recommended method is AUTO which uses GZIP raw (RFC1951, called ZIP in RFC4880) compression with level 6, if the data contains redundancy and no compression otherwise. If the data is already compressed, an additional compression can expand the data. The default behavior prevents such an expansion. Additionally, you can activate ASCII armor encoding for the encrypted data stream. If PGP encryption is used with write.record(), the file attributes cannot be stored in the PGP file. To solve this, a GZIP file can be produced before or an ARMOR encoding afterwards to store the file attributes, unless the ZIP archive option is selected. The record attributes can be added in front of the record (PRNCTR=RETAIN). By default, a 4 byte length field in little endian is written in front of the data. Such a PGP file can be used on record-oriented platforms to later recreate the original dataset. Be aware that you can get a GZIP file if you read such a file with other tools and that the decoded data can contain length fields and control characters. * `NUMBER: METHOD=CRYPT/SIGN/ENCSIG - Method for OpenPGP encryption and signing [CRYPT]` ** `CRYPT - Only encryption` ** `SIGN - Only signatures` ** `ENCSIG - Encryption and signing` * `NUMBER: FORMAT=SENC/SEIP/PLAIN - Format for symmetric data encryption [SEIP]` ** `SENC - Symmetrically encrypted` ** `SEIP - Symmetrically encrypted and integrity protected` ** `PLAIN - No encryption (plain text)` * `NUMBER: ALGORITHM=AES128/AES192/AES256/TDES/CAST5/IDEA/BLOWFISH/CAMELLIA128/CAMELLIA192/CAMELLIA256/PLAIN - Algorithm for symmetric data encryption [preferred]` ** `AES128 - AES (Rijndael) with 128 bit (16 byte) key length` ** `AES192 - AES (Rijndael) with 192 bit (24 byte) key length` ** `AES256 - AES (Rijndael) with 256 bit (32 byte) key length` ** `TDES - Triple DES with 192 bit (24 byte) key length` ** `CAST5 - CAST5 with 128 bit (16 byte) key length` ** `IDEA - IDEA with 128 bit (16 byte) key length` ** `BLOWFISH - Blowfish with 128 bit (16 byte) key length` ** `CAMELLIA128 - CAMELLIA with 128 bit (16 byte) key length` ** `CAMELLIA192 - CAMELLIA with 192 bit (24 byte) key length` ** `CAMELLIA256 - CAMELLIA with 256 bit (32 byte) key length` ** `PLAIN - No encryption (plain text)` * `STRING: PASSWORD['bin'...] - Passphrases for symmetrically encryption` * `STRING: USERID/RECEIVER['str'...] - Receiver user IDs for public key encryption` * `STRING: SIGNID/SIGNER='str' - Owner user ID for signing` * `NUMBER: SIGHASH=MD5/SHA1/RIPEMD/SHA224/SHA256/SHA384/SHA512 - Hash algorithm for signature generation [preferred]` ** `MD5 - 128 bit (16 byte) MD5 checksum` ** `SHA1 - 160 bit (20 byte) SHA checksum` ** `RIPEMD - 160 bit (20 byte) RipeMD checksum` ** `SHA224 - 224 bit (28 byte) SHA checksum` ** `SHA256 - 256 bit (32 byte) SHA checksum` ** `SHA384 - 384 bit (48 byte) SHA checksum` ** `SHA512 - 512 bit (64 byte) SHA checksum` * `NUMBER: COMPRESS=COPY/GZIP/ZLIB/BZIP/AUTO - Method used for compression [auto]` ** `COPY - Copy / no compression` ** `GZIP - Raw GZIP compression (RFC1951)` ** `ZLIB - ZLIB compression (RFC1950)` ** `BZIP - BZIP2 compression` ** `AUTO - If redundancies then GZIP else COPY` * `STRING: MEMBER='str' - File name for header [origin]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encrypt-pwd_a6e3.html",
"PWD",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCRYPT.PWD]] ==== PWD indexterm:[Object, PWD, CONV.WRITE.BINARY.ENCRYPT.PWD] OpenSSL-compatible encryption based on passwords. This object is a subset of <<CNV.EDC,CNV.EDC()>>. For more information see the <<CNV.EDC,corresponding page>> of the `XCNV` command. The encryption key is derived from the password and randomly generated salt value. This salt value is prepended to the output for use during decryption. Only OpenSSL-compatible password-based encryption is supported by this object. To use keys, key labels or other advanced encryption options, please use the EDC object. Below you can find an example for OpenSSL-compatible encryption on mainframe and the corresponding decryption on any platform supported by OpenSSL. Write a compressed, encrypted and base64-encoded dataset to a remote system: The output is written with Unix-style newline characters (NL). Trailing whitespace will be suppressed (SUPTWS) and the character conversion is done from German EBCDIC (IBM-1141) to UTF-8. The resulting text file is compressed with GZIP and encrypted using password-based AES-256-CBC encryption and the PBKDF2 key derivation function. OpenSSL requires line endings for decoding (`openssl enc -d base64`). Therefore, the `LINE` and `DELIM` parameters in the `BASE64` object are needed. Below is the command line call for decoding it with FLCL: The encoding is automatically detected and removed because the header containing the salt value is found. For decryption, the algorithm parameters and the passphrase must be specified. The `DECODE` switch enables automatic GZIP decompression. The result is the text file which was prepared on the mainframe system. The same can be done with OpenSSL and GZIP standard utilities: * `NUMBER: ALGO=AES/TDES/CAST5/CAST128/IDEA/BLOWFISH/BF/CAMELLIA - Algorithm used for encryption [AES]` ** `AES - Advanced encryption standard (Rijndael)` ** `TDES - Triple DES (Data encryption standard)` ** `CAST5 - CAST5/CAST-128 (Carlisle Adams, Stafford Tavares)` ** `CAST128 - CAST-128/CAST5 (Carlisle Adams, Stafford Tavares)` ** `IDEA - International Data Encryption Algorithm` ** `BLOWFISH - Blowfish from Bruce Schneier` ** `BF - Blowfish from Bruce Schneier` ** `CAMELLIA - Camellia from Japan (Mitsubishi Electric and NTT)` * `NUMBER: KEYLEN=num/KL064/KL128/KL192/KL256/KL08/KL16/KL24/KL32 - Key length if passphrase used [longest possible]` ** `KL064 - Key length 64 bits (8 bytes)` ** `KL128 - Key length 128 bits (16 bytes)` ** `KL192 - Key length 192 bits (24 bytes)` ** `KL256 - Key length 256 bits (32 bytes)` ** `KL08 - Key length 8 bytes (64 bits)` ** `KL16 - Key length 16 bytes (128 bits)` ** `KL24 - Key length 24 bytes (192 bits)` ** `KL32 - Key length 32 bytes (256 bits)` * `NUMBER: MODE=ECB/CBC/OFB/CFB/CTR/GCM - Mode of operation [CBC]` ** `ECB - Electronic codebook mode` ** `CBC - Cipher block chaining mode` ** `OFB - Output feedback mode` ** `CFB - Cipher feedback mode` ** `CTR - Counter mode` ** `GCM - Galois/Counter Mode ` * `NUMBER: PADDING=NONE/NOPAD/PKCS - Padding for CBC or ECB mode [PKCS]` ** `NONE - No padding (remaining data must have a multiple of the block length)` ** `NOPAD - No padding (remaining data must have a multiple of the block length)` ** `PKCS - OpenSSL conform PKCS padding` * `NUMBER: KDF/PW2KEY=OLDSSL/PBKDF2 - Password to key derivation function [OLDSSL]` ** `OLDSSL - Legacy OpenSSL key derivation (avoid use, default: SHA-256 with 1 round, hint: OpenSSL < 1.1.0 used MD5)` ** `PBKDF2 - PBKDF2 key derivation function (default: SHA-256 with 10000 rounds, available from OpenSSL 1.1.1)` * `NUMBER: MD/HASH=MD5/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512 - Hash algorithm for key derivation [SHA256]` ** `MD5 - Message Digest 5 with 128 bits` ** `SHA1 - Secure Hash Algorithm 1 with 160 bits` ** `SHA224 - Secure Hash Algorithm 2 with 224 bits` ** `SHA256 - Secure Hash Algorithm 2 with 256 bits` ** `SHA384 - Secure Hash Algorithm 2 with 384 bits` ** `SHA512 - Secure Hash Algorithm 2 with 512 bits` ** `SHA3-224 - Secure Hash algorithm 3 with 224 bits` ** `SHA3-256 - Secure Hash Algorithm 3 with 256 bits` ** `SHA3-384 - Secure Hash Algorithm 3 with 384 bits` ** `SHA3-512 - Secure Hash Algorithm 3 with 512 bits` * `NUMBER: ITER=num - Iteration count for PBKDF2, implies METHOD=PBKDF2 if specified [10000]` * `STRING: PASSWORD='str' - Salted passphrase for encryption` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encrypt-edc_b156.html",
"EDC",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCRYPT.EDC]] ==== EDC indexterm:[Object, EDC, CONV.WRITE.BINARY.ENCRYPT.EDC] Encryption based on clear keys, passwords or the FLAM5 key management extension (FKM5) using a key label. This object is a subset of <<CNV.EDC,CNV.EDC()>>. For more information see the <<CNV.EDC,corresponding page>> of the `XCNV` command. * `NUMBER: METHOD=CLEAR/PASSWORD/LABEL - Method for key determination [AUTO]` ** `CLEAR - Clear key crypto (en/decrypt with raw unprotected key value)` ** `PASSWORD - Password-based crypto (using key derivation function (KDF))` ** `LABEL - Protected key crypto using label (FKM5 required)` * `NUMBER: FORMAT=NOHDR/OPENSSL - File format used [OpenSSL]` ** `NOHDR - Don't use an header in front of the data` ** `OPENSSL - Use OpenSSL '__SLATED__' header if required` * `NUMBER: ALGO=AES/TDES/CAST5/CAST128/IDEA/BLOWFISH/BF/CAMELLIA - Algorithm used for encryption [AES]` ** `AES - Advanced encryption standard (Rijndael)` ** `TDES - Triple DES (Data encryption standard)` ** `CAST5 - CAST5/CAST-128 (Carlisle Adams, Stafford Tavares)` ** `CAST128 - CAST-128/CAST5 (Carlisle Adams, Stafford Tavares)` ** `IDEA - International Data Encryption Algorithm` ** `BLOWFISH - Blowfish from Bruce Schneier` ** `BF - Blowfish from Bruce Schneier` ** `CAMELLIA - Camellia from Japan (Mitsubishi Electric and NTT)` * `NUMBER: KEYLEN=num/KL064/KL128/KL192/KL256/KL08/KL16/KL24/KL32 - Key length if passphrase used [longest possible]` ** `KL064 - Key length 64 bits (8 bytes)` ** `KL128 - Key length 128 bits (16 bytes)` ** `KL192 - Key length 192 bits (24 bytes)` ** `KL256 - Key length 256 bits (32 bytes)` ** `KL08 - Key length 8 bytes (64 bits)` ** `KL16 - Key length 16 bytes (128 bits)` ** `KL24 - Key length 24 bytes (192 bits)` ** `KL32 - Key length 32 bytes (256 bits)` * `NUMBER: MODE=ECB/CBC/OFB/CFB/CTR/GCM - Mode of operation [CBC]` ** `ECB - Electronic codebook mode` ** `CBC - Cipher block chaining mode` ** `OFB - Output feedback mode` ** `CFB - Cipher feedback mode` ** `CTR - Counter mode` ** `GCM - Galois/Counter Mode ` * `NUMBER: PADDING=NONE/NOPAD/PKCS - Padding for CBC or ECB mode [PKCS]` ** `NONE - No padding (remaining data must have a multiple of the block length)` ** `NOPAD - No padding (remaining data must have a multiple of the block length)` ** `PKCS - OpenSSL conform PKCS padding` * `NUMBER: KDF/PW2KEY=OLDSSL/PBKDF2 - Password to key derivation function [OLDSSL]` ** `OLDSSL - Legacy OpenSSL key derivation (avoid use, default: SHA-256 with 1 round, hint: OpenSSL < 1.1.0 used MD5)` ** `PBKDF2 - PBKDF2 key derivation function (default: SHA-256 with 10000 rounds, available from OpenSSL 1.1.1)` * `NUMBER: MD/HASH=MD5/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512 - Hash algorithm for key derivation [SHA256]` ** `MD5 - Message Digest 5 with 128 bits` ** `SHA1 - Secure Hash Algorithm 1 with 160 bits` ** `SHA224 - Secure Hash Algorithm 2 with 224 bits` ** `SHA256 - Secure Hash Algorithm 2 with 256 bits` ** `SHA384 - Secure Hash Algorithm 2 with 384 bits` ** `SHA512 - Secure Hash Algorithm 2 with 512 bits` ** `SHA3-224 - Secure Hash algorithm 3 with 224 bits` ** `SHA3-256 - Secure Hash Algorithm 3 with 256 bits` ** `SHA3-384 - Secure Hash Algorithm 3 with 384 bits` ** `SHA3-512 - Secure Hash Algorithm 3 with 512 bits` * `NUMBER: ITER=num - Iteration count for PBKDF2, implies METHOD=PBKDF2 if specified [10000]` * `STRING: IV='bin-hex'/ZERO/RANDOM - Initialization vector for all modes except ECB [ZERO]` ** `ZERO - Initialization vector of binary zeros` ** `RANDOM - Generate random initialization vector` * `STRING: SALT='bin-hex'/NONE/RANDOM - Salt for passphrase-based encryption [RANDOM]` ** `NONE - No salt (not recommended)` ** `RANDOM - Random generated salt` * `STRING: KEY='bin-hex'/RANDOM - Clear key value (direct entry of raw value (dangerous))` ** `RANDOM - Random generated key` * `STRING: PASSWORD='str' - Passphrase with or without salting` * `STRING: LABEL='str' - Label to reference a protected key (FKM5 required)` * `SWITCH: PRNKEY - Enforce print of clear key values (incl. IV and SALT) to side file (else only if random generated)` * `STRING: TAG='str'/STDOUT/STDERR - File to write tag value if GCM mode used (if defined then tag is not written to side file)` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` * `NUMBER: OFFSET=num - Offset before encryption begins [0]` * `STRING: PARM='str'/STDOUT/STDERR - Side file with parameter for decryption (can assigned as parameter file)` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encode_dc78.html",
"ENCODE",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCODE]] ==== ENCODE indexterm:[Overlay, ENCODE, CONV.WRITE.BINARY.ENCODE] The overlay 'encode' allows to choose which kind of encoding method is used for the data. Depending on the encoding method, different parameters can be set. If no encoding method is selected, then no data encoding will be done. Example: ASCII armor encoding for encrypted OpenPGP file, previously deflated and prepared for usage on a UTF-8-based UNIX system. See below for the available encoding options. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-encode-base64-armor_ab6e.html",
"ARMOR",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ENCODE.BASE64.ARMOR]] ==== ARMOR indexterm:[Object, ARMOR, CONV.WRITE.BINARY.ENCODE.BASE64.ARMOR] The ARMOR object activates ASCII armor encoding. Depending on the specified CHRSET, it may also use EBCDIC encoding. ASCII armored data is Base64 encoded binary data followed by an optional checksum, surrounded by a header and trailer. For this you can set the header, version and comment strings illustrated in the example below: The header data is usually set by the previous component in a meaningful way. Therefore, we recommend not to overwrite these values, especially when using the PGP converter. But sometimes it could be required that not all private extensions are written. In this case you can set the FORMAT parameter to OFF to prevent such key value pairs or to STD to include only the version, comment and if available the charset. In general, it only makes sense to set the header data if none is set by another component (e.g. after reading binary). In this case, the default header is the current data type BINARY/RECORD/TEXT/..., the version is the current FLAM version and the comment the current default comment. Applying ASCII armor on an XML file would yield a result similar to the example below: If you activate the ARMOR object and no line length is specified, then a default of 72 is used. ASCII armor can be applied to block- or record- oriented data. When reading, header and trailer are stripped away and the decoded data is passed to the next component. If no header is found, only the decoding is done. To verify that trailer contains the same string used in the header, you must enable a switch. The base encoding component also supports the optional CRC24 checksum for Base64 defined in RFC4880. For the other base encoding schemas, CRC checksum lengths are used that match the respective block size. The same XML example as above, but with a CRC24 checksum, looks like this: To verify the checksum, a switch must be enabled as it is not verified by default. Since the checksum is optional, it is useless to calculate the CRC just to find out that there is no CRC appended to the data that can be compared against. NOTE: An empty file that has been ASCII-armored consists of a header and trailer plus optional CRC checksum (00...00), only. Such a file is not detected automatically as ASCII-armored when trying to read it. It will be handled as normal text file with delimiters. To read such a file as base encoded without any data, you must set the correct decoding method. From the perspective of auto detection, such a file is a simple text file. Files are only detected as ASCII-armored if they contain some actual data. Example for activating ASCII-armor encoding with CRC checksum: When using the ASCII armor feature together with a binary and block- oriented format (PGP, GZIP, BZIP2, ...), then, by default, several file attributes are added. This allows FLAM to restore host datasets from an ASCII armored file. The keywords below are supported: * Format: BINARY/RECORD/RECTXT/CHAR/TEXT/XML * Charset: Encoding string (IBM-1141/UTF-8/...) * Platform: free text (e.g. Linux on x86 with 64 bit (linx64d0)) * BinaryDelimiter: Hex-value for a binary record delimiter (DLM) * LengthField: L4X/L4I/B4X/B4I/HBX/HBI/HLX/HLI (see FMT.REC(METHOD)) * TextDelimiter:  Hex value for a text record delimiter (TXT) * FileOrganization: SEQ/RDS/KDS/EDS/... (see FIO.REC(FILORG)) * BlockSize: decimal value for the block size * RecordFormat: (see FIO.REC(RECFMT)) * RecordLength: decimal value for the record length * KeyLength: key length of VSAM KSDS * KeyPosition: key position of VSAM KSDS * SlotNumbers: Yes (8 byte slot number of an RRDS in front of the record) * PrintControl: Yes (1 byte print control character in front of the record) The printed values are decimal numbers or keywords used by FLCL. You can find a detailed description for each keyword if you search for it in this document. Below you can see an example for a PS-VBA dataset archived in a BZIP2 file using L4X length field for record separation: With the FORMAT parameter you can deactivate these extensions. * `NUMBER: FORMAT=OFF/STD/EXT - Format of ARMOR header (which information is printed) [EXT]` ** `OFF - Disable the printout of key value lines in ARMOR header` ** `STD - Only the standard key value pairs (Version, Comment, Chrset) for ARMOR header` ** `EXT - All available key value pairs are printed to ARMOR header (required for archiving)` * `STRING: HEADER='str' - String for the header [AUTO]` * `STRING: VERSION='str' - Version string as key value [AUTO]` * `STRING: COMMENT='str' - Comment string as key value [AUTO]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-archive_2098.html",
"ARCHIVE",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ARCHIVE]] ==== ARCHIVE indexterm:[Overlay, ARCHIVE, CONV.WRITE.BINARY.ARCHIVE] The overlay 'archive' allows you to choose an archive format to store the data in. Depending on the archive format selected, different parameters can be set. See below for the archiving options. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-archive-zip_1af0.html",
"ZIP",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ARCHIVE.ZIP]] ==== ZIP indexterm:[Object, ZIP, CONV.WRITE.BINARY.ARCHIVE.ZIP] Can be used to store one or more files in a ZIP archive. Files are compressed using the deflate algorithm unless another algorithm is set with the ALGO parameter. The compression level, the character set for filenames stored in the archive and a custom comment can be set. The supported compression algorithms are DEFLATE (default), BZIP2 and COPY (no compression). Note that many compression utilities do not support decompression of files not compressed with DEFLATE. If a file written to the ZIP archive is not compressible, it is stored in COPY mode automatically to avoid unnecessary CPU utilization. If compression or encryption has been enabled via the COMPRESS or ENCRYPT overlay of the surrounding WRITE.*() object (e.g. WRITE.BIN(COMPRESS.GZIP())), the resulting stream is written to the ZIP archive as-is, without attempting further compression (i.e. the resulting ZIP file has a .gz member that was written in COPY mode). By activating the APPEND switch, new members are appended to the ZIP file and existing members are replaced. If the REMAIN switch is enabled on append, an error occurs if a member already exists in the archive. If the APPEND switch is not used, but the REMAIN flag is set and the archive already exists, the archive is not overwritten. If this object is used to write records (WRITE.RECORD(ARCHIVE.ZIP())), each record is prepended with a 4 byte record length field in little endian (length field itself not included), conforming to PKWARE APPNOTE. If the PRNCONTROL parameter is set to RETAIN, then ASA or machine control characters are part of the record and included in the length field. When using WRITE.BINARY() or WRITE.CHAR() to write ZIP archives in combination with record-based input, the length field format can be configured, including dropping record length information. Archives larger than 4 GiB or containing more than 65535 members are supported with 64 bit ZIP archive support which some ZIP tools are not capable to read. Creation of 64 bit ZIP archives can be prevented by enforcing the 32 bit format. In this case, an error occurs when reaching one of the limits of the original ZIP format. The 64 bit format might be enforced too. If no format or 'FORMAT=AUTO' is given a backward compatible 32 bit format with 64 bit extensions for files smaller than 4 GiB are written. This format will result in a warning by 7z since version 19 and can be ignored. To prevent this warning Z32 or Z64 bit format must be enforced. NOTE: Writing ZIP archives requires repositioning within the file which is not supported for PDS(E) members on z/OS. Hence, ZIP archives cannot be written to a PO member. You can copy ZIP files to a PO member and read the ZIP archive from there, but you cannot write to it. You also cannot use the REMOVE switch when reading from a PO member, because this requires rewriting the ZIP archive. With the switch STREAM the streamed version of the ZIP file format is enforced while writing. This will improve performance if only sequential I/O is required and a record oriented dataset is used. If no format is given the Zip64 format will be written in this case. With 'FORMAT=Z32' the older version of a ZIP archive can be enforced if the stream doesn't exceed 4 GiB. With the switch NOXFLD you can deactivate the write of the FLAM private extra field to the local and directory file header. If this is used the ZIP file doesn't contain this private extension and the reconstruction of files with FLAM to the original format will fail, because not all required information are available for it. * `STRING: MEMBER='str' - File name for header [from origin]` * `NUMBER: ALGO=COPY/DEFLATE/BZIP2/XZ/ZSTD - Compression algorithm [DEFLATE]` ** `COPY - Store uncompressed` ** `DEFLATE - DEFLATE algorithm (GZIP)` ** `BZIP2 - BZIP2 algorithm (BZIP2)` ** `XZ - LZMA algorithm (XZ)` ** `ZSTD - ZSTD algorithm (ZSTD)` * `NUMBER: LEVEL=FAST/NORMAL/BEST - Compression level [AUTO]` ** `FAST - Fastest compression` ** `NORMAL - Optimal compression` ** `BEST - Highest compression` * `NUMBER: FORMAT=AUTO/Z32/Z64 - Choose the format to write [AUTO]` ** `AUTO - As needed (32 bit for small files and 64 for large ones)` ** `Z32 - Always 32 bit format (old)` ** `Z64 - Always 64 bit format (modern)` * `NUMBER: ENCODE=UTF8/DOS/ASCII - Select encoding for file names and comments [UTF-8]` ** `UTF8 - UTF-8 encoding (recommended)` ** `DOS - IBM437 encoding (old 8 bit ASCII of ZIP files))` ** `ASCII - IBM367 encoding (US ASCII (only 7 bit subset of UTF-8 and IBM437))` * `STRING: COMMENT='str' - Define a comment for this ZIP archive` * `SWITCH: NOXFLD - Don't write extra fields into the member header [FALSE]` * `SWITCH: STREAM - Write streamed ZIP file, uses only sequential I/O, no seek [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-archive-zip-mbratr_07d5.html",
"MBRATR",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ARCHIVE.ZIP.MBRATR]] ==== MBRATR indexterm:[Object, MBRATR, CONV.WRITE.BINARY.ARCHIVE.ZIP.MBRATR] The attribute object can be used to set file access permissions or file flags on Windows and Linux. Linux: read/write/execute permission for user/group/other Windows: archive, hidden, read only and system flags. It is also possible to add additional permissions to original permission: This adds execute permissions for everyone on Linux. * `SWITCH: ORIGINAL - Preserve attributes of input file / archive member` * `SWITCH: RUSR - Unix readable by owner` * `SWITCH: WUSR - Unix writable by owner` * `SWITCH: XUSR - Unix executable by owner` * `SWITCH: RGRP - Unix readable by group` * `SWITCH: WGRP - Unix writable by group` * `SWITCH: XGRP - Unix executable by group` * `SWITCH: ROTH - Unix readable by others` * `SWITCH: WOTH - Unix writable by others` * `SWITCH: XOTH - Unix executable by others` * `SWITCH: ARCHIVE - Windows archive flag` * `SWITCH: HIDDEN - Windows hidden flag` * `SWITCH: READONLY - Windows read only flag` * `SWITCH: SYSTEM - Windows system flag` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-archive-fl4_4db5.html",
"FL4",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.ARCHIVE.FL4]] ==== FL4 indexterm:[Object, FL4, CONV.WRITE.BINARY.ARCHIVE.FL4] Stores the data in a FLAM version 4 archive. You can specify various compression and encryption parameters for the created FLAMFILE. If the input data is not compressible, it is automatically stored in the FLAM archive with MODE=NDC (no data compression) as compressing already compressed data does not make sense. If the record-oriented writing method (write.record()) is used, the records, including all attributes, are written to the FLAM archive. If a block-oriented method (write.binary/char/text/xml()) is used, the data blocks are wrapped into records and written to the FLAMFILE as binary chunks with an undefined record format (U). NOTE: Since version 5.1.12, this object replaces the former FLAM4NDC switch, the FLAM4 object of the COMPRESS overlay (comp.flam4()) and the F4PWD/KME objects of the ENCRYPT overlay (encr.f4pwd() or encr.f4kme()). Passwords can be provided in four different ways: * In hexadecimal format (recommended): password=x'hex' * In ASCII format: PASSWORD=a'ascii' * In EBCDIC format: PASSWORD=e'ebcdic' * In local charset: PASSWORD='system' NOTE: Don't use the local charset variant if you wish to open the file on different platforms. To prevent passwords from being logged and for a better protection, we recommend to store passwords in files and use that password file instead passing the password directly. NOTE: In a password file, you can define the password in one of the variants described above. If the data is already compressed, then MODE=NDC (no data compression) is used. Otherwise, ADC compression is used. If you set the compression mode to CX7/CX8/VR8 then no encryption is possible. If you use the FLAM4 key management extension (FKME). The FLAM data key is provided by an FKME module. The library name, function name and corresponding parameter list must be provided. On mainframe systems, the load module name and the entry name must be identical, the load module must be in the STEPLIB concatenation and the library name is ignored. If only a function name is provided, then the default library name is '' on mainframes and 'libfkme' on other platforms. If only a library name is provided, the default function name 'FKMESTD0' is used. If no FKME parameter is provided then FKMESTD0 from the default library (see above) is used. The default FKMESTD0 returns a hardcoded key as encryption key identical to the default password. IMPORTANT: Encrypting using the default FKME is strongly discouraged in production as this equals using a publicly known password! The data is merely obfuscated. You may define the encryption mode. The default and recommended mode is AES. * `STRING: MEMBER='str' - File name for header [from origin]` * `NUMBER: CMPMODE=CX7/CX8/VR8/ADC/NDC - Compression mode [ADC]` ** `CX7 - Compression encoding as printable characters` ** `CX8 - Compression encoding as binary data` ** `VR8 - Enhanced compression encoding as binary data` ** `ADC - Advanced Data Compression` ** `NDC - No data compression` * `NUMBER: ENCMODE=OFF/AES/FLAMENC - Encryption mode [NONE]` ** `OFF - Disable encryption` ** `AES - AES encryption` ** `FLAMENC - FLAM encryption` * `STRING: COMMENT='str' - Comment for the member in the FLAMFILE [internal use]` * `STRING: PASSWORD/CRYPTOKEY='bin'/DEFAULT - Passphrase to encrypt the FLAMFILE ['']` ** `DEFAULT - FLAM4 default password` * `STRING: KMLIBRARY='str' - Library name for FKME ['']` * `STRING: KMFUNCTION='str' - Function name of FKME ['']` * `STRING: KMPARAMETER='bin' - Parameter for the call of FKME ['']` * `SWITCH: NOPATH - Exclude directory path of the original file in the compressed data [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table_6256.html",
"TABLE",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE]] ==== TABLE indexterm:[Object, TABLE, CONV.WRITE.BINARY.TABLE] The object 'format table' is used to describe the structure of the table rows to be written. A table can be in various formats (FB, VB, CSV, The table to be written can specified via row specifications that describe the columns of each row. A pre-defined output format can be used, together with some default settings, to reduce the number of parameters you need to specify for each column or to modify the behavior of the formats (e.g. change the CCSID, set delimiters, etc.). If no row specification is provided a default format, CCSID, record delimiter and other default values can be set depending on the format. These defaults are used to convert the tables based on the row specification in the internal table header. If no output format is defined, then the original table is written as close to the original as possible depending on the remaining default values. Row specifications allow to re-order or omit columns of the input table by using the original columns' names in the column specifications for the output table. An input column can also be written to multiple output columns, e.g. for obtaining different data formats of the same column. The table name is used to assign a row specification to a table in the list. If a read table's name does not match a row specification, an error will occur. More row specifications can be defined than required, but for each input table format, there must be a matching row specification. If you don't want output for one of the tables in the list (i.e. delete a table, then don't provide any column specification. A row specification without columns will not print any column, resulting in the table not being written at all. If the FLAM element list does not contain table header elements (which is only possible if an application uses the element interface to write an element list), then all row specifications are in charge and the first one that fits is used. In this case, it makes sense to use only one matching row specification. By default a headline is written, if all columns supports headlines. For example, this is the case if all columns are of type CSV. Headlines can be deactivated through the default settings. When the output is written as records: If all columns are defined as fixed-length, the sum of all column lengths will be the record length and the default record format is set to FB except a delimiter was defined at the end of the record (last column). If the maximum length is set for all variable length columns, then the sum is used as default record length for a VB dataset. Table formatting supports many powerful features which can be accessed with the parameters below. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` * `STRING: PATH/ROOT='str' - Define path to table (root) in a structured format (prefix for higher level)` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-format_4e90.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.FORMAT]] ==== FORMAT indexterm:[Parameter, FORMAT, CONV.WRITE.BINARY.TABLE.FORMAT] This selection is used to define a base output format for a table to simplify the corresponding row specifications. If a default format is specified, then only the columns which differ from the defaults must describe theses differences. For example: To write a CSV file that contains only the seventh, third and fifth column, it is sufficient to specify the three columns and their names and set the format and corresponding default values because they apply to all columns. By default, every column's value is enclosed in double quotes when writing in CSV format. If we don't want double quotes around the values in the second column, the row specification must be changed as follows: When specifying the format as FIX, there is no need to specify the format overlay in the column specification. Instead, the parameter MAXLEN or the synonym FIXLEN for the column must be set and the type defined. For format LFD, the type specification is required and each value will be encoded with a two bytes length field in local endianness, containing the length of the data (S2X) by default. The VAR format works like LFD except that you get a pointer to the data instead of the data itself and a length field after the pointer (PPTRLEN) which is 32 bit long and in local endianness. The format VAR is only useful and possible when writing to memory. An error occurs when attempting to read this format from a file. For the format DLM, the system specific text delimiter is the default delimiter and all data elements are converted to strings in the local character set. In other words, this format generates a text file with one line for each element. If row specifications and no format are provided, the original data is written. For fixed length, length fields and delimiter formats, the result will be binary equal to the original file. However, when writing CSV, strings are enclosed by double quotes by default, which may result in CSV output that is not binary equal to the original CSV file. A special behavior is implemented, if ORG is selected as format. In this case, the specified default settings are used to convert the data to the original form as close as possible. For example, by setting the SYSTEM switch as default, all strings are converted to the local character set, all binary integers, floats and length field are in system endianness, all text delimiter characters are changed to the system text delimiter, and so on. This mode is the default behavior if a table was read and 'write.record()' is used to write the table into records. * `ORG - Keep close as possible to the original but use the defaults` * `FIX - Write fixed-length records (length and type must be provided)` * `LFD - Write variable length elements based on default (S2X) length fields (type must be provided)` * `DLM - Write variable length elements separated by default delimiter (strings conversion done)` * `VAR - Write variable length elements as length pointer structure (only at write to memory)` * `CSV - Convert anything to a comma separated value stream (spread sheet)` * `TVD - Convert anything to a tag value delimiter text stream` * `XML - Convert anything to a XML (Extensible Markup Language) stream` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-defaults_4819.html",
"DEFAULTS",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.DEFAULTS]] ==== DEFAULTS indexterm:[Object, DEFAULTS, CONV.WRITE.BINARY.TABLE.DEFAULTS] Default values can be set for many values that would otherwise need to be specified for every single column. By setting defaults via this object, the values set here apply to all rows/columns which are defined within the same table object. The defaults set here can be overridden by specifying other values for the respective columns parameters. The SYSTEM switch can be used to ensure that everything is written in the system-specific representation. For example, length fields, binary integers and floats are written in system endianness, all strings are in local character set (encoding) and the system delimiters are used. * `NUMBER: TYPE=BINARY/STRING/INTEGER/FLOAT - Default data type used for conversion [NONE]` ** `BINARY - Write binary data` ** `STRING - Write a string data type` ** `INTEGER - Write a integer value` ** `FLOAT - Write a fractional numbers` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Default separator character as Unicode codepoint [COMMA]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDCHR=num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS - Default field enclosing character as Unicode codepoint [DQM]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: FLDMTD=ALWAYS/IFREQ/NONE - Default method for field enclosing character [ALWAYS]` ** `ALWAYS - Use always field enclosing characters` ** `IFREQ - Use field enclosing characters only if required` ** `NONE - Don't use field enclosing characters` * `NUMBER: RECDLM=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Define default record delimiter for automatic write [auto]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `SWITCH: NOHDLN - Deactivate writing of a headline by default [FALSE]` * `NUMBER: LENFLD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Default format of the length field in front of elements [original]` ** `L4I - Parse binary 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse binary 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse binary 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse binary 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse binary 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse binary 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse binary 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse binary 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse binary 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse binary 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse binary 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse binary 4 byte length fields: System endian short (LLxx), length exclusive` ** `L2I - Parse binary 2 byte length fields: Little endian integer, length inclusive` ** `L2X - Parse binary 2 byte length fields: Little endian integer, length exclusive` ** `B2I - Parse binary 2 byte length fields: Big endian integer, length inclusive` ** `B2X - Parse binary 2 byte length fields: Big endian integer, length exclusive` ** `S2I - Parse binary 2 byte length fields: System endian integer, length inclusive` ** `S2X - Parse binary 2 byte length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Parse binary 1 byte length fields: Length inclusive` ** `S1X - Parse binary 1 byte length fields: Length exclusive` ** `D1I - Parse decimal 1 byte length fields: Length inclusive` ** `D2I - Parse decimal 2 byte length fields: Length inclusive` ** `D3I - Parse decimal 3 byte length fields: Length inclusive` ** `D4I - Parse decimal 4 byte length fields: Length inclusive` ** `D5I - Parse decimal 5 byte length fields: Length inclusive` ** `D6I - Parse decimal 6 byte length fields: Length inclusive` ** `D7I - Parse decimal 7 byte length fields: Length inclusive` ** `D8I - Parse decimal 8 byte length fields: Length inclusive` ** `D9I - Parse decimal 9 byte length fields: Length inclusive` ** `D0I - Parse decimal 10 byte length fields: Length inclusive` ** `D1X - Parse decimal 1 byte length fields: Length exclusive` ** `D2X - Parse decimal 2 byte length fields: Length exclusive` ** `D3X - Parse decimal 3 byte length fields: Length exclusive` ** `D4X - Parse decimal 4 byte length fields: Length exclusive` ** `D5X - Parse decimal 5 byte length fields: Length exclusive` ** `D6X - Parse decimal 6 byte length fields: Length exclusive` ** `D7X - Parse decimal 7 byte length fields: Length exclusive` ** `D8X - Parse decimal 8 byte length fields: Length exclusive` ** `D9X - Parse decimal 9 byte length fields: Length exclusive` ** `D0X - Parse decimal 10 byte length fields: Length exclusive` * `STRING: ELMDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Default delimiter used to define end of element [original]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: FIXLEN=num - Default length for fixed-length fields (activate cut or padding) [original]` * `NUMBER: PADBYT=num - Default padding byte to pad data to the given fixed length [0x00]` * `NUMBER: ENCODE/DECODE=OFF/BASE16/BASE32/BASE64 - Default base encoding of binary data [BASE16(text output), NONE(binary output)]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `NUMBER: INTFMT=BIN/BCD/STR - Default format for integer values [auto]` ** `BIN - Integer in binary format (two's complement)` ** `BCD - Binary coded decimal (BCD) number` ** `STR - String representation of an integer` * `NUMBER: FLTFMT=BIN/BCD/STR - Default format for floating point values [auto]` ** `BIN - Floating point number in binary format` ** `BCD - Binary coded decimal (BCD) floating point number` ** `STR - String representation of an floating point number` * `STRING: INTVAL='str' - Default value used, to produce an empty integer string [NONE]` * `STRING: FLTVAL='str' - Default value (period) used, to produce an empty float string [NONE]` * `NUMBER: SIGMOD=IFNEGATIVE/SPACEIFPOSITIVE/PLUSIFPOSITIVE - Default handling of leading sign for numbers [IFNEGATIVE]` ** `IFNEGATIVE - Minus for negative values only, no sign if positive` ** `SPACEIFPOSITIVE - Minus for negative, space for positive values` ** `PLUSIFPOSITIVE - Minus for negative, plus for positive values` * `NUMBER: INTBAS=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Default base / radix for integers [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: INTCAS=UPPER/LOWER - Default upper or lower case for hexadecimal numbers [NONE]` ** `UPPER - Change character to upper case` ** `LOWER - Change character to lower case` * `NUMBER: FRASEP=SYSTEM/PERIOD/COMMA/APOSTROPHE - Default floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `SWITCH: FLTSIG - Default: float is signed [FALSE]` * `SWITCH: INTSIG - Default: integer is signed [FALSE]` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Default byte order for binary numbers [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: INTWID=num/W08/W16/W32/W64 - Default width of integer in bits [dynamic]` ** `W08 - 8 bit integer` ** `W16 - 16 bit integer` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` * `NUMBER: FLTWID=num/W32/W64 - Default width of floating point number in bits [64]` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` * `NUMBER: FLTTYP=SYSTEM - Default type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `NUMBER: BCDTYP=UNPACKED/PACKED/ZONED - Default BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: INTDIG=num - Default number of integral digits (before decimal separator)` * `NUMBER: FRADIG=num - Default number of fractional digits (after decimal separator)` * `NUMBER: FROUND=AWAYFROMZERO/NEAREST/TOWARDZERO/ERROR - Rounding method if fractional digits don't fit [TOWARDZERO]` ** `AWAYFROMZERO - Round fractional part away from zero (0.1 => 1; -0.1 => -1)` ** `NEAREST - Round fractional part toward nearest integer (0.1=>0; 0.5=>1; -0.5=>-1)` ** `TOWARDZERO - Round fractional part toward zero (=cut off) (0.9 => 0; -0.9 => 0)` ** `ERROR - Return an error instead of rounding a too long number` * `NUMBER: XMLSCM=STRUCTURED/UNSTRUCTURED - Default scheme for XML writing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `STRING: VALUE='str' - Default value, if structured formats require optional detection ['0' for float and integer else '']` * `SWITCH: USENID - Default to activate usage of null indication at write [FALSE]` * `SWITCH: USEINTEID - Use empty indication, don't print default value if read integer was an empty string [FALSE]` * `SWITCH: USEFLTEID - Use empty indication, don't print default value if read float was an empty string [FALSE]` * `SWITCH: NOESCP - Default to deactivate escaping of syntax elements [FALSE]` * `SWITCH: NOCHECK/NOCHEK/NOCHK - Default to deactivate different data checks [FALSE]` * `NUMBER: LINEFD=num - Default amount of line feeds in front of each line [1]` * `NUMBER: INDSIZE=num - Default indentation size for XML writing [2 if space, 1 if tab]` * `NUMBER: INDCHAR/INDCHR=SPACE/TABULATOR - Default indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `STRING: COMMENT='str' - Default comment for write operations [auto]` * `NUMBER: ALIGN=num - Default alignment for data fields in flat formats [1 (no alignment)]` * `SWITCH: SYSTEM - Enforce system character set, endianness, delimiter, etc. if nothing else is defined[FALSE]` * `SWITCH: TLRCLS - Close one additional level if trailer was written [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row_5f95.html",
"ROW",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW]] ==== ROW indexterm:[Object, ROW, CONV.WRITE.BINARY.TABLE.ROW] This object can be used to define different kinds of tables. Since table formatting is performed on each row, one row specification describes the structure of each row in the table. Columns can be re-ordered and/or eliminated. It is also possible to write the same column multiple times with different representations of the same value. Any conversions are performed per column. Data formats, character sets and various conversions can be mixed at will. A row specification supports many powerful features which can be used with the parameters below. * `STRING: NAME='str' - Logical name for a row format (table)` * `NUMBER: MAXLEN/FIXLEN=num - Maximum length of a row/record for plausibility checking [no limit]` * `SWITCH: HEADLN - Write a headline [FALSE]` * `STRING: PATH/ROOT='str' - Define path to row (root) in a structured format [name]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column_a2e8.html",
"COLUMN",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN]] ==== COLUMN indexterm:[Object, COLUMN, CONV.WRITE.BINARY.TABLE.ROW.COLUMN] Describes how a table column is written to the output, the format of the column, which post-processing steps are run (e.g. encryption) and how the produced data is put together to build a row/record. The value parameter allows to specify a default value for a column. If the column does not exist in the original, this default is used. With this mechanism, columns with constant values can be added. The parameter is a string and must represent the value depending on the column type: * NONE/BINARY: hexadecimal value, length must be multiple of 2 * STRING: string value in local charset, is converted to UTF-8 * INTEGER: decimal value or ENUM key word in local charset * FLOAT: real number with period as decimal separator in local charset You can control over the selection INSERT the error handling. If the INSERT parameter not defined and a default value is given, then INSERT will be set to POSSIBLE else to NOTALLOWED by default. You can enforce an error if the column present but INSERT is set to REQUIRED. You can additional disallow insertion if you define INSERT to NOTALLOWED. If you only provide the INSERT keyword this will assumed as POSSIBLE. The neutral format of the data can be validated or manipulated using a regular expression. A column specification supports many powerful features which can be accessed with the parameters below. * `STRING: NAME='str' - Logical name of the column` * `NUMBER: MINLEN=num - Required minimal length to enforce data in external format [0 - no length check]` * `NUMBER: MAXLEN/FIXLEN=num - Default fixed length or maximum allowed length [0 - no length check]` * `STRING: PATH='str' - Define path to element in a structured format [name]` * `STRING: ROOT='str' - Define root path to element in a structured data format` * `STRING: VALUE='str' - Optional default value, used to determine optional fields in structured data formats ['0' for float and integer else '']` * `NUMBER: INSERT=POSSIBLE/REQUIRED/NOTALLOWED - Define insert handling [if VALUE then POSSIBLE else NOTALLOWED]` ** `POSSIBLE - Insert of columns are possible, if column not found in table header` ** `REQUIRED - This column must be inserted and not found in the table header` ** `NOTALLOWED - Insert is not allowed, this means that the column must be found in the table header` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-type_d151.html",
"TYPE",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.TYPE]] ==== TYPE indexterm:[Overlay, TYPE, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.TYPE] The WRITE overlay for a element data conversion allows to choose a type specific conversion. It specifies how the data is converted from a neutral FLAM5 data type into an external representation. The currently supported data types and conversions are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-process_2a66.html",
"PROCESS",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS]] ==== PROCESS indexterm:[Overlay, PROCESS, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS] This array of overlays allows to run certain post-processings on the column data in front of forming the data to the output format. The input is the external represenation of the given data type. The result must fit in the format specified for write. The currently supported post-processings are explained in dedicated chapters below. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-process-mask_5833.html",
"MASK",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS.MASK]] ==== MASK indexterm:[Object, MASK, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS.MASK] This object can be used to mask strings as post-processing step. For this you can define the masking character (default is '*'), the character set, the start (6) and end points (4) and if the replacement is done for the inner or outer part. When writing, this component is useful to limit the PCIDSS environment. After correct masking, card holder data in another network segment is no longer in the scope of the payment card industry data security standard (PCIDSS). The masking is not invertible. A later pre-processing step while reading cannot reproduce the original data. * `NUMBER: CHAR=ASTERISK/MINUS/DOT/X - Masking character [ASTERISK]` ** `ASTERISK - Asterisk also known as star (0x2A for ASCII/UTF, 0x5C for EBCDIC)` ** `MINUS - Minus sign (0x2D for ASCII/UTF, 0x60 for EBCDIC)` ** `DOT - Dot sign (0x2E for ASCII/UTF, 0x4B for EBCDIC)` ** `X - Small x sign (0x2E for ASCII/UTF, 0xA7 for EBCDIC)` * `STRING: CCSID='str' - CCSID / Character encoding [auto]` * `NUMBER: HEAD=num - Number of characters at the beginning [if TAIL then 0 else 6]` * `NUMBER: TAIL=num - Number of characters at the end [if HEAD then 0 else 4]` * `NUMBER: CHANGE=INNER/OUTER - Mask inner or outer part [INNER]` ** `INNER - Mask inner part` ** `OUTER - Mask outer part` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-process-exit_ac17.html",
"EXIT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS.EXIT]] ==== EXIT indexterm:[Object, EXIT, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.PROCESS.EXIT] This object can be used to call a customer exit for column post- processing. You can set the filename of the library (libfcpe) which implements the different column processing functions. On mainframe systems, the library name can be an empty string to fetch load modules from the STEPLIB concatenation. Beside library and function name you must provide function-specific parameters. Please refer to the corresponding FCPE documentation to find out how these strings are to be specified. To write your own FLAM column processing exit (FCPE), you must implement the interface specified in 'FCPE.h' header file. It is independent of the platform and programming language. You must simply provide a DLL/SO or load module which implements one main entry. The interface specifies an open, run and close function. The parameter string is given to the open function, which returns a handle. The run function uses the handle to transform input data to the output data and the close function can be used to release resources allocated by the handle. The interface specification can be found under the link below: https://flam.de/ftp/FL5/doxygen/FCPE/ The processing component, which drives this exit, has limited (only the CCSID) possibilities to give attributes about the data to the exit. Your exit must fit with the data provided as input. On output all the data attributes except the CCSID are unknown and you must define the complete data representation for the next processor or the formatting component. This exit can be used to implement several validation, tokenization, anonymization or masking services. To be PCIDSS compliant, it can be used for individual column encryption or to build summaries over the column data. * `STRING: LIBRARY='str' - Exit library name` * `STRING: FUNCTION='str' - Exit function name` * `STRING: PARAMETER='str' - Exit function parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format_37b6.html",
"FORMAT",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT]] ==== FORMAT indexterm:[Overlay, FORMAT, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT] When writing a column of a row, it is important to write it in a structured way, so that it is possible identify a column in a row when it is read later on. This overlay is intended to specify how a column is written. It can be used to either specify the length directly, or to embed the length or end of column marker in the written data. The currently supported data formats are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-fix_3c02.html",
"FIX",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.FIX]] ==== FIX indexterm:[Object, FIX, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.FIX] Writes the data of this column as a byte sequence with a fixed length. If no length is specified, then the length of the element is used. If the length parameter is provided, then the element length must match the set length. Otherwise, you have to active the appropriate switches to cut or pad the data to the desired length. An alignment can be used to pad each cell to the next multiple of the specified byte count, so that the next column starts at a pre-defined offset. The bytes in between are padded with binary zeros unless the padding byte is set to a different value. * `NUMBER: LENGTH=num - Fixed length for the data field [0 = length of data is used, no padding, no cutting]` * `SWITCH: CUTDAT - Cut data if longer than LENGTH [FALSE]` * `SWITCH: ADDPAD/REMPAD - Pad data to the given length as necessary [FALSE]` * `NUMBER: PADBYT=num - Padding byte value to use [0x00]` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-lfd_e423.html",
"LFD",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.LFD]] ==== LFD indexterm:[Object, LFD, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.LFD] This object is used to write a length field in front of every cell's data. An alignment can be used to pad each cell to the next multiple of the specified byte count, so that the next column starts at a pre-defined offset. The bytes in between are padded with binary zeros. * `NUMBER: LENFMT=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Format of the length field [S2X (VARCHAR)]` ** `L4I - Adds 4 byte binary length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte binary length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte binary length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte binary length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte binary length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte binary length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte binary length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte binary length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte binary length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte binary length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte binary length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte binary length fields: System endian short (LL00), length exclusive` ** `L2I - Adds 2 byte binary length fields: Little endian integer, length inclusive` ** `L2X - Adds 2 byte binary length fields: Little endian integer, length exclusive` ** `B2I - Adds 2 byte binary length fields: Big endian integer, length inclusive` ** `B2X - Adds 2 byte binary length fields: Big endian integer, length exclusive` ** `S2I - Adds 2 byte binary length fields: System endian integer, length inclusive` ** `S2X - Adds 2 byte binary length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Adds 1 byte binary length fields: Length inclusive` ** `S1X - Adds 1 byte binary length fields: Length exclusive` ** `D1I - Adds 1 byte decimal length fields: Length inclusive` ** `D2I - Adds 2 byte decimal length fields: Length inclusive` ** `D3I - Adds 3 byte decimal length fields: Length inclusive` ** `D4I - Adds 4 byte decimal length fields: Length inclusive` ** `D5I - Adds 5 byte decimal length fields: Length inclusive` ** `D6I - Adds 6 byte decimal length fields: Length inclusive` ** `D7I - Adds 7 byte decimal length fields: Length inclusive` ** `D8I - Adds 8 byte decimal length fields: Length inclusive` ** `D9I - Adds 9 byte decimal length fields: Length inclusive` ** `D0I - Adds 10 byte decimal length fields: Length inclusive` ** `D1X - Adds 1 byte decimal length fields: Length exclusive` ** `D2X - Adds 2 byte decimal length fields: Length exclusive` ** `D3X - Adds 3 byte decimal length fields: Length exclusive` ** `D4X - Adds 4 byte decimal length fields: Length exclusive` ** `D5X - Adds 5 byte decimal length fields: Length exclusive` ** `D6X - Adds 6 byte decimal length fields: Length exclusive` ** `D7X - Adds 7 byte decimal length fields: Length exclusive` ** `D8X - Adds 8 byte decimal length fields: Length exclusive` ** `D9X - Adds 9 byte decimal length fields: Length exclusive` ** `D0X - Adds 10 byte decimal length fields: Length exclusive` * `NUMBER: CHRSET=SYSTEM/ASCII/EBCDIC/LOCAL - Character set for decimal digits [auto]` ** `SYSTEM - Use default system code page` ** `ASCII - Use ASCII (UTF-8) code page` ** `EBCDIC - Use EBCDIC code page` ** `LOCAL - Use real local code page` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-dlm_3f06.html",
"DLM",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.DLM]] ==== DLM indexterm:[Object, DLM, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.DLM] This object is used to write a column with a trailing binary delimiter. An alignment can be used to pad each cell to the next multiple of the specified byte count, so that the next column starts at a pre-defined offset. The bytes in between are padded with binary zeros. * `STRING: DELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter written after the data element` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-var_db5c.html",
"VAR",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.VAR]] ==== VAR indexterm:[Object, VAR, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.VAR] This object is used to write a column as certain length pointer structure to memory. An alignment can be used to pad each cell to the next multiple of the specified byte count, so that the next column starts at a pre-defined offset. * `NUMBER: METHOD=PLENPTR/ALENPTR/PPTRLEN/APTRLEN/PFLGLENPTR/PPTRLENFLG - Sets field order of buffer pointer and pointer length as well as padding [PFLGLENPTR]` ** `PLENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; no padding (packed) (8/12 bytes on 32/64 bit systems)` ** `ALENPTR - Buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length; with memory alignment (unpacked) (8/16 bytes on 32/64 bit systems)` ** `PPTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; no padding (packed) (8/12 bytes on 32/64 bit systems)` ** `APTRLEN - Pointer in architecture-specific length followed by buffer length as 32 bit (system endian) integer; with memory alignment (unpacked) (8/12 bytes on 32/64 bit systems)` ** `PFLGLENPTR - 32 bit flag word (system endian), buffer length as 32 bit (system endian) integer followed by pointer in architecture-specific length (12/16 bytes on 32/64 bit systems)` ** `PPTRLENFLG - Pointer in architecture-specific length, buffer length as 32 bit (system endian) integer followed by 32 bit flag word (system endian) (12/16 bytes on 32/64 bit systems)` * `NUMBER: ALIGN=num - Align data in the buffers pointed at to the next multiple of this value in bytes [1 (no alignment)]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-csv_1a41.html",
"CSV",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.CSV]] ==== CSV indexterm:[Object, CSV, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.CSV] This object is used to write a column as one manifestation of columns in the CSV format. The field separator, field enclosing character and record delimiter can be configured as needed. A special behavior is implemented for brackets. If one of the opening brackets '(<{[' is selected as field enclosing character, then the fields of the column start with the specified bracket and end with the corresponding closing bracket. If the data field contains the field enclosing character, then this character is escaped by doubling the character. An alignment can be used to pad each cell of a column with whitespace characters to make the sheet human readable. * `STRING: COLNAM='str' - Name of the column in the CSV header [COLUMN-NAME]` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set for the CSV column [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Separator character as Unicode codepoint [COMMA]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDMTD=ALWAYS/IFREQ/NONE - When to write field enclosing characters [ALWAYS]` ** `ALWAYS - Use always field enclosing characters` ** `IFREQ - Use field enclosing characters only if required` ** `NONE - Don't use field enclosing characters` * `NUMBER: FLDCHR=num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS - Field enclosing character as Unicode codepoint [DQM]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: RECDLM=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Which record delimiter to use after each row [auto]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `NUMBER: ALIGN=num - Align data to the next multiple of this value in bytes [1 (no alignment)]` * `SWITCH: NOCHECK/NOCHEK/NOCHK - Don't check if field enclosing character is required [OFF]` * `SWITCH: NOESCP - Don't escape field enclosing character in the data [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-tvd_250b.html",
"TVD",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.TVD]] ==== TVD indexterm:[Object, TVD, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.TVD] This object is used to write a column with data that is enclosed by a tag and a trailing delimiter. The format was mainly developed to write SWIFT MT transaction data but can also be used for other complex hierarchical text formats such as XML or JSON. The format can have an arbitrary hierarchical depth. This is expressed via a path specification with an opening tag and a closing delimiter, with each level separated by a slash. If TVD data from an underlying tag and delimiter are included, they can occur in any order. If this is not the case, the order must correspond to the information in the row specification. In such hierarchical formats, the beginning of the table is determined by the beginning of the repeating data. This beginning is indicated by the longest root path. The repeating data can itself be structured arbitrarily deep, which is indicated by a further path specification. The repeating data can be preceded by so-called headers or followed by trailer data. This header data is distinguished by a shorter root specification which must be placed before the repeating data as a template in the row specifications. The same applies to trailer data, except that it must follow after the repeating data. A short root in between will result in an error. A change in the header or trailer data, leads to an interruption of the table to output the changed header data. The main differences between TVD and the explicit XML and JSON as part of the table support are: * The format definitions for XML or JSON in the TVD root and path syntax   are much more complex. * The TVD processor knows nothing about JSON or XML. That is why no   plausibility checks are possible. * The explicit XML and JSON processors do not support mixed formats. The   whole data stream must be in JSON or XML format. The TVD format can   be mixed with any other format except XML and JSON. * Some validations (e.g. exist a required branch with only optional   fields) are not implemented with TVD. The format validation for XML   or JSON is higher. The column specification can be split into three parts. The middle part consists of the columns with the longest root, defining the repeating data portion. In front of it, it is possible to define header values with a shorter root and trailer values after the repeating data, also with a shorter root. Trailer values are not known at the beginning. Therefore they are optional by default. With the switch TLRCLS, you can enforce to close one additional level after the last trailer value was written. This is required for JSON but useless for SWIFT-MT, for example. For the definition of root and path strings please refer to the documentation for <<tvd.rootpath,reading TVD data>>. The differences for writing the TVD format are explained below: Only the first tag or delimiter is written if alternative/aliases are defined in the strings. The default value is used to determine if an optional value must be written (identical) or not (value differs from the default). Additionally, the `USENID` switch can be activated to use the null indication. In this case, a tag containing the default value is written, if it was present in the original file (the null indicator was not defined). When writing, indentation, the character code points used for the indentation and the code points for a line break can be defined. The indentation is done if a new line printed at the end of a tag or delimiter. With `\\N` you can enforce new lines at the end of an tag or delimiter. In the case a tag ends with a new line, then the value is intended and also for the corresponding delimiter an indentation is done, if this delimiter starts with a new line.  The CCSID specified in format.tvd() is only valid for the tag and the delimiter. As default the CCSID of the value is used, which is determined by the type converter or the interconnected post processors. If using a definition with fixed length (`%%...%%` or `%n`), this specifies the number of characters which will be validated. In this case the CCSID defined in format.tvd() is used. That means that the fixed data will be interpreted in this character set and checked that they correspond to this length. In this case the charset for the tags and delimiters should be the same as the charset of the value, otherwise odd effects may be the result.  The escape sequences below are available when writing to enable the use of the same root/path for reading and writing the same file structure with the same string. They are usually not required to build a root/path string that is specified for writing only. These escape sequences are replaced by the following fixed values unless they are part of a push back: * `\\z`   replaced by 'a' * `\\m`   replaced by 'a' * `\\a`   replaced by 'a' * `\\l`   replaced by 'a' * `\\u`   replaced by 'A' * `\\d`   replaced by '0' * `\\x`   replaced by '0' * `\\p`   replaced by '.' * `\\s`   replaced by newline ('\n') Normally these character classes are used in read mode to match different options of data items and should be part of a push back amount and not part of the written tag or delimiter. The special escape sequences below can be used to write formats containing separators (like JSON) and for formatting the output with newline and space characters. * `\\B`  is replaced by ' ' (whitespace) * `\\N`  is replaced like '\n' (newline) * `\\C`  is replaced by a comma and a line break (i.e. ',\n'),          but only if there is another element that follows. * `\\c`  is replaced by a comma and space characters (i.e. ', '),          but only if there is another element that follows. * `\\k`  is replaced by a comma (i.e. ','),          but only if there is another element that follows. The upper case character classes for termination of tags or delimiters described <<tvd.characterclasses,here>> are not relevant when writing. The tabulator ('\t') is replaced by the code point 0x0009. The code points for newline ('\n') can be set via the corresponding selection. The separator character's code point can also be set and defaults to comma. If a list of separators is defined, the first of them will be used. Below is a JSON example (Row definition with possible data as comment): Now the same sample as XML (Row definition with data as comment): The attribute list in the XML tags are parsed as additional level, where the start tag (`<menu`) and start end tag (`>`) are used as tag and delimiter. The start tag (`<menu`) has also a corresponding end tag (`</menu>`) in the level below. For this to work, this start tag must be provided with a push back (`\\<menu\\W<*` (in full length (no digit behind `<`))), so that it can be read again in the next level for the attribute list. And last but not least the CSV portion for the same data (the data below will be the default data format, if the tables above written as text): For this it would be better to use the CSV format for this (control about the headline), but it is also possible to parse CSV with TVD support. By default, if a column value changes between two table rows, and this column is specified with a 'short root', only the changed value is written out, even if multiple column specifications with the same root exist. In order to write out all columns with the same root if the data in one of the columns changes between rows, put an additional `!` after the mandatory/optional modifier at the beginning of the root string.  Below is an example for SWIFT MT103 message which demonstrates the additional `!` modifier. The complete definition is provided together with the example file MT101 in your FLAM installation. The HSPF header and TSPF trailer in the above example are printed if a change in the basic, application or user header block occurs. For more information about the root and path strings, please read the explanations about <<tvd.rootpath,parsing the TVD format>>. To write records, the delimiter of the TVD format must be used. The BLK2REC switch should be activated for this in the CONV command. If the XCNV command is used, then a block to record conversion (`CNV.REC()`) must be added, if each line should be a record in the data set or FLAMFILE. * `STRING: ROOT='str' - Root to XML element [taken from table/row/column]` * `STRING: PATH='str' - Path to XML element [taken from column]` * `STRING: VALUE='str' - Optional default value, to determine if a element optional ['0' for float and integer else '']` * `STRING: CCSID='str'/DEFAULT/ASCII/EBCDIC/SYSTEM/LOCAL - Conversion from UTF-8 to this CCSID [system]` ** `DEFAULT - Use default CCSID (environment)` ** `ASCII - Use default ASCII CCSID (environment)` ** `EBCDIC - Use default EBCDIC CCSID (environment)` ** `SYSTEM - Use system character set (same as DEFAULT)` ** `LOCAL - Use local character set (system/physical)` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Separator character as Unicode codepoint [COMMA]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: INDSIZE=num - Define indentation size for writing [2 if space, 1 if tab else 0]` * `NUMBER: INDCHAR/INDCHR=SPACE/TABULATOR - Indentation character used to indent TVD tags [NONE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `NUMBER: NLNCHAR/NLNCHR=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Codepoints used for new lines (\n) in tags and delimiters [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `SWITCH: TLRCLS - Close one additional level if trailer was written [FALSE]` * `SWITCH: USENID - Use null indication for write [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-xml_e964.html",
"XML",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.XML]] ==== XML indexterm:[Object, XML, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.XML] This object is used to transform data stored in table format into an XML document. If one column format is set to XML, then all column formats of all row specifications must be set to XML. Data elements are addressed via root and path strings in a hierarchical path syntax. The syntax equals that of the corresponding 'read' object. So, please refer to its documentation first to understand the underlying concepts. The only difference when writing XML is the '%' and '!' characters. The '%' can be used to put a data element inside a CDATA section. In this example, the value under the path table/row/complex/value is put inside a CDATA section due to the % before the leaf's name: The '!' character can be used to enforce print of a complete branch if a header change was detected. By default only for the changed value the print flag is activated. If it is required to print the whole branch if a column change was detected as part of this branch then this branch must be mark with '!' in the root or path definition of the header column. This is also required if a lower start level must be ensured if a header change was detected. Below you can find a sample for some SEPA XML format, where the complete branch'BBkDNF:FIToFICstmrDrctDbt' must be printed if a header change in such a column occur: Hint: When reading, the '%' and '!' is optional and ignored, so the same root/path definition can be used for both, reading and writing XML. To support different EBCDIC code pages the pipe symbol '|' will be a synonym for '!'. The '!' at read is used for the last path component (leaf) to disallow empty fields and at write it can be used somewhere on the path but not for the leaf. If no root path is specified, then '<table/row>' is the default when using the structured XML scheme and '<table>' is used for the unstructured scheme. This means that, the root path should contain at least two elements in the structured version: One to enclose the whole document/table (i.e. the root tag) and the second to enclose each row. By default, the table name of the row specification is used to enclose the table (as root tag) in the structured and unstructured variant. In the structured scheme there is no default name to enclose each row and the literal 'row' is then used to build a valid structured XML document. Since version 5.1.25 of FLAM XML files with only one level are supported in the structured version, if the root and path given. This is required if only a header as one line/row/transaction in the data (SWIFT-MX). When writing, the order of the columns defines the order of elements in the XML document. Therefore, branches with multiple sub-branches and tags must be grouped together. Otherwise, they are written out as multiple distinct branches. By default, each element is printed on a separate line with, indented by 2 whitespace characters (pretty printing). The indentation amount and character can be configured, if needed. If the tabulator is used, then the default indentation amount is 1. The number of line feeds printed between elements can be controlled as well. By setting the LINEFD and INDSIZE parameters to 0, a minimized output without any added whitespace or line breaks is generated. By default, characters that are part of the XML syntax, are written as escape sequences as required by the XML specification (e.g. & => &amp;). Scanning for these characters has a performance impact. If the processed data is known to not contain any of these characters (e.g.: <>''&) and performance is important, the NOESCP flag can be set. This disables the scanning of all data for characters that need to be escaped, speeding up the writing of the XML document. If data is written as a CDATA section (element name prefixed with %) and the data contains the CDATA end sequence ']]>', that sequence leads to a split of the CDATA section into two CDATA sections to prevent a premature end of the CDATA section (and thus a broken XML document): ']]]]><![CDATA[>' This behavior is also disabled if the NOESCP flag is set. For the structured version, which accounts for the beginning and end of a row, optional values and branches are supported by using the question mark (?) in the path. The logic to determine if a value or a branch is optional and must not be printed, depends on the provided default value. If the value in the table equals the provided default value and the item is marked as optional, then this item will not be printed. For a branch, all items within this optional branch must match the default value to make this branch optional. If an optional branch's children contain at least one non-default value, then all non-optional children of this branch are printed. The default value for binary and strings is the empty string. For integer and float types, '0' is the default value. For optional fields, a null indication is implemented when reading. When writing a null-indication-dependent procedure can be activated. If an optional value in the XML data is equal to the defined default value, the value is not written, except if the null-indication is used when writing. This, however, only works if no other format is in between where the null indication information is lost. With the VAR formats PFLGLENPTR and PPTRLENFLG, you can define the null-indication bit through the flag word or keep it between read and write operation. To print header values, the value must differ between the last and the current row. In this case, the table end and table begin processing is done based on the differences in the header values. When reading XML, actual data can exist anywhere within the XML tree: This XML document can be read with the following row specification: However, writing data into non-leaf XML tags is currently not supported. Writing the same data with the row specification above, results in the XML document below: This version can be read with the same row specification. If writing data into non-leaf parts of an XML branch is a necessity, please contact us for a solution. XML name spaces must normally be handled by the application. Since version 5.1.24 with the selection 'PREFIX' the name space abbreviations can be exclude from tag comparisons. At write this requires, that only tree wide name space definitions are possible and must be defined as attribute for this tree by the application. In a later version we plan to support name space objects to define the name space URI for each column. At read this URI will be validated unless the prefix selection is defined. At write the name space will be defined if possible per tree and only for elements where a local name space is required the given name space abbreviation is used. For SEPA, SWIFT-MX or other complex formats it would be useful to use a row definition generator using the specification given XSD or something like this. In this case it would be useful to generate each format as an own row specification into a simple text file. Later you can build several table specification be combining these different generated row specifications. In this example a central format server is used as repository for all row specification available in the company. The access is done per SSH and the format descriptions are encoded in UTF-8. * `STRING: ROOT='str' - Root to XML element [taken from table/row/column]` * `STRING: PATH='str' - Path to XML element [taken from column]` * `STRING: VALUE='str' - Optional default value, to determine if a element optional ['0' for float and integer else '']` * `STRING: COMMENT='str' - Add a comment to the XML data stream [default]` * `NUMBER: SCHEME=STRUCTURED/UNSTRUCTURED - Scheme for XML writing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `NUMBER: LINEFD=num - Amount of line feeds in front of each line [1]` * `NUMBER: INDSIZE=num - Define indentation size for XML writing [2 if space, 1 if tab]` * `NUMBER: INDCHAR/INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: USENID - Use null indication for write [FALSE]` * `SWITCH: NOESCP - Don't escape XML syntax elements (prevent double read and copy of data to add &...; sequences) [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-column-format-rst_b9c0.html",
"RST",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.RST]] ==== RST indexterm:[Object, RST, CONV.WRITE.BINARY.TABLE.ROW.COLUMN.FORMAT.RST] This object is used to write data up to a certain offset into the record. Normally such columns are added and have no data, in this case the padding byte if used as filler. If data is provided then the padding is done for the remining gap or if the provided data longer then the rest up to the offset the data will be cut off. * `NUMBER: OFFSET=num - Absolute offset to write a rest into the output data` * `NUMBER: PADBYT=num - Padding value to fill up the remaining bytes [0x00]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-binary-table-row-defaults_369c.html",
"DEFAULTS",
"[[CLEP.COMMAND.CONV.WRITE.BINARY.TABLE.ROW.DEFAULTS]] ==== DEFAULTS indexterm:[Object, DEFAULTS, CONV.WRITE.BINARY.TABLE.ROW.DEFAULTS] Default values can be set for many values that would otherwise need to be specified for every single column. By setting defaults via this object, the values set here apply to all columns which are defined within the same row object. The defaults set here can be overridden by specifying other values for the respective columns parameters. The SYSTEM switch can be used to ensure that everything is written in the system-specific representation. For example, length fields, binary integers and floats are written in system endianness, all strings are in local character set (encoding) and the system delimiters are used. * `NUMBER: TYPE=BINARY/STRING/INTEGER/FLOAT - Default data type used for conversion [NONE]` ** `BINARY - Write binary data` ** `STRING - Write a string data type` ** `INTEGER - Write a integer value` ** `FLOAT - Write a fractional numbers` * `NUMBER: SEPCHR[num/COMMA/COLON/SEMICOLON/TABULATOR/BLANK...] - Default separator character as Unicode codepoint [COMMA]` ** `COMMA - Comma separated (default)` ** `COLON - Separated by colon (':')` ** `SEMICOLON - Separated by semicolon (';')` ** `TABULATOR - Separated by tabulator (x'0009')` ** `BLANK - Separated by blank (x'0020')` * `NUMBER: FLDCHR=num/QUOTATION/APOSTROPHE/GRAVEACCENT/PARENTHESES/RBRACKETS/SBRACKETS/BRACES/CBRACKETS/ABRACKETS - Default field enclosing character as Unicode codepoint [DQM]` ** `QUOTATION - Quotation mark as enclosing character` ** `APOSTROPHE - Apostrophe as enclosing character` ** `GRAVEACCENT - Grave accent as enclosing character` ** `PARENTHESES - Round brackets as enclosing character` ** `RBRACKETS - Round brackets as enclosing character` ** `SBRACKETS - Square brackets as enclosing character` ** `BRACES - Curly brackets as enclosing character` ** `CBRACKETS - Curly brackets as enclosing character` ** `ABRACKETS - Angle brackets as enclosing character` * `NUMBER: FLDMTD=ALWAYS/IFREQ/NONE - Default method for field enclosing character [ALWAYS]` ** `ALWAYS - Use always field enclosing characters` ** `IFREQ - Use field enclosing characters only if required` ** `NONE - Don't use field enclosing characters` * `NUMBER: RECDLM=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Define default record delimiter for automatic write [auto]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `SWITCH: NOHDLN - Deactivate writing of a headline by default [FALSE]` * `NUMBER: LENFLD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/L2I/L2X/B2I/B2X/S2I/S2X/S1I/S1X/D1I/D2I/D3I/D4I/D5I/D6I/D7I/D8I/D9I/D0I/D1X/D2X/D3X/D4X/D5X/D6X/D7X/D8X/D9X/D0X - Default format of the length field in front of elements [original]` ** `L4I - Parse binary 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse binary 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse binary 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse binary 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse binary 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse binary 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse binary 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse binary 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse binary 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse binary 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse binary 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse binary 4 byte length fields: System endian short (LLxx), length exclusive` ** `L2I - Parse binary 2 byte length fields: Little endian integer, length inclusive` ** `L2X - Parse binary 2 byte length fields: Little endian integer, length exclusive` ** `B2I - Parse binary 2 byte length fields: Big endian integer, length inclusive` ** `B2X - Parse binary 2 byte length fields: Big endian integer, length exclusive` ** `S2I - Parse binary 2 byte length fields: System endian integer, length inclusive` ** `S2X - Parse binary 2 byte length fields: System endian integer, length exclusive (VARCHAR)` ** `S1I - Parse binary 1 byte length fields: Length inclusive` ** `S1X - Parse binary 1 byte length fields: Length exclusive` ** `D1I - Parse decimal 1 byte length fields: Length inclusive` ** `D2I - Parse decimal 2 byte length fields: Length inclusive` ** `D3I - Parse decimal 3 byte length fields: Length inclusive` ** `D4I - Parse decimal 4 byte length fields: Length inclusive` ** `D5I - Parse decimal 5 byte length fields: Length inclusive` ** `D6I - Parse decimal 6 byte length fields: Length inclusive` ** `D7I - Parse decimal 7 byte length fields: Length inclusive` ** `D8I - Parse decimal 8 byte length fields: Length inclusive` ** `D9I - Parse decimal 9 byte length fields: Length inclusive` ** `D0I - Parse decimal 10 byte length fields: Length inclusive` ** `D1X - Parse decimal 1 byte length fields: Length exclusive` ** `D2X - Parse decimal 2 byte length fields: Length exclusive` ** `D3X - Parse decimal 3 byte length fields: Length exclusive` ** `D4X - Parse decimal 4 byte length fields: Length exclusive` ** `D5X - Parse decimal 5 byte length fields: Length exclusive` ** `D6X - Parse decimal 6 byte length fields: Length exclusive` ** `D7X - Parse decimal 7 byte length fields: Length exclusive` ** `D8X - Parse decimal 8 byte length fields: Length exclusive` ** `D9X - Parse decimal 9 byte length fields: Length exclusive` ** `D0X - Parse decimal 10 byte length fields: Length exclusive` * `STRING: ELMDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Default delimiter used to define end of element [original]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: FIXLEN=num - Default length for fixed-length fields (activate cut or padding) [original]` * `NUMBER: PADBYT=num - Default padding byte to pad data to the given fixed length [0x00]` * `NUMBER: ENCODE/DECODE=OFF/BASE16/BASE32/BASE64 - Default base encoding of binary data [BASE16(text output), NONE(binary output)]` ** `OFF - No en/decoding (copy)` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `NUMBER: INTFMT=BIN/BCD/STR - Default format for integer values [auto]` ** `BIN - Integer in binary format (two's complement)` ** `BCD - Binary coded decimal (BCD) number` ** `STR - String representation of an integer` * `NUMBER: FLTFMT=BIN/BCD/STR - Default format for floating point values [auto]` ** `BIN - Floating point number in binary format` ** `BCD - Binary coded decimal (BCD) floating point number` ** `STR - String representation of an floating point number` * `STRING: INTVAL='str' - Default value used, to produce an empty integer string [NONE]` * `STRING: FLTVAL='str' - Default value (period) used, to produce an empty float string [NONE]` * `NUMBER: SIGMOD=IFNEGATIVE/SPACEIFPOSITIVE/PLUSIFPOSITIVE - Default handling of leading sign for numbers [IFNEGATIVE]` ** `IFNEGATIVE - Minus for negative values only, no sign if positive` ** `SPACEIFPOSITIVE - Minus for negative, space for positive values` ** `PLUSIFPOSITIVE - Minus for negative, plus for positive values` * `NUMBER: INTBAS=num/BIN/B02/OCT/B08/DEC/B10/HEX/B16 - Default base / radix for integers [DECIMAL]` ** `BIN - Binary base (2)` ** `B02 - Base 2 (binary)` ** `OCT - Octal base (8)` ** `B08 - Base 8 (octal)` ** `DEC - Decimal base (10)` ** `B10 - Base 10 (decimal)` ** `HEX - Hexadecimal base (16)` ** `B16 - Base 16 (hexadecimal)` * `NUMBER: INTCAS=UPPER/LOWER - Default upper or lower case for hexadecimal numbers [NONE]` ** `UPPER - Change character to upper case` ** `LOWER - Change character to lower case` * `NUMBER: FRASEP=SYSTEM/PERIOD/COMMA/APOSTROPHE - Default floating point separator [SYSTEM]` ** `SYSTEM - Use locale dependent separator` ** `PERIOD - Use period (.) as separator` ** `COMMA - Use comma (,) as separator` ** `APOSTROPHE - Use apostrophe (') as separator` * `SWITCH: FLTSIG - Default: float is signed [FALSE]` * `SWITCH: INTSIG - Default: integer is signed [FALSE]` * `NUMBER: ENDIAN=SYSTEM/BIG/LITTLE/LOCAL - Default byte order for binary numbers [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` * `NUMBER: INTWID=num/W08/W16/W32/W64 - Default width of integer in bits [dynamic]` ** `W08 - 8 bit integer` ** `W16 - 16 bit integer` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` * `NUMBER: FLTWID=num/W32/W64 - Default width of floating point number in bits [64]` ** `W32 - 32 bit integer` ** `W64 - 64 bit integer` * `NUMBER: FLTTYP=SYSTEM - Default type of floating point format [SYSTEM]` ** `SYSTEM - Floating-point representation of the system's architecture` * `NUMBER: BCDTYP=UNPACKED/PACKED/ZONED - Default BCD type [UNPACKED]` ** `UNPACKED - Unpacked BCD number` ** `PACKED - Packed BCD number` ** `ZONED - Zoned BCD number` * `NUMBER: INTDIG=num - Default number of integral digits (before decimal separator)` * `NUMBER: FRADIG=num - Default number of fractional digits (after decimal separator)` * `NUMBER: FROUND=AWAYFROMZERO/NEAREST/TOWARDZERO/ERROR - Rounding method if fractional digits don't fit [TOWARDZERO]` ** `AWAYFROMZERO - Round fractional part away from zero (0.1 => 1; -0.1 => -1)` ** `NEAREST - Round fractional part toward nearest integer (0.1=>0; 0.5=>1; -0.5=>-1)` ** `TOWARDZERO - Round fractional part toward zero (=cut off) (0.9 => 0; -0.9 => 0)` ** `ERROR - Return an error instead of rounding a too long number` * `NUMBER: XMLSCM=STRUCTURED/UNSTRUCTURED - Default scheme for XML writing [STRUCTURED]` ** `STRUCTURED - Structured XML with enclosing tag for each row` ** `UNSTRUCTURED - Unstructured XML with enclosing tag only for the table` * `STRING: VALUE='str' - Default value, if structured formats require optional detection ['0' for float and integer else '']` * `SWITCH: USENID - Default to activate usage of null indication at write [FALSE]` * `SWITCH: USEINTEID - Use empty indication, don't print default value if read integer was an empty string [FALSE]` * `SWITCH: USEFLTEID - Use empty indication, don't print default value if read float was an empty string [FALSE]` * `SWITCH: NOESCP - Default to deactivate escaping of syntax elements [FALSE]` * `SWITCH: NOCHECK/NOCHEK/NOCHK - Default to deactivate different data checks [FALSE]` * `NUMBER: LINEFD=num - Default amount of line feeds in front of each line [1]` * `NUMBER: INDSIZE=num - Default indentation size for XML writing [2 if space, 1 if tab]` * `NUMBER: INDCHAR/INDCHR=SPACE/TABULATOR - Default indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `STRING: COMMENT='str' - Default comment for write operations [auto]` * `NUMBER: ALIGN=num - Default alignment for data fields in flat formats [1 (no alignment)]` * `SWITCH: SYSTEM - Enforce system character set, endianness, delimiter, etc. if nothing else is defined[FALSE]` * `SWITCH: TLRCLS - Close one additional level if trailer was written [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-character_2487.html",
"CHARACTER",
"[[CLEP.COMMAND.CONV.WRITE.CHARACTER]] ==== CHARACTER indexterm:[Object, CHARACTER, CONV.WRITE.CHARACTER] Write character formats all UTF-8 text elements to one block. With this UTF-8 based text block a character set conversion is done. After this such block can then optionally compressed, encrypted and encoded and is written or appended to the specified file on a local or remote system. During the character conversion it supports: * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Reporting of ignored or substituted characters For compression, encryption, encoding and archiving, one of the supported methods can be used. For each of these methods, specific parameters can be set to control the outbound conversions. If the data to be written consists of table elements and the 'TABLE' object is not specified or with no further formatting (i.e. TABLE()), then a standard CSV (comma separated value) format is written. Use the 'TABLE' object to reformat the table. * `STRING: FILE='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append data to this file or add member to archive  [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: METHOD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method to convert records in blocks [NONE]` ** `L4I - Adds 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte length fields: System endian short (LL00), length exclusive` ** `DLM - Adds provided binary record delimiter` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record [system]` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: SUPPADDING - Suppress trailing padding/equal characters` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCREC - Enforce record orientation on record oriented devices [FALSE]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-character-bom_86de.html",
"BOM",
"[[CLEP.COMMAND.CONV.WRITE.CHARACTER.BOM]] ==== BOM indexterm:[Parameter, BOM, CONV.WRITE.CHARACTER.BOM] If the write byte order mark (BOM) keyword is defined, then the corresponding BOM sign is written at the start of the output stream (block oriented) or at the beginning of each record. If this BOM keyword is not used, then the BOM sign will not be written (this is valid independent of the chosen encoding/CCSID). If a valid BOM sign is located in the middle of the input stream, it is removed from the data. If you define the BOM keyword and the target charset contains only single bytes or no valid BOM sign, then no byte order mark will be written to the output file. If an invalid BOM sign is recognized, then it will be ignored and causes no entry in the report file. If the byte order changes in the middle of text and the BOM handling switch is not activated, the conversion will stop and an error message is thrown. By default, the write BOM keyword is set to OFF. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-character-elf2nl_961b.html",
"ELF2NL",
"[[CLEP.COMMAND.CONV.WRITE.CHARACTER.ELF2NL]] ==== ELF2NL indexterm:[Parameter, ELF2NL, CONV.WRITE.CHARACTER.ELF2NL] The replacement of EBCDIC line feed control characters (0x25) by new line characters (0x15) at conversion to EBCDIC can be activated on non EBCDIC (ASCII) systems or deactivated on EBCDIC systems by enabling this switch. This is for example required to prepare text files on open platforms for USS on z/OS. The usual delimiter for text in ASCII and UTF is 0x0A and will normally be translated to 0x25 in EBCDIC. On z/OS(USS), however, 0x15 (NL) is expected. For the normal transfer of text data between ASCII and EBCDIC systems the internal adjustment of the translation table is done by FLAM automatically. This means that normally you don't need to activate this switch, only in exceptional situations this option can be useful to achieve the opposite of the expected behavior. To ensure a correctly delimited text record, only a line feed and not a carriage return (0x0D) line feed (0x0A) is used. If text formatting is used with method=NL, this will result in a single LF on distributed systems and the internal conversion will be activated by default to produce a valid text file for z/OS under USS on Windows, Unix and other open platforms. This conversion is pre-calculated once at beginning of execution to reduce the required CPU time for the conversion. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-character-reportfile_18c0.html",
"REPORTFILE",
"[[CLEP.COMMAND.CONV.WRITE.CHARACTER.REPORTFILE]] ==== REPORTFILE indexterm:[Parameter, REPORTFILE, CONV.WRITE.CHARACTER.REPORTFILE] With the report capability, you can log every substitution (stop / ignore / substitute / translit / skip / ...) to a log file. For the report file, all rules and replacements are valid, which are described under 'FILENAME HANDLING' above. For example: A substitution report has the syntax listed below: A comment behind brackets explains the reason for substitution:    'invalid character'    'incomplete character'    'incomplete character at the end of a record' The notations STP (stop), IGN (ignore), SUB (substitute), XLT (transliteration), IDT (identical) or SKP (skip) before round brackets indicate the action taken. If the task cannot be determined then UKW (unknown) is used. A ignore of an invalid character is realized as substitution with nothing. All substitutions with a length of 0 are indicated with IGN (ignore). The position of such an abnormal/irregular character is coded inside the braces: * UNIT     number of records or blocks (depends on the data) * OFFSET   byte offset up to this unit in the complete data stream * POSITION number of bytes inside the unit where the activity was done All counting starts with 0. The first block or record has unit 0. The position is relative to the data stream which was presented to the character conversion module. After conversions and formatting the position values can be far off from the input file which was read originally. For example, when reading a text file with text formatting to records, then delimiting characters are not included in the byte offset, the units are records and the position indicates which character was the issue for this log entry. The CODEPOINTs (Unicode) are taken from the defined substitution table The BYTESTRINGs are taken from the input (read characters) and output data (written characters). BYTESTRINGs and CODEPOINTs are provided if they are known in the cases of such an irregularity. In some cases, these values can be missing. For interpreting the report file, you must know that only the values inside round brackets are meaningful. Text before or behind round brackets are comments, but this may be subject to changes. * `STDOUT - Write output to stdout` * `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-text_d3cf.html",
"TEXT",
"[[CLEP.COMMAND.CONV.WRITE.TEXT]] ==== TEXT indexterm:[Object, TEXT, CONV.WRITE.TEXT] Write text formats UTF-8 text elements into a list of records / lines, each terminated by a delimiter. These text records are converted to a character set defined by the CSSID. The resulting record list can optionally be compressed, encrypted and/or encoded and is written or appended to the specified file on a local or remote system. Text formatting also supports: * Different methods to define the record/line delimiter * Suppression of trailing whitespace * Replacement of horizontal tabs by whitespace characters * Suppression or replacement of remaining control characters * Validation of or replacements in records using regular expressions During character conversion these options are supported: * Stopping, ignoring or substitution when encountering an invalid or incomplete character * A freely defined substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters For compression, encryption, encoding and archiving, one of the supported methods can be used. For each of these methods, specific parameters can be set to control the conversions. If the data to be written consists of table elements and the 'TABLE' object is not specified or with no further formatting (i.e. TABLE()), then a standard CSV (comma separated value) format is written. Use the 'TABLE' object to reformat the table. * `STRING: FILE='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append data to this file or add member to archive [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: METHOD=HOST/BIN/REC/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/SYSTEM/ORIGINAL/L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method for text formatting [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `REC - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` ** `ORIGINAL - Adds the original data at the end of a line (only for band FMT)` ** `L4I - Adds 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte length fields: System endian short (LL00), length exclusive` ** `DLM - Adds binary record delimiter` * `NUMBER: RPLTAB/RPLHTB=num - Replace horizontal tabulators by spaces using this tab width [0 - no replacement]` * `NUMBER: RPLVTB=num - Replace vertical tabulators by new lines using this tab width [0 = no replacement]` * `SWITCH: RPLBSP - Replace backspace (deletes the backspace and the byte before) [FALSE]` * `NUMBER: RPLCTR=SPACE/SUBSTITUTE/DELETE - Replace remaining control characters [NONE]` ** `SPACE - Replace control characters with whitespace character (0x20/0x40)` ** `SUBSTITUTE - Replace control characters with substitution character (0x1A/0x3F)` ** `DELETE - Remove control characters` * `SWITCH: SUPCTR - Suppress control characters [FALSE] (RPLCTR=DELETE)` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCREC - Enforce record orientation on record oriented devices [FALSE]` * `SWITCH: DUMP - Write text dump of binary data [FALSE]` * `NUMBER: INDSIZ=num - Number of XML indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml_2311.html",
"XML",
"[[CLEP.COMMAND.CONV.WRITE.XML]] ==== XML indexterm:[Object, XML, CONV.WRITE.XML] Write XML formats FLAM elements containing parsed XML data. The output is a valid XML document. The output XML can be formatted using 3 different methods: * STANDARD:    The XML document is reconstructed as close to the original XML document as possible. * PRETTYPRINT: Creates an XML document with indentation suitable for human readability. * MINIMIZED:   Creates a minimized XML document. Line breaks and whitespace are removed unless they are part of actual character data. The XML output is written in blocks and encoded in UTF-8 with line feed (0xA) as line delimiter unless a CCSID is supplied, in which case character conversion is performed. If writing XML, the semantics of read modes (read.*()) change as follows: * BINARY:     The binary input data is assumed to be a valid XML  document encoded in UTF-8. It is parsed and then written according to  the selected write options. * CHARACTER:  The input data is assumed to be a valid XML document. The  input is converted to UTF-8 before it is passed to the XML parser. The  parsed XML data is then written according to the selected write  options. * TEXT:       The input data is assumed to be a valid XML document. The  input is converted to UTF-8 before it is passed to the XML parser. The  parsed XML data is then written according to the selected write  options. * XML:        The input data is a valid XML document. If a CCSID is  supplied, the input is converted to UTF-8 prior to parsing. If no CCSID  is given, then UTF-8 is assumed. * RECORD:     The input records are converted to UTF-8, line delimiters  added after each record and converted into binary blocks before the  input is passed to the XML parser. The parsed XML data is then written  according to the selected write options. * FLAM4:      Same as RECORD, but read from a FLAM4 file. For compression, encryption, encoding and archiving, one of the supported methods can be used. For each of these methods, specific parameters can be set to control the conversions. The output file can be written to a local or remote system. * `STRING: FILE='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append data to this file or add member to archive [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: FRCREC - Enforce record orientation on record oriented devices [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml-method_e9e3.html",
"METHOD",
"[[CLEP.COMMAND.CONV.WRITE.XML.METHOD]] ==== METHOD indexterm:[Overlay, METHOD, CONV.WRITE.XML.METHOD] The XML formatting method defines how an XML document will be created and written from FLAM elements containing XML data. It is also possible to dump non-XML elements into an XML document in raw format. The supported methods are listed below. The standard method is the default for 'write.binary()' and 'write.xml()'. Minimized is the default for 'write.char()'. Pretty printing is the default for 'write.record()' and 'write.flam()'. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml-method-standard_45cd.html",
"STANDARD",
"[[CLEP.COMMAND.CONV.WRITE.XML.METHOD.STANDARD]] ==== STANDARD indexterm:[Object, STANDARD, CONV.WRITE.XML.METHOD.STANDARD] The standard method recreates the original XML document from FLAM XML elements as close as possible. All document structure, indentation, line breaks, etc. are preserved. All line breaks are normalized to line feeds (0xA) according to the XML specification. * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` * `SWITCH: WLLFMD - Verify that the written XML document is well-formed [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml-method-prettyprint_733f.html",
"PRETTYPRINT",
"[[CLEP.COMMAND.CONV.WRITE.XML.METHOD.PRETTYPRINT]] ==== PRETTYPRINT indexterm:[Object, PRETTYPRINT, CONV.WRITE.XML.METHOD.PRETTYPRINT] The pretty printing method creates an XML document that is very suitable to be read by humans. All XML elements start on its own line and are properly indented occording to its hierarchical position, unless they are surrounded by text data. Elements containing actual text (i.e. they do not only contain whitespace and newlines) have all their whitespace and newline characters preserved. *Example:* If the original XML document is the following one: [source,xml] then pretty printing will result in the following document: [source,xml] * `NUMBER: MAXWSP=num - Size of internal whitespace cache (only used when method is minimize or pretty printing) [4096]` * `NUMBER: WSPERR=WRITE/ABORT - Action when the whitespace cache overflows [WRITEOUT]` ** `WRITE - Write out cached whitespace on full buffer, causing less nicely formatted output` ** `ABORT - Abort XML writing when the whitespace buffer is full, output formatting has priority` * `NUMBER: INDSIZ=num - Number of indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of elements for preallocation [128]` * `SWITCH: WLLFMD - Verify that the written XML document is well-formed [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml-method-minimized_2244.html",
"MINIMIZED",
"[[CLEP.COMMAND.CONV.WRITE.XML.METHOD.MINIMIZED]] ==== MINIMIZED indexterm:[Object, MINIMIZED, CONV.WRITE.XML.METHOD.MINIMIZED] The minimized method creates an XML document that has whitespace and linebreaks removed unless they are part of other character data, as well as all comments. This is most suitable if data is primarily contained in the child nodes of the XML document, the document is read by a machine and if storage/bandwidth is an issue. *Example:* If the original XML document is the following one: [source,xml] then minimization will result in the following document: [source,xml] * `NUMBER: MAXWSP=num - Size of internal whitespace cache (only used when method is minimize or pretty printing) [4096]` * `NUMBER: WSPERR=WRITE/ABORT - Action when the whitespace cache overflows [WRITEOUT]` ** `WRITE - Write out cached whitespace on full buffer, causing less nicely formatted output` ** `ABORT - Abort XML writing when the whitespace buffer is full, output formatting has priority` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of elements for preallocation [128]` * `SWITCH: WLLFMD - Verify that the written XML document is well-formed [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-xml-method-dump_273e.html",
"DUMP",
"[[CLEP.COMMAND.CONV.WRITE.XML.METHOD.DUMP]] ==== DUMP indexterm:[Object, DUMP, CONV.WRITE.XML.METHOD.DUMP] The dump method takes lists of arbitrary FLAM elements and dumps them into XML format. For each element list, an `<elementList>...<elementList>` block is created, containing an arbitrary number of `<element>...</element>` tags. A FLAM element contains element data, an element type, attributes and a hash, which are represented as body, `type`, `attr` and `hash` attributes, respectively. The attributes `attr` and `hash` are optional and only written if they contain any data. The output format of data, attributes and hashes can be configured independantly. Valid formats are binary (may result in a not wellformed XML document), hexadecimal or numeric (bytes printed as decimal numbers separated by whitespace). The output format configuration is saved as part of the XML document. The resulting XML document has the following form: [source,xml] * `NUMBER: DATAFMT=BINARY/HEXADECIMAL/NUMERIC - Format in which element data is dumped [HEX]` ** `BINARY - Dump in binary format` ** `HEXADECIMAL - Dump in hexadecimal format` ** `NUMERIC - Dump in numeric (decimal) format` * `NUMBER: ATTRFMT=BINARY/HEXADECIMAL/NUMERIC - Format in which attribute data is dumped [HEX]` ** `BINARY - Dump in binary format` ** `HEXADECIMAL - Dump in hexadecimal format` ** `NUMERIC - Dump in numeric (decimal) format` * `NUMBER: HASHFMT=BINARY/HEXADECIMAL/NUMERIC - Format in which hash data is dumped [HEX]` ** `BINARY - Dump in binary format` ** `HEXADECIMAL - Dump in hexadecimal format` ** `NUMERIC - Dump in numeric (decimal) format` * `NUMBER: INDSIZ=num - Number of indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of elements for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-record_1a5d.html",
"RECORD",
"[[CLEP.COMMAND.CONV.WRITE.RECORD]] ==== RECORD indexterm:[Object, RECORD, CONV.WRITE.RECORD] Write record formats the list of elements as records for host data set formats or to archive the dataset in a format like GZIP, ZIP, PGP or as a FLAMFILE on a local or remote system. The following options are supported: * Cutting or wrapping of records which are too long * ASA and machine print control character handling * All kind of mainframe records formats, length and block size * Different record formats for the distributed world * Free definition of padding character for fixed length formats * Validation of or replacements in records using regular expressions If a record is marked as text record, character conversion from UTF-8 to a defined CCSID is done. The following options are supported for character conversion: * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Reporting of ignored or substituted characters During record I/O, encryption and compression can be applied. When selecting output formats like GZIP, PGP or ZIP, records are converted to data blocks. By default, a record length field (L4X) is put in front of binary records. For text records, a text delimiter is add by default. You can also specify a binary delimiter or another kind of 4 byte length field. The default text record conversion to a data block is compatible with a text file on non-mainframe platforms. If you chose to retain control characters, then all record attributes (slot number, ASA and MCC) are stored in front the a binary record. If text handling used, then ASA and machine control character are lost, except the print control at READ.RECORD() was retain, in which case character conversion does not make much sense. The file attributes can only be stored in a FLAMFILE, GZIP or ZIP member header or if an ASCII armor header is used. If you create, for example, a BZIP2 or binary PGP file, then all the DCB parameter are lost. When reading the file back, a PS-VB dataset will be created by default. The combinations below produce an archive that allow restoring the host data set without losing meta data (except load module entry addresses of a PDS(E) load library): This functionality uses a private extension field in GZIP, ZIP or ARMOR headers and a per-record length field in the data. You can also use a binary delimiter for variable length records. When archiving files with FLCL, you must read them with FLCL to restore the datasets correctly. To read such a file, the example below can be used: Write record supports different encoding schemes (e.g. Base64). By default, the encoding is done record by record. If you enforce block orientation for the encoding, the record boundaries are lost and the resulting blocks can wrapped to new records, if you define all the corresponding parameters accordingly. When writing archive formats, the encoding is done after all compression/encryption. If the data to be written consists of table elements and the 'TABLE' object is not specified or with no further formatting (i.e. TABLE()), then the original record in system representation without header 'TABLE(FORMAT=ORG DEFAULTS(SYSTEM,NOHDLN))' is written. Character conversion is done on a per-element basis. There is no report file or BOM support if table formatting is used. Use the 'TABLE' object to reformat the table. * `STRING: FILE='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append data to this file or add member to archive [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: RECMODE=STOP/CUT/WRAP/SKIP - Mode used to write records [STOP]` ** `STOP - Stop if record too long` ** `CUT - Cut if record too long` ** `WRAP - Wrap if record too long` ** `SKIP - Skip if record too long` * `STRING: RECDELIM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: SUPPADDING - Suppress trailing padding characters (useful for variable records)` * `STRING: PADCHAR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Character to pad records to a fixed length [system] or used for empty variable length records [NONE]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `SWITCH: NOSPANNED - Deactivate write of large spanned records to V(B)S datasets [FALSE]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: BLK2REC - Convert block with delimiter to records (including suppression of trailing whitespace` * `NUMBER: INDSIZ=num - Number of XML indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-flam4_43e8.html",
"FLAM4",
"[[CLEP.COMMAND.CONV.WRITE.FLAM4]] ==== FLAM4 indexterm:[Object, FLAM4, CONV.WRITE.FLAM4] Writing with FLAM4 formats a list of elements into records and writes these records to a FLAMFILE of version 4 or older. If such a record is marked as text, a character set conversion from UTF-8 to the provided CCSID is done. If data elements are large blocks, then the result of the conversion is wrapped into records of the provided length or the default fixed length of 32,752 bytes. During character conversion, the following options are supported: * Stop, ignore or substitution of invalid or incomplete characters * A custom substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to override the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters For the FLAMFILE archive, the following options are supported: * Definition of record format and length for the FLAMFILE * Definition of compression and encryption mode * Correct ASA and machine print control character handling * Pass phrase based or FKME based encryption technology * If no FKME encryption is used, a comment can be stored The default member name is the name of the original file from the read operation. You can change this by defining a mapping rule for the member name. The block mode is always set to blocked, which means no unblocked FLAMFILEs can be generated. All the original file attributes are set to the right values in the file header automatically. User I/O as well as pre- and post- processing exits are not supported. If these features are really required, the extended variant (XCNV/XDCO) of this command should be used. If the data to be written consists of table elements and the 'TABLE' object is not specified or with no further formatting (i.e. TABLE()), then the original record in system representation without header 'TABLE(FORMAT=ORG DEFAULTS(SYSTEM,NOHDLN))' is written. Character conversion is done on a per-element basis. There is no report file or BOM support if table formatting is used. Use the 'TABLE' object to reformat the table. * `STRING: FILE='str' - Name/URL of the FLAMFILE to write [''==stdout]` * `STRING: MEMBER='str' - Name of the member stored in the FLAMFILE header` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: APPEND - Append the member to this FLAMFILE (not useful with encryption) [FALSE]` * `SWITCH: NOPATH - Exclude directory path of the original file in the compressed data [FALSE]` * `NUMBER: CMPMODE=CX7/CX8/VR8/ADC/NDC - Compression mode [ADC]` ** `CX7 - Compression encoding as printable characters` ** `CX8 - Compression encoding as binary data` ** `VR8 - Enhanced compression encoding as binary data` ** `ADC - Advanced Data Compression` ** `NDC - No data compression` * `NUMBER: ENCMODE=OFF/AES/FLAMENC - Encryption mode [NONE]` ** `OFF - Disable encryption` ** `AES - AES encryption` ** `FLAMENC - FLAM encryption` * `NUMBER: CLIMIT=num - Minimum compression in per cent (0 no Limit)[0]` * `NUMBER: ORGANIZATION=SEQ/PS/EDS/ESDS/KDS/KSDS/RDS/RRDS/LDS - Organization of the FLAMFILE [SEQ]` ** `SEQ - Sequential access [DEFAULT]` ** `PS - Sequential access [DEFAULT]` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` ** `LDS - Linear data set (VSAM-LDS)` * `NUMBER: RECFORMAT=VAR/FIX/UND/TXT/DLM/VB/FB/V2B-XBE/V4B-XBE/V4A-ICL/V4E-ICL/V2B-ILE/V2B-IBE/V4B-IBE - Record format for the FLAMFILE [FIX]` ** `VAR - Variable` ** `FIX - Fix` ** `UND - Undefined` ** `TXT - Text/Stream` ** `DLM - Stream with special delimiter` ** `VB - Variable blocked` ** `FB - Fix blocked` ** `V2B-XBE - Variable 2 byte length field without the length in big endian` ** `V4B-XBE - Variable 4 byte length field without the length in big endian` ** `V4A-ICL - Variable 4 byte length field in ASCII inclusive the length` ** `V4E-ICL - Variable 4 byte length field in EBCDIC inclusive the length` ** `V2B-ILE - Variable 2 byte length field inclusive the length in little endian` ** `V2B-IBE - Variable 2 byte length field inclusive the length in big endian` ** `V4B-IBE - Variable 4 byte length field inclusive the length in big endian` * `NUMBER: RECLENGTH=num - Record length for the FLAMFILE [512]` * `NUMBER: ORGLENGTH=num - Record length to wrap block oriented original data [32752]` * `NUMBER: KEYPOSITION=num - Key position (>=1) for key sequential data sets [1]` * `NUMBER: KEYLENGTH=num - Key length (>=1) for key sequential data sets [8]` * `STRING: COMMENT='str' - Comment for the member in the FLAMFILE [internal use]` * `STRING: PASSWORD/CRYPTOKEY='bin'/DEFAULT - Passphrase to encrypt the FLAMFILE ['']` ** `DEFAULT - FLAM4 default password` * `STRING: KMLIBRARY='str' - Library name for FKME ['']` * `STRING: KMFUNCTION='str' - Function name of FKME ['']` * `STRING: KMPARAMETER='bin' - Parameter for the call of FKME ['']` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `NUMBER: INDSIZ=num - Number of XML indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: BLK2REC - Convert block with delimiter to records (including suppression of trailing whitespace` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-flam4-space_8109.html",
"SPACE",
"[[CLEP.COMMAND.CONV.WRITE.FLAM4.SPACE]] ==== SPACE indexterm:[Object, SPACE, CONV.WRITE.FLAM4.SPACE] The FLAM4 file space allocation object collects several parameters for platforms where the cylinders or tracks, volume, classes and other things must be predefined. The supported parameters are platform dependent. Only parameters relevant for a certain platform are used. This way its possible to store files on special volumes, units, and with SMS-classes without any JCL usage on z/OS(R). All size values must be given in megabytes (MiB). The calculation in the platform-dependent units (tracks, cylinders, ...) are done internally. NOTE: 1 MiB = 1024 KiB = 1024*1024 Byte * `NUMBER: PRIMARY=num - Primary size in megabytes` * `NUMBER: SECONDARY=num - Secondary size in megabytes` * `STRING: VOLSER='str' - Volume serial number` * `STRING: VOLUNIT='str' - Volume unit` * `STRING: DATACLASS='str' - Data class` * `STRING: MGMTCLASS='str' - Management class` * `STRING: STORCLASS='str' - Storage class` * `NUMBER: DISPSTATUS=NEW/SHR/MOD/OLD - Disposition status` ** `NEW - Disposition status NEW (brand new file)` ** `SHR - Disposition status SHR (read exiting  file)` ** `MOD - Disposition status MOD (append/modify file)` ** `OLD - Disposition status OLD (overwrite existing file)` * `NUMBER: NORMALDISP=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for normal end` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` * `NUMBER: ABORTDISP=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for abnormal end` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-flam4-split_630f.html",
"SPLIT",
"[[CLEP.COMMAND.CONV.WRITE.FLAM4.SPLIT]] ==== SPLIT indexterm:[Overlay, SPLIT, CONV.WRITE.FLAM4.SPLIT] During compression a FLAMFILE can be split serially or in parallel into several parts, subject to the settings of the parameters SPLITMODE, SPLITNUMBER, and SPLITSIZE. Only the filename (or DD-name) of the first fragment of a split FLAMFILE must be specified at decompression and no additional settings are required. FLAM detects automatically whether and, if so, how a FLAMFILE has been split and searches by itself for the remaining fragments. Splitting of FLAMFILEs is only available for binary compression modes (MODE=CX8,VR8,ADC,NDC). Binary information has been added to every part of a split FLAMFILE. Serial splitting (SPLIT.SIZE=nnnn) means that when the file currently used to store compressed data reaches a specified size limit it is closed and subsequent processing stores the compressed data into a newly created file (fragment). The number of fragments of a split FLAMFILE created is not limited. It only depends on the amount of data generated by the compression process. At decompression, FLAM verifies the order, the presence and the affiliation of all fragments. This feature provides an efficient support for file size limitations (e.g. with e-mail attachments or file transfers). It can also improve system performance by allowing transmission of fragments over a network to begin before termination of the entire compression process. With parallel splitting (SPLIT.NUMBER=n) compressed data is stored into a specified number of fragments. The current version can handle up to 4 parallel fragments. The size of the fragments depends on the amount of data generated during compression. At decompression, FLAM verifies the order, the presence and the affiliation of all fragments. Decompression requires the accessibility of all fragments of a FLAMFILE. None of the data can be recovered when one parallel fragment is missing. One benefit of parallel splitting can consist in improved utilization of transmission capacities. Also, locally distributing FLAMFILE fragments may avoid unauthorized decompression without using encryption. * `NUMBER: SIZE=num - Size for serial splitting (after 1-4096 in megabytes (only for z/OS)) [100]` * `NUMBER: NUMBER=num - Number for parallel splitting (2-4 files (only for z/OS)) [4]` ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-write-dummy_dcf4.html",
"DUMMY",
"[[CLEP.COMMAND.CONV.WRITE.DUMMY]] ==== DUMMY indexterm:[Parameter, DUMMY, CONV.WRITE.DUMMY] Write dummy is simply an abbreviation for the command below. It simply discards any output, just like /dev/null on Unix systems. ",
"",
""
],
[
"flcl_manual-flcl_commands-conv-inverse_5718.html",
"INVERSE",
"[[CLEP.COMMAND.CONV.INVERSE]] ==== INVERSE indexterm:[Parameter, INVERSE, CONV.INVERSE] With the INVERSE parameter you can generate an XCNV command file that inverts the operations executed by the specified CONV command. For the inverse file, all rules and replacements are valid which are described under 'FILENAME HANDLING' above. For example: This can be used, for example, if you need a solution to edit a file inside an archive and the file to be edited is in a format that is not supported by the system (e.g. an ASCII text file on an EBCDIC system). With the INVERSE parameter of the CONV command, you can extract the file from the archive, do necessary conversions and write it to a temporary file. After editing, you pass the generated XCNV command file to the XCNV command which reverses all operations performed by CONV, i.e. the text file is converted back to its original form and written back to the archive. Below you can see an example of how it works: * <DSN> - Dataset name to edit * <TMP> - Temporary file for editing * <IVR> - Command file to inverse write back There are many other possibilities to use the INVERSE parameter. This sample is implemented in the FLEDIT line command for ISPF. This allows you to correct TEXT and XML files with the normal ISPF editor even though they may be encoded, compressed or in another codepage not supported by the editor. The inverse command reverses what the call of CONV produces. This could be different from the original. For example, if you use on an XML file, then pretty printing is used to form the records. The inverse command converts back the pretty printed XML. The result would be the same XML document but with a different text formatting. If the file is a text file, write.record() replaces the delimiter with record length information. Since the original delimiter was lost, the inverse command adds the system delimiter. If the original file was delimited with 0x0D0A and you use the inversion feature on a non-Windows system, the original delimiter will be replaced by the correct delimiter for the current system and is then translated to the original character set. The same will happen if you read a base encoded file. This file can be in ASCII or EBCDIC at read, but it will be written in the system specific character set. This behavior ensures, that the written file is a correct base encoded file for this platform. * `STDOUT - Write output to stdout` * `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv_fd50.html",
"XCNV",
"[[CLEP.COMMAND.XCNV]] === XCNV indexterm:[Command, XCNV, XCNV] The XCNV command reads and writes various data formats, local or remote, on different platforms. It uses the read and write routines for original data of FLAM. More precisely, it provides all conversion capabilities of FLAM without a FLAM archive in the background. The XCNV command was designed to provide the full capacity of the powerful Frankenstein Limes Universal Converter (FLUC). It can be used to read and write local or remote data of different kinds, performing optional conversion steps in the process. For example, the XCNV command can be used to read an encoded, encrypted, compressed text file in UTF-16 from a PC platform and write the text records into a mainframe data set with a dedicated record format (FB, VB, ...) in EBCDIC with ASA or machine print control characters. You could even write the same data in UTF-8 with line delimiters as PGP file to a remote (SSH) ZIP archive in one step or vice versa. When using XCNV, you must know precisely what kind of data you read, as you can manipulate any kind of attribute and you have the complete control over each conversion step. Some of the formats and conversions that XCNV supports: * Different kinds of remote access protocols (IP-Nativ, MQ-Series, SSH) * Different kinds of data sources (Files, Streams, Tables, Archives) * Different kinds of IO methods (Binary, Character, Text, Record, FLAM) * Various data encoding formats (HEX aka. Base16, Base32, Base64) * Multiple encryption methods (FLAM, PGP) * Different compression methods (GZIP, BZIP2, XZ) * Powerful character conversion (Unicode, subsets, tranlitteration, reporting, mapping, NFD/NFC, input assistance) * Different logical data formatting methods (BIN, TEXT, XML, tables (FB-CSV-VB)) If the XCNV command is too complex or you need auto detection capabilities, you can use the simplified variant called CONV which also provides the full conversion capabilities of FLAM, but with more automatism. The CONV command provides an easy to handle subset of all the supported conversion capabilities. In contrast to XCNV, the CONV command does a lot of auto detection and automated conversions. It tries to guess how the data must be represent on the current system. For XCNV command, the user must know in detail what kind of data is read and can full control how the data is written. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or in a file) or by properties taken from the corresponding property file. Reads a remote file as binary blocks, generates a SHA1 checksum in BSD style, performs GZIP decompression, converts characters from UTF-8 to IBM1141 and formats the data into text records and rest elements in the read operation. On first write, the text elements are formatted without a delimiter, a SHA-512 checksum is calculated for the result and the data elements are written to a record-oriented PS-VB-512 dataset. A second output specification produce a PGP file containing the text in LATIN1 (ISO-8859-1) encoding with 0x0A (UNIX) as delimiter. The binary PGP file is hashed with SHA256 in BSD style and then an ASCII-ARMOR encoding are done. These result is then written to a local file and in a remote ZIP archive. * `SWITCH: NORUN - Don't run the command only show parsed parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input_f4f7.html",
"INPUT",
"[[CLEP.COMMAND.XCNV.INPUT]] ==== INPUT indexterm:[Object, INPUT, XCNV.INPUT] Over the object INPUT you can define how the data is read. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save_ddd1.html",
"SAVE",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE]] ==== SAVE indexterm:[Overlay, SAVE, XCNV.INPUT.SAVE] With the overlay SAV you can choose the kind of source or target for the read or write operation. Below You can find the currently supported procedures and the corresponding parameter explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file_5ea8.html",
"FILE",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE]] ==== FILE indexterm:[Object, FILE, XCNV.INPUT.SAVE.FILE] The object FILE can be used to define how a list of neutral FLAM5 elements with type, length, value and attributes is read from a file. The type of I/O (block, record, text, FLAM4, ...), an unlimited amount of conversions (decoding, decryption, decompression, character set, ...) and a formatting method (binary, text, xml, ...) for the data can be selected. If you pass a URL containing a CCSID to the FIO object, this CCSID is the default inbound CCSID (FROM) for all character conversion objects you use. If no character conversion is requested, the CCSID defined in the URL is not used. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-env_41a8.html",
"ENV",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.ENV]] ==== ENV indexterm:[Object, ENV, XCNV.INPUT.SAVE.FILE.ENV] With the object ENV you can override environment variables for read operation. This is useful, for example, to define another LANG variable to emulate another platform for character conversion. * `STRING: KEYWORD='str' - Keyword of environment variable` * `STRING: VALUE='str' - Value of environment variable` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio_0f79.html",
"FIO",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO]] ==== FIO indexterm:[Overlay, FIO, XCNV.INPUT.SAVE.FILE.FIO] With the overlay FIO you can choose different kind of file IO methods for read operations. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-blk_fa21.html",
"BLK",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.BLK]] ==== BLK indexterm:[Object, BLK, XCNV.INPUT.SAVE.FILE.FIO.BLK] This object defines the block oriented read operation for files. This method reads block size bytes as one chunk and gives this block simply in binary form to the subsequent conversion layer. This is the most famous and simplest way to read a file. This read method is useful for all non record oriented file formats. You can also read record oriented data sets. In this case the block size defines how many records are processed in one chunk. If the next complete record too big for this block, it is copied as first record of the next block. If you read records with FIOBLK there are no capability to store any attributes except the record length. This means that print control character and slot number are lost. Record oriented data sets you can use FIOREC to manage record attributes separately. Print control character can remain in the record oriented data block or detached, but the attribute is lost after the read operation. You can also enforce block orientation on a record-oriented device, in which case record boundaries are lost and the block is filled byte-wise. This will result in better performance, but a transparent read of different file formats and normal host data sets is not possible anymore. Additionally, you can also add the system delimiter behind each record to produce a valid block for text formatting. * `STRING: NAME/FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [STDIN]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: DATTYP=NONE/BINARY/RECORD/RECTXT/CHAR/TEXT/XML/TABLE - Definition of data type for better handling [NONE]` ** `NONE - Unknown data type` ** `BINARY - Binary data (not printable)` ** `RECORD - Binary record (not printable)` ** `RECTXT - Text record (printable)` ** `CHAR - Character data (no delimiter)` ** `TEXT - Text data (with delimiter)` ** `XML - XML data (like CHAR)` ** `TABLE - Table (various elements per record)` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: FRCBLK - Enforce block orientation on record oriented devices [FALSE]` * `SWITCH: ADDDLM - Add a delimiter behind each record to produce a text block [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-blk-prepro_b72e.html",
"PREPRO",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.BLK.PREPRO]] ==== PREPRO indexterm:[Object, PREPRO, XCNV.INPUT.SAVE.FILE.FIO.BLK.PREPRO] By specifying the file I/O pre command object, the provided command is executed before each input and/or output file of the containing file specification is opened for processing. If the file is located on a remote SSH host, the command is executed on that host. Otherwise, it is executed locally. The command string can reference parts of the corresponding filename (see <<flcl.input.output.name.mapping,INPUT TO OUTPUT NAME MAPPING>>). If a command is specified, it is executed on the target (local or remote) in an operating system dependent manner. An optional timeout can be specified, which limits the maximum execution time. Timeouts are not supported on all platforms. The following paragraphs describe the differences between the supported execution environments: *POSIX (Linux/Solaris/AIX/USS):* The command is executed by the default system shell as if run via `/bin/sh -c 'command'`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *Windows:* The command is executed by the Windows command line interpreter as if run via `cmd.exe /C command`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *z/OS:* The command is executed through the `system()` function which allows you to call commands, EXECs, CLISTs or executable modules under MVS and TSO/E. For more information on how to build the command string, please refer to the documentation of the `system()` function (ANSI variant) in IBM's 'z/OS XL C/C++ Runtime Library Reference'. Timeouts are not supported. Therefore, specifying a timeout value has no effect. The command's termination is always waited for before processing by FLAM continues. *SSH:* The command is executed on the remote host through the command execution feature in SSH as described in RFC4254. To be able to execute commands on a remote SSH host, the server must support this feature and the login user must have sufficient privileges to run commands. How the command is executed is server-specific. OpenSSH on a Linux host usually runs the command via `/bin/sh -c 'command'` and sends the standard output and standard error streams through the SSH channel back to the client. If a non-zero timeout is specified and the execution time exceeds the timeout value, a timeout error occurs. No attempt is made to terminate the process on the remote host because this not supported by the SSH protocol and is highly specific to the (unknown) operating system on the remote host. Therefore, the remote process may or may terminate successfully after the timeout was reached. The exit code is logged if the command terminates normally. It is possible to provide a list of acceptable exit codes. When the command terminates with an acceptable exit codes, it is considered successful and file processing continues. All other exit codes are considered a failure. The only default acceptable exit code is 0. The action taken when a command fails depends on whether it is a pre or post command. If a pre command fails, an error is logged and the conversion of the file (for per-file pre commands) or the whole conversion (for global pre commands) is not performed. If a post command fails, an error is logged and processing of the next file (for per-file post commands) continues. For failed commands, the beginning of the standard error stream is printed as part of the error trace if the STDERR parameter has not been assigned to help you debug the issue. The standard output and standard error streams of the executed command are ignored by default. By specifying a file URL for the STDOUT or STDERR parameter, the respective output stream can be written to the log (STDOUT=:LOG), to the respective output streams of the current process (STDOUT=:STDOUT / STDERR=:STDERR) or to a file at the given path (can be remote). By setting STDOUT=:STDERR or STDERR=:STDOUT, the respective streams output can also be redirected to the location of the respective other stream's output. For example, by setting STDOUT=/any/path and STDERR=:STDOUT both output streams can be redirected to the same file without having to specify the path twice. Please note that by multiplexing both output streams into one file, the order of lines might not accurately reflect the order in which they were written by the executed application if it alternates between writing to stdout and stderr. If command output is written to the log, character conversion to the local character set is performed automatically (relevant for remote execution). The CCSID parameter can be used to set the character set that the output from the remote system is encoded in. If not specified, FLAM uses UTF-8 as default and falls back to Latin-1 for remote command execution and the local character set for local command execution. This works well if the output is text. Please note that lines longer than 1023 bytes are truncated. As a result, a warning is written to the log (this will result in completion code 1). Non-convertible characters are transliterated. If this is not possible, they are ignored (like CHRMODE=TRANSLIT). When writing the output to a file (local or remote) by specifying a file URL, character conversion can be activated by setting the parameter CCSID and/or by appending the target CCSID to the URL (e.g. ssh://user@host/myfile/&UTF-8). Otherwise, the binary output is written as-is. Using the CCSID parameter activates text mode processing. If the target CCSID is defined via the URL, a binary transfer of the character converted data stream is performed. An error occurs if character conversion or the write operation fails. The CHRMODE parameter can be used to change the handling of non-convertible or damaged characters. This parameter also enforces character conversion. By default, character conversion between identical CCSIDs are skipped. * `STRING: COMMAND='str' - Command(s) to be executed` * `NUMBER: TIMEOUT=num - Timeout for the command in seconds (not for local z/OS commands) [0=infinite]` * `NUMBER: ACCEPT[num...] - List of exit codes that are considered as successful execution [0]` * `STRING: STDOUT='str'/LOG/STREAM/STDERR - Where to write standard output of the command [IGNORE]` ** `LOG - Write standard output to the log` ** `STREAM - Write standard output to local stdout stream` ** `STDERR - Write standard output defined by STDERR parameter` * `STRING: STDERR='str'/LOG/STREAM/STDOUT - Where to write standard error of the command [IGNORE]` ** `LOG - Write standard error output to the log` ** `STREAM - Write standard error output to local stderr stream` ** `STDOUT - Write standard error output defined by STDOUT parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-blk-postpro_99db.html",
"POSTPRO",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.BLK.POSTPRO]] ==== POSTPRO indexterm:[Object, POSTPRO, XCNV.INPUT.SAVE.FILE.FIO.BLK.POSTPRO] By specifying the file I/O post command object, the provided command is executed after each input and/or output file of the containing file specification was processed. If the file is located on a remote SSH host, the command is executed on that host. Otherwise, it is executed locally. The command can be executed or not depending on whether processing the file was successful. It can be executed on success, on error or both. The command string can reference parts of the corresponding filename (see <<flcl.input.output.name.mapping,INPUT TO OUTPUT NAME MAPPING>>). At write the file post-processing are only done by default in the final close of the I/O component. This results at directory walk in only one post-processing for the final file. This is required for example if you will write all the files to one archive or append anything to one file. If you process n input files to n output files it could be useful to enforce the post processing per file. Since version 5.1.24 of FLAM the switch 'PERFILE' could be activate for this. If the 'PERFILE' switch defined be aware that the post-processing for write is done in front of the post-processing for read, because only if the write was successful the optional remove (if the 'REMOVE' switch at read is used) can be done. If a command is specified, it is executed on the target (local or remote) in an operating system dependent manner. An optional timeout can be specified, which limits the maximum execution time. Timeouts are not supported on all platforms. The following paragraphs describe the differences between the supported execution environments: *POSIX (Linux/Solaris/AIX/USS):* The command is executed by the default system shell as if run via `/bin/sh -c 'command'`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *Windows:* The command is executed by the Windows command line interpreter as if run via `cmd.exe /C command`. If a non-zero timeout is specified and the execution time exceeds the timeout value, the process and all its children are killed and a timeout error occurs. *z/OS:* The command is executed through the `system()` function which allows you to call commands, EXECs, CLISTs or executable modules under MVS and TSO/E. For more information on how to build the command string, please refer to the documentation of the `system()` function (ANSI variant) in IBM's 'z/OS XL C/C++ Runtime Library Reference'. Timeouts are not supported. Therefore, specifying a timeout value has no effect. The command's termination is always waited for before processing by FLAM continues. *SSH:* The command is executed on the remote host through the command execution feature in SSH as described in RFC4254. To be able to execute commands on a remote SSH host, the server must support this feature and the login user must have sufficient privileges to run commands. How the command is executed is server-specific. OpenSSH on a Linux host usually runs the command via `/bin/sh -c 'command'` and sends the standard output and standard error streams through the SSH channel back to the client. If a non-zero timeout is specified and the execution time exceeds the timeout value, a timeout error occurs. No attempt is made to terminate the process on the remote host because this not supported by the SSH protocol and is highly specific to the (unknown) operating system on the remote host. Therefore, the remote process may or may terminate successfully after the timeout was reached. The exit code is logged if the command terminates normally. It is possible to provide a list of acceptable exit codes. When the command terminates with an acceptable exit codes, it is considered successful and file processing continues. All other exit codes are considered a failure. The only default acceptable exit code is 0. The action taken when a command fails depends on whether it is a pre or post command. If a pre command fails, an error is logged and the conversion of the file (for per-file pre commands) or the whole conversion (for global pre commands) is not performed. If a post command fails, an error is logged and processing of the next file (for per-file post commands) continues. For failed commands, the beginning of the standard error stream is printed as part of the error trace if the STDERR parameter has not been assigned to help you debug the issue. The standard output and standard error streams of the executed command are ignored by default. By specifying a file URL for the STDOUT or STDERR parameter, the respective output stream can be written to the log (STDOUT=:LOG), to the respective output streams of the current process (STDOUT=:STDOUT / STDERR=:STDERR) or to a file at the given path (can be remote). By setting STDOUT=:STDERR or STDERR=:STDOUT, the respective streams output can also be redirected to the location of the respective other stream's output. For example, by setting STDOUT=/any/path and STDERR=:STDOUT both output streams can be redirected to the same file without having to specify the path twice. Please note that by multiplexing both output streams into one file, the order of lines might not accurately reflect the order in which they were written by the executed application if it alternates between writing to stdout and stderr. If command output is written to the log, character conversion to the local character set is performed automatically (relevant for remote execution). The CCSID parameter can be used to set the character set that the output from the remote system is encoded in. If not specified, FLAM uses UTF-8 as default and falls back to Latin-1 for remote command execution and the local character set for local command execution. This works well if the output is text. Please note that lines longer than 1023 bytes are truncated. As a result, a warning is written to the log (this will result in completion code 1). Non-convertible characters are transliterated. If this is not possible, they are ignored (like CHRMODE=TRANSLIT). When writing the output to a file (local or remote) by specifying a file URL, character conversion can be activated by setting the parameter CCSID and/or by appending the target CCSID to the URL (e.g. ssh://user@host/myfile/&UTF-8). Otherwise, the binary output is written as-is. Using the CCSID parameter activates text mode processing. If the target CCSID is defined via the URL, a binary transfer of the character converted data stream is performed. An error occurs if character conversion or the write operation fails. The CHRMODE parameter can be used to change the handling of non-convertible or damaged characters. This parameter also enforces character conversion. By default, character conversion between identical CCSIDs are skipped. * `STRING: COMMAND='str' - Command(s) to be executed` * `NUMBER: TIMEOUT=num - Timeout for the command in seconds (not for local z/OS commands) [0=infinite]` * `NUMBER: ACCEPT[num...] - List of exit codes that are considered as successful execution [0]` * `STRING: STDOUT='str'/LOG/STREAM/STDERR - Where to write standard output of the command [IGNORE]` ** `LOG - Write standard output to the log` ** `STREAM - Write standard output to local stdout stream` ** `STDERR - Write standard output defined by STDERR parameter` * `STRING: STDERR='str'/LOG/STREAM/STDOUT - Where to write standard error of the command [IGNORE]` ** `LOG - Write standard error output to the log` ** `STREAM - Write standard error output to local stderr stream` ** `STDOUT - Write standard error output defined by STDOUT parameter` * `NUMBER: ON=SUCCESS/FAILURE - Condition under which the command is executed [ALWAYS]` ** `SUCCESS - Execute command on success` ** `FAILURE - Execute command on failure` * `SWITCH: PERFILE - Enforce processing per file in directory walk [OFF]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-rec_6818.html",
"REC",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.REC]] ==== REC indexterm:[Object, REC, XCNV.INPUT.SAVE.FILE.FIO.REC] This object defines the record-oriented read operation for files. This method reads records from a data set. You can define the record length and the behavior (STOP/CUT/WRAP) if the record is longer than the defined record length. You can activate the suppression of padding characters and set the padding character. You can define the file organization, block size, record format and a lot of other parameters (see below). The record length is always the real data length after all deductions. For example, for a FBA with a LRECL of 121, the record length of FLAM is 120 because the print control character is normally an attribute and not a part of the record. On record oriented systems (mainly mainframes), a lot of these parameters are known from the catalog and need not be defined. On other platforms (Windows, Unix, ...), catalogs do not exist. On such systems, you must specify how the record-oriented file was written (record format, length format). FLAM supports some record formats on mainframes which are not supported by the corresponding catalog system. For example, record formats with print control characters for VSAM data sets are supported by FLAM. If you know your data in a KSDS has a print control character in the first byte, you can choose the corresponding record format (VKA/VKM) to DETACH the print control character as attribute from the record. The record I/O component also supports text files with delimiters. The record format _text_ can be used to parse records form a delimiter-based text file, for which you can define the character set. It is also possible to parse binary data into records based on a custom delimiter. For this, the record format DLM can be used. The record format BIN simply wraps the data into records of the provided record length. The final record may be shorter. With the 'FIX' record format, the last record also has the provided record length. For variable length record formats (VAR) on non-record-oriented systems, the length format must be defined. All these formats are supported to transfer data between record-oriented and block-oriented systems. For USS on z/OS the default length format for variable records conforms to SVC99 allocation with FILEDATA=RECORD. The record format TXT works like FILEDATA=TEXT if default settings used. Attributes (length, slot number of RRDS, print control character) are stored in front of each record on non-record-oriented systems. Example: If you read a RRDS with print control characters (FRA) and you write this on UNIX as record format VRA to a file, the file format looks like this: Where LLLL is the record length, nn...nn is the slot number C is the print control character and dd..dd is the record data. To read such a file on a UNIX system, the record format and length format (if you write with defaults, you can read with defaults) must be defined correctly. * `STRING: NAME/FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [STDIN]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECMOD=STOP/CUT/WRAP/SKIP - Mode used to read records [STOP]` ** `STOP - Stop if record too long` ** `CUT - Cut if record too long` ** `WRAP - Wrap if record too long` ** `SKIP - Skip if record too long` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: SUPPAD - Suppress trailing padding characters (useful for fixed records)` * `STRING: PADCHR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Define padding character for suppression [automatic]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `NUMBER: FILORG=SEQ/PS/LIB/PDS/USS/EDS/ESDS/KDS/KSDS/RDS/RRDS - File organization [SEQ]` ** `SEQ - Sequential data set [DEFAULT]` ** `PS - Sequential data set [DEFAULT]` ** `LIB - Library (ZOS-PDSE)` ** `PDS - Partitioned data set (ZOS-PDS)` ** `USS - UNIX files (path based)` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` * `NUMBER: RECFMT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format for read operations [NONE]` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLEN=num - Record length for read operations [512]` * `NUMBER: RECCNT=num - Amount of records handled in one read operation [4<128<1024]` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [auto detection]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `STRING: RECDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: KEYPOS=num - Key position (>=1) for index/key sequential data sets [0=NONE]` * `NUMBER: KEYLEN=num - Key length (>=1) for index/key sequential data sets [if KEYPOS>0 then 8]` * `SWITCH: NOSPAN - Deactivate read of large spanned records from V(B)S datasets [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-txt_dc6a.html",
"TXT",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.TXT]] ==== TXT indexterm:[Object, TXT, XCNV.INPUT.SAVE.FILE.FIO.TXT] This object defines the text-oriented read operation for files. This method reads text records from a file with text delimiters. The data must be a text file in a certain character set where each record is terminated with the system specific delimiter. You can define the maximum record length and what to do, if a record is longer than the provided record length. On read, you can also activate the conversion of the data into a printout-like amount of records, i.e. print control characters are replaced by records so that it looks like the data was printed. The access method removes zero padding and trailing whitespaces from each record by default. Additional You can activate the suppression of control and space character (except tabulators or blank) in the data. * `STRING: NAME/FILE['str'/STREAM/DUMMY...] - Name/URL of file to read [STDIN]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: RECMOD=STOP/CUT/WRAP/SKIP - Mode used to read records [STOP]` ** `STOP - Stop if record too long` ** `CUT - Cut if record too long` ** `WRAP - Wrap if record too long` ** `SKIP - Skip if record too long` * `NUMBER: RECLEN=num - Record (Host) length / Line (Unix/Win) length for read operations [512]` * `NUMBER: RECCNT=num - Amount of records handled in one read operation [128]` * `NUMBER: PRNOUT=num - Amount of lines per page if print control replacement active [0 = inactive]` * `SWITCH: SUPCTR - Suppress control characters [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-fl4_7820.html",
"FL4",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.FL4]] ==== FL4 indexterm:[Object, FL4, XCNV.INPUT.SAVE.FILE.FIO.FL4] This object defines the FLAM4 read operation for files. This method reads records from a FLAMFILE of version 4 or older. It uses the FLAM4 record interface to read members from a FLAMFILE. The parameters below are explained in detail by the FLAM command of FLCL. * `STRING: NAME/FLAMFILE/FILE['str'/STREAM/DUMMY...] - Name/URL of FLAMFILE to read [STDIN]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: MEMBER='str' - Name or index of the member in the FLAMFILE` * `NUMBER: RECLEN=num - Maximum record length for read operations [512]` * `NUMBER: RECCNT=num - Amount of records handled in one read operation [128]` * `SWITCH: TRUCAT - Allow truncation of records [FALSE]` * `SWITCH: NONFIL - Switch to replace original file name with FILEnnnn [FALSE]` * `NUMBER: DEVICE=FILE/DISK/TAPE/FLOPPY/STREAMER/USER - Device used to store the FLAMFILE [FLATFILE]` ** `FILE - Write to a file (equal to disk)` ** `DISK - Write to a disk (equal to file)` ** `TAPE - Write to a tape` ** `FLOPPY - Write to a floppy` ** `STREAMER - Write to a streamer tape` ** `USER - Use user IO` * `STRING: PASSWD='bin'/DEFAULT - Passphrase to decrypt the FLAMFILE ['']` ** `DEFAULT - FLAM4 default password` * `STRING: KMELIB='str' - Library name for FKME ['']` * `STRING: KMEFUC='str' - Function name of FKME ['']` * `STRING: KMEPAR='bin' - Parameter for the call of FKME ['']` * `STRING: EXTCMP/EXK20='str' - Name of user exit for compression` * `STRING: EXTDCO/EXD20='str' - Name of user exit for decompression` * `NUMBER: FLFCDP=REWIND/UNLOAD/LEAVE - Close disposition for the FLAMFILE (mainly host related)` ** `REWIND - Rewind the tape to the beginning` ** `UNLOAD - Rewind the tape and unload it` ** `LEAVE - Do not rewind` * `NUMBER: SECINF=YES/NO/IGNORE/MEMBER - Define handling of secure information` ** `YES - Create secure information at compression` ** `NO - Do not store any additional secure information` ** `IGNORE - Ignore any security violations on decompression` ** `MEMBER - Only member-specific security information is verified` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fio-zip_7665.html",
"ZIP",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FIO.ZIP]] ==== ZIP indexterm:[Object, ZIP, XCNV.INPUT.SAVE.FILE.FIO.ZIP] This method reads members from a ZIP or Zip64 archive. The FIO.ZIP() method does not decompress files from the archive. You must use it in conjunction with CNV.ZIP() or a dedicated decompression converter to get the decompressed data. When reading a deflated file from a ZIP archive without decompression, a GZIP file is the result. The same is valid for BZIP2 compressed archive members. By activating the REMOVE switch, the file is deleted from the archive after the extracted file was successfully written. If no member is left in the archive, the ZIP file itself is deleted. If there are still members in the ZIP file, a reorganized version of the ZIP file is left behind without the files that have been processed successfully. This re-organization requires a temporary file in the background. On z/OS it will be allocated a memory file in the hyper space. For huge archives it is not recommended to use the remove switch. * `STRING: NAME/FILE['str'/STREAM/DUMMY...] - Name/URL of ZIP file to read [required]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: MEMBER='str' - Name or index of the member in the ZIP archive` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv_5bc2.html",
"CNV",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV]] ==== CNV indexterm:[Overlay, CNV, XCNV.INPUT.SAVE.FILE.CNV] With the overlay CNV you can choose the different kind of conversions supported at read operations. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-blk_b00a.html",
"BLK",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.BLK]] ==== BLK indexterm:[Object, BLK, XCNV.INPUT.SAVE.FILE.CNV.BLK] The block converter can be used to convert records into data blocks with delimiters. On output, it can also add different length formats in front of the records or append a binary delimiter. You can also put all attributes of a record in front of the data. With CNV.REC() (opposite of CNV.BLK()) the length fields, delimiter and attributes can be parsed back. This conversion component uses the text, block and binary formatting components and provides all their features. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: METHOD=HOST/BIN/REC/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM/ORIGINAL - Method for block/text formatting [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `REC - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` ** `ORIGINAL - Adds the original data at the end of a line (only for band FMT)` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `SWITCH: SUPTWS - Suppress trailing whitespace [FALSE]` * `NUMBER: RPLTAB/RPLHTB=num - Replace horizontal tabulators by spaces using this tab width [0 = no replacement]` * `NUMBER: RPLVTB=num - Replace vertical tabulators by new lines using this tab width [0 = no replacement]` * `SWITCH: RPLBSP - Replace backspace (deletes the backspace and the byte before) [FALSE]` * `NUMBER: RPLCTR=SPACE/SUBSTITUTE/DELETE - Replace remaining control characters [NONE]` ** `SPACE - Replace control characters with whitespace character (0x20/0x40)` ** `SUBSTITUTE - Replace control characters with substitution character (0x1A/0x3F)` ** `DELETE - Remove control characters` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-rec_2ddb.html",
"REC",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.REC]] ==== REC indexterm:[Object, REC, XCNV.INPUT.SAVE.FILE.CNV.REC] The record converter can be used to convert data blocks with delimiters or on input with different record length formats into data lists with records. This conversion component uses the text and record formatting component and provides all its features. Auto detection of 4 byte record length fields is attempted if no method is provided. If the data block contains no record length fields or the provided binary delimiter does not fit and the switch to skip text formatting is not enabled, then all capabilities of the text formatting component are used to form records. The SKPTXT flag causes input blocks to be only converted to records if record length fields or binary delimiter are detected. This can be useful, for example, for reading ZIP archives containing record-oriented files. PKZIP stores record-oriented files with a 4 byte length field (length of the field itself not included) in front of the record data in little endian (L4X). Another example files stored with FILEDATA=RECORD (B4X) in USS. When reading such a file, the length fields must be interpreted to re-build the corresponding records. This conversion can be added after any I/O or other conversion step. ZIP files, GZIP files and the ASCII armor header support storing custom attributes which is used to store file attributes like the length field format, binary delimiter of the records, whether ASA or machine control characters are present, etc. If the file is written using CNV.BLK(PUTATR), the record attributes (RRDS slot number, print control characters) are written in front of each record and a custom file attribute stores a flag to mark which record attributes are present in order to be able to later parse the records correctly automatically. Other file formats do not support custom attributes. Hence, it is not possible to store file attributes in, e.g., BZIP2 or binary PGP files. In these cases, the PRSATR (parse attributes) parameter must be set to the correct keyword in order to read the file correctly if it has been written with the PUTATR switch enabled. The keyword to choose depends on the original file format. * `NUMBER: METHOD=BIN/TXT/REC/WRP/LEN/L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method for record/text formatting [DEFAULT]` ** `BIN - Convert data blocks in text records of defined record length` ** `TXT - Parse data block for text delimiter (DEFAULT)` ** `REC - Use read/known record length (only useful on mainframes)` ** `WRP - Binary wrap of data blocks in records of defined record length` ** `LEN - Parse data based on 4 byte length fields with auto detection of the format` ** `L4I - Parse data based on 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse data based on 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse data based on 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse data based on 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse data based on 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse data based on 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse data based on 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse data based on 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse data based on 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse data based on 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse data based on 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse data based on 4 byte length fields: System endian short (LLxx), length exclusive` ** `DLM - Parse data based on the provided binary record delimiter` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `NUMBER: RPLTAB/RPLHTB=num - Replace horizontal tabulators by spaces using this tab width [0 = no replacement]` * `NUMBER: RPLVTB=num - Replace vertical tabulators by new lines using this tab width [0 = no replacement]` * `SWITCH: RPLBSP - Replace backspace (deletes the backspace and the byte before) [FALSE]` * `NUMBER: RPLCTR=SPACE/SUBSTITUTE/DELETE - Replace remaining control characters [NONE]` ** `SPACE - Replace control characters with whitespace character (0x20/0x40)` ** `SUBSTITUTE - Replace control characters with substitution character (0x1A/0x3F)` ** `DELETE - Remove control characters` * `SWITCH: SUPTWS - Suppress trailing whitespaces at text parsing [FALSE]` * `SWITCH: NELDLM - Activate NEL (0x85) as delimiter for ASCII character sets [FALSE]` * `NUMBER: PADCHR=num - Padding character [0x00]` * `NUMBER: RECLEN=num - Length used to cut the data block in records [512]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [4<128<1024]` * `STRING: RECDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to parse end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: RSTDAT=RECORD/ERROR/IGNORE - Defines handling of remaining rest [auto]` ** `RECORD - Build a record with the remaining rest (default for delimiter)` ** `ERROR - Return an error if a remaining rest found (default for length fields)` ** `IGNORE - Ignore a remaining rest (no record, no error)` * `SWITCH: SUPPAd - Suppress trailing padding/equal bytes at record parsing [FALSE]` * `NUMBER: PRSATR=ASA/MCC/REL/RELASA/RELMCC - Parse attributes (e.g. print control character) in front of the record [NONE]` ** `ASA - ASA print control character (1 byte)` ** `MCC - Machine print control character (1 byte)` ** `REL - Slot number of RRDS (8 byte integer in big endian)` ** `RELASA - Slot number plus ASA print control character (9 byte)` ** `RELMCC - Slot number plus Machine print control character (9 byte)` * `SWITCH: SKPTXT - Skip and don't try text conversion if no record length fields found in the data [FALSE]` * `SWITCH: SKPLEN - Skip conversion if method LEN and no record length fields found in the data [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-cry_9745.html",
"CRY",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.CRY]] ==== CRY indexterm:[Object, CRY, XCNV.INPUT.SAVE.FILE.CNV.CRY] The CRYPTO converter can read encrypted data streams. The decryption method is detected automatically. All stream-based encryption procedures (OpenPGP, ...) are supported which are also available separately on the conversion level of XCNV. This component simply uses the dedicated decryption components and adds the auto detection. Please refer to the individual crypto components for more details. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation[65536]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-pgp_3d26.html",
"PGP",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.PGP]] ==== PGP indexterm:[Object, PGP, XCNV.INPUT.SAVE.FILE.CNV.PGP] The OpenPGP converter can be used to encrypt or decrypt data streams conforming to RFC4880. The available functionality depends mainly on the functions implemented by the used FLAM key management extension version 5 (FKM5). Encryption always results in binary blocks of data. The decryption result can be text or binary data. Record boundaries are lost. Please use delimiters, length fields or fixed length data if records must be exchanged. The encrypted data can be ASCII-armored for transport/storage via/on text-based media. If compression parameters are not specified and the data is marked as being without redundancy, then no compression is done. In all other cases, the default level 6 (AUTO) with GZIP is used. You can switch to level 1 or 9 with the FAST and BEST keywords, respectively. Currently, the compression procedures GZIP (DEFAULT, raw without header, called ZIP in RFC4880), ZLIB and BZIP2 are supported. With the compression mode COPY, no compression is done, but to save CPU time, we recommend to use the defaults. On z/OS, the GZIP compression is done with ZEDC if available. Some PGP crypto operations use a random number generator (e.g. for session key generation) which needs to be initialized with high quality entropy. If there is no good source of entropy available from the operating system (e.g. /dev/urandom, /dev/random or /dev/srandom on Unix-like systems including z/OS (which requires ICSF)), some operations may fail. Without a source of entropy, cryptographically safe randomness cannot be generated and would likely lead to weak encryption. Therefore, it is better to abort the operation. If you wish to continue anyway and potentially weak encryption is acceptable, you can define the environment variable FL_ALLOW_LOW_ENTROPY. It allows the random number generator to be seeded with a low entropy source based on the variability of CPU clock cycles. Plase note that there is no 100% guarantee for this to work. The component supports different methods, formats and algorithms for encryption and signing. By default, a newer format of PGP data packets is used that protects the encrypted data against modification (SEIP, c.f. RFC4880 'Symmetrically Encrypted Integrity Protected Data Packet'). The old format (SENC) without integrity protection can also be used if necessary (not recommended). Additionally, you can define the key label templates as well as user and signer IDs for FKM5 usage. PGP files containing (un)compressed and unencrypted data are supported. If you want to ensure that only encrypted data is accepted when reading, you can enable the FRCENC switch. FRCINT enforces integrity protection. Additionally, you can also enforce signing. Symmetrical encryption using a password is also supported, but is not recommended to use. For a professional solution, the FLAM key management extension version 5 can be used. Several implementations are available in LIBFKM5. For example, on z/OS the use of ICSF PKDS is the default. When reading, the key is chosen based on the key ID provided in the PGP message. Some tools like GunPG support hidden recipients, where no key ID is stored. In such a case, the user ID must be provided to read the encrypted PGP file. If there are multiple keys for the same user ID and the required key is not the currently active key (i.e. the youngest of valid keys at the current point in time), a timestamp must also be provided which is used instead of the current time. It must be within the validity period of the key. Setting a timestamp has the same effect as setting the system time to the timestamp. So, if you specify a timestamp one year in the future, the key is selected that matches the user ID and is the youngest of valid keys at the date one year from now. If there is more than one matching key (multiple keys with same user ID and creation date), the key with the shortest validity period is chosen. To generate, import, export and delete PGP keys, the corresponding KEY command can be used. Below you can see examples for generating a new key, exporting the resulting public key and importing a key from another node. If you can use the standard FKM5 for your platform, reading PGP files can be done completely transparently. It is possible to define different decryption specifications (3 passphrases and 2 different FKM5) by using CNV.PGP() more than once. To control this, the switches SKPKEY (skip if key does not match) and SKPFMT (skip if invalid format) are may be used. When writing you can define a list of user IDs or passwords as recipients. These arrays allows to define more than one entity which can read this file. A PGP file consists of layered packets. An encrypted PGP file usually consists of literal packets containing the plain text. This stream can then be compressed and put into compression packets. The last layer is the encryption using SEIP (symmetrically encrypted and integrity protected) or SENC (only symmetrically encrypted) packets. Each of these levels are valid PGP files and many more combinations are possible. To implement this hierarchical system of PGP file formats, the CNVPGP component internally uses various conversion layers. Normally, decoding is done up to the literal (parameter LEVEL not set) packet layer to produce the original plain text. If you want stop decoding earlier, for example after decryption, then set LEVEL to 1. To stop after decompression set the parameter LEVEL to 2. When reading encrypted data that is not integrity protected (i.e. consists of old format SENC packets), a warning is printed to the log because the encrypted data might have been modified. With SENC, however, there is no way to detect encrypted data modifications. When reading PGP files, packet layers are removed until reaching the literal packet layer. With the LITERR switch you can enforce an error if no literal data can be found. By default, this is disabled because another PGP conversion can follow. If the block size is too small, situations can occur where level X does not have enough data to provide input to level X+1. In such case a SIZE error occurs. Especially if BZIP2 is used as compression algorithm or a very small block size is used this likely to occur. We recommend to work with the default block sizes, to prevent this error. Simple write example (with ICSF/CCA FKM5) On z/OS, 'LIBFKM5' is the default library and 'PGPCCA' the default function. With HCR77B0 (z/OS2.2) the 'KEYSTORE' must not longer be provided, if the PKDS only solution is used. In this case, only the FKM5 object must be activated. Simple read example (with PKCS11 FKM5) In general, it would be useful to define the FKM5 object via a property file to simplify the use of the CNVPGP component. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `SWITCH: NOSIGV - Disable signature verification [FALSE]` * `STRING: PASSWD='bin' - Passphrase for symmetrically encrypted OpenPGP File` * `SWITCH: SKPKEY - Skip decryption if key not match (try next conversion) [FALSE]` * `SWITCH: SKPFMT - Skip decryption if data format not match (try next conversion) [FALSE]` * `SWITCH: FRCENC - Enforce an error of PGP file is not encrypted [FALSE]` * `SWITCH: FRCINT - Enforce an error if PGP file is not integrity protected [FALSE]` * `SWITCH: FRCSIG - Enforce an error if PGP file is not signed [FALSE]` * `SWITCH: LITERR - Enforce an error if no plain text returned [FALSE]` * `STRING: USERID='str' - Receiver user ID for decryption (only for hidden recipients)` * `NUMBER: TIMSTP=num - Time stamp (seconds since 1970) used for key selection [0 - current]` * `NUMBER: LEVELS=num - Limit amount of decodings [0-ALL]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-edc_bf8b.html",
"EDC",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.EDC]] ==== EDC indexterm:[Object, EDC, XCNV.INPUT.SAVE.FILE.CNV.EDC] [[CNV.EDC]] The encryption/decryption converter can be used to encrypt or decrypt data streams. These streams are compatible with the `openssl enc` command, allowing to encrypt data with FLAM and decrypt with OpenSSL or vice versa. Crypto operations are performed in software, with hardware-acceleration (if available) or via FKM5 using a key label. Encryption always results in binary blocks of data. The decryption result can be text or binary data. Record boundaries are lost. Please use delimiters, length fields or fixed length data if records must be exchanged. The OpenSSL-compatible encryption output is raw encrypted data. An automatic detection of this format is not possible, except for the salt of the salted passphrase procedure, in which case a corresponding header is written. The encrypted data can be ASCII-armored for transport/storage via/on text-based media. Compression should be done before encryption because the encrypted output looks like random data which is incompressible. The component supports different methods, algorithms, key lengths, modes and paddings. Invalid or unsupported combinations will result in an error. Additional the password to key derivation function can be specified including the hashing procedure and amount of iterations. NOTE: Please have a look at the <<cnvedc.considerations,security considerations section>> before using this component. During encryption, a parameter side file can be generated. It contains information from the encryption process that is relevant for decryption (e.g. the GCM tag value if encrypting with AES-GCM). If decryption is done with `cnv.edc()` as well, the existing side file can be specified, avoiding the need to specify the relevant parameters manually. The example below uses an SSH server for the side file. The parameter side file is a text file which contains the parameter values used during encryption. The same parameter values must be passed to CNVEDC for decryption. To facilitate this, you can generate this side file during encryption by assigning a file path to the `parm` parameter. This same file can then be used during decryption via the same parameter, allowing you to omit most parameters (except the key) during decryption. Hence, the parameter side file is mainly useful if the data will be decrypted with FLAM. To generate random IVs or random clear keys, the keyword `RANDOM` can be used for the respective parameters. The generated values are then written to the side file and required for decryption. NOTE: Please be aware that if `key=RANDOM` was specified, a new encryption key is generated per file and the generated encryption key is written to the side file (which is required in this case) because it would be impossible to decrypt the data without the randomly generated key. Anyone who can read this side file can decrypt your data! We _do not_ recommend to store encrypted data and side file together or transmit both over the same channel. If you do not fully understand the security implications, we recommend not to use `key=RANDOM`. If you specify your own clear key via `key` parameter, it is not written to the parameter side file. However, you can instruct to explicitly write the key to the side file with the `PRNKEY` flag. The warning above also applies in this case. The parameter side file may contain: * Method (as comment) * Cipher algorithm * Cipher mode * Key length * For password-based encryption: ** Key derivation function (KDF) ** Hash function used for key derivation ** Iteration count for key derivation * Offset (i.e. the position of the first encrypted byte) * Clear key value (only if random or `PRNKEY` flag is set, see warning above) * Initialization vector (only if random or `PRNKEY` flag is set) * Salt (if password-based encryption is used with a random salt and no header is written or `PRNKEY` flag is set) * Authentication Tag (only if no tag file defined, required by AEAD cipher modes like GCM to verify authenticity of encrypted data during decryption) The side file is required if at least one of the following is true: * GCM is used as cipher mode and no separate `TAG` file is provided * `key=RANDOM` or `IV=RANDOM` was specified * Password-based encryption with a random salt is used and no header is written This corresponds to the following usage patterns: If you use a clear key, passphrase or KFM5 key label for encryption and also specify a parameter side file, it is sufficient to specify the side file and your key/passphrase/label during decryption because all other parameters are contained in the side file: All cipher modes except ECB require an initialization vector. An initialization vector (IV) makes sure that the ciphertext is completely different for every encryption operation even if the same data is encrypted with the same key multiple times. Each IV value should only be used once with a given key for encryption. The same IV must be used for decryption, otherwise the output will be random data. Using the same IV more than once may allow an attacker to gather information about common prefixes in your plaintext (i.e. files that start identically). To avoid that, use a different IV for each file. The default IV is all zeroes. You can and _should_ either specify a (hexadecimal) IV that you generated on your own or you can generate a random IV with `iv=RANDOM` (recommended) which is written to the parameter side file. Alternatively, a clear key or key label can be combined with a password as additional factor. The IV is then derived from the password and a salt (with properties described below). For password-based encryption, the key and IV are derived from the password and a salt by default. Multiple key derivation methods are available (e.g. OpenSSL, PBKDF2). Unless specified otherwise, the salt is randomly generated. The 8 bytes magic string `Salted__` followed by the generated 8 bytes salt value is prepended to the encryption output, making it compatible to OpenSSL's `enc` command. The prepended salt is automatically detected during decryption. Writing of the salt header can be disabled with `FORMAT=NOHDR`. The salt is then written to the parameter side file which, in this case, is required because otherwise decryption is impossible. You can specify a custom 8-byte salt value in hexadecimal form via the parameter `salt` or set it to `none` to not use a salt, which is not recommended because the same key and IV will be derived for each encryption operation. An IV can also explicitly be specified in which case it overrides the derived IV. [[cnvedc.defaults]] When writing with `cnv.edc()` using key-based encryption, the defaults below apply: * METHOD=CLEAR * ALGO=AES * KEYLEN=KL128 * MODE=CBC * IV=ZERO * KEY=RANDOM For password-based encryption (i.e. a password is supplied), these defaults apply: * METHOD=OLDSSL * ALGO=AES * KEYLEN=KL128 * MODE=CBC * SALT=RANDOM * IV=DERIVED FROM PASSWORD+SALT * KEY=DERIVED FROM PASSWORD+SALT NOTE: These defaults may change in the future. Depending on your use case, you might want to explicitly specify all relevant parameters to avoid behavioral changes when upgrading to future FLAM versions. AEAD modes combine encryption and authentication in a single algorithm, making a separate HMAC unnecessary to ensure authenticity. In addition to protecting confidential data, AEAD ensures the authenticity and integrity of other data that is not encrypted, called associated data. The purpose is, for example, the transmission of a message header, which must be available as plaintext for processing. With AEAD, the associated data and the encrypted data become inseparable. Currently, only GCM is supported as AEAD scheme. It was developed with the protection of network communication protocols in mind that often require header data that must be processed by involved entities without decrypting the content. Each transmitted message is typically relatively small and protocols usually re-negotiate encryption keys after a certain amount of data was transmitted. As a result, GCM has limitations that make it less suitable for file encryption. The maximum amount of data that can be encrypted with the same Key+IV combo is slightly below 64 GiB (2^36-32 = 68,719,476,704 bytes). The same key should not be used for more than 2^32 encryption operations because the IV is only 96 bits and the collision probability of randomly generated IVs rises significantly beyond that limit. The authentication tag, which is mandatory for decrypting the data with GCM, can optionally be written to and read from a dedicated file by specifying a path for the `tag` parameter. If the `tag` parameter is not specified, the tag is written to the parameter side file. In any case, one of the two is needed during decryption to ensure authenticity. Example for the `tag` parameter: With the parameter `offset`, you can start the encryption after offset amount of bytes. The data between the beginning and the offset will remain plaintext. This can be useful to keep some meta data (e.g. headers) at the beginning of the file in unencrypted form. With GCM, this unencrypted part becomes associated data and is thus part of the authentication tag, protecting it against tampering. TODO: Describe filename patterns for PARM when implemented If the component is used on multiple files at once, the parameter side file will contain a concatenation of all metadata for all files processed. The original filenames are written as comment to the side file to separate the sections. However, such a parameter file cannot be used for decryption. Therefore, we don't recommend to use a side file when encrypting multiple files with a single invocation. [[cnvedc.considerations]] Some recommendations to safely and securely use this component: * Default values may change in the future. We recommend to set at least   the parameters mentioned in the <<cnvedc.defaults,defaults section>>   if you don't want behavioral changes after FLAM updates. * Do not use the same IV value more than once for encryption * If you specify a custom IV and write multiple files (e.g. by using file   name patterns), the same IV will be used to encrypt all files which   leaks information about common prefixes if the files start with the   same sequence of bytes. * Avoid predictable IV values (unsafe against chosen plaintext attacks like BEAST) * Use `iv=RANDOM` if possible * Change encryption keys periodically * For GCM: Do not encrypt files larger than 64 GiB (minus 32 bytes) * For GCM: Do not encrypt more than 2^32 files with the same key  * Avoid password-based encryption without salt (results in constant key   and IV for every encrypted file) * If you write a parameter side file that contains a key (`key=RANDOM` or flag `PRNKEY`)   make sure to not store it at the same location or transmit it over the   same channel as the encrypted file. The component was implemented with compatibility to the `enc` command of the OpenSSL command line utility in mind. Data that was encrypted with this component can be decrypted with OpenSSL and vice versa as long as their parameterization is equivalent. There are a few exceptions to OpenSSL compatibility: * GCM is not a supported mode of the OpenSSL command line tool because of the limitations described above and resulting security implications. * If the `offset` parameter is used, the file cannot be decrypted with the OpenSSL command line tool * Too short keys or IVs will lead to an error, unlike the OpenSSL command line tool Here is an example for interoperability using password-based encryption with PBKDF2 as key derivation method and a custom IV. The first two lines represent the parameters for encryption and decrytion with CNVEDC. The other two lines are the equivalent OpenSSL command line parameters. A simple example for file encryption with AES-128-CBC using a custom clear key and IV. Note that you should use a randomly generated IV per file. In order to be able to use the component in the detection when reading, its removal can be activated under certain circumstances via the parameter `SKPFMT`. On the one hand, with the selection `NOHEADER` (activated in the CONV command with DECRYPT.PWD()), which leads to removal if no salted header is found. The next stage is called `SUPPORTED`, where no decryption takes place if the data at hand corresponds to a format that is processed by other components. With `REDUNDANT` it can be prevented that the decryption takes place on data that show redundancies, which cannot be the case with a cryptogram (white noise). An exception to this is ECB mode, which can lead to recurring cryptograms if the data are identical. Therefore, `REDUNTANT` is not supported in ECB mode. With `SUPPREDU`, the latter two mechanisms can be requested together, which comes into play in the read string of the CONV command in DECRYPT.EDC(). * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: METHOD=CLEAR/PASSWORD/LABEL - Method for key determination [AUTO]` ** `CLEAR - Clear key crypto (en/decrypt with raw unprotected key value)` ** `PASSWORD - Password-based crypto (using key derivation function (KDF))` ** `LABEL - Protected key crypto using label (FKM5 required)` * `NUMBER: ALGO=AES/TDES/CAST5/CAST128/IDEA/BLOWFISH/BF/CAMELLIA - Algorithm used for decryption [AES]` ** `AES - Advanced encryption standard (Rijndael)` ** `TDES - Triple DES (Data encryption standard)` ** `CAST5 - CAST5/CAST-128 (Carlisle Adams, Stafford Tavares)` ** `CAST128 - CAST-128/CAST5 (Carlisle Adams, Stafford Tavares)` ** `IDEA - International Data Encryption Algorithm` ** `BLOWFISH - Blowfish from Bruce Schneier` ** `BF - Blowfish from Bruce Schneier` ** `CAMELLIA - Camellia from Japan (Mitsubishi Electric and NTT)` * `NUMBER: KEYLEN=num/KL064/KL128/KL192/KL256/KL08/KL16/KL24/KL32 - Key length if passphrase used` ** `KL064 - Key length 64 bits (8 bytes)` ** `KL128 - Key length 128 bits (16 bytes)` ** `KL192 - Key length 192 bits (24 bytes)` ** `KL256 - Key length 256 bits (32 bytes)` ** `KL08 - Key length 8 bytes (64 bits)` ** `KL16 - Key length 16 bytes (128 bits)` ** `KL24 - Key length 24 bytes (192 bits)` ** `KL32 - Key length 32 bytes (256 bits)` * `NUMBER: MODE=ECB/CBC/OFB/CFB/CTR/GCM - Mode of operation [if TAG then GCM else CBC]` ** `ECB - Electronic codebook mode` ** `CBC - Cipher block chaining mode` ** `OFB - Output feedback mode` ** `CFB - Cipher feedback mode` ** `CTR - Counter mode` ** `GCM - Galois/Counter Mode ` * `NUMBER: PADDING=NONE/NOPAD/PKCS - Padding for CBC or ECB mode [PKCS]` ** `NONE - No padding (remaining data must have a multiple of the block length)` ** `NOPAD - No padding (remaining data must have a multiple of the block length)` ** `PKCS - OpenSSL conform PKCS padding` * `NUMBER: KDF/PW2KEY=OLDSSL/PBKDF2 - Password to key derivation function [OLDSSL]` ** `OLDSSL - Legacy OpenSSL key derivation (avoid use, default: SHA-256 with 1 round, hint: OpenSSL < 1.1.0 used MD5)` ** `PBKDF2 - PBKDF2 key derivation function (default: SHA-256 with 10000 rounds, available from OpenSSL 1.1.1)` * `NUMBER: MD/HASH=MD5/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512 - Hash algorithm for key derivation [SHA256]` ** `MD5 - Message Digest 5 with 128 bits` ** `SHA1 - Secure Hash Algorithm 1 with 160 bits` ** `SHA224 - Secure Hash Algorithm 2 with 224 bits` ** `SHA256 - Secure Hash Algorithm 2 with 256 bits` ** `SHA384 - Secure Hash Algorithm 2 with 384 bits` ** `SHA512 - Secure Hash Algorithm 2 with 512 bits` ** `SHA3-224 - Secure Hash algorithm 3 with 224 bits` ** `SHA3-256 - Secure Hash Algorithm 3 with 256 bits` ** `SHA3-384 - Secure Hash Algorithm 3 with 384 bits` ** `SHA3-512 - Secure Hash Algorithm 3 with 512 bits` * `NUMBER: ITER=num - Iteration count for PBKDF2, implies METHOD=PBKDF2 if specified [10000]` * `STRING: IV='bin-hex'/ZERO - Initialization vector for all modes except ECB [ZERO]` ** `ZERO - Initialization vector of binary zeros` * `STRING: SALT='bin-hex'/NONE/RANDOM - Salt for salted passphrase-based decryption [AUTO]` ** `NONE - No salt (not recommended)` ** `RANDOM - Random generated salt` * `STRING: KEY='bin-hex' - Clear key value (direct entry of raw value (dangerous))` * `STRING: PASSWORD='str' - Passphrase with or without salting` * `STRING: LABEL='str' - Label to reference a protected key (FKM5 required)` * `STRING: TAG='bin-hex' - The tag value for verification (only for GCM mode)` * `NUMBER: OFFSET=num - Offset before decryption begins [0]` * `STRING: PARM='str'/STDOUT/STDERR - Side file with parameter used for decryption (merged if not empty else written)` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` * `NUMBER: SKPFMT=NOHEADER/SUPPORTED/REDUNDANT/SUPPREDU - Skip decryption if format not valid [NO]` ** `NOHEADER - Skip if no salted header found` ** `SUPPORTED - Skip if format supported (PGP, GZIP, BZIP, XL, ZSTD, XML, ...)` ** `REDUNDANT - Skip if data redundant (not a white noise)` ** `SUPPREDU - Skip if format known or data redundant` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-gzp_8fde.html",
"GZP",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.GZP]] ==== GZP indexterm:[Object, GZP, XCNV.INPUT.SAVE.FILE.CNV.GZP] The GZIP converter can be used to compress or decompress data streams. The result of a compression is a binary block. The result of a decompression can be text, XML, a base encoding or binary data. Record boundaries are lost. Please use delimiters, length fields or fixed length data if records must be exchanged. The GZIP decompression can read all supported formats of zlib and writes RFC1952/51/50-compliant data streams. If a IBM ZEDC acceleration card is available and can be used, the ZEDC is used to save CPU time. In this case, however, the compression does not conform to RFC1951. The compressed data is encoded based on RFC1950 and the file format conforms to RCF1952. For a checksummed GZIP header, an additional switch must be activated, because this feature is not supported by all GZIP implementations. The GZIP header is used to store meta information about the data, which can be used if FLAM is also used for decompression. This can be very useful to clearly define the character set, CCSID and other information about the data. If no compression level is set and the data is marked as being without redundancy, then level 0 (copy) is used. Otherwise, the default level 6 is used. Decompression of concatenated GZIP files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: GZIP data streams are written to ZIP archives as compression mode 8. The GZIP header and trailer are replaced by a ZIP local file header. If a deflated file (compression mode 8) is read from a ZIP archive, it is converted to a GZIP data stream which can be inflated with this component. * `STRING: MEMBER='str' - Index of the member in the GZIP-File to read` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation[65536]` * `SWITCH: SKPORG - Skip decompression if original was copied [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-bz2_1723.html",
"BZ2",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.BZ2]] ==== BZ2 indexterm:[Object, BZ2, XCNV.INPUT.SAVE.FILE.CNV.BZ2] The BZIP2 converter can be used to compress or decompress data streams compatible with the BZIP2 utility on UNIX systems. The result of a compression is a binary block. The result of a decompression can be text, XML, a base encoding or binary data. Record boundaries are lost. Please use delimiters, length fields or fixed length data if records must be exchanged. There is no header to store meta information about the data, so all metadata is lost. If no compression level is defined, the level used depends on the block size. A block size larger than 900KB results in the best compression level 9, greater than 800KiB and smaller than 900KiB in level 8, and so on. For blocks smaller than 100KB level 1 is used. Decompression of concatenated BZIP2 files is also possible. All concatenated files will be decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: BZIP2 data is written to ZIP archives as compression mode 12. The BZIP2 header and trailer are replaced by a ZIP local file header. If a BZIP2 file (compression mode 12) is read from a ZIP archive, it is converted to a BZIP2 data stream and can be decompressed with this component. * `STRING: MEMBER='str' - Index of the member in the BZIP2-File to read` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `SWITCH: SMLSPC - Use small memory space for decompression [FALSE]` * `SWITCH: SKPORG - Skip decompression if original was copied [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-lxz_5667.html",
"LXZ",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.LXZ]] ==== LXZ indexterm:[Object, LXZ, XCNV.INPUT.SAVE.FILE.CNV.LXZ] The LZMA/XZ converter can be used to compress or decompress data streams compatible with the XZ utility on UNIX systems. The result of a compression is a binary block. The result of a decompression can be text, XML, a base encoding or binary data. Please use delimiters, length fields or fixed length data if records must be exchanged. There is no header to store meta information about the data, so all metadata is lost. If no compression level is defined and the data is marked as being without redundancy, then level 0 (copy) is used. In all other cases the default level 6 is used. Decompression of concatenated XZ files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: XZ data streams are written to ZIP archives as compression mode 14 (LZMA). The XZ header and trailer are replaced by a ZIP local file header. If an LZMA file (compression mode 14) is read from a ZIP archive, it is converted to an XZ data stream which can be decompressed with this component. * `STRING: MEMBER='str' - Index of the member in the XT-File to read` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `SWITCH: SKPORG - Skip decompression if original was copied [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-zst_4a4c.html",
"ZST",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.ZST]] ==== ZST indexterm:[Object, ZST, XCNV.INPUT.SAVE.FILE.CNV.ZST] The ZSTD converter can be used to compress or decompress data streams compatible with the ZSTD utility on UNIX systems. The result of a compression is a binary block. The result of a decompression can be text, XML, a base encoding or binary data. Please use delimiters, length fields or fixed length data if records must be exchanged. There is no header to store meta information about the data, so all metadata is lost. If no compression level is defined and the data is marked as being without redundancy, then level 0 (copy) is used. In all other cases the default level 6 is used. Decompression of concatenated ZSTD files is also possible. All concatenated files are decompressed into one file. It is also possible to decompress one specific member of this concatenation by specifying the member index of the file to be decompressed: ZSTD data streams are written to ZIP archives as compression mode 14 (LZMA). The ZSTD header and trailer are replaced by a ZIP local file header. If an ZSTD file (compression mode 14) is read from a ZIP archive, it is converted to an ZSTD data stream which can be decompressed with this component. * `STRING: MEMBER='str' - Index of the member in the XT-File to read` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `SWITCH: SKPORG - Skip decompression if original was copied [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-zip_658a.html",
"ZIP",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.ZIP]] ==== ZIP indexterm:[Object, ZIP, XCNV.INPUT.SAVE.FILE.CNV.ZIP] The ZIP converter can read or write compressed data streams. It is meant to be used in combination with ZIP archives (FIO.ZIP()), otherwise the archived files are stored uncompressed. When reading, the compression algorithm is detected automatically. When writing, compression is skipped dynamically when no redundancies are found in the data and hence data reduction is not possible, resulting in the data being stored uncompressed. The supported compression algorithms are DEFLATE (default) and BZIP2. Note that many compression utilities do not support decompression of files not compressed with DEFLATE (ISO). Internally, this component uses the dedicated compression components for CNV.GZP() and CNV.BZ2(). For details like compression levels, please refer to the documentation of these components. When using this component together with FIO.ZIP() to decompress archive members and the ZIP file to be read contains files that are compressed with GZIP, BZIP2 or XZ, they are automatically decompressed. To prevent automatic decompression, the SKPORG switch must be activated. NOTE: If you use one of the dedicated compression components (CNV.GZP(), CNV.BZ2(), ...) instead of CNV.ZIP(), the resulting ZIP file contains uncompressed (from ZIP perspective) files that have been compressed with GZIP/BZIP2/... before they have been added to the ZIP file. * `STRING: MEMBER='str' - Index of the member in the compressed file to read` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation[65536]` * `SWITCH: SKPORG - Skip decompression if original was copied [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-chr_83e6.html",
"CHR",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.CHR]] ==== CHR indexterm:[Object, CHR, XCNV.INPUT.SAVE.FILE.CNV.CHR] This component can be used to convert a text stream to a different character set after reading or before writing. Character conversion requires a source CCSID (FROM) and a target CCSID (TO). Using the keyword MODE, you can define the behavior when invalid or incomplete characters are encountered in the input data. It is possible to stop at, ignore or substitute unsupported characters. For the latter case, you can define a substitution character list (SUBCHR) and/or a user substitution table (USRTAB) and/or use one of the pre-defined system substitution tables (SYSTAB) for transliteration. When using a system table, you can override some of the pre-defined code points using a user table. Each character must be defined as Unicode codepoint in hexadecimal notation. Each ignore or substitution process, including transliteration, can be recorded in a report file for review. Moreover, you can convert to upper, lower, special case or use case folding. The component also provides powerful support for byte order marks (BOM) including: * Byte order change handling at read (for example UTF-16LE in UTF-16BE) * Byte order marks per stream (if block oriented) or record at write * Charset detection based on byte order marks You can differentiate between block- and record-oriented conversion by the keyword METHOD. * record oriented conversion - throws an error if an incomplete byte   sequence occurs at the end of a record * block oriented conversion - no check for record boundaries, regards   all data as one block If the input text is record-oriented then record orientation will be used by default, and you must explicitly enable block-oriented conversion if you do not intend to check the data at each end of a record. If you choose block orientation, the record lengths table will be lost. Additionally, you can enforce to skip incomplete character sequences at the end of a record to keep the length information. In case of an error, all position and counter values printed to the error trace contain the current indexes. All indexes start at zero. The first block or record is unit 0. It supports replacement of EBCDIC new line (0x15) characters by line feed (0x25) at character conversion takes place. When converting to UTF-8/16/32, this will result in the new line characters to be converted to line feeds (0x0A) instead of UTF-8 next line characters (0xC285). In read mode, the component supports auto-detection of charsets. This can be activated by using the keyword DEFAULT as CCSID. Auto-detection will analyze the first block of input data to determine if the input uses ASCII, EBCDIC or a UTF encoding. The statistics-based computation cannot determine the actual ASCII or EBCDIC character set. Instead, the final CCSID is derived from the language identifier of the environment variable LANG. Character conversion can skipped or enforced if the CCSIDs are equal or or binary data is detected. To get a list of supported CCSIDs, use the command below: For more information, please have a look at the man pages for each parameter. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-chr-method_631e.html",
"METHOD",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.CHR.METHOD]] ==== METHOD indexterm:[Parameter, METHOD, XCNV.INPUT.SAVE.FILE.CNV.CHR.METHOD] The method of character conversion defines how the input data fields are handled. A data field can be one block or a number of records dependent from how the data is read and converted before character conversion is done. Is the data field a list of records then the record oriented method shall be used. Is the data field a single block the block oriented conversion shall be used. This means that the METHOD must only be set to enforce record or block orientation against the usual way of processing the data. * Block Orientation  - This means all records are handled as one                        block and the record length information will                        go lost. If incomplete characters occur at                        the end of this block it will be remembered                        as rest and copied to the next block. Using                        this method there will be no interruption of                        the data stream. * Record Orientation - This method ensures that each record contains                        only complete character sequences. An                        incomplete character sequence will only be                        accepted at the end of the last record and                        handled also as rest for the record in the                        next data field. To enforce record                        orientation processing of one block of data                        there will be no difference to block                        orientation conversion, besides for                        processing the last block. Thus it makes only sense to switch for a record organized data field to block orientation conversion. But this is very critical, as the length information will go lost. This means that there will be no chance to retrieve the record information, besides the record contains some delimiters which can be used to build a new list of record lengths. So we recommend to use the METHOD switch only if you know what you are doing. In some cases analysis of the error trace might result in the correct method that can be used to convert the text. If an incomplete byte sequence progresses in the next record, then it can be helpful to enforce block oriented conversion, because the record length conversion can be invalid. On the other side, if the next record starts with a new valid byte sequence, then a skip of the damaged byte sequence in the last record can be helpful. If SKIP is selected then each incomplete character at the end of a record is recorded in the report file with a special code point 0xFFFFFF including the really skipped byte sequence. If this problem happens in the last block you can enforce record oriented conversion with SKIP to convert the data and the incomplete rest of the last block. They are written to the report file. Normally the corresponding MODE is used for the final block to prevent a rest. Please don't mix up SKIP as METHOD for the rest of a record contained in a data field and the IGNORE as MODE for the content of a record as unit of work. The default method depends on the data. If the data is marked as block-oriented or the record type is text with delimiters, then the method BLOCK is used. In all other cases, record orientation with the method KEEP is used. * `AUTO - Automatic orientation (block or record with keep)` * `BLOCK - Block-oriented conversion (all data is one chunk)` * `RECORD - Record-oriented conversion (check record boundaries)` * `KEEP - Keep (Move a rest from the end to begin of next record)` * `SKIP - Skip a rest at the end of a record (not recommended)` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-chr-skpbin_c3fc.html",
"SKPBIN",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.CHR.SKPBIN]] ==== SKPBIN indexterm:[Parameter, SKPBIN, XCNV.INPUT.SAVE.FILE.CNV.CHR.SKPBIN] If set, this switch bypasses the character conversion module if the from-code cannot be detected. Charset detection is performed only when no CCSID or DEFAULT is provided. For automated conversion, it is useful to activate this mechanism. This may allow you to process binary and character data using the same command by performing character conversion only on printable, but not on binary data. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-chr-skpequ_d8f8.html",
"SKPEQU",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.CHR.SKPEQU]] ==== SKPEQU indexterm:[Parameter, SKPEQU, XCNV.INPUT.SAVE.FILE.CNV.CHR.SKPEQU] If set, this switch bypasses the character conversion module if the from-code equals the to-code (which may happen when using charset auto detection), resulting in increased performance. This, however, also means that the input data will not be checked for invalid characters. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-cnv-bas_f657.html",
"BAS",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.CNV.BAS]] ==== BAS indexterm:[Object, BAS, XCNV.INPUT.SAVE.FILE.CNV.BAS] The base converter can be used to convert data from binary format to printable text and vice versa using one of a couple of base encoding schemes (RFC 4648). When writing, binary data is encoded, when reading, encoded text is decoded. Encoding data to a different base results in expansion of the data. The ratio of expansion depends on the base used. Most base encoding schemes append some padding bytes to the end of output data to pad it to a multiple of a specific length.  As a result, encoding and decoding can be performed in one of two modes: The block mode converts the input data as one large block of binary data. Padding will only be added at the end of the output file. This mode is the default for any type of input data, unless specified otherwise. This implies that record-based data will not retain record boundaries after encoding.  As the output is printable text when encoding, it can optionally be split into multiple lines. The 'line' length parameter specifies after how many characters a line is wrapped. The line delimiter can be configured, but can also be omitted, which is useful to write the output record-oriented.  When writing record-oriented, each output line results in one record. Note that if the 'line' length parameter is specified and a line delimiter is set, then the total maximum record length will be line length plus the length of the delimiter. The record mode can be useful if the input data is record-based. In record mode, each record is encoded independently, which results in retaining the ability to access specific records by only decoding those specific records.  Each output record is padded as required by the respective encoding scheme. Due to base encoding resulting in expansion of the data, the resulting records will be longer after encoding and shrink when decoding. To read a file that has been encoded in record mode, setting mode=record is mandatory. Otherwise, the result might be garbage. The character set used (ASCII or EBCDIC) can also be configured. By default, the system-specific character set is used. Mainly for PGP support, the component supports optional ASCII armor (also in EBCDIC) headers and trailers around the base encoded data (see RFC4880), but can also be used for other data and is independent of the encoding method (Base16/32/64). ASCII-armored data data is wrapped into lines, which can be written as records or as blocks with lines and delimiters. The default line length is 72 if no length is specified. When reading, the trailer string can optionally be verified to match the header string. Another feature for OpenPGP support is a CRC checksum that is appended to the data. This is also optional and usable independently of the data, the encoding schema and the ASCII armor support. When writing, a switch can be enabled to add a CRC24 checksum conforming to RCF4880 for Base64 encodings. The other encoding schemas use the same mechanism to append a checksum to the base encoded data, but use another CRC variant. Base16 uses CRC32 and Base32 uses CRC40, known from the GSM network. When reading, a switch enables verification of this checksum. By default, no CRC verification is done. Since the checksum is optional, it is useless to calculate the CRC just to find out that there is no CRC appended to the data that can be compared against. If the verification fails, you get an error. If the verification is successful, you get an informational. If there is no checksum appended for verification, you get a warning. The same is true if verification is not requested, but a checksum is found. With the TARGET selection you can limit the valid target formats after base decoding. For example, this can be used to ensure, that a base decoding is only done, if the result XML or a PGP message or a compressed data stream. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` * `NUMBER: RECLEN=num - Record length to parse ASCII Armor without delimiter` * `NUMBER: METHOD=BASE16/BASE32/BASE64 - Base encoding selector [AUTO]` ** `BASE16 - Base16 (hexadecimal) encoding` ** `BASE32 - Base32 encoding` ** `BASE64 - Base64 encoding` * `NUMBER: MODE=BLOCK/RECORD - Enforces record or block-oriented conversion [BLOCK]` ** `BLOCK - Block-oriented conversion (all data is one chunk)` ** `RECORD - Record-oriented conversion (convert each record individually)` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `SWITCH: CRCCHK - Check CRC if available [FALSE]` * `SWITCH: ARMCHK - Check ARMOR trailer if available [FALSE]` * `SWITCH: RSTCHK - Check if a rest after encoded data [FALSE]` * `SWITCH: SKPNOB - Skip base decoding if no base encoding detected [FALSE]` * `NUMBER: TARGET=PGP/CRY/ZIP/BIN/CHR/TXT/XML - Limit target format for base decoding [NONE]` ** `PGP - PGP files (message, signature or key file)` ** `CRY - Encrypted data stream (including PGP message)` ** `ZIP - Compressed data stream (GZIP, BZIP2, XZ)` ** `BIN - Binary data` ** `CHR - Character data` ** `TXT - Text data` ** `XML - XML data` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt_89fc.html",
"FMT",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT]] ==== FMT indexterm:[Overlay, FMT, XCNV.INPUT.SAVE.FILE.FMT] With the overlay FMT you can choose the different kind of formatting methods to convert the data lists in elements at read operations. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt-bin_e78e.html",
"BIN",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT.BIN]] ==== BIN indexterm:[Object, BIN, XCNV.INPUT.SAVE.FILE.FMT.BIN] The object 'format binary' converts each item from a data list (blocks or records with attributes) to an element. The data is untouched, the assigned element's types depend on the attributes and the attributes are stored for each element. This formatting method is mainly useful for records or binary chunks of data. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt-blk_9410.html",
"BLK",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT.BLK]] ==== BLK indexterm:[Object, BLK, XCNV.INPUT.SAVE.FILE.FMT.BLK] The object 'format block' formats all data items (a block or a bunch of records) as an element containing the raw block/chunk of data. All additional attributes and record boundaries are lost. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt-rec_27b9.html",
"REC",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT.REC]] ==== REC indexterm:[Object, REC, XCNV.INPUT.SAVE.FILE.FMT.REC] By default (i.e. no method provided), the object 'format record' formats data blocks to records by slicing the block into records of the provided record length if none of the valid 4 byte length formats or the defined binary delimiter is detected. If the data is already organized as records, then the data is re-wrapped. You can enforce an error to prevent the default wrapping if no record length information is found. If the method DLM is used, then a delimiter must be specified. When specifying a binary delimiter without a method or method DLN or ALL, then the detector will verify if the binary delimiter is present in the data. If you use archive formats where the file attributes can be stored, the binary delimiter will be set automatically If you have written attributes (see FMT.BLK()) in front of the records, you can parse these attributes. If you use archive formats where the file attributes can be stored, the PRSATR selection will be set to the right method automatically. * `NUMBER: METHOD=WRP/LEN/L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM/DLN/ALL - Method for record formatting [AUTO]` ** `WRP - Wrap blocks in records of defined record length` ** `LEN - Parse data based on 4 byte length fields with auto detection of the format` ** `L4I - Parse data based on 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Parse data based on 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Parse data based on 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Parse data based on 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Parse data based on 4 byte length fields: System endian integer, length inclusive` ** `S4X - Parse data based on 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Parse data based on 4 byte length fields: Little endian short (LLxx), length inclusive` ** `HLX - Parse data based on 4 byte length fields: Little endian short (LLxx), length exclusive` ** `HBI - Parse data based on 4 byte length fields: Big endian short (LLxx), length inclusive (MVS)` ** `HBX - Parse data based on 4 byte length fields: Big endian short (LLxx), length exclusive` ** `HSI - Parse data based on 4 byte length fields: System endian short (LLxx), length inclusive` ** `HSX - Parse data based on 4 byte length fields: System endian short (LLxx), length exclusive` ** `DLM - Parse data based on the provided binary record delimiter` ** `DLN - Parse delimiter or length field with auto detection` ** `ALL - Parse delimiter or length field with auto detection else wrap in records` * `NUMBER: RECLEN=num - Maximum length of a record [512] also used for wrapping` * `STRING: RECDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to parse end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: RSTDAT=RECORD/ERROR/IGNORE - Defines handling of remaining rest [auto]` ** `RECORD - Build a record with the remaining rest (default for delimiter)` ** `ERROR - Return an error if a remaining rest found (default for length fields)` ** `IGNORE - Ignore a remaining rest (no record, no error)` * `SWITCH: SUPPAd - Suppress trailing padding/equal bytes [FALSE]` * `NUMBER: PRSATR=ASA/MCC/REL/RELASA/RELMCC - Parse attributes (e.g. print control character) in front of the record [NONE]` ** `ASA - ASA print control character (1 byte)` ** `MCC - Machine print control character (1 byte)` ** `REL - Slot number of RRDS (8 byte integer in big endian)` ** `RELASA - Slot number plus ASA print control character (9 byte)` ** `RELMCC - Slot number plus Machine print control character (9 byte)` * `SWITCH: WRPERR - If no method defined (auto detection) enforce an error if no length format (wrapping) detected [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt-txt_369f.html",
"TXT",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT.TXT]] ==== TXT indexterm:[Object, TXT, XCNV.INPUT.SAVE.FILE.FMT.TXT] The object 'format text' splits the data into text records and rest elements based on delimiters (METHOD=TXT). The rest element contains the delimiter and optional trailing whitespace if the suppression of trailing whitespace is activated. The text record and the rest element together compose the original data. If the data contains no delimiters but record length is available, record formatting (METHOD=REC) is used. In this case, the rest element is empty unless suppression of trailing whitespace is used. If no delimiters and no length fields are found and the BINERR switch is not set, then binary formatting (wrapping of the data into records of the defined length) is done. If the BINERR switch is set, an error is triggered if the data is binary. Delimiter, record or binary formatting can be enforced by defining the corresponding method or the data dependent automatism can be used. If you have text in one of the ISO code pages with 0x85 (NEL) as delimiter, you can optionally enable recognition of NEL as delimiter. NEL (next line) is optional because this value is the general currency sign or the continuation symbol and not a new line in many single byte ASCII codepages. * 0x00 (padding character (can be changed)) * 0x0A (carriage return (EBCDIC 0x25)) * 0x0D (line feed (EBCDIC 0x0D)) * 0x0A, 0x0D (carriage return line feed) * 0x0A, ..., 0x0A, 0x0D (dirty delimiters) * 0x0A, 0x0D, ..., 0x0D (dirty delimiters) * 0x0C (form feed (EBCDIC 0x0C)) * 0x85 (new/next line (EBCDIC 0x15, optional if single byte ASCII)) The raw text record (without the rest element) can be validated using a regular expression. Non-matching records can be configured to be ignored or cause an error (default). Text formatting supports a lot of powerful features which can be accessed with the parameters below. * `NUMBER: METHOD=BIN/TXT/DLM/REC - Method for text formatting [DEFAULT]` ** `BIN - Wrap data block in records of record length` ** `TXT - Parse data block for text delimiter (DEFAULT)` ** `DLM - Parse data block for text delimiter (DEFAULT)` ** `REC - Parse data block based on record length fields` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [auto detection]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `SWITCH: NELDLM - Activate NEL (0x85) as delimiter for ASCII character sets [FALSE]` * `NUMBER: PADCHR=num - Padding character (is regarded as additional delimiter) [0x00]` * `NUMBER: RECLEN=num - Maximum length of a text record (Host) / line (Unix/Win) [512]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` * `SWITCH: BINERR - Enforce an error if binary data detected [FALSE]` * `SWITCH: CHRERR - Enforce an error if character data without delimiter detected [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-input-save-file-fmt-xml_e2a6.html",
"XML",
"[[CLEP.COMMAND.XCNV.INPUT.SAVE.FILE.FMT.XML]] ==== XML indexterm:[Object, XML, XCNV.INPUT.SAVE.FILE.FMT.XML] The object 'format XML' parses block of text data containing an XML document. The XML data is parsed using the Expat library and transformed into FLAM elements, which allows various formatting options when writing, including minimizing and pretty printing the XML data. The text data must be in UTF-8 or ASCII. Lines must be delimited with 0x0A, 0x0D or 0x0D0A. During parsing, all line delimiters are normalized to line feed characters (0xA) as defined by the XML specification. There are several switches available to exclude certain types of XML elements from the parsed element list. When reading XML documents through the byte or record interface using the element formatter (format.element()), the character data between starting and closing tags may be split into multiple XML data elements as the data can be of an arbitrary length. The DATLEN parameter controls the minimum length of a data element before being split (default is 1024). Note that this a minimum, so the data elements returned may be actually much larger. As a rule of thumb, the maximum length of data elements is close to the input buffer size (but may exceed it). If you want to get all data between any pair of starting and closing tags as a single data element, simply set the DATLEN parameter to a large number. You must be aware, however, that this might require considerable amounts of memory, depending the maximum data length in tag bodies. With the LENERR parameter, an error occurs if a data element exceeds the specified length. If the ignore empty data (NOEMPD) switch is set, data elements containing only whitespace are suppressed. With the ADDEMP switch, an empty data element is inserted to the element list if an end tag follows directly after a start tag (only relevant when writing custom applications using the APIs). XML formatting supports a lot of powerful features which can be accessed with the parameters below. * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [auto]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `SWITCH: FMTERR - Enforce a format error if data contains only space or is empty [FALSE]` * `SWITCH: NOCMNT - Ignore XML comments [FALSE]` * `SWITCH: NODFLT - Ignore XML default elements (i.e. whitespace before/after root tag) [FALSE]` * `SWITCH: NOEMPD - Ignore empty/whitespace XML data elements (not in CDATA section) [FALSE]` * `SWITCH: ADDEMP - Add an empty XML data element if end tag follows direct a start tag [FALSE]` * `SWITCH: NOPINS - Ignore XML processing instructions [FALSE]` * `SWITCH: NODTD - Ignore XML document type definitions [FALSE]` * `SWITCH: CCDATA - Collect CDATA to simple data elements [FALSE]` * `NUMBER: DATLEN=num - Minimum length of returned XML data elements (for APIs only) [1024]` * `SWITCH: LENERR - Return an error if minimum data element length exceeded [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output_bb08.html",
"OUTPUT",
"[[CLEP.COMMAND.XCNV.OUTPUT]] ==== OUTPUT indexterm:[Object, OUTPUT, XCNV.OUTPUT] Over the object OUTPUT you can define how the data is written. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file_3dc3.html",
"FILE",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE]] ==== FILE indexterm:[Object, FILE, XCNV.OUTPUT.SAVE.FILE] The object FILE allows to specify how a neutral list of FLAM5 elements with type, length, value and attributes is written to one or more files. You can specify a method to format the data (binary, text, XML, ...), an unlimited amount of conversions (character set, compression, encryption, encoding, ...) and an unlimited amount of output procedures (block, record, text FLAM4, ...) to write the output to multiple destinations at the same time (e.g. to a remote machine + local backup). If you pass a URL containing a CCSID to the FIO object, this CCSID is the default outbound CCSID (TO) for all character conversion objects you use. If no character conversion is requested, the CCSID defined in the URL is not used. When using multiple I/Os, then only the last provided URL-CCSID is used. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-env_46a7.html",
"ENV",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.ENV]] ==== ENV indexterm:[Object, ENV, XCNV.OUTPUT.SAVE.FILE.ENV] With the object ENV you can override an unlimited amount of environment variables for the write operation. This is useful to define for example another LANG variable to emulate another platform for character conversion. * `STRING: KEYWORD='str' - Keyword of environment variable` * `STRING: VALUE='str' - Value of environment variable` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt_5a13.html",
"FMT",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT]] ==== FMT indexterm:[Overlay, FMT, XCNV.OUTPUT.SAVE.FILE.FMT] With the overlay FMT you can choose the different kind of formatting methods to convert elements in data lists at write operations. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt-bin_5d81.html",
"BIN",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT.BIN]] ==== BIN indexterm:[Object, BIN, XCNV.OUTPUT.SAVE.FILE.FMT.BIN] The object 'format binary' simply concatenates the data of each element to a binary stream. If the elements are records, then the record length and other attributes are still available in the data list. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt-blk_fb07.html",
"BLK",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT.BLK]] ==== BLK indexterm:[Object, BLK, XCNV.OUTPUT.SAVE.FILE.FMT.BLK] By default (i.e. no method provided), the object 'format block' simply concatenates the data of each element to one block of data. Through the method parameter, you can format blocks of data with 4 byte length fields in front of or a binary delimiter at the end of the element data. For example, if you provide a length method (METHOD) and a record delimiter (RECDLM), then a length field is written in front of the record and the delimiter at the end. Be aware that the result can be parsed only in 2 steps (e.g. cnv.rec() followed by fmt.rec()). All attributes and additional element information is lost unless the PUTATR switch is activated. In this case, the attributes (slot number of RRDS, ASA or MCC) are written in front of each record. If a length field is added for each element, the data will be organized as binary blocks and it is not possible, for example, to do character conversion or other text oriented things anymore. With FMT.REC() length field formats or binary delimiters can be defined or detected and, if required, previously written attributes can be parsed. * `NUMBER: METHOD=L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method for block formatting [JOIN ELEMENTS TOGETHER]` ** `L4I - Adds 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte length fields: System endian short (LL00), length exclusive` ** `DLM - Adds provided binary record delimiter` * `STRING: RECDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `SWITCH: SUPPAd - Suppress trailing padding/equal bytes [FALSE]` * `SWITCH: PUTATR - Put attributes in front of the records  [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt-rec_08f6.html",
"REC",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT.REC]] ==== REC indexterm:[Object, REC, XCNV.OUTPUT.SAVE.FILE.FMT.REC] The object 'format record' simply turns each element into a standard record. This can result in strange data. For example, if you have XML elements then only the raw data of each element will be a record. Or for text elements a record with the text element and a record with the corresponding rest element is created. If this is written with FIO.REC() then one line contains the text record and the next line contains the original delimiter with the optional suppressed trailing whitespace in front of it. * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt-txt_5150.html",
"TXT",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT.TXT]] ==== TXT indexterm:[Object, TXT, XCNV.OUTPUT.SAVE.FILE.FMT.TXT] The object 'format text' formats text elements into text records with a certain delimiter, no delimiter (mainly useful for record-oriented systems) or produces the original data (concatenate the text element with the corresponding rest element). To add the delimiter in the correct encoding the charset must be known and can be defined. But normally the charset is already known through the read operation and it is not required to specify this value. You can replace horizontal and vertical tabs by whitespace characters and new records so that the data looks like it was printed. Additionally, all remaining control characters can be suppressed or replaced by whitespace or the substitution character. This features are useful to convert text data containing tabs and other control characters for host data sets. The method ORIGINAL uses the original delimiter that is present in the input data. If the option suppress trailing whitespace is used, then all whitespace characters in front of the original delimiter are removed. Regular expressions can be used to validate text records or perform replacements to manipulate text records. Text formatting supports a lot of powerful features which can be accessed with the parameters below. * `NUMBER: METHOD=HOST/BIN/REC/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM/ORIGINAL - Method for text formatting [DEFAULT]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `REC - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` ** `ORIGINAL - Adds the original data at the end of a line (only for band FMT)` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [auto]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: RPLTAB/RPLHTB=num - Replace horizontal tabulators by spaces using this tab width [0 - no replacement]` * `NUMBER: RPLVTB=num - Replace vertical tabulators by new lines using this tab width [0 = no replacement]` * `SWITCH: RPLBSP - Replace backspace (deletes the backspace and the byte before) [FALSE]` * `NUMBER: RPLCTR=SPACE/SUBSTITUTE/DELETE - Replace remaining control characters [NONE]` ** `SPACE - Replace control characters with whitespace character (0x20/0x40)` ** `SUBSTITUTE - Replace control characters with substitution character (0x1A/0x3F)` ** `DELETE - Remove control characters` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `NUMBER: BUFSIZ=num - Initial buffer size for preallocation [65536]` * `NUMBER: INICNT=num - Initial amount of records for preallocation [128]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fmt-xml_1e51.html",
"XML",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FMT.XML]] ==== XML indexterm:[Object, XML, XCNV.OUTPUT.SAVE.FILE.FMT.XML] The object 'format XML' creates a valid XML document from FLAM elements, resulting in UTF-8 data block with character data. The output XML can be formatted using 4 different methods: * STANDARD:    The XML document is reconstructed exactly as described by the list of FLAM elements (i.e. as close to the original XML document as possible). * PRETTYPRINT: Creates an XML document with indentation suitable for easy human readability. * MINIMIZED:   Creates a minimized XML document. Line breaks and whitespace are removed unless they are part of actual character data. * DUMP:        Can be used to dump out any arbitrary (even non-XML) FLAM elements and its attributes into an XML document. Can be used to inspect The XML output is written in blocks and encoded in UTF-8 with line feed (0xA) as line delimiter unless a CCSID is supplied, in which case character conversion is performed. The PRETTYPRINT and MINIMIZED methods have two parameters that allow control of how to deal with whitespace in input data. In order to decide whether whitespace in the input may be dropped or not, it needs to be cached until the next non-whitespace characters occur. By default, up to 4096 consecutive whitespace characters can be cached. You can increase this number if your documents may contain more consecutive whitespace. You can also specify what to do if the cache runs full. The cached whitespace can either be written to output, possibly resulting in less nicely formatted XML, or processing can be aborted with an error. An XML document created by the DUMP method has a root tag `<flam>`. It contains one `<configuration>` and one or more `<elementList>` blocks. The `<configuration>` section reflects the options used to create the FLAM elements dump. The `<elementList>` contains one `<element>` tag for each FLAM element in the input data in the order of input. It may have up to three optional attributes (_type_, _attr_, _hash_). The element's data is written to the tag's body. The data formats of the data as well as of the attributes _attr_ and _hash_ are the ones defined in the `<configuration>` section. Here is a simple example of two FLAM elements dumped to XML with data in hexadecimal format: [source,xml] XML formatting supports a lot of powerful features which can be accessed with the parameters below. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-cnv_6451.html",
"CNV",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.CNV]] ==== CNV indexterm:[Overlay, CNV, XCNV.OUTPUT.SAVE.FILE.CNV] With the overlay CNV you can choose the different kind of conversions supported at write operations. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio_54b2.html",
"FIO",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO]] ==== FIO indexterm:[Overlay, FIO, XCNV.OUTPUT.SAVE.FILE.FIO] With the overlay FIO, various kinds of file I/O methods can be selected for write operations. You can specify multiple output operations to write the same data stream to different targets (local, remote or archive). In this case, the first I/O definition is used to build the inverse read string, which can be used for a later read operation. ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio-blk_827a.html",
"BLK",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO.BLK]] ==== BLK indexterm:[Object, BLK, XCNV.OUTPUT.SAVE.FILE.FIO.BLK] This object defines the block-oriented write operation for files. This method writes the all data after any conversions as one chunk to the file. This is the most common and simplest way to write a file. This write method is useful for all non-record-oriented file formats. If the block still contains a record length information, you can enforce a record-oriented write. It is also possible to add the system delimiter behind each record to produce a valid text block. To retain the modification time of the original file, the `modtime` parameter can be set to `ORIGINAL`. * `STRING: NAME/FILE='str'/STREAM/DUMMY - Name/URL of file to write [auto]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: APPEND - Append data to this file [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `SWITCH: FRCREC - Enforce record orientation on record oriented devices [FALSE]` * `SWITCH: ADDDLM - Add a delimiter behind each record to produce a text block [FALSE]` * `NUMBER: ACSTIM=num - Define the last access time for this file` * `NUMBER: MODTIM=num/ORIGINAL - Define the last modification time for this file` ** `ORIGINAL - Copy modification time from the original file` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `SWITCH: BINDMP - Write dump for binary data [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio-rec_96eb.html",
"REC",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO.REC]] ==== REC indexterm:[Object, REC, XCNV.OUTPUT.SAVE.FILE.FIO.REC] This object defines the record-oriented write operation for files. This method writes each data list entry as one record to a data set. You can define the behavior (STOP/CUT/WRAP) if the record is longer than the accepted record length for this file. You can activate the suppression of padding characters and set the padding character. You can define the file organization, block size, record format, add a delimiter behind each record and a lot of other parameters (see below). A dynamic allocation of the file can be used. This is very powerful and simplifies the generation of files on mainframe systems. The default values for this dynamic allocation depend on the data itself and the original file where the data came from. For example, if you have read an FB80 data set with a GZIP data stream which was formatted based on delimiters in text records and you write it to a file on z/OS without any further parameters, then a PS-VB data set (not FB) with data dependent records is allocated with the correct size. If the result of the decompression is still binary data, then still a PS-FB80 dataset will be allocated. But you can also define other parameters for the file allocation. In this case, the data is converted to this format as good as possible. On non-mainframe platforms (Windows, Unix, ...), the record I/O module can be used to write records terminated by a delimiter (TXT/DLM) or in a fixed or variable length format. For variable format, the length format must be defined. The default in this case is a 4 byte integer in the platform-dependent endianness. This default conforms to FILEDATA=RECORD for USS on a z/OS mainframe system. If you chose a host record format for the write on a non-record-oriented Attributes (length, slot number of RRDS, print control character) are stored in front of each record on non-record-oriented systems. Example: If you read a RRDS with print control characters (FRA) and you write this on UNIX as record format VRA to a file, the file format looks like this: If you chose a host record format for writing on a non-record-oriented system, then the length (only if it is a variable format) and other attributes (slot number, print control character) are stored in front of the data. Here is an example for VRA (variable, relative record format with ASA print control character): Where LLLL is the record length, nn...nn is the slot number, C is the print control character and dd..dd is the record data. To read such a file on the UNIX system, the record format and length format (if you write with defaults, you can read with defaults) must be defined correctly. This feature allows to unload an RRDS to a WINDOWS or UNIX system and to load this RRDS again with same records and gaps between. Each supported record format has a corresponding representation on non-mainframe systems. This means this unload and load is possible for each kind of data set type of mainframe systems. To retain the modification time of the original file, the `modtime` parameter can be set to `ORIGINAL`. * `STRING: NAME/FILE='str'/STREAM/DUMMY - Name/URL of file to write [auto]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: APPEND - Append data to this file [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: RECMOD=STOP/CUT/WRAP/SKIP - Mode used to write records [STOP]` ** `STOP - Stop if record too long` ** `CUT - Cut if record too long` ** `WRAP - Wrap if record too long` ** `SKIP - Skip if record too long` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with empty records assuming n lines per page [60]` * `NUMBER: RECCNT=num - Initial amount of records for preallocation [128]` * `SWITCH: SUPPAD - Suppress trailing padding characters (useful for variable length records)` * `STRING: PADCHR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Character to pad records to a fixed length [SYSTEM] or used for empty variable length records [NONE]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `STRING: RECDLM='bin'/CR-ASCII/LF-ASCII/NL-ASCII/CRLF-ASCII/CR-EBCDIC/LF-EBCDIC/NL-EBCDIC/CRLF-EBCDIC/CR-UTF08/LF-UTF08/NL-UTF08/CRLF-UTF08/CR-UTF16BE/LF-UTF16BE/NL-UTF16BE/CRLF-UTF16BE/CR-UTF16LE/LF-UTF16LE/NL-UTF16LE/CRLF-UTF16LE/CR-UTF32BE/LF-UTF32BE/NL-UTF32BE/CRLF-UTF32BE/CR-UTF32LE/LF-UTF32LE/NL-UTF32LE/CRLF-UTF32LE - Delimiter used to define end of record` ** `CR-ASCII - Delimiter: carriage return in ASCII (0x0D)` ** `LF-ASCII - Delimiter: line feed in ASCII (0x0A)` ** `NL-ASCII - Delimiter: new line in ASCII (0x85)` ** `CRLF-ASCII - Delimiter: carriage return line feed in ASCII (0x0D0A)` ** `CR-EBCDIC - Delimiter: carriage return in EBCDIC (0x0D)` ** `LF-EBCDIC - Delimiter: line feed in EBCDIC (0x25)` ** `NL-EBCDIC - Delimiter: new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Delimiter: carriage return line feed in EBCDIC (0x0D25)` ** `CR-UTF08 - Delimiter: carriage return in UTF-8 (0x0D)` ** `LF-UTF08 - Delimiter: line feed in UTF-8 (0x0A)` ** `NL-UTF08 - Delimiter: new line in UTF-8 (0xC285)` ** `CRLF-UTF08 - Delimiter: carriage return line feed in UTF-8 (0x0D0A)` ** `CR-UTF16BE - Delimiter: carriage return in UTF-16BE (0x000D)` ** `LF-UTF16BE - Delimiter: line feed in UTF-16BE (0x000A)` ** `NL-UTF16BE - Delimiter: new line in UTF-16BE (0x0085)` ** `CRLF-UTF16BE - Delimiter: carriage return line feed in UTF-16BE (0x000D000A)` ** `CR-UTF16LE - Delimiter: carriage return in UTF-16LE (0x0D00)` ** `LF-UTF16LE - Delimiter: line feed in UTF-16LE (0x0A00)` ** `NL-UTF16LE - Delimiter: new line in UTF-16LE (0x8500)` ** `CRLF-UTF16LE - Delimiter: carriage return line feed in UTF-16LE (0x0D000A00)` ** `CR-UTF32BE - Delimiter: carriage return in UTF-32BE (0x0000000D)` ** `LF-UTF32BE - Delimiter: line feed in UTF-32BE (0x0000000A)` ** `NL-UTF32BE - Delimiter: new line in UTF-32BE (0x00000085)` ** `CRLF-UTF32BE - Delimiter: carriage return line feed in UTF-32BE (0x0000000D0000000A)` ** `CR-UTF32LE - Delimiter: carriage return in UTF-32LE (0x0D000000)` ** `LF-UTF32LE - Delimiter: line feed in UTF-32LE (0x0A000000)` ** `NL-UTF32LE - Delimiter: new line in UTF-32LE (0x85000000)` ** `CRLF-UTF32LE - Delimiter: carriage return line feed in UTF-32LE (0x0D0000000A000000)` * `NUMBER: ACSTIM=num - Define the last access time for this file` * `NUMBER: MODTIM=num/ORIGINAL - Define the last modification time for this file` ** `ORIGINAL - Copy modification time from the original file` * `SWITCH: NOSPAN - Deactivate write of large spanned records to V(B)S datasets [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio-txt_2eb1.html",
"TXT",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO.TXT]] ==== TXT indexterm:[Object, TXT, XCNV.OUTPUT.SAVE.FILE.FIO.TXT] This object defines the text-oriented write operation for files. This method writes each data list entry as a text record with delimiter to the file. This method supposes that the data elements are text records and writes each record with the system specific delimiter (0x0A on UNIX, 0x0D0A on WINDOWS, 0x15 on USS) to a file. The access method removes trailing whitespaces from each record by default. Additional You can activate the suppression of control and space character (except tabulators or blank) in the data. To retain the modification time of the original file, the `modtime` parameter can be set to `ORIGINAL`. * `STRING: NAME/FILE='str'/STREAM/DUMMY - Name/URL of file to write [auto]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: SUPCTR - Suppress control characters [FALSE]` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: APPEND - Append data to this file [FALSE]` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: ACSTIM=num - Define the last access time for this file` * `NUMBER: MODTIM=num/ORIGINAL - Define the last modification time for this file` ** `ORIGINAL - Copy modification time from the original file` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio-fl4_cf7f.html",
"FL4",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO.FL4]] ==== FL4 indexterm:[Object, FL4, XCNV.OUTPUT.SAVE.FILE.FIO.FL4] This object defines the FLAM4 write operation for files. This method writes each data list entry as a record to a FLAMFILE of version 4 or older. It uses the FLAM4 record interface to write members to a FLAMFILE. The parameters below are explained in detail by the FLAM command of FLCL. * `STRING: NAME/FLAMFILE/FILE='str'/STREAM/DUMMY - Name/URL of FLAMFILE to write [auto]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: MEMBER='str' - Rename the member in the FLAMFILE` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: APPEND - Append the member to this FLAMFILE (not useful with encryption) [FALSE]` * `NUMBER: CMPMOD=CX7/CX8/VR8/ADC/NDC - FLAM Mode [ADC]` ** `CX7 - Compression encoding as printable characters` ** `CX8 - Compression encoding as binary data` ** `VR8 - Enhanced compression encoding as binary data` ** `ADC - Advanced Data Compression` ** `NDC - No data compression` * `NUMBER: ENCMOD=OFF/AES/FLAMENC - Encryption Mode [NONE]` ** `OFF - Disable encryption` ** `AES - AES encryption` ** `FLAMENC - FLAM encryption` * `NUMBER: BLKMOD=UNBLOCKED/BLOCKED - Block mode [unblocked]` ** `UNBLOCKED - Each segment starts on new record (VSAM KSDS only)` ** `BLOCKED - Segment can start within a record (recommended)` * `NUMBER: MAXBUF=num - Maximum buffer size for FLAM matrix [65336]` * `NUMBER: MAXREC=num - Maximum amount of records per matrix [255]` * `NUMBER: CLIMIT=num - Minimum compression in per cent (0 no Limit)[0]` * `NUMBER: FLFORG=SEQ/PS/EDS/ESDS/KDS/KSDS/RDS/RRDS/LDS - Organization of the FLAMFILE [SEQ]` ** `SEQ - Sequential access [DEFAULT]` ** `PS - Sequential access [DEFAULT]` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` ** `LDS - Linear data set (VSAM-LDS)` * `NUMBER: FLFRCF=VAR/FIX/UND/TXT/DLM/VB/FB/V2B-XBE/V4B-XBE/V4A-ICL/V4E-ICL/V2B-ILE/V2B-IBE/V4B-IBE - Record format for the FLAMFILE [FIX]` ** `VAR - Variable` ** `FIX - Fix` ** `UND - Undefined` ** `TXT - Text/Stream` ** `DLM - Stream with special delimiter` ** `VB - Variable blocked` ** `FB - Fix blocked` ** `V2B-XBE - Variable 2 byte length field without the length in big endian` ** `V4B-XBE - Variable 4 byte length field without the length in big endian` ** `V4A-ICL - Variable 4 byte length field in ASCII inclusive the length` ** `V4E-ICL - Variable 4 byte length field in EBCDIC inclusive the length` ** `V2B-ILE - Variable 2 byte length field inclusive the length in little endian` ** `V2B-IBE - Variable 2 byte length field inclusive the length in big endian` ** `V4B-IBE - Variable 4 byte length field inclusive the length in big endian` * `NUMBER: FLFRCL=num - Record length for the FLAMFILE [512]` * `NUMBER: FLFRCD=NONE/LF-ASCII/CR-ASCII/NL-ASCII/CRLF-ASCII/LF-EBCDIC/CR-EBCDIC/NL-EBCDIC/CRLF-EBCDIC - Record delimiter for the FLAMFILE (only for CX7)` ** `NONE - No record separation` ** `LF-ASCII - Record separation with line feed in ASCII (0x0A)` ** `CR-ASCII - Record separation with carriage return in ASCII (0x0D)` ** `NL-ASCII - Record separation with new line in ASCII (0x85)` ** `CRLF-ASCII - Record separation with carriage return line feed in ASCII (0x0D0A)` ** `LF-EBCDIC - Record separation with line feed in EBCDIC (0x25)` ** `CR-EBCDIC - Record separation with carriage return in EBCDIC (0x0D)` ** `NL-EBCDIC - Record separation with new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Record separation with carriage return line feed in EBCDIC (0x0D25)` * `NUMBER: FLFBLS=num - Block size for the FLAMFILE (mainly host related)` * `NUMBER: FLFCDP=REWIND/UNLOAD/LEAVE - Close disposition for the FLAMFILE (mainly host related)` ** `REWIND - Rewind the tape to the beginning` ** `UNLOAD - Rewind the tape and unload it` ** `LEAVE - Do not rewind` * `NUMBER: FLFCOD=SYSTEM/ASCII/EBCDIC - Character set for string encoding in the FLAMFILE [SYSTEM]` ** `SYSTEM - System specific encoding` ** `ASCII - String encoding in ASCII` ** `EBCDIC - String encoding in EBCDIC` * `NUMBER: SPLMOD=NONE/SERIAL/PARALLEL - Split mode [NONE] (only for z/OS)` ** `NONE - No splitting (default)` ** `SERIAL - Serial splitting (after 1-4096 Megabyte)` ** `PARALLEL - Parallel splitting (in 2, 3 or 4 files)` * `NUMBER: SPLNBR=num - Split number (2-4 files for parallel splitting (only for z/OS)) [4]` * `NUMBER: SPLSIZ=num - Split size (1-4096 MB for serial splitting (only for z/OS)) [100]` * `NUMBER: ORGORG=SEQ/PS/EDS/ESDS/KDS/KSDS/RDS/RRDS/LDS - Organization of the original file [from origin]` ** `SEQ - Sequential access [DEFAULT]` ** `PS - Sequential access [DEFAULT]` ** `EDS - Entry data set (VSAM-ESDS)` ** `ESDS - Entry data set (VSAM-ESDS)` ** `KDS - Keyed data set (VSAM-KSDS)` ** `KSDS - Keyed data set (VSAM-KSDS)` ** `RDS - Relative data set (VSAM-RRDS)` ** `RRDS - Relative data set (VSAM-RRDS)` ** `LDS - Linear data set (VSAM-LDS)` * `NUMBER: ORGRCF=VAR/FIX/UND/TXT/DLM/VB/FB/V2B-XBE/V4B-XBE/V4A-ICL/V4E-ICL/V2B-ILE/V2B-IBE/V4B-IBE - Record format for the original file [from origin]` ** `VAR - Variable` ** `FIX - Fix` ** `UND - Undefined` ** `TXT - Text/Stream` ** `DLM - Stream with special delimiter` ** `VB - Variable blocked` ** `FB - Fix blocked` ** `V2B-XBE - Variable 2 byte length field without the length in big endian` ** `V4B-XBE - Variable 4 byte length field without the length in big endian` ** `V4A-ICL - Variable 4 byte length field in ASCII inclusive the length` ** `V4E-ICL - Variable 4 byte length field in EBCDIC inclusive the length` ** `V2B-ILE - Variable 2 byte length field inclusive the length in little endian` ** `V2B-IBE - Variable 2 byte length field inclusive the length in big endian` ** `V4B-IBE - Variable 4 byte length field inclusive the length in big endian` * `NUMBER: ORGRCL=num - Record length for the original file [from origin]` * `NUMBER: ORGBLS=num - Block size for the original file [from origin]` * `NUMBER: ORGRCD=NONE/LF-ASCII/CR-ASCII/NL-ASCII/CRLF-ASCII/LF-EBCDIC/CR-EBCDIC/NL-EBCDIC/CRLF-EBCDIC - Record delimiter for the original file [from origin]` ** `NONE - No record separation` ** `LF-ASCII - Record separation with line feed in ASCII (0x0A)` ** `CR-ASCII - Record separation with carriage return in ASCII (0x0D)` ** `NL-ASCII - Record separation with new line in ASCII (0x85)` ** `CRLF-ASCII - Record separation with carriage return line feed in ASCII (0x0D0A)` ** `LF-EBCDIC - Record separation with line feed in EBCDIC (0x25)` ** `CR-EBCDIC - Record separation with carriage return in EBCDIC (0x0D)` ** `NL-EBCDIC - Record separation with new line in EBCDIC (0x15)` ** `CRLF-EBCDIC - Record separation with carriage return line feed in EBCDIC (0x0D25)` * `STRING: ORGSYS=DOS/WIN/UNIX/MAC/ZOS/VSE/ZVM/AIX/ZLINUX/AS400/OS2/HPUX/MPE/SUNOS/SOLARIS/BS2000/SINIX/VMS/NONSTOP/UNISYS/OFS/DUX/AMIGA/FL5 - Operating system for the original file [from origin]` ** `DOS - MS DOS` ** `WIN - MS Windows` ** `UNIX - UNIX (general)` ** `MAC - Apple MAC OS` ** `ZOS - IBM z/OS` ** `VSE - IBM z/VSE` ** `ZVM - IBM z/VM` ** `AIX - IBM AIX (Power)` ** `ZLINUX - IBM z/Linux` ** `AS400 - IBM AS400 / iSeries` ** `OS2 - IBM OS/2` ** `HPUX - HP-UX` ** `MPE - HP MPE` ** `SUNOS - SUN OS` ** `SOLARIS - SUN / Open Solaris` ** `BS2000 - Siemens BS2000 OSD` ** `SINIX - Siemens Nixdorf Unix` ** `VMS - HP Open VMS / DEC-VMS` ** `NONSTOP - HP Non Stop / Tandem` ** `UNISYS - UNISYS` ** `OFS - DEC OFS1` ** `DUX - DEC UNIX` ** `AMIGA - Amiga / Motorola` ** `FL5 - FLAM 5 component (FLUC)` * `NUMBER: DEVICE=FILE/DISK/TAPE/FLOPPY/STREAMER/USER - Device used to store the FLAMFILE [FLATFILE]` ** `FILE - Write to a file (equal to disk)` ** `DISK - Write to a disk (equal to file)` ** `TAPE - Write to a tape` ** `FLOPPY - Write to a floppy` ** `STREAMER - Write to a streamer tape` ** `USER - Use user IO` * `SWITCH: NONHDR - Switch to write no file header [FALSE]` * `SWITCH: NONFIL - Switch to write no file name in file header [FALSE]` * `STRING: COMENT='str' - Comment for the member in the FLAMFILE [internal use]` * `STRING: PASSWD='bin'/DEFAULT - Passphrase to encrypt the FLAMFILE ['']` ** `DEFAULT - FLAM4 default password` * `STRING: KMELIB='str' - Library name for FKME ['']` * `STRING: KMEFUC='str' - Function name of FKME ['']` * `STRING: KMEPAR='bin' - Parameter for the call of FKME ['']` * `STRING: EXTCMP/EXK20='str' - Name of user exit for compression` * `STRING: EXTDCO/EXD20='str' - Name of user exit for decompression` * `NUMBER: ACSTIM=num - Define the last access time for this file` * `NUMBER: MODTIM=num - Define the last modification time for this file` * `SWITCH: BLKORI - Enforce block-oriented write of records (32752) with FLAM4` * `NUMBER: PRISPC=num - Primary size in megabytes` * `NUMBER: SECSPC=num - Secondary size in megabytes` * `STRING: VOLSER='str' - Volume serial number` * `STRING: VOLUNT='str' - Volume unit` * `STRING: DATCLS='str' - Data class` * `STRING: MGMCLS='str' - Management class` * `STRING: STOCLS='str' - Storage class` * `NUMBER: DSPSTA=NEW/SHR/MOD/OLD - Disposition status` ** `NEW - Disposition status NEW (brand new file)` ** `SHR - Disposition status SHR (read exiting  file)` ** `MOD - Disposition status MOD (append/modify file)` ** `OLD - Disposition status OLD (overwrite existing file)` * `NUMBER: DSPNRM=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for normal end` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` * `NUMBER: DSPABO=CATALOG/CATLG/DELETE/KEEP/UNCATALOG/UNCATLG - Close disposition for abnormal end` ** `CATALOG - Close disposition catalog` ** `CATLG - Close disposition catalog` ** `DELETE - Close disposition delete` ** `KEEP - Close disposition keep` ** `UNCATALOG - Close disposition uncatalog` ** `UNCATLG - Close disposition uncatalog` * `NUMBER: KEYPOS=num - Key position (>=1) for index/key sequential data sets [1]` * `NUMBER: KEYLEN=num - Key length (>=1) for index/key sequential data sets [8]` * `NUMBER: SECINF=YES/NO/IGNORE/MEMBER - Define handling of secure information` ** `YES - Create secure information at compression` ** `NO - Do not store any additional secure information` ** `IGNORE - Ignore any security violations on decompression` ** `MEMBER - Only member-specific security information is verified` * `SWITCH: NOPATH - Exclude directory path of the original file in the compressed data [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-xcnv-output-save-file-fio-zip_357a.html",
"ZIP",
"[[CLEP.COMMAND.XCNV.OUTPUT.SAVE.FILE.FIO.ZIP]] ==== ZIP indexterm:[Object, ZIP, XCNV.OUTPUT.SAVE.FILE.FIO.ZIP] This FIO.ZIP() object is used to write ZIP archives. Members are written to a ZIP archive in a block-oriented way. The FIO.ZIP() object does not compress the data by itself. You must use CNV.ZIP() or one of the compression converters to produce a compressed archive, otherwise files are stored uncompressed. Using CNV.ZIP() without any further parameters compresses archive members using the deflate compression algorithm. If you use CNV.GZP(), then a GZIP file is stored in the archive. This means that an Unzip utility will extract a still compressed GZIP file from the ZIP file. The same is valid for BZIP2 and other supported compressors. By activating the APPEND switch, new members are appended to the ZIP file and existing members are replaced. If the REMAIN switch is enabled on append, an error occurs if a member already exists in the archive. If the APPEND switch is not used, but the REMAIN flag is set and the archive already exists, the archive is not overwritten. Replacing a member (APPEND without REMAIN) requires a re-organization which requires a temporary file in the background. On z/OS, a memory file is allocated in the hyper space. For huge archives it is not recommended to use the overwrite feature for ZIP archives because re-organization requires considerable time and disk space. All member names and comments are encoded in UTF-8 by default unless you specify another encoding. Currently, you can set the DOS encoding (CCSID IBM437), which is an old fashioned encoding in ZIP archives, or you can use US-ASCII as a subset of DOS and UTF-8. Archives larger than 4 GiB or containing more than 65535 members are supported with the 64 bit ZIP archive support which some ZIP tools are not capable to read. Creation of 64 bit ZIP archives can be prevented by enforcing the 32 bit format. In that case, an error occurs when reaching one of the limits of the original ZIP format. The 64 bit format might be enforced too. If no format or 'FORMAT=AUTO' is given a backward compatible 32 bit format with 64 bit extensions for files smaller than 4 GiB are written. This format will result in a warning by 7z since version 19 and can be ignored. To prevent this warning 32 or 64 bit format must be enforced. NOTE: Writing ZIP archives requires repositioning within the file which is not supported for PDS(E) members on z/OS. Hence, ZIP archives cannot be written to a PO member. You can copy ZIP files to a PO member and read the ZIP archive from there, but you cannot write to it. You also cannot use the REMOVE switch when reading from a PO member, because this requires rewriting the ZIP archive. With the switch STREAM the streamed version of the ZIP file format is enforced while writing. This will improve performance if only sequential I/O is required and a record oriented dataset is used. If no format is given the Zip64 format will be written in this case. With 'FORMAT=Z32' the older version of a ZIP archive can be enforced if the stream doesn't exceed 4 GiB. With the switch NOXFLD you can deactivate the write of the FLAM private extra field to the local and directory file header. If this is used the ZIP file doesn't contain this private extension and the reconstruction of files with FLAM to the original format will fail, because not all required information are available for it. * `STRING: NAME/FILE='str'/STREAM/DUMMY - Name/URL of ZIP file to write [auto]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: MEMBER='str' - Rename the member in the ZIP archive` * `SWITCH: REMAIN - Remain existing files (no append) or member (with append) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: APPEND - Append member to this ZIP archive [FALSE] (use remain to prevent overwrite of members)` * `SWITCH: FLUSH - Enforce flush in front of close file [FALSE]` * `NUMBER: ACSTIM=num - Define the last access time for this file` * `NUMBER: MODTIM=num - Define the last modification time for this file` * `STRING: COMENT='str' - Define a comment for this ZIP archive` * `NUMBER: FORMAT=AUTO/Z32/Z64 - Choose the format to write [AUTO]` ** `AUTO - As needed (32 bit for small files and 64 for large ones)` ** `Z32 - Always 32 bit format (old)` ** `Z64 - Always 64 bit format (modern)` * `NUMBER: ENCODE=UTF8/DOS/ASCII - Select encoding for file names and comments [UTF-8]` ** `UTF8 - UTF-8 encoding (recommended)` ** `DOS - IBM437 encoding (old 8 bit ASCII of ZIP files))` ** `ASCII - IBM367 encoding (US ASCII (only 7 bit subset of UTF-8 and IBM437))` * `SWITCH: NOXFLD - Don't write extra fields into the member header [FALSE]` * `SWITCH: STREAM - Write streamed ZIP file, uses only sequential I/O, no seek [FALSE]` ",
"",
""
],
[
"flcl_manual-flcl_commands-icnv_6405.html",
"ICNV",
"[[CLEP.COMMAND.ICNV]] === ICNV indexterm:[Command, ICNV, ICNV] The ICNV command converts local or remote files from one character encoding to another encoding set. More precisely, it converts the input file from the encoding given for the FROM option to an output file where the encoding is given in the TO option. Both encodings must be defined and supported by the platform you are running on. During this it supports: * Record or block oriented conversion * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Replacement of EBCDIC new line (0x15) by line feed (0x25) * Reporting of ignored or substituted characters The ICNV command runs the character conversion as part of the read operation of the Frankenstein Limes Universal Converter (FLUC). As default the block oriented binary read and write of files is used. With the keyword RECORD it will be possible to switch to record oriented binary read and write IO operations. Only binary formatting of the data is used. All the other conversion capabilities of FLUC are not available with this command. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined by the command line (directly or per file) or by properties taken from the corresponding property file converts input from Unicode to the old West-European encoding ISO-8859-1 and discards non convertible characters in the output converts input from the old West-European encoding ISO-8859-1 to unicode on and write to a remote system. * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: REMAIN - Remain existing files (don't overwrite) [FALSE]` * `SWITCH: NOMKDIR - Don't create path if path not exists [FALSE]` * `SWITCH: NORUN - Don't run the command only show parsed parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-icnv-in_f395.html",
"IN",
"[[CLEP.COMMAND.ICNV.IN]] ==== IN indexterm:[Parameter, IN, ICNV.IN] Defines the input file which is read. The encoding for the input file must be defined with the FROM option. * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-icnv-out_749e.html",
"OUT",
"[[CLEP.COMMAND.ICNV.OUT]] ==== OUT indexterm:[Parameter, OUT, ICNV.OUT] Defines the output file which is written. The encoding for the output file is defined by the TO code. * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-icnv-record_33ff.html",
"RECORD",
"[[CLEP.COMMAND.ICNV.RECORD]] ==== RECORD indexterm:[Parameter, RECORD, ICNV.RECORD] Switches from block oriented file io to record oriented file io. This option is mainly relevant for mainframes. ",
"",
""
],
[
"flcl_manual-flcl_commands-icnv-append_9afe.html",
"APPEND",
"[[CLEP.COMMAND.ICNV.APPEND]] ==== APPEND indexterm:[Parameter, APPEND, ICNV.APPEND] With APPEND the data is written at the end of the file. If the file does not exist then it will be created. If the file exists then the data will be appended to the file and not overwritten. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam_8685.html",
"FLAM",
"[[CLEP.COMMAND.FLAM]] === FLAM indexterm:[Command, FLAM, FLAM] The FLAM command can be used to compress or decompress individual files or groups of files either interactively or by means of procedures. The compress or decompress parameter specifies which operation is to be performed. All the information necessary to execute the command can be specified in the form of inputs made directly on the command line, in a parameter file or as installation-specific default values. The FLAM command is backward-compatible with the FLAM4 utility and designed to work with FLAM4 archives, also called FLAMFILEs. There are a few differences to the old FLAM4 utility: * Completion/Condition codes are defined by CLE/P ** Return code 0, 4 and 8 have the same meaning (OK, WARNING, ERROR) ** Higher return codes are different and correspond to more critical issues ** There are also completion codes between 0 and 4 or 4 and 8, for example 1 if a warning in the log (can be deactivated) ** Special condition codes (>64) are the same ** Please use the built-in function 'ERRORS' or refer to the appendix 'Return Codes' for more information ** The main difference in completion codes are: *** DMS errors result in a return code of 8 and not 12 with FLAM5 *** If directory walk (wildcards) fail for all files FLAM5 returns 8 instead of 4 (it returns 4 like FLAM4 if not all files processed successfully) * The log output is in FLAM5 syntax and looks different to the old FLAM4 utilities but is now the same on each platform * The default value file is replaced by the FLAM5 property management (and much more intelligent default behavior) * The default behavior differs a little bit and if required the property management must be used to adjust it * If squared, curly brackets or other operators are required, the parameters must be enclosed in quotation marks ** This was minimized as much as possible to be compatible with the old syntax * If keywords used insaide a string value in a parameter assignment the string must enclose in quotation marks ** IDDN=FLAMDD will result in a syntax error, because FLAMDD is a valid keyword and CLP try to assign the value of FLAMDD ** IDDN='FLAMDD' will work because 'FLAMDD' is interpreted a string value * The selection of members to read from a FLAMFILE is now made via the member definition of the FLAMIN parameter ** As part of the URL: FLAMIN='FLAM.FILE.ADC/?HUGO.PDS(*)' ** Or by the new parameter MEMBER: MEMBER='HUGO.PDS(*)' ** Instead of: FLAMOUT=<HUGO.PDS(*)> * The file name mapping (selection and replacement rules) is different and works like documented below (see INPUT TO OUTPUT NAME MAPPING) * No support of VSAM-LDS as FLAMIN or FLAMOUT (original data) on z/OS (not supported by LE) * The new FL5 system header is not supported by the old FLAM4 components ** VSAM data sets archived with FLAM4 can be reproduced with FLAM5 but not vice versa ** Sizes of original files are only known by FLAM5 (FLAM4 uses hard-coded defaults for primary (2/4MiB) and secondary space (40/50(MiB))) * Recreation of archived PDS load libraries is not yet supported within FLAM5 ** FLAM4 archived PDS load libraries and can be recreated ** FLAM4 does not support this for PDSEs ** FLAM5 does not support it at all till the XMIT support will be available * FLAM5 uses the CEE runtime environment (LE) and FLAM4 works LE-less on z/OS, which may result in different behavior ** Writing KSDS with new key position and length with FLAM5 results in re-ordered records and in a FIOPUT error on FLAM4 if reordering is required ** Empty records are really empty records (length=0) with FLAM4, with FLAM5 (LE) a empty record is written as one padding byte (see <<flcl.handling.empty.records,Handling of Empty Records>>)  * FLAM4 recognizes some errors only after an open of an output file, which may result in an empty file ** FLAM5 detects a lot of such errors before opening to avoid creation of empty files * FLAM5 recognizes from the combination of specified parameters whether compression or decompression is requested ** FLIMIN FLAMFILE (=COMP) and FLAMFILE FLAMOUT (=DECO) ** On z/OS, COMPRESS or DECOMPRESS must be specified for FLAM4 ** On Unix and Windows DECOMPRESS is the default for FLAM4 * The print control character handling is more intelligent in FLAM5 ** To be backward compatible: +    In the case you set a certain record format without print control character    and the original file contains print control character you must define OPRNCTR=RETAIN    to ensure the print control character as part of the record like in FLAM4.    If this new parameter not defined to RETAIN the print control character is not part of the record in this case. ** The provided record length in FLAM5 don't include the print control character (is one byte shorter then in FLAM4) * The default padding character is in FLAM4 always x'40' and in FLAM5 x'40' only used if text (ASA/MCC or CCSID defined) else it is x'00' * With FLAM4 for undefined files the record length must be provided by the caller, FLAM5 use the block size instead * The LIST switch on Windows will be the same as HELP. To get the current default values (properties) the built-in function GETPROP must be used. * FLAM4 on z/OS often requires upper case. FLAM5 syntax is not case sensitive,i.e. lower case can often be used * Given IRECFM and IRECSIZE are override by FLAM4 if the file is cataloged, FLAM5 try to allocate and open the file with the given parameter ** This result sometimes in errors with FLAM5 because the read file don't match with the given parameter (file attributes in conflict) ** Sometimes the runtime environment converts the data to the requested record format (original is VBA and requested is VB) * The FLAM4 UserIO is no longer supported for original data (`IDEVICE=USER` and `ODEVICE=USER` is ignored) * FLAM4 don't support large files (`DSNTYPE=LARGE`) at dynamic allocation, a corresponding data class must be used in this case ** FLAM5 supports large files by default if the amount of required tracks above the limit ** With version 5.1.22 the FLAM4 components set the DSNTYPE too large if more than 64K tracks allocated ** Only FLAM5 supports since version 5.1.22 extended attribute datasets (up to 16 TiB) * FLAM4 works with hard-coded defaults for space allocation (primary 2/4MiB secondary 40/50MiB) ** FLAM5 determines the file size and allocates depending on the space used by the original file by default ** This does not work for multi-volume datasets, in this case only the space used of the first volume will be allocated ** If you write a PO and you will extend this dataset later it is recommended to provide custom space values * FLAM5 supports also the default DD name 'FLAMOUT' at compress if 'FLAMFILE' not allocated and the same for 'FLAMIN' at read If the FLAM command is specified with the 'list' parameter, a list of the currently active settings of the default values is displayed; they can be modified by the system manager using the '-defaults' parameter. The FLAM command permits a separate FLAMFILE to be created from each original file (this requires input name mapping, which is differs to FLAM4). It is also possible to compress a group of original files into one FLAMFILE. The input files which are to be (de)compressed can either be specified by their fully qualified name or by patterns with wildcards. Output filenames can be explicit or generated by substitution rules. When decompressing, by default a file is to be restored with its original name and attributes. With the exception of the '-list' and '-defaults' parameters, there are equivalent FLAM parameters for all the elements of the command syntax, so that each setting can be entered either directly in the command line or in a parameter file which is referred to in the command by the parameter parfile=parameter file. Using a parameter file permits complicated keyboard inputs to be avoided, for example if settings which differ from the installed default values are required frequently. The following features are supported: * Different kinds of remote access protocols (SSH) * Different kinds of data sources (Files, Streams, Tables) * Different kinds of I/O methods (Binary, Character, Text, Record, FLAM) * Different compression modes (ADC, CX7, CX8, VR8 and NDC) * Different encryption modes (AES and FLAMENC) * Powerful character conversion based on CCSIDs If the FLAM command is not sufficient, you can use the CONV command which supports FLAMFILEs and other compression formats and provide various conversion and formatting modes. FLAM and CONV parameter are not identical. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or through a parameter file) or via properties taken from the corresponding property file. For the FLAM4 utility the command name 'flam' is default and can be omitted. The FLCL utility has no default command, in this case the command name 'FLAM' must be defined. Reads file in record format stream (usual text), compresses with default compression mode ADC, writes FLAMFILE. Reads and decompresses FLAMFILE, writes output file in record format stream. * `SWITCH: NORUN - Don't run the command only show parsed parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-compress_656a.html",
"COMPRESS",
"[[CLEP.COMMAND.FLAM.COMPRESS]] ==== COMPRESS indexterm:[Parameter, COMPRESS, FLAM.COMPRESS] This parameter activates data compression. FLAM compresses the standardized data formats with a typical compression rate of 4:1. The compression rate can be as high as 95% (20:1). FLAM does not need any additional specification about data to be compressed. The compression method is independent from file, record, and field formats. As FLAM compresses a file, it will write the result into a sequential or index sequential file, the FLAMFILE. This file may have a header that will store information about the original file. FLAM is able to process all PS, PO and VSAM files. It is possible to compress a number of files into one or a number of FLAMFILEs. To adapt the compression process to the requirements of the user, it is possible to specify parameters during the program call. It is also possible to define the parameters using a parameter file or while generating the system. FLAM creates a job protocol for each execution (on screen or into a log file). During compression, FLAM processes a set of 1-4095 (logical) records within one block (Matrix). FLAM can process input and output from both disc and magnetic tape or cartridge. This is also true for the compressed file, the FLAMFILE. FLAM always compresses a set of records in one step. The size of the intermediate buffer can be specified via the parameter MAXBUFFER. FLAM will read only as many input records in one step as can be stored within the intermediate buffer. For compatibility reasons to all FLAM versions, the size of the intermediate buffer is restricted to 32 KiB. However, if the target computer (i.e., the computer on which the compressed file will be decompressed) is known and the FLAM version installed on this computer allows for it, a bigger buffer size for optimal compression can be defined. It is also possible to restrict the number of records within one set using the MAXRECORDS parameter. If you define MAXRECORDS=1, FLAM will use a serial context free compression method that is only useful with long records. The typical compression ratios are usually achieved with 16-32 records within one set. With a bigger set, a slightly better compression ratio can be achieved (which also leads to less CPU utilization!), but the intermediate buffer has to be bigger. The better the compression ratio is, the less CPU time is needed ! It is possible to generate all compressed data in EBCDIC and ASCII code. Compressed records can be created in both fixed and variable format. The compression method is always the same - based on the Frankenstein-Limes-Access-Method. Only the treatment of the matrix columns and the representation of the compressed files differs from case to case. This is controlled with the MODE parameter. Compression mode ADC is introduced as default value. That means, that when the MODE parameter is omitted, MODE=ADC is used. With MODE=CX8, FLAM will only compress repeating characters (horizontally and vertically). With MODE=VR8, the remaining data is compressed in addition using the FL-B(4) code. This process first translates the characters into a special 8-bit code and then homogenizes them using specially designed logical operations. The results are bit strings that can be compressed efficiently. In both cases, the compressed file, the FLAMFILE, is a sequence of 8-bit combinations that are written into sequential or index sequential files. Record size, record format, block size can be defined by the user. Each record of a file is protected with a checksum. Code conversions within the FLAMFILE are not allowed. During transmission, the file has to be treated as a binary file. Compression modes CX7, CX8 or VR8 are processed by zIIP processors when a free zIIP processor is found. This decreases CPU utilization and leads to cost savings. It is done automatically without any parameter. For files that contain only printable characters and shall be transmitted using a 7-bit-line, FLAM offers MODE=CX7. This mode creates a compressed file which will 'behave' during transmission in the same way as the uncompressed file. FLAM does not check, if the original file is suitable for transmission, but will create a compressed file using a very restricted character set that is neutral to the different code conversion utilities on the marketplace. Using this mode, FLAM can create compressed files that can be converted from EBCDIC to ASCII and vice versa (e.g., during a file transfer). However, it is necessary that the code conversion is reversible without any changes. Otherwise, FLAM will signal a syntax error in the compressed file due to differences in the byte numbers and will stop decompression. Such cases are possible if the original file contains printer control characters or tabulator characters, which are not converted 1:1. Apart from this, code conversion can be performed integrated with the compression step. FLAM offers the possibility of code conversion (before compression, or after decompression). Code conversion is controlled via standard code tables or user defined code tables. For special cases where a 1:1 code conversion is not possible for all characters, user exits are provided. Syntax restrictions for FLAMv4 or older: * z/OS ** `COMPRESS` ** `C` * UNIX ** `-compress` * WINDOWS ** `compress` *Values* * No values *Default* * z/OS ** `COMPRESS` * UNIX/WINOWS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-decompress_9145.html",
"DECOMPRESS",
"[[CLEP.COMMAND.FLAM.DECOMPRESS]] ==== DECOMPRESS indexterm:[Parameter, DECOMPRESS, FLAM.DECOMPRESS] This parameter activates data decompression. FLAM decompresses lossless data from a compressed file (FLAMFILE) into a target file (FLAMOUT). A FLAMFILE can be converted during decompression into any file or record format as specified by the user on any system. FLAM reads a compressed file, decompresses the content and writes the result into an output file. During decompression the characteristic parameters of the original files are normally restored depending on the information in the file header of the FLAMFILE. To adapt the decompression process to special requirements of the user, it is possible to specify several parameters used in decompression process (e.g. passsword usage against unauthorized access, transformation of file format, code and file name conversion, etc.). FLAM automatically configures itself the output file and output data according to file header of the FLAMFILE used during compression and possibly specified decompression parameters (e.g., buffer size or record set size ). That the FLAMFILE eventually was created in a different environment (e.g. different operating system) lacks influence on the decompression operation of FLAM. Data are decompressed into equivalent file or in user defined file formats. To be even more flexible, FLAM provides user exits that allow the user to apply user defined post data processing. FLAM creates a job protocol for each execution (on screen or into a log file). Syntax restrictions for FLAMv4 or older: * z/OS ** `DECOMPRESS` ** `D` * UNIX ** `-decompres` * WINDOWS ** `decompess` *Values* * No values *Default* * z/OS ** `COMPRESS` +    Specification is required for DECOMPRESS, otherwise malfunction. * UNIX/WINOWS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-remain_85b6.html",
"REMAIN",
"[[CLEP.COMMAND.FLAM.REMAIN]] ==== REMAIN indexterm:[Parameter, REMAIN, FLAM.REMAIN] Existing files are overwritten in compression and decompression process by default.The REMAIN switch has to be defined to prevent this. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-append_6e7e.html",
"APPEND",
"[[CLEP.COMMAND.FLAM.APPEND]] ==== APPEND indexterm:[Parameter, APPEND, FLAM.APPEND] The data is appended to an existing file. If the file does not exist, it will be created. This feature is not allowed for secure FLAMFILES and was only supported till FLAM3 for Windows. With FLAM5 it is only implemented for z/OS. Syntax restrictions for FLAMv4 or older: * WIN ** `append` (for output files till FLAM3) ** `add` (for FLAMFILEs till FLAM3) * z/OS ** `append` (for FLAMFILE and FLAMOUT with FLAM5) ** `add` (for FLAMFILE and FLAMOUT with FLAM5) *Values* * none *Default* * none *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-flamfile_8584.html",
"FLAMFILE",
"[[CLEP.COMMAND.FLAM.FLAMFILE]] ==== FLAMFILE indexterm:[Parameter, FLAMFILE, FLAM.FLAMFILE] Filename for FLAMFILE with compressed (or uncompressed) data. During <<CLEP.COMMAND.FLAM.COMPRESS,compression>>, compressed data is written into the specified FLAMFILE. During <<CLEP.COMMAND.FLAM.DECOMPRESS,decompression>>, compressed data is read from specified FLAMFILE and is stored uncompressed. The parameter `FLAMFILE` can be used together with parameter <<CLEP.COMMAND.FLAM.MEMBER,MEMBER>>. In case of compression, the input filename is renamed to the string in parameter 'MEMBER' and is stored as member name in the FLAMFILE. In case of decompression, the member in the FLAMFILE is renamed to the string in parameter 'MEMBER' and is stored with this name as output file. NOTE: Selection and conversion rules using pointed brackets '<>' in parameter `FLAMFILE` are dropped in FLAM5 and cannot be used anymore. So, the rules described in in the FLAM4 Manual are deprecated. The new rules are explained in the section <<flcl.input.output.name.mapping,Input to Output Name Mapping>> and apply to the parameter FLAMFILE. The old FLAM4 syntax must be migrated in this case.  Instead of using pointed brackets '<>' use of URL syntax is possible now and is a substitute for using the parameter FLAMFILE and <<CLEP.COMMAND.FLAM.MEMBER,MEMBER>>. Example: `FLAMFILE=flamfile.adc/?newifile.txt` In the case of compression, the input file specified as FLAMIN is written to the FLAMFILE `flamfile.adc` as `newifile.txt` (stored as member in the FLAMFILE). Syntax restrictions for FLAMv4 or older: * z/OS ** `FLAMFILE=filename` ** `FL=filename` ** `*DUMMY` * UNIX / WINDOWS ** `-flamfile=file specification` *Values* * z/OS ** Filename with max. 54 characters. ** > Filename with max. 53 characters of file containing file list. ** URL syntax, e.g. flamfile.adc/?inputfile.txt * UNIX ** file specification *** Note:With compression, file specification specifies a specific          file or a list of files separated by commas. A substitution          rule is also permitted.          With decompression, file specification specifies a specific          file, a pattern (with wildcards * or ?), or a list of such          elements separated by commas. * WINDOWS ** -file specification *Default* * no name *Valid for* * compression * decompression Specifying a filename is an alternative to assigning the file by means of a DD statement. The specification can contain a conversion rule for filenames. The name can be specified in wildcard syntax for decompression. The character `>` in front of the filename means that the flamfile contains a list of filenames to be decompressed. `DUMMY` acts like the DD-statement `//.. DD DUMMY` In principle, FLAM is able to process all filenames via JCL valid in z/OS. FLAM stores the name of the compressed file into the FLAMFILE, if required. To avoid any conflicts with national character sets or naming conventions in other systems, all filenames stored in ASCII character set are translated for message and selection in the following way: All national characters are translated to 'X', a backslash '\\' to slash '/', and whitespace ' ' to underline '_'. So it is easier to enter foreign filenames that are unsupported in the z/OS environment. The filename itself remains unchanged in the FLAMFILE.  Entering `DUMMY` as a filename causes FLAM to use this file as dummy like the JCL command `//ddname DD DUMMY`. I.e. reading an input file leads to EOF (end of file), writing to an output file has no effect. So, DD-statements are not necessary for DUMMY files. By prefixing the '>' character (greater than) to the filename or DD-NAME, the FLAM parameters `FLAMIN` and `IDDN` are able to specify a list of files for compression instead of one single file. It is also possible to specify a file list for decompression by means of the `FLAMFILE` or `FLAMDD` parameter. In this list, each filename must be contained in a separate record; leading or trailing space characters (X'40') are ignored. A comment can be inserted after the first space character following the filename. Empty records or records with an asterisk '*' in the first column are regarded as comment lines. All filenames usable in z/OS are legal. Wildcard syntax is allowed. *Example:* If the records in the file USER.DAT.LIST contain the following filenames: the specification leads to all the files specified being compressed into one FLAMFILE (group file). The file that contains the list of filenames can have any format supported by FLAM and be of any type. For 'in-stream files', i.e. input files temporarily created by JES, it is advisable to assign the filenames by means of DD names: This allows the filename list to be specified directly in the job. Filenames can be specified in FLAM by means of parameters written with wildcard syntax. Correspondingly, the entry `FLAMIN=USER.*.DATA.%BC` leads to the compression of all files with the 1st qualifier USER, any 2nd qualifier, DATA as the third part of their name, and a three-digit 4th qualifier which ends with BC and begins with any character. The asterisk '*' stands for any (even an empty) character string. The percent character '%' stands for any character. These special characters are also allowed within members of one or more PO libraries: specifies all members of the library USER.POLIB, that begin with FL; specifies all members whose 4-digit names begin with A and end with B and whose libraries have the identification USER, LIB as their final qualifier, and D as the last character of the second to the last part of their name. All input files are stored in this way in one compressed file (group file). Correspondingly, the wildcard entry in the selection rule for decompression leads to the decompression of only those items of compressed data whose original names conform to the syntax specified. (Comment: this procedure requires a FLAM file header (`HEADER=YES`) and the file information `FILEINFO=YES`) for compression). *Example:* All files with names that conforming to the FLAMIN specification are to be compressed into the file USER.DAT.CMP. If the files are catalogued, the 1st file does not conform to the wildcard syntax and is ignored during compression. If is now specified for decompression, only the files `USER.DATCB.CLIB` and `USER.DATCB.DLIB` will be decompressed. Correspondingly, it is also possible to select a number of FLAMFILEs for decompression: means all FLAMFILEs with the identification USER, CMP as their 2nd qualifier, any character string as the 3rd part of their name and VR8 as their last qualifier are to be decompressed. If the input specification contains more than one element, the following rules regarding syntax and assignment to the FLAMFILE specifications must be obeyed. The input specification may consist of a file or directory name, a pattern (with wildcards), or a list of such elements. Elements of a list are separated by commas. Filenames may contain space characters, but not as first characters. Filnames containing spaces must be enclosed in double quotes. The files specified as input files must actually exist. At least one matching file must exist for a pattern. Otherwise, the `flam` command will be aborted and an error message output. If the input specification specifies files for processing by FLAM, either the `-flamin` parameter or `-flamfile` must be specified for the compression or decompression procedure respectively. If the data is to be entered via the special stdin file, the parameter for the input specification is omitted. FLAM can thus be used as a filter. If the flam command contains several different input and output specifications, they are assigned to one another. The assignment determines where the compressed data of each original file and the decompressed data of each compressed file is saved. The input and output specifications are assigned to one another by means of their positions in the lists. The first input specification is assigned to the first output specification and the second input specification to the second output specification, etc. If there are more input specifications than output specifications, the excess input specifications are assigned to the final output specification. If there are too many output specifications, the excess ones are ignored. If the output specification is a file specification, all the outputs which result from processing the assigned input files are saved in this file. The file attributes must be compatible. If the output specification is a substitution rule, a separate FLAMFILE, which is named according to this rule, is created during the compression procedure for each of the assigned input files. During the decompression procedure, the substitution rule is applied to the names of the FLAMFILEs and not to the names of the compressed original files, i.e. each FLAMFILE results in a separate decompressed file. If a FLAMFILE which contains the compressed data of several different files is assigned an output file, all the compressed data in this FLAMFILE is decompressed into the output file. The output specification [] or [`*`] is then necessary in order to create separate files again. In this case, each compressed block is decompressed into a file with the original name. In the example below, the flam command contains a list of input specifications and a list of output specifications. The list of input specifications contains four entries, namely the output specifications, two substitution rules and a file specification. In accordance with the assignment rules, a file with the same name and a .cmp extension is created for each file which has a .dat extension, and the compressed data of all the files with a .txt extension is saved in a single FLAMFILE called text.arc. The compressed data of `func1.hlp` is saved in func1xyz on  account of the substitution rule contained in the final output specification. Since there are no further output specifications, this rule is also applied to func2.hlp, i.e. a FLAMFILE called `func2xyz` is created for its compressed data. It should be noted that text.arc can only be decompressed into separate files if `-attributes=all` is specified for the compression procedure, so that the names of all the original files are included in the FLAMFILE. Either of the output  specifications  []  or  [`*`]  can  be used for the decompression procedure, to ensure that the files are decompressed separately and given their original names again. If an output file were to be specified, a single file would result, in which all the records of the original files would be concatenated. If the output specification contains more than one file, the following rules described with regard to the syntax and the assignment to the FLAMFILE specifications must be observed. The output specification may consist of a filename, a list of filenames (separated by commas), or a substitution rule. A substitution rule has the following format: [string1=string2]. Moreover, one of the output specifications [ ], [`*`], or [filename] may be used (see description below). Output files are created if they do not exist and overwritten if they do. If a substitution rule is defined as an output specification, the name of the FLAMFILE or the decompressed file must be formed by substituting string2 for string1 in the name of the input file. The strings and the equal sign must have no separating spaces in between. The substitution rule applies only to file names and not to path names. *Example:* causes the files called helptxt1.txt and helptxt2.txt to be compressed and the compressed data to be saved in the associated FLAMFILEs called helptxt1.cmp and helptxt2.cmp. The substitution rule must be applicable to all the assigned input files, i.e. string1 must be contained in the names of every one of these files, or the flam command will be aborted for the file to which it does not apply and an error message will be output. Only one substitution takes place when the name of the output file is formed, even if string1 occurs more than once in the name of the input file. The output specifications [file name], [ ], and [`*`] have special meanings. Using [file name] as output specification causes the decompression to select one or  when file name contains wildcards-, possibly several, matching file(s) from  a FLAMFILE archive. Those are decompressed into the current directory unless -outpath=... directs otherwise. If the output specification for the decompression procedure is [*], the names of the decompressed files are derived from the FLAMFILE, provided the FLAMFILE actually contains them. If not, an error message is output. -attributes=all must be specified for the compression procedure, in order to include the names of the original files in the FLAMFILE. If the output specification is [], the effect is similar to the output specification [`*`], i.e. the names of the decompressed files are derived from the FLAMFILE(s), except that only the file name is taken into account. The path name is ignored. All the files are thus created in the current directory if no -outpath specification is given. Once again, -attributes=all must have been set for the compression procedure. The output specifications [file name], [], and [`*`] must not be part of a list of output specifications, i.e. they must stand alone. If the output specification specifies files for processing by FLAM, either the -flamfile parameter or -flamout must be specified  for the compression or decompression procedure respectively. If the data is to be output to the special file stdout, the parameter for the output specification must be omitted. FLAM can thus be used as a filter.  man_flam4_assignintooutspec.txt * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-member_cd64.html",
"MEMBER",
"[[CLEP.COMMAND.FLAM.MEMBER]] ==== MEMBER indexterm:[Parameter, MEMBER, FLAM.MEMBER] String, contains name or index of a member in the FLAMFILE. If a compress process receives a string in the MEMBER parameter, the selected input file is stored with the specified MEMBER name in the FLAMFILE. If a decompress process receives a string in the MEMBER parameter, the decompressed file in the FLAMFILE is stored with the specified string content from the MEMBER parameter as output filename. The parameter MEMBER is used together with parameter <<CLEP.COMMAND.FLAM.FLAMFILE,FLAMFILE>>. Syntax restrictions for FLAMv4 or older: * `MEMBER=string` * `MEM=string` *Values* * string of up to 8 bytes *Default* *  none (no string) *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-flamin_060d.html",
"FLAMIN",
"[[CLEP.COMMAND.FLAM.FLAMIN]] ==== FLAMIN indexterm:[Parameter, FLAMIN, FLAM.FLAMIN] This parameter specifies the files to be compressed. This parameter defines the default name for the input file during the compression procedure. The input specification is a file specification. It must name a single file uniquely an may not contain patterns (wildcards). Note that when a default name is defined, stdin and pipelines can no longer be used for flamin. With `flamin=none`, the default value for this parameter is dropped. Syntax restrictions for FLAMv4 or older: * z/OS ** `FLAMIN=filename` ** `FLAMI=filename` * UNIX ** `-flamin=input specification` * WINDOWS ** `flamin='name of original files'` *Values* * z/OS ** Filename with max. 54 characters * > Filename with max. 53 characters ** `*DUMMY` * UNIX ** -input specification +     The input specification specifies a specific file, a directory,     a search pattern (with wildcards * or ?), or a list of such     elements separated by commas. +     The specified files are compressed in accordance with the     other parameters specified for the command. When a name refers     to a directory, all files in that directory and, if present,     its subdirectories are compressed. * WINDOWS ** name of original files +    With this parameter the files that are to be compressed are    specified. Usual wildcards (*?) are allowed. *Default* * z/OS ** COMPRESS * UNIX/WINOWS ** none *Valid for* * compression Specifying a filename is an alternative to assigning the file by means of a DD statement. The specification can contain a conversion rule for filenames. The name can be specified in wildcard syntax for decompression. The character `>` in front of the filename means that the flamfile contains a list of filenames to be decompressed. `DUMMY` acts like the DD-statement `//.. DD DUMMY` In principle, FLAM is able to process all filenames via JCL valid in z/OS. FLAM stores the name of the compressed file into the FLAMFILE, if required. To avoid any conflicts with national character sets or naming conventions in other systems, all filenames stored in ASCII character set are translated for message and selection in the following way: All national characters are translated to 'X', a backslash '\\' to slash '/', and whitespace ' ' to underline '_'. So it is easier to enter foreign filenames that are unsupported in the z/OS environment. The filename itself remains unchanged in the FLAMFILE.  Entering `DUMMY` as a filename causes FLAM to use this file as dummy like the JCL command `//ddname DD DUMMY`. I.e. reading an input file leads to EOF (end of file), writing to an output file has no effect. So, DD-statements are not necessary for DUMMY files. By prefixing the '>' character (greater than) to the filename or DD-NAME, the FLAM parameters `FLAMIN` and `IDDN` are able to specify a list of files for compression instead of one single file. It is also possible to specify a file list for decompression by means of the `FLAMFILE` or `FLAMDD` parameter. In this list, each filename must be contained in a separate record; leading or trailing space characters (X'40') are ignored. A comment can be inserted after the first space character following the filename. Empty records or records with an asterisk '*' in the first column are regarded as comment lines. All filenames usable in z/OS are legal. Wildcard syntax is allowed. *Example:* If the records in the file USER.DAT.LIST contain the following filenames: the specification leads to all the files specified being compressed into one FLAMFILE (group file). The file that contains the list of filenames can have any format supported by FLAM and be of any type. For 'in-stream files', i.e. input files temporarily created by JES, it is advisable to assign the filenames by means of DD names: This allows the filename list to be specified directly in the job. Filenames can be specified in FLAM by means of parameters written with wildcard syntax. Correspondingly, the entry `FLAMIN=USER.*.DATA.%BC` leads to the compression of all files with the 1st qualifier USER, any 2nd qualifier, DATA as the third part of their name, and a three-digit 4th qualifier which ends with BC and begins with any character. The asterisk '*' stands for any (even an empty) character string. The percent character '%' stands for any character. These special characters are also allowed within members of one or more PO libraries: specifies all members of the library USER.POLIB, that begin with FL; specifies all members whose 4-digit names begin with A and end with B and whose libraries have the identification USER, LIB as their final qualifier, and D as the last character of the second to the last part of their name. All input files are stored in this way in one compressed file (group file). Correspondingly, the wildcard entry in the selection rule for decompression leads to the decompression of only those items of compressed data whose original names conform to the syntax specified. (Comment: this procedure requires a FLAM file header (`HEADER=YES`) and the file information `FILEINFO=YES`) for compression). *Example:* All files with names that conforming to the FLAMIN specification are to be compressed into the file USER.DAT.CMP. If the files are catalogued, the 1st file does not conform to the wildcard syntax and is ignored during compression. If is now specified for decompression, only the files `USER.DATCB.CLIB` and `USER.DATCB.DLIB` will be decompressed. Correspondingly, it is also possible to select a number of FLAMFILEs for decompression: means all FLAMFILEs with the identification USER, CMP as their 2nd qualifier, any character string as the 3rd part of their name and VR8 as their last qualifier are to be decompressed. If the input specification contains more than one element, the following rules regarding syntax and assignment to the FLAMFILE specifications must be obeyed. The input specification may consist of a file or directory name, a pattern (with wildcards), or a list of such elements. Elements of a list are separated by commas. Filenames may contain space characters, but not as first characters. Filnames containing spaces must be enclosed in double quotes. The files specified as input files must actually exist. At least one matching file must exist for a pattern. Otherwise, the `flam` command will be aborted and an error message output. If the input specification specifies files for processing by FLAM, either the `-flamin` parameter or `-flamfile` must be specified for the compression or decompression procedure respectively. If the data is to be entered via the special stdin file, the parameter for the input specification is omitted. FLAM can thus be used as a filter. If the flam command contains several different input and output specifications, they are assigned to one another. The assignment determines where the compressed data of each original file and the decompressed data of each compressed file is saved. The input and output specifications are assigned to one another by means of their positions in the lists. The first input specification is assigned to the first output specification and the second input specification to the second output specification, etc. If there are more input specifications than output specifications, the excess input specifications are assigned to the final output specification. If there are too many output specifications, the excess ones are ignored. If the output specification is a file specification, all the outputs which result from processing the assigned input files are saved in this file. The file attributes must be compatible. If the output specification is a substitution rule, a separate FLAMFILE, which is named according to this rule, is created during the compression procedure for each of the assigned input files. During the decompression procedure, the substitution rule is applied to the names of the FLAMFILEs and not to the names of the compressed original files, i.e. each FLAMFILE results in a separate decompressed file. If a FLAMFILE which contains the compressed data of several different files is assigned an output file, all the compressed data in this FLAMFILE is decompressed into the output file. The output specification [] or [`*`] is then necessary in order to create separate files again. In this case, each compressed block is decompressed into a file with the original name. In the example below, the flam command contains a list of input specifications and a list of output specifications. The list of input specifications contains four entries, namely the output specifications, two substitution rules and a file specification. In accordance with the assignment rules, a file with the same name and a .cmp extension is created for each file which has a .dat extension, and the compressed data of all the files with a .txt extension is saved in a single FLAMFILE called text.arc. The compressed data of `func1.hlp` is saved in func1xyz on  account of the substitution rule contained in the final output specification. Since there are no further output specifications, this rule is also applied to func2.hlp, i.e. a FLAMFILE called `func2xyz` is created for its compressed data. It should be noted that text.arc can only be decompressed into separate files if `-attributes=all` is specified for the compression procedure, so that the names of all the original files are included in the FLAMFILE. Either of the output  specifications  []  or  [`*`]  can  be used for the decompression procedure, to ensure that the files are decompressed separately and given their original names again. If an output file were to be specified, a single file would result, in which all the records of the original files would be concatenated. * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-flamout_ded6.html",
"FLAMOUT",
"[[CLEP.COMMAND.FLAM.FLAMOUT]] ==== FLAMOUT indexterm:[Parameter, FLAMOUT, FLAM.FLAMOUT] Filename for the output file. With this parameter the names of the decompressed files are specified. During decompression the decompressed data of the FLAMFILE are written into the specified file(s). Selection and conversion rules using pointed brackets '<>' are dropped in FLAM5 and cannot be used anymore. So, the rules described in section the old FLAM4 manuals are deprecated and a migration is required. The new rules are explained in the section <<flcl.input.output.name.mapping,Input to Output Name Mapping>> and apply to the parameter FLAMFILE. Syntax restrictions for FLAMv4 or older: * z/OS ** `FLAMOUT=filename` ** `FLAMO=filename` * UNIX ** `-flamout=output specification` * WINDOWS ** `flamout=output specification` *Values* * z/OS ** Filename with max. 54 characters ** `*DUMMY` * UNIX ** output specification *** Note: With compression, file specification specifies a specific     file or a list of files separated by commas. A substitution     rule is also permitted. +     With decompression, file specification specifies a specific     file, a pattern (with wildcards * or ?), or a list of such     elements separated by commas. * WINDOWS ** output specification *** Note: With the output specification one or more files are specified     into which the decompressed data is to be written.     The following special characters are possible, especially in     combination with outpath: **** `flamout=[]` - original file names are stored in FLAMFILE **** `flamout=[*]` - just as [], but including path, if outpath not specified **** `flamout=[#]` - Filenames are generated to FILE#nnn, e.g. File#002 = 2nd file in FLAMFILE **** `flamout=[#3]` - Only the 3rd file from a FLAMFILE archive is decompressed, using the original name **** `flamout=[#3=<name>]` - Only the 3rd file is decompressed (with <name>) *Default* * no name *Valid for* * compression Specifying a filename is an alternative to assigning the file by means of a DD statement. The specification can contain a conversion rule for filenames. The name can be specified in wildcard syntax for decompression. The character `>` in front of the filename means that the flamfile contains a list of filenames to be decompressed. `DUMMY` acts like the DD-statement `//.. DD DUMMY` In principle, FLAM is able to process all filenames via JCL valid in z/OS. FLAM stores the name of the compressed file into the FLAMFILE, if required. To avoid any conflicts with national character sets or naming conventions in other systems, all filenames stored in ASCII character set are translated for message and selection in the following way: All national characters are translated to 'X', a backslash '\\' to slash '/', and whitespace ' ' to underline '_'. So it is easier to enter foreign filenames that are unsupported in the z/OS environment. The filename itself remains unchanged in the FLAMFILE.  Entering `DUMMY` as a filename causes FLAM to use this file as dummy like the JCL command `//ddname DD DUMMY`. I.e. reading an input file leads to EOF (end of file), writing to an output file has no effect. So, DD-statements are not necessary for DUMMY files. By prefixing the '>' character (greater than) to the filename or DD-NAME, the FLAM parameters `FLAMIN` and `IDDN` are able to specify a list of files for compression instead of one single file. It is also possible to specify a file list for decompression by means of the `FLAMFILE` or `FLAMDD` parameter. In this list, each filename must be contained in a separate record; leading or trailing space characters (X'40') are ignored. A comment can be inserted after the first space character following the filename. Empty records or records with an asterisk '*' in the first column are regarded as comment lines. All filenames usable in z/OS are legal. Wildcard syntax is allowed. *Example:* If the records in the file USER.DAT.LIST contain the following filenames: the specification leads to all the files specified being compressed into one FLAMFILE (group file). The file that contains the list of filenames can have any format supported by FLAM and be of any type. For 'in-stream files', i.e. input files temporarily created by JES, it is advisable to assign the filenames by means of DD names: This allows the filename list to be specified directly in the job. Filenames can be specified in FLAM by means of parameters written with wildcard syntax. Correspondingly, the entry `FLAMIN=USER.*.DATA.%BC` leads to the compression of all files with the 1st qualifier USER, any 2nd qualifier, DATA as the third part of their name, and a three-digit 4th qualifier which ends with BC and begins with any character. The asterisk '*' stands for any (even an empty) character string. The percent character '%' stands for any character. These special characters are also allowed within members of one or more PO libraries: specifies all members of the library USER.POLIB, that begin with FL; specifies all members whose 4-digit names begin with A and end with B and whose libraries have the identification USER, LIB as their final qualifier, and D as the last character of the second to the last part of their name. All input files are stored in this way in one compressed file (group file). Correspondingly, the wildcard entry in the selection rule for decompression leads to the decompression of only those items of compressed data whose original names conform to the syntax specified. (Comment: this procedure requires a FLAM file header (`HEADER=YES`) and the file information `FILEINFO=YES`) for compression). *Example:* All files with names that conforming to the FLAMIN specification are to be compressed into the file USER.DAT.CMP. If the files are catalogued, the 1st file does not conform to the wildcard syntax and is ignored during compression. If is now specified for decompression, only the files `USER.DATCB.CLIB` and `USER.DATCB.DLIB` will be decompressed. Correspondingly, it is also possible to select a number of FLAMFILEs for decompression: means all FLAMFILEs with the identification USER, CMP as their 2nd qualifier, any character string as the 3rd part of their name and VR8 as their last qualifier are to be decompressed. If the output specification contains more than one file, the following rules described with regard to the syntax and the assignment to the FLAMFILE specifications must be observed. The output specification may consist of a filename, a list of filenames (separated by commas), or a substitution rule. A substitution rule has the following format: [string1=string2]. Moreover, one of the output specifications [ ], [`*`], or [filename] may be used (see description below). Output files are created if they do not exist and overwritten if they do. If a substitution rule is defined as an output specification, the name of the FLAMFILE or the decompressed file must be formed by substituting string2 for string1 in the name of the input file. The strings and the equal sign must have no separating spaces in between. The substitution rule applies only to file names and not to path names. *Example:* causes the files called helptxt1.txt and helptxt2.txt to be compressed and the compressed data to be saved in the associated FLAMFILEs called helptxt1.cmp and helptxt2.cmp. The substitution rule must be applicable to all the assigned input files, i.e. string1 must be contained in the names of every one of these files, or the flam command will be aborted for the file to which it does not apply and an error message will be output. Only one substitution takes place when the name of the output file is formed, even if string1 occurs more than once in the name of the input file. The output specifications [file name], [ ], and [`*`] have special meanings. Using [file name] as output specification causes the decompression to select one or  when file name contains wildcards-, possibly several, matching file(s) from  a FLAMFILE archive. Those are decompressed into the current directory unless -outpath=... directs otherwise. If the output specification for the decompression procedure is [*], the names of the decompressed files are derived from the FLAMFILE, provided the FLAMFILE actually contains them. If not, an error message is output. -attributes=all must be specified for the compression procedure, in order to include the names of the original files in the FLAMFILE. If the output specification is [], the effect is similar to the output specification [`*`], i.e. the names of the decompressed files are derived from the FLAMFILE(s), except that only the file name is taken into account. The path name is ignored. All the files are thus created in the current directory if no -outpath specification is given. Once again, -attributes=all must have been set for the compression procedure. The output specifications [file name], [], and [`*`] must not be part of a list of output specifications, i.e. they must stand alone. If the output specification specifies files for processing by FLAM, either the -flamfile parameter or -flamout must be specified  for the compression or decompression procedure respectively. If the data is to be output to the special file stdout, the parameter for the output specification must be omitted. FLAM can thus be used as a filter.  man_flam4_assignintooutspec.txt * `STREAM - Read from stdin or write to stdout` * `DUMMY - Read EOF or write nothing` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-outpath_7e35.html",
"OUTPATH",
"[[CLEP.COMMAND.FLAM.OUTPATH]] ==== OUTPATH indexterm:[Parameter, OUTPATH, FLAM.OUTPATH] This parameter determines the directory location used by FLAM to create a decompressed file. Syntax restrictions for FLAMv4 or older: * UNIX ** `-outpath=output path` * WINDOWS ** *outpath=path` *Values* * UNIX ** An existing directory in which FLAM will create the file(s) being    decompressed. This may be an absolute or a relative path.    An explicit specification `-flamout=...` at decompression    may also include a complete directory path. This option is    not available when decompressing with `-flamout=[ ]`. In    that case, an output directory can be specified using    `outpath=...`. * WINDOWS ** The specified path becomes the target directory.    The directory structure is generated if necessary. *Default* * UNIX ** No default value can be set for -outpath. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-mode_a591.html",
"MODE",
"[[CLEP.COMMAND.FLAM.MODE]] ==== MODE indexterm:[Parameter, MODE, FLAM.MODE] * z/OS: Compression mode only. * Unix: Compression mode and, when desired, with encryption mode. * Windows: Compression mode only. Input file(s) are compressed with the specified FLAM mode. FLAM supports four compression modes: adc, cx7, cx8, and vr8. In the adc, cx8, and vr8 modes, it creates the FLAMFILE as a binary file. Mode adc is the most efficient one. It compresses the datastream by removing the redundancy of repetitive sequences and can be used universally. The other modes mainly eliminate 'vertical redundancy', i.e. their efficiency relies on the recognition of re-occurring column contents in table-structured data. Compression mode adc can be combined with one of two encryption methods supported by FLAM. The first is AES, that has been declared standard for US government agencies by NIST (National Institute of Standards and Technology), the second flamenc is a proprietary algoriths of limes datentechnik gmbh. None of the other compression methods allows encryption. In all binary modes the compressed information is largely independent of the characteristics of the system on which the compression took place, i.e. the FLAMFILEs must not be modified, for example, if they are transmitted on a line which translates codes automatically. FLAMFILEs which are compressed in the cx7 mode, on the other hand, are insensitive to code translations, since they represent all control information by means of alphanumeric characters, the codes for which are standardized internationally in the ASCII and EBCDIC systems. Providing the original data is character-coded and suitable for exchange between systems with different character sets, the information content of the FLAMFILE remains fully intact after it has been converted to the character set of the destination system, despite the altered binary contents, thanks to the character-oriented interpretation. The compression mode is identified automatically when the file is decompressed. The user thus does not need to know the compression mode in order to decompress a file. NOTE: Compression mode CX8 and VR8 does not support `CRYPTOMODE=FLAM`.       Compression mode CX7 does not support either `CRYPTOMODE=ADC`       nor `CRYPTOMODE=FLAM`.          The compression mode is especially important for file transfer.          For local use only the 8 bit modes should be used (ADC/CX8/VR8)          for better efficiency. +          For file transfer on transparent lines also the 8 bit modes          should be used. For compressed text data (only printable          characters - no control or tab characters) shall be transferred          via non transparent lines the 7 bit mode (CX7) is appropriate.          as encryption mode. +          This parameter specifies the mode in which the original file is          compressed and, if desired, encrypted.           The input file is compressed with the specified FLAM mode.           The key word mode= may be omitted. Syntax restrictions for FLAMv4 or older: * z/OS ** `MODE=ADC/CX7/CX8/VR8/NDC` ** `MO=ADC/CX7/CX8/VR8/NDC` * UNIX ** `-mode=adc/aes/cx7/cx8/vr8/flamenc` +    (see also parameter <<CLEP.COMMAND.FLAM.NDC,NDC>>) * WINDOWS ** `mode=adc/aes/cx7/cx8/vr8/ndc` *Values* * z/OS ** `ADC` - 8 bit compression of highest efficiency ** `CX7` - transformable 7 bit compression ** `CX8` - 8 bit compression (CPU time optimised) ** `VR8` - 8 bit compression (space optimised) ** `NDC` - no compression * UNIX ** `adc` - 8 bit compression of highest efficiency. +            With `-mode=adc` the input file is compressed in adc mode and a            binary FLAMFILE is created. This is the most efficient            mode and can be used universally irrespective of the            data structure. With this mode, a password can be            specified to encrypt the FLAMFILE, see also parameters            <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>> and <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>> ** `aes` - `mode=aes` causes the input file to be compressed in the adc            mode with AES encryption. A *password must be specified* with            the `-password` parameter, see also parameters            <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>> and <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. ** `cx7` - transformable 7 bit compression. +            With `-mode=cx7`, the input file is compressed in the cx7 mode            and a character-coded FLAMFILE is created. However,            files should only be compressed in this mode if they do not            contain any non-printing characters. It is a slightly less            efficient mode, though on the other hand the FLAMFILE which            is created can be converted to other character sets, e.g.            from ASCII to EBCDIC, without losing information. ** `cx8` - 8 bit compression (CPU time optimised). +            With `-mode=cx8` the input file is compressed in the cx8 mode,            respectively, and a binary FLAMFILE is created. The purpose            of this mode is to ensure compatibility with previous versions. ** `vr8` - 8 bit compression (space optimised). +            With `-mode=vr8`, the input file is compressed in            vr8 mode, respectively, and a binary FLAMFILE is            created. The purpose of this mode is to ensure compatibility            with previous versions. ** `flamenc` - `mode=flamenc` causes the input file to be compressed in the                 adc mode with FLAM encryption (the  proprietary                 encryption method used with FLAM 3).                 A *password must be specified* with the `-password`                 parameter.                 See also parameters <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>> and                 <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. ** See also parameter <<CLEP.COMMAND.FLAM.NDC,NDC>>. * WINDOWS ** `adc` - 8 bit compression of highest efficiency. +            FLAM Version 3:  The input file is compressed            in ADC mode and a binary FLAMFILE is generated. ** `aes` - FLAM Version 4:  The input file is compressed            with the AES method. A password must be specified, see also               parameters <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>> and               <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. ** `cx7` - Transformable 7 bit compression. +            The input file is compressed in CX7 mode and a            character coded FLAMFILE is generated. However, in this mode            only those files should be compressed that solely contain            printable characters. This mode is a little less efficient,            but the generated. FLAMFILE can be converted to other            character codes without information loss, for example from            ASCII to EBCDIC using remote data transmission.e.g.            from ASCII to EBCDIC, without losing information. ** `cx8` - 8 bit compression (CPU time optimised). +            The input file is compressed in cx8 mode and a            binary FLAMFILE is generated. This mode is more efficient            and includes a stricter integrity check during decompression.            But the generated FLAMFILE cannot be transmitted via 7 bit            lines or via line sections where automatic code conversion            takes place. ** `vr8` - 8 bit compression (space optimised). +            The input file is compressed in vr8 mode and a            binary  FLAMFILE®  is generated. In contrast to CX8 and CX7            mode the VR8-compressed data is a continuous bit stream and            has no byte structure.this mode is to ensure compatibility            with previous versions. ** `ndc` - No data compression.  +            FLAM Version 3 compatible: The input file            is not compressed.  An ADC-compatible binary FLAMFILE® is            generated. This mode is used for the packaging and the            encryption of already compressed data. *Default* * z/OS ** ADC * UNIX ** none * WINDOWS ** none *Valid for* * compression * `CX7 - Compression encoding as printable characters` * `CX8 - Compression encoding as binary data` * `VR8 - Enhanced compression encoding as binary data` * `ADC - Advanced Data Compression` * `NDC - No data compression` * `AES - AES encryption` * `FLAMENC - FLAM encryption` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ndc_d101.html",
"NDC",
"[[CLEP.COMMAND.FLAM.NDC]] ==== NDC indexterm:[Parameter, NDC, FLAM.NDC] This parameter can be used in ADC mode to suppress compression (UNIX only). For z/OS and UNIX see parameter <<CLEP.COMMAND.FLAM.MODE,MODE>>. + For data that is known to compress badly, FLAM's performance can be improved by this parameter which suppresses compression. With modes aes and flamenc, only encryption is done while with mode adc this parameter causes FLAM to simply copy the data. With other modes, -ndc has no effect. FLAMFILEs  created  with  `-ndc` are always Secure FLAMFILEs and are logged as adc-compressed files at decompression. -ndc cannot be set as default. Syntax: * `-ndc` *Values:* * none *Default:* * `-ndc` cannot be set as default. *Valid for:* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-cryptomode_7710.html",
"CRYPTOMODE",
"[[CLEP.COMMAND.FLAM.CRYPTOMODE]] ==== CRYPTOMODE indexterm:[Parameter, CRYPTOMODE, FLAM.CRYPTOMODE] This parameter has the effect that the FLAMFILE is encrypted. This encryption method is activated by setting the parameters `CRYPTOMODE=AES` and `CRYPTOKEY=key` and is available with compression modes ADC or NDC. With `CRYPTOMODE=AES` the compression mode defaults to ADC rather than the mode specified in the default settings. For compression with `mode=adc` or `mode=ndc` the password specification is required. Without entering a `MODE` parameter, ADC is used. Syntax restrictions for FLAMv4 or older: * z/OS ** `CRYPTOMODE=AES/FLAM` ** `CRYPTOM=AES/FLAM` +    Password specification required,    see also  parameters <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>>    and <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. * UNIX ** See parameter <<CLEP.COMMAND.FLAM.MODE,MODE>> for `-mode=aes` or `flamenc` +    This parameter specifies the mode in which the original file is    compressed and encrypted. * WINDOWS ** `cryptmode=crypt option` +    Password specification required,    see also parameter <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>>    and <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. *Values* * z/OS ** `CRYPTOMODE=FLAM` +    Internal FLAM encryption ( FLAM Version 3 ). CRYPTOMODE=FLAM and MODE CX8 or VR8 are not supported. ** `CRYPTOMODE=AES` +    Advanced Encryption Standard ( FLAM Version 4 ) +    Note: AES with `MODE=ADC` was introduced in FLAM V4.0 and is not    compatible to older versions. AES and `MODE=CX8/VR8` is introduced    in this version and requires FLAM V4.7 as minimum.    FLAM and `MODE=CX8/VR8` is not supported. * WINDOWS ** `cryptmode=none` +    no encryption ** `cryptmode=flam` +    FLAM encryption (FLAM Version 3) ** `cryptmode=aes` +    encryption with AES (FLAM Version 4) *Default* * z/OS ** `FLAM` * WINDOWS ** none *Valid for* * compression * `OFF - Disable encryption` * `AES - AES encryption` * `FLAMENC - FLAM encryption` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-cryptokey_a38e.html",
"CRYPTOKEY",
"[[CLEP.COMMAND.FLAM.CRYPTOKEY]] ==== CRYPTOKEY indexterm:[Parameter, CRYPTOKEY, FLAM.CRYPTOKEY] Key to encrypt or decrypt a FLAMFILE. This parameter activates the crytographic method, entered with parameter CRYPTOMODE. The FLAMFILE is encrypted with AES in combination with `mode=adc` or `mode=ndc`. See also parameters <<CLEP.COMMAND.FLAM.MODE,MODE>>, <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>>, <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>, <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>, <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>> or <<CLEP.COMMAND.FLAM.PAASCII,PAEBCDIC>>. NOTE: Regardless of the encryption algorithm, a key should consist of at       least 6 - 8 characters and it should at least contain 1 character       from the following sets: * Lower case letters * Upper case letters * Numbers 0 - 9 * Punctuation characters Syntax restrictions for FLAMv4 or older: * z/OS ** `CRYPTOKEY=password` ** `CRYPTOK=password` * UNIX ** See parameter <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. * WINDOWS ** `cryptkey=password` +    Alternative specification: `cryptmode=aes password=password` +    See also parameters <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>> and    <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>. *Values* * z/OS ** 1 - 64 characters starting with A'...', C'...', X'...' or a string. +    Using A'...' all characters are translated to ASCII using the    internal translation table A/E (ch. A). * WINDOWS ** Regardless of the encryption algorithm a key should consist of at   least 6 - 8 characters and it should contain at least 1 character   from each of the following sets: *** Lower case letters *** Capital letters *** Numbers 0 - 9 *** Punctuation characters *Default* * No default value can be set for password. *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-password_e7c7.html",
"PASSWORD",
"[[CLEP.COMMAND.FLAM.PASSWORD]] ==== PASSWORD indexterm:[Parameter, PASSWORD, FLAM.PASSWORD] Password used for en-/decryption. During compression the FLAMFILE is encrypted with the specified password and can only be decompressed with the same password. FLAM uses the specified password during compression with mode ADC to encrypt the compressed data and during decompression to decrypt the encrypted compressed data. The passwords used at compression and decompression must be identical or else the decompression command is rejected with an appropriate error message. With modes other than adc, aes, or flamenc this parameter causes an error. When used with mode adc, the flamenc method is used for encryption. A password entered as a character string is equivalent to a hexadecimal sequence consisting of its character codes and vice versa. Note that a given character string entered on an ASCII system is not equivalent to the same string entered on a system using EBCDIC code. Therefore, for data exchange among systems with different character codes the hexadecimal format must be used if the codes of the password characters are not available on the keyboard. This parameter cannot be set by default. This parameter and `-kmexit` are mutually exclusive. See also parameters <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>> , <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY/cryptkey>>, <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>, <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>> or <<CLEP.COMMAND.FLAM.PAASCII,PAEBCDIC>>. NOTE: Regardless of the encryption algorithm, a key should consist of at least 6 - 8 characters and it should at least contain 1 character from the following sets: * Lower case letters * Upper case letters * Numbers 0 - 9 * Punctuation characters Syntax restrictions for FLAMv4 or older: * z/OS ** `PASSWORD=password` ** `PASSW=password` +    Password used for en-/decryption (same as CRYPTOK, see also parameter <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY>>). * UNIX ** `-password=password` * WINDOWS ** `password=password` *Values* * z/OS ** any input up to 64 characters (512 bit). *** Note: Please take care of the different code tables or           national character sets used on the different           platforms.           E.g. using the password C'FLAM ' both on Windows           systems (ASCII) and on MVS (EBCDIC) leads to a           password error. You have to pass X'464C414D20' (this           is 'FLAM' in ASCII) on MVS instead.           We recommend to use the hex input for a heterogeneous           environment. * UNIX ** The value for password can be entered in two formats: *** As a simple character string: In this format, the password is entered     immediately following the equal sign as a string of up to 64     characters. Valid characters are all capital and small Latin letters,     decimal digits, the minus sign (-) and underscore (_). Using any     other characters may yield unpredictable results. Note that     passwords are case sensitive. +     Example: `-password=Alligator` *** As a sequence of hexadecimal digits: In this format the password may     consist of an even number of up to 128 hexadecimal digits (0-9, a-f,     A-F). In this context small and capital letters are interchangeable.     The sequence is enclosed in single quotes (\\') and preceded by the     letter 'X'. Any such combination is permitted. +     Example: `-password=X\\'416c6c696761746f72\\'` * WINDOWS ** String with a length of 1 to 64 characters. *** Note: On the command line not all characters are allowed, e.g. commas           and subsequent blanks. If required a hex-encoded password can           be entered with paxword, see also parameter <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>. *Default* * No default value can be set for password. *Valid for:* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-paascii_5c98.html",
"PAASCII",
"[[CLEP.COMMAND.FLAM.PAASCII]] ==== PAASCII indexterm:[Parameter, PAASCII, FLAM.PAASCII] Password in ASCII (used in WINDOWS only). Is equal to parameter password. See also  parameters <<CLEP.COMMAND.FLAM.MODE,MODE>>, <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>>, <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>, <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>> or <<CLEP.COMMAND.FLAM.PAEBCDIC,PAEBCDIC>>. NOTE: Regardless of the encryption algorithm, a key should consist of at least 6 - 8 characters and it should at least contain 1 character from the following sets: * Lower case letters * Upper case letters * Numbers 0 - 9 * Punctuation characters Syntax restrictions for FLAMv4 or older: * `paascii=password` * `paa=password` *Values* * String with a length of 1 to 64 characters.   The password is converted to ASCII before it is used. *Default* * No default value can be set for PASSWORD. *Valid for:* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-paebcdic_25c9.html",
"PAEBCDIC",
"[[CLEP.COMMAND.FLAM.PAEBCDIC]] ==== PAEBCDIC indexterm:[Parameter, PAEBCDIC, FLAM.PAEBCDIC] Password in EBCDIC used with `mode=adc`, `aes` or `ndc` (in WINDOWS only). During compression the FLAMFILE is encrypted with the specified password and can only be decompressed with the same password. Before usage the password is converted to EBCDIC. This is helpful when communicating with a main frame. Only those characters that can be clearly classified as either ASCII or EBCDIC should be used. This applies to all letters and numbers plus many punctuation marks (usually  !'#$%&*+,./:;=?@  ). German umlauts must be avoided. In critical cases hex input with parameter <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>) is helpful. See also parameters <<CLEP.COMMAND.FLAM.MODE,MODE>>, <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>>, <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>, <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>> or <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>>. NOTE: Regardless of the encryption algorithm, a key should consist of at       least 6 - 8 characters and it should at least contain one character       from the following sets: * Lower case letters * Upper case letters * Numbers 0 - 9 * Punctuation characters Syntax restrictions for FLAMv4 or older: * `paebcdic=password` * `pae=password` *Values* * String with a length of 1 to 64 characters.   Before usage the password is converted to EBCDIC. *Default* * No default value can be set for PASSWORD. *Valid for:* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-paxword_ce13.html",
"PAXWORD",
"[[CLEP.COMMAND.FLAM.PAXWORD]] ==== PAXWORD indexterm:[Parameter, PAXWORD, FLAM.PAXWORD] Password as hexadecimal character string used for en-/decryption (in WINDOWS only). During compression the FLAMFILE is encrypted with the specified password and can only be decompressed with the same password. FLAM uses the specified password during compression with mode adc to encrypt the compressed data and during decompression to decrypt the encrypted compressed data. The passwords used at compression and decompression must be identical or else the decompression command is rejected with an appropriate error message. With modes other than adc or aes this parameter causes an error. A password entered as a character string is equivalent to a hexadecimal sequence consisting of its character codes and vice versa. Note that a given character string entered on an ASCII system is not equivalent to the same string entered on a system using EBCDIC code. Therefore, for data exchange among systems with different character codes the hexadecimal format must be used if the codes of the password characters are not available on the keyboard. E.g. the word SECRET is encoded in ASCII as 534543524554 and in EBCDIC as E2C5C3E1C5E3. For EBCDIC the entry for SECRET as password is as follows: pax= E2C5C3E1C5E3 or pae= SECRET. This parameter cannot be set by default. See also parameters <<CLEP.COMMAND.FLAM.MODE,MODE>>, <<CLEP.COMMAND.FLAM.CRYPTOMODE,CRYPTOMODE>>, <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>, <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>> or <<CLEP.COMMAND.FLAM.PAEBCDIC,PAEBCDIC>>. NOTE: Regardless of the encryption algorithm, a key should consist of at least 6 - 8 characters and it should at least contain 1 character from the following set: * Lower case letters * Upper case letters * Numbers 0 - 9 * Punctuation characters Syntax restrictions for FLAMv4 or older: * `paxword=password` * `pax=password` *Values* * Hexadecimal character string with a length of 2 to 128 characters *Default* * No default value can be set for `PAXWORD`. `Valid for:` * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-parfile_239b.html",
"PARFILE",
"[[CLEP.COMMAND.FLAM.PARFILE]] ==== PARFILE indexterm:[Parameter, PARFILE, FLAM.PARFILE] This parameter specifies a file name containing FLAM parameters. Specifying a parameter file permits default values to be overridden without the need for complex inputs in the command line. This specified file can be created interactively using a text editor. Syntax restrictions for FLAMv4 or older: * z/OS ** `PARFILE=parameter filename` ** `PARF=parameter filename` *** Note: Specifying the file name is an alternative to           assigning the file by means of a DD statement. This file           is needed only if additional parameters are to be read           from a catalogued file. * UNIX ** `-parfile=parameter filename` * WINDOWS ** `parfile=parameter filename` *Values* * z/OS ** Filename with max. 54 characters. * UNIX ** Path to a file containing FLAM parameters. Specifying a parameter file    permits default values to be overridden without the need for complex    inputs in the command line.    One parameter file cannot refer to another, i.e. it may not contain a    `parfile` specification. Furthermore, it may not change the `-show`    parameter whose setting is determined when the command line is    analyzed. * WINDOWS ** Path to a file that contains FLAM parameters. *** Note: One parameter per line.           The entries on the command line have a higher priority.           At the end of line comments may be attached with '!'. Lines           that begin with ; or ! are ignored. *Default* * no name *Valid for* * compression * decompression Settings such as the type of operation (compress or decompress), the input/output files, etc., can be entered either directly in the flam command or explicitly in a parameter file. Implicit settings are also possible simply by omitting certain information, for example the compression mode for the compression procedure. The settings which apply automatically if any specifications are missing or redundant are determined by evaluating certain information in a fixed sequence; this results in an order of priorities, which is based both on the category and on the origin of the information. Since parameter files may refer to other parameter files, it is possible for several such files, possibly containing contradictory information, to be concatenated. The first of these parameter files has priority over all the others. If the same parameter is specified more than once within a parameter file, however, only the final specification is valid. The information which is used to determine the FLAM settings is evaluated in the following order: * The command itself * The parameter files * The installed default values If the command itself contains any contradictory or incompatible information, it is rejected and an error message is output. The following priority rules apply in all other situations: * If a FLAM operation is specified in the command (compress/decompress),   it has priority over all the other specifications. If the command does   not contain such a specification, a search is made for it in the   parameter file if one is named by `-parfile=...` or by default.   If the operation is not specified as a FLAM parameter either, the   installed default value, i.e. the default operation, is taken instead. * Any specifications which are incompatible with the FLAM operation are   rejected. * All specifications missing in the command are set according to the   parameter file, if one is specified either in the command itself or   as an installation-specific default value. * All settings which cannot be established either at all or in part   after rules 1 to 3 have been applied are determined on the basis of   the installation-specific default values. * If the input or output specification is missing, the special `stdin`   and `stdout` files are used. In the case of FLAM parameters,   specifications with a lower priority are always completely overridden   by the higher priority, i.e. it is not possible to define a list of   input specifications partly in the command itself and partly in the   parameter file or in the form of default values. The list in the   command cancels out the list at the lower specification level. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-parddn_a6d9.html",
"PARDDN",
"[[CLEP.COMMAND.FLAM.PARDDN]] ==== PARDDN indexterm:[Parameter, PARDDN, FLAM.PARDDN] Symbolic Job Control file name for parameter file (z/OS only). This parameter allows to change standard DD-NAME FLAMPAR to another one. If no symbolic file name is specified for the parameter file (`PARDDN=(NONE)`), FLAM will not try to read from the parameter file. If the parameter file is not existent or empty, no error is recorded. Syntax restrictions for FLAMv4 or older: * z/OS ** `PARDDN=DD-NAME` *Values* * z/OS ** DD-NAME with max. 8 characters. *Default* * z/OS ** `PARDDN=FLAMPAR` +     result: `FLAMPAR DD=DSN=......` *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-recdelim_1f2f.html",
"RECDELIM",
"[[CLEP.COMMAND.FLAM.RECDELIM]] ==== RECDELIM indexterm:[Parameter, RECDELIM, FLAM.RECDELIM] Record delimiter for FLAMFILE. See also parameters <<CLEP.COMMAND.FLAM.INRECDELIM,INRECDELIM>> and <<CLEP.COMMAND.FLAM.OUTRECDELIM,OUTRECDELIM>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `RECDEL=String` ** `RECD=String` *** Note: Not evaluated by FLAM under z/OS * UNIX ** `-recdelim=record delimiter` * WINDOWS ** `recdelim=record delimiter` *Values* * z/OS ** String with max. 4 characters. * UNIX ** Hexadecimal characters between 01 and ff, with a length of either 1 or 2 bytes. *** Note: This parameter permits a record delimiter to be specified           for the stream record format.           If a record delimiter is not specified for the stream record           format, 0x0a is used as a default delimiter.           If `-recdelim=0D0A` is specified, for example, the data can           be used for MS-DOS format.           This parameter can only be specified for the compression           procedure. * WINDOWS ** Hexadecimal characters between 01 and FF. Length: 1 or 2 bytes (2 or 4 hex characters) *** Note: Regarding Record format text: With this parameter the record delimiter           of the FLAMFILE can be specified in connection with `recform=text` in `mode=cx7`.           If no record delimiter is specified for record format text, 0D0A (CRLF) is used.           For example, with `recdelim=0a` the output of data is possible in UNIX format.           This parameter can only be specified for the compression procedure. *Default* * no record delimiter *Valid for* * z/OS ** compression, decompression * UNIX ** compression * WINDOWS ** compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-recformat_964f.html",
"RECFORMAT",
"[[CLEP.COMMAND.FLAM.RECFORMAT]] ==== RECFORMAT indexterm:[Parameter, RECFORMAT, FLAM.RECFORMAT] Record format for FLAMFILE (compressed file). Syntax restrictions for FLAMv4 or older: * z/OS ** `RECFM=F/V/U/FB/VB/VBS/FBS` ** `RECFORM=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` ** `RECF=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` *** Note: Not evaluated by FLAM under z/OS * UNIX ** `-recformat=fix/var/stream` *** Note: The FLAMFILE always contains records of identical size.           In the cx8 and vr8 modes, the records can be written either           with (variable) or without (fixed) a record size field. +           The stream record format is used in the cx7 mode. If           `recdelim` is not specified, 0x0a is used as the default           record delimiter. +           `-recformat` needs only to be specified for the compression           procedure. * WINDOWS ** `recformat=**f**ix / **v**ar / **t**ext` *Values* * z/OS ** `F/FIX` - Fixed record length ** `V/VAR` - Variable record length ** `U/UNDEF` - Undefined record length ** `FB/FIXBLK` - Fix blocked ** `VB/VARBLK` - Variable blocked ** `VBS/VARSPAN` - Variable spanned ** `FBS/FIXS` - Fix standard * UNIX ** `fix` - Fixed-size records, size as set by the -recsize parameter. ** `var` - Variable-size records; the record size field is 2 bytes long. ** `stream` - Variable-size records with a record delimiter. * WINDOWS ** `**f**ix` - records with a fixed record length (default for all FLAMFILES). ** `**v**ar` - Variable-size records; the record size field is 2 bytes long. ** `**t**ext` - Variable-size records with a record delimiter. *Default* * z/OS ** FB/FIXBLK * UNIX ** none * WINDOWS ** f/fix *Valid for* * z/OS ** compression, decompression * UNIX ** compression * WINDOWS ** compression * `FIX - Records with a fixed record length (default for all FLAMFILES)` * `F - Records with a fixed record length (default for all FLAMFILES)` * `VAR - Records with a variable record length. The additional (!) record length field is 2 bytes long` * `V - Records with a variable record length. The additional (!) record length field is 2 bytes long` * `TEXT - Records with a variable record length and end-of-record characters (CX7 only)` * `STREAM - Variable-size records with a record delimiter` * `UNDEFINED - Records with undefined record length (Host only)` * `UNDEF - Records with undefined record length (Host only)` * `U - Records with undefined record length (Host only)` * `FIXBLK - Fix blocked (Host only)` * `FB - Fix blocked (Host only)` * `FIXS - Fix standard (Host only)` * `FBS - Fix standard (Host only)` * `VARBLK - Variable blocked (Host only)` * `VB - Variable blocked (Host only)` * `VARSPAN - Variable spanned (Host only)` * `VBS - Variable spanned (Host only)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-recsize_4235.html",
"RECSIZE",
"[[CLEP.COMMAND.FLAM.RECSIZE]] ==== RECSIZE indexterm:[Parameter, RECSIZE, FLAM.RECSIZE] This parameter specifies the maximum record length of the FLAMFILE (without record length fields). See also parameters <<CLEP.COMMAND.FLAM.RECFORMAT,RECFORMAT>>, <<CLEP.COMMAND.FLAM.INRECSIZE,INRECSIZE>> and <<CLEP.COMMAND.FLAM.OUTRECSIZE,OUTRECSIZE>>. The compressed data are written as records of the same length regardless of the record format. There is no relation between compressed data blocks and the records in the compressed file (FLAMFILE). A record can contain data from one or more compressed data blocks. A compressed data block can be included in one or more records. The record length of the compressed file is independent from the record length of the original file. This parameter should be chosen according only to the aspect of efficiency and functionality. To avoid padding in blocks, for fixed record length the block length should be a multiple of the record length. File transfer may require other record length (e.g.: 80 bytes fix for RJE (IBM) or 2036 bytes fix for transfer between SINIX and BS2000 with FT-BS2000). This parameter is used for compression only. Syntax restrictions for FLAMv4 or older: * ZOS ** `MAXSIZE=n` ** `MAXS=n` * UNIX ** `-recsize=n` * WINDOWS ** `recsize=nnn` ** `recs=nnn` *Values* * ZOS ** 80 - 32760 * UNIX ** Integer number between 80 and 32760 for all modes except cx7. ** Integer number between 80 and 4095 for the cx7 mode. *** Note: The compressed data is always written in records of the same           size, irrespective of the record format. There is no           relationship between the compressed blocks and the records in           the compressed file. A record may contain data pertaining to           one or more compressed blocks. A compressed block may be           contained in one or more records.           There is no relationship between the records in the compressed           and non-compressed files. This parameter need only be           specified for the compression procedure. * WINDOWS ** Integer decimal number between 80 and 32760 for modes CX8, VR8, ADC, NDC, AES ** Integer number between 80 and 4095 in CX7 mode. *Default* * 512 Bytes *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-inrecdelim_3aa8.html",
"INRECDELIM",
"[[CLEP.COMMAND.FLAM.INRECDELIM]] ==== INRECDELIM indexterm:[Parameter, INRECDELIM, FLAM.INRECDELIM] Record delimiter for original input file. See also parameters <<CLEP.COMMAND.FLAM.RECDELIM,RECDELIM>> and <<CLEP.COMMAND.FLAM.OUTRECDELIM,OUTRECDELIM>>. Syntax restrictions for FLAMv4 or older: * Z/OS ** `IRECDEL=String` ** `IRECD=String` *** Note: Not evaluated by FLAM under z/OS. * UNIX ** `-inrecdelim=record delimiter` * WINDOWS ** `inrecdelim=record delimiter` ** `inrecd=record delimiter` *Values* * Z/OS ** String of up to 4 characters * UNIX ** Hexadecimal characters between 01 and ff, with a length of either 1 or 2 bytes. *** Note: This parameter specifies the record delimiter for an           original file with a stream record format. If a stream record           format is specified without a record delimiter, 0x0a and           0x0d0a are interpreted as the end of a record. +           If only 0x0a should be interpreted as the end of a record,           `inrecdelim=0a` must be specified, in order to ensure that           occurrences of 0x0d which precede 0x0a are interpreted           as part of the data and not as part of a record delimiter. If           only 0x0d0a should be interpreted as a record delimiter in           a particular file, `inrecdelim=0d0a` must be specified, to           ensure that any 0x0a strings which occur alone are           identified as belonging to the data. +           Any other character combinations can be used as record           delimiters, in addition to 0x0a and 0x0d0a. * WINDOWS ** Hexadecimal characters between 01 and FF, length: 1 or 2 bytes (2 or 4 hex characters). *** NOTE: With this parameter the input record delimiter of an original file is           specified with <<CLEP.COMMAND.FLAM.RECFORMAT,record format>> text.           When using record format text without specification of input record delimiter,           0d0a (CRLF) is interpreted as the end of record.           If only '0a' is intended as the end of record, then `inrecdelim=0a`           has to be specified in order to interpret a '0d' before a '0a' not as           part of the input record delimiters but as part of the data. If a file           is meant to contain the input record delimiter characters 0d0a only,           `inrecdelim=0d0a` has to be specified in order to recognize isolated           characters '0a' as part of the data.           Not only 0a and 0d0a are allowed as input record delimiters, but           also any other character combinations. *Default* * no input record delimiter *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-inrecformat_94d6.html",
"INRECFORMAT",
"[[CLEP.COMMAND.FLAM.INRECFORMAT]] ==== INRECFORMAT indexterm:[Parameter, INRECFORMAT, FLAM.INRECFORMAT] This parameter specifies the record format of the original input file. The data is read from the input file in the form of logical records with the specified format in order to save them compressed or uncompressed in the FLAMFILE. Syntax: * z/OS ** `IRECFM=F/V/U/FB/VB/VBS/FBS` ** `IRECFORM=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` ** `IRECF=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` *** Note: This parameter is not necessary for catalogued files in z/OS. * UNIX ** `-inrecformat=eaf/fix/stream/undefined/variable/var_2B/var2b_data/var_4b/var_ascii/var_ebcdic` * WINDOWS ** inrecformat=**f**ix / **dtext** / **t**ext / **v**ariable / **var_2**b / **var_4**b / **var_a**scii / **var_e**bcdic / **u**ndefined ** inrecf=**f**ix / **dtext** / **t**ext / **v**ariable / **var_2**b / **var_4**b / **var_a**scii / **var_e**bcdic / **u**ndefined *Values* * z/OS ** `F/FIX` - Fixed record length ** `V/VAR` - Variable record length ** `U/UNDEF` - Undefined record length ** `FB/FIXBLK` - Fix blocked ** `VB/VARBLK` - Variable blocked ** `VBS/VARSPAN` - Variable spanned ** `FBS/FIXS` - Fix standard * UNIX ** `*eaf*` - EAF data, variable record size with a 4-byte size field in              ASCII or EBCDIC code. The record size only specifies the              length of the data excluding the size field. The size field              is part of the data. ** `*fix*` - Fixed record size as set by -inrecsize. ** `*stream*` - Variable record size (max. 2048 characters) with record                 delimiter. Typically text data. ** `undefined` - Records with no defined structure; records of an identical                  size are read (with the possible exception of the last one). ** `*variable*` - Variable record size with 2-byte binary record size                   (including length field). ** `*var_2b*` - Variable record size with 2-byte binary record size                 (including length field). ** `*var2b_data*` - Variable record size with 2-byte binary record size                     (not including length field). ** `*var_4b*` - Variable record size with 4-byte binary record size                 (including length field) (host). ** `*var_ascii*` - Variable record size with 4-byte size field in ASCII                    code (including length field). ** `*var_ebcdic*` - Variable record size with 4-byte size field in EBCDIC                     code (including length field). * WINDOWS ** `**f**ix` - fixed record length  *inrecsize* ** `**dtext**` - variable record length with input record delimiter,                  last record without delimiter. ** `**t**ext` - variable record length with input record delimiter ** `**v**ariable` - variable record length with a binary record length of 2 bytes. ** `**var_2**b` - variable record length with a binary record length of 2 bytes. ** `**var_4**b` - variable record length with a binary record length of 4 bytes                   (host: length of 2 bytes, padding is ignored). ** `**var_a**scii` - variable record length with a length field of 4 bytes in ASCII code. ** `**var_e**bcdic` - variable record length with a length field of 4 bytes in EBCDIC code. ** `**u**ndefined` - records without structure; records with the length  inrecsize are                      read, last record may be shorter. *Default* * z/OS ** `FB/FIXBLK` * UNIX ** none * WINDOWS ** none *Valid for* * compression * `EAF - EAF data, variable record size with a 4-byte size field in ASCII or EBCDIC code. The record size only specifies the length of the data excluding the size field. The size field is part of the data` * `FIX - Fixed record length (in/out)recsize` * `DTEXT - Variable record length with end-of-record characters,  last record without delimiter` * `TEXT - Variable record length with end-of-record characters` * `STREAM - Variable record size (max. 2048 characters) with record delimiter. Typically text data` * `VARIABLE - Variable record size with 2-byte binary record size (including length field)` * `UNDEFINED - Records without structure; records with the length  inrecsize are read, last record may be shorter` * `U - Undefined (Host only)` * `F - Fix (Host only)` * `FIXBLK - Fix blocked (Host only)` * `FB - Fix blocked (Host only)` * `V - Variable (Host only)` * `VARBLK - Variable blocked (Host only)` * `VB - Variable blocked (Host only)` * `FIXS - Fix standard (Host only)` * `FBS - Fix standard (Host only)` * `VARSPAN - Variable spanned (Host only)` * `VBS - Variable spanned (Host only)` * `VAR_2B - Variable record size with 2-byte binary record size (including length field)` * `VAR2B_DATA - Variable record size with 2-byte binary record size (not including length field)` * `VAR_4B - Variable record size with 4-byte binary record size (including length field) (host)` * `VAR_ASCII - Variable record size with 4-byte size field in ASCII code (including length field)` * `VAR_EBCDIC - Variable record size with 4-byte size field in EBCDIC code (including length field)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-inrecsize_80a8.html",
"INRECSIZE",
"[[CLEP.COMMAND.FLAM.INRECSIZE]] ==== INRECSIZE indexterm:[Parameter, INRECSIZE, FLAM.INRECSIZE] This parameter specifies the record size of the original input file. See also parameter <<CLEP.COMMAND.FLAM.INRECFORMAT,INRECFORMAT>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `IRECSIZE=n` ** `IRECS=n` *** Note: Record length of input file (true length, without record length field.)           This parameter is not necessary for catalogued files in z/OS. * UNIX ** `-inrecsize=n` *** Note: This parameter specifies the record size of original input files           with a fixed or undefined record format. * WINDOWS ** `inrecsize=nnn` ** `inrecs=nnn` *** Note: This parameter specifies the record length of original input     files with record format `fix` or `undefined` resp. the maximum     record length. *Values* * z/OS ** 0-32760 * UNIX ** 1-32760 * WINDOWS ** 1-32760 *Default* * z/OS ** 32752 * UNIX ** none * WINDOWS ** 512 *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-outrecdelim_789b.html",
"OUTRECDELIM",
"[[CLEP.COMMAND.FLAM.OUTRECDELIM]] ==== OUTRECDELIM indexterm:[Parameter, OUTRECDELIM, FLAM.OUTRECDELIM] Record delimiter for original output file. See also parameters <<CLEP.COMMAND.FLAM.RECDELIM,RECDELIM>> and <<CLEP.COMMAND.FLAM.OUTRECDELIM,OUTRECDELIM>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `ORECDEL=String` ** `ORECD=String` *** Note: Not evaluated by FLAM under z/OS. * UNIX ** `-outrecdelim=record delimiter` * WINDOWS ** `outrecdelim=record delimiter` ** `outrecd=record delimiter` *Values* * z/OS ** String of up to 4 characters. * UNIX ** Hexadecimal characters between 01 and FF, with a length of either 1 or 2 bytes. *** Note: This parameter specifies the record delimiter for a           decompressed file with the stream record format.           If a record delimiter is not specified for the stream record format, 0x0A is used as a           default delimiter. If outrecdelim=0D0A is specified, the decompressed file can be           generated in MSDOS format. Any other character combinations are also allowed as           record delimiters. * WINDOWS ** Hexadecimal characters between 01 and FF, length: 1 or 2 bytes (2 or 4 hex characters). *** NOTE: With this parameter the end-of-record character of the decompressed file is           specified with record format text (see also parameter <<CLEP.COMMAND.FLAM.RECFORMAT,RECFORMAT>>).           When using record format text without specifying the end-of-record character,           0D0A (CRLF) is written as the end-of-record character. With the specification           `outrecdelim=0A` it is possible to generate the decompressed file in UNIX format.           Beyond that every other combination of characters is allowed as           end-of-record characters. *Default* * no input record delimiter *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-outrecformat_5cf3.html",
"OUTRECFORMAT",
"[[CLEP.COMMAND.FLAM.OUTRECFORMAT]] ==== OUTRECFORMAT indexterm:[Parameter, OUTRECFORMAT, FLAM.OUTRECFORMAT] This parameter specifies the record format of original output files (decompressed files). The data are read from the FLAMFILE and are written in form of logical records with the specified format in order to save them uncompressed. Syntax restrictions for FLAMv4 or older: * z/OS ** `ORECFM=F/V/U/FB/VB/VBS/FBS` ** `ORECFORM=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` ** `ORECF=FIX/VAR/UNDEF/FIXBLK/VARBLK/VARSPAN/FIXS` *** Note: This value must only be specified if the record format           differs from the original file. * UNIX ** `-outrecformat=eaf/fix/stream/undefined/variable/var_2B/var2b_data/var_4b/var_ascii/var_ebcdic` * WINDOWS ** `outrecformat=**f**ix / **dtext** / **t**ext / **v**ariable / **var_2**b / **var_4**b / **var_a**scii / **var_e**bcdic / **u**ndefined` ** `outrecf=**f**ix / **dtext** / **t**ext / **v**ariable / **var_2**b / **var_4**b / **var_a**scii / **var_e**bcdic / **u**ndefined` *Values* * z/OS ** `F/FIX` - Fixed record length ** `V/VAR` - Variable record length ** `U/UNDEF` - Undefined record length ** `FB/FIXBLK` - Fix blocked ** `VB/VARBLK` - Variable blocked ** `VBS/VARSPAN` - Variable spanned ** `FBS/FIXS` - Fix standard * UNIX ** `*eaf*` - EAF data, variable record size with a 4-byte size field in              ASCII or EBCDIC code. The record size only specifies the              length of the data excluding the size field. The size field              is part of the data. ** `*fix*` - Fixed record size as set by `-inrecsize`. ** `*stream*` - Variable record size (max. 2048 characters) with record                 delimiter. Typically text data. ** `*undefined*` - Records with no defined structure; records of an identical                    size are read (with the possible exception of the last one). ** `*variable*` - Variable record size with 2-byte binary record size (including length field). ** `*var_2b*` - Variable record size with 2-byte binary record size (including length field). ** `*var2b_data*` - Variable record size with 2-byte binary record size (not including length field). ** `*var_4b*` - Variable record size with 4-byte binary record size (including length field) (host). ** `*var_ascii*` - Variable record size with 4-byte size field in ASCII code (including length field). ** `*var_ebcdic*` - Variable record size with 4-byte size field in EBCDIC code (including length field). * WINDOWS ** `**f**ix` - fixed record length ** `**dtext**` - variable record length with output record delimiter, last record                  without delimiter ** `**t**ext` - variable record length with output record delimiter ** `**v**ariable` - variable record length with a binary record length of 2 bytes ** `**var_2**b` - variable record length with a binary record length of 2 bytes ** `**var_4**b` - variable record length with a binary record length of 4 bytes (host:                   length of 2 bytes, padding is ignored) ** `**var_a**scii` - variable record length with a length field of 4 bytes in ASCII code ** `**var_e**bcdic` - variable record length with a length field of 4 bytes in EBCDIC code ** `**u**ndefined` - Records without structure. The records are written with length outrecsize *Default* * z/OS ** `VARBLK` or value from the file header. * UNIX ** none * WINDOWS ** none *Valid for* * decompression * `EAF - EAF data, variable record size with a 4-byte size field in ASCII or EBCDIC code. The record size only specifies the length of the data excluding the size field. The size field is part of the data` * `FIX - Fixed record length (in/out)recsize` * `DTEXT - Variable record length with end-of-record characters,  last record without delimiter` * `TEXT - Variable record length with end-of-record characters` * `STREAM - Variable record size (max. 2048 characters) with record delimiter. Typically text data` * `VARIABLE - Variable record size with 2-byte binary record size (including length field)` * `UNDEFINED - Records without structure; records with the length  inrecsize are read, last record may be shorter` * `U - Undefined (Host only)` * `F - Fix (Host only)` * `FIXBLK - Fix blocked (Host only)` * `FB - Fix blocked (Host only)` * `V - Variable (Host only)` * `VARBLK - Variable blocked (Host only)` * `VB - Variable blocked (Host only)` * `FIXS - Fix standard (Host only)` * `FBS - Fix standard (Host only)` * `VARSPAN - Variable spanned (Host only)` * `VBS - Variable spanned (Host only)` * `VAR_2B - Variable record size with 2-byte binary record size (including length field)` * `VAR2B_DATA - Variable record size with 2-byte binary record size (not including length field)` * `VAR_4B - Variable record size with 4-byte binary record size (including length field) (host)` * `VAR_ASCII - Variable record size with 4-byte size field in ASCII code (including length field)` * `VAR_EBCDIC - Variable record size with 4-byte size field in EBCDIC code (including length field)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-outrecsize_03a1.html",
"OUTRECSIZE",
"[[CLEP.COMMAND.FLAM.OUTRECSIZE]] ==== OUTRECSIZE indexterm:[Parameter, OUTRECSIZE, FLAM.OUTRECSIZE] This parameter specifies the record size of the decompressed file. See also parameter <<CLEP.COMMAND.FLAM.OUTRECFORMAT,OUTRECFORMAT>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `ORECSIZE=n` ** `ORECS=n` *** Note: True length without record length field. This value must only     be specified if the record length differs from the original file. * UNIX ** `-outrecsize=n` *** Note: This parameter specifies the record size of the decompressed           files with a fixed or undefined record format. For other           record formats, this indicates the buffer size. * WINDOWS ** `outrecsize=nnn` ** *outrecs=nnn` *** Note: This parameter specifies the record length of the decompressed           files with record format 'fix' or 'undefined' resp. the maximum           record length. *Values* * z/OS ** 0-32760 * UNIX ** 1-32760 * WINDOWS ** 1-32760 *Default* * z/OS ** 32752 bytes or value from the file header * UNIX ** none * WINDOWS ** 512 *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-blksize_fe6c.html",
"BLKSIZE",
"[[CLEP.COMMAND.FLAM.BLKSIZE]] ==== BLKSIZE indexterm:[Parameter, BLKSIZE, FLAM.BLKSIZE] Logical block length for compressed file/FLAMFILE (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `BLKSIZE=n` ** `BLKS=n` *** Note: This parameter is not necessary for catalogued files in z/OS.           A value of zero leads to a system determined blocksize. *Values* * z/OS ** 0-32760 *Default* * z/OS ** 0 bytes (leads to a system determined blocksize) *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-iblksize_df8d.html",
"IBLKSIZE",
"[[CLEP.COMMAND.FLAM.IBLKSIZE]] ==== IBLKSIZE indexterm:[Parameter, IBLKSIZE, FLAM.IBLKSIZE] Logical block length for input files (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `IBLKSIZE=n` ** `IBLK=n` *** Note: This parameter is not necessary for catalogued files in z/OS. *Values* * z/OS ** 0-32760 *Default* * z/OS ** 32760 bytes *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-oblksize_3dcf.html",
"OBLKSIZE",
"[[CLEP.COMMAND.FLAM.OBLKSIZE]] ==== OBLKSIZE indexterm:[Parameter, OBLKSIZE, FLAM.OBLKSIZE] Block length of the output file (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `OBLKSIZE=n` ** `OBLK=n` *** Note: A value of zero leads to a system determined blocksize for           the output data set. *Values* * z/OS ** 0-32760 *Default* * z/OS ** 0 +    A value of zero leads to a system determined blocksize for the output data set. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-attributes_cbdf.html",
"ATTRIBUTES",
"[[CLEP.COMMAND.FLAM.ATTRIBUTES]] ==== ATTRIBUTES indexterm:[Parameter, ATTRIBUTES, FLAM.ATTRIBUTES] This parameter has the effect that compression information are written into the FLAMFILE (UNIX and WINDOWS only). See also parameter <<CLEP.COMMAND.FLAM.HEADER,HEADER>> for z/OS. The insertion of compression information into the FLAMFILE allows a subsequent extraction of this information, without the necessity to totally decompress the FLAMFILE. In doing so, the file organization, the record format and the record length can be logged during compression. This is also true for the attribute under which operating system the compression has taken place (attributes=common). As result the decompressed file can be generated with the same characteristics during decompression, if necessary. The file specification of the original file may optionally be entered in addition (attributes=all). This option makes it possible to specify the output specification [ ] or [*] for decompression, with the result that FLAM will use the entered file specification and the related characteristics automatically. With attributes=none no information about the original file is written into the FLAMFILE at all. Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.HEADER,HEADER>> for z/OS. * UNIX ** `-attributes=attribute option` * WINDOWS ** `-attributes=attribute option` *Values* * UNIX / WINDOWS ** `none` - No file information. Corresponds z/OS: FILEINFO=NO and HEADER=NO. ** `common` -  Common file information. Corresponds z/OS: FILEINFO=NO and HEADER=YES. ** `all` - Common file information and system specific information            about the original file. Corresponds to z/OS: FILEINFO=YES and HEADER=YES. *Default* * none *Valid for* * compression * `NONE - No compression information` * `COMMON - Common compression information` * `ALL - General compression information and system specific information about the original file` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-option_93ff.html",
"OPTION",
"[[CLEP.COMMAND.FLAM.OPTION]] ==== OPTION indexterm:[Parameter, OPTION, FLAM.OPTION] This parameter controls FLAM's behaviour when decompressed records are output (UNIX only). See also similar parameters for z/OS and WINDOWS: * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS and Windows * <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>> for notruncate in z/OS and Windows * <<CLEP.COMMAND.FLAM.SUPPRESS,SUPPRESS>> for suppress and trimchar in WINDOWS * <<CLEP.COMMAND.FLAM.NOSUPPRESS,NOSUPPRESS>> in WINDOWS * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for padchar in z/OS During the decompression, the record format and size of the decompressed file can either be specified explicitly or adopted from predecessor versions, so that the maximum record size is less than in the original file. If CUT option is specified, the decompression continues and any records which is too long is truncated to the maximum size. If `NOCUT` is specified, decompression is aborted and an error message is put out. If the decompressed file is written with the stream record format during the decompression procedure, whitespace at the end of a record can be suppressed by specifying suppress. Nosuppress causes the whitespace to be written. Syntax restrictions for FLAMv4 or older: * UNIX ** `-option=FLAM option` *Values* * UNIX ** `cut` - Records with a length greater than the maximum record size            are truncated. ** `nocut` - Records with a length greater than the maximum record size              are not truncated. ** `suppess` -  Blank space at the end of a record is suppressed. ** `nosuppess` -  Blank space at the end of a record is not suppressed. *Default* * none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-option-cut_2cd4.html",
"CUT",
"[[CLEP.COMMAND.FLAM.OPTION.CUT]] ===== CUT indexterm:[Constant, CUT, FLAM.OPTION.CUT] Truncate output record (z/OS and WINDOWS only). Records with a record length longer than the maximum record length may be shortened. Syntax restrictions for FLAMv4 or older: * z/OS ** `TRUNCATE=NO/YES` ** `TRU=NO/YES` * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> * WINDOWS ** `cut` ** `truncate` (synonym for cut) ** `tru` +    Records with a record length longer than the maximum record    length may be shortened. +    See also parameter <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>>. *Values* * z/OS ** `NO` - No truncation. If records longer than specified occur,    decompression is aborted. ** `YES` - If a decompressed record is longer than specified for the    output file, the record is truncated. * WINDOWS ** none/no values *Default* * z/OS ** `TRUNCATE=NO` * WINDOWS ** none/no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-option-nocut_04c9.html",
"NOCUT",
"[[CLEP.COMMAND.FLAM.OPTION.NOCUT]] ===== NOCUT indexterm:[Constant, NOCUT, FLAM.OPTION.NOCUT] Records with a record length larger than the maximum record length are not cut/truncated (Windows only). Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for `TRUNCATE=NO` * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION, OPTION>> for `Option=nocut` * WINDOWS ** `nocut` ** `notruncate` (synonym for cut) ** `notr` (whitespace at the end of records are not suppressed) *Values* * WINDOWS ** none/no values *Default* * WINDOWS ** none/no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-option-suppress_cbff.html",
"SUPPRESS",
"[[CLEP.COMMAND.FLAM.OPTION.SUPPRESS]] ===== SUPPRESS indexterm:[Constant, SUPPRESS, FLAM.OPTION.SUPPRESS] Blanks or other signs at the end of any record are be suppressed (Windows only). The character that is to be suppressed can also be specified with `<<CLEP.COMMAND.FLAM.TRIMCHAR,trimchar=characters>>`. If trimchar is not specified in addition to suppress, then the setting is `trimchar=20` (ASCII) or `trimchar=40` (EBCDIC), depending on the character set of the original data. With the specification <<CLEP.COMMAND.FLAM.TRIMCHAR, `trimchar=characters`>>, parameter `suppress` is  set automatically. Parameters in the same context: * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS * <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress and nosuppress on UNIX * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for PADCHAR in z/OS * <<CLEP.COMMAND.FLAM.TRIMCHAR,TRIMCHAR>> for trimchar in WINDOWS * <<CLEP.COMMAND.FLAM.NOSUPPRESS,NOSUPPRESS>> for nosuppress in WINDOWS Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress * WINDOWS ** `suppress` ** `su` +    See also parameter <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>>. *Values* * WINDOWS ** for suppress and su: none/no values. *Default* * WINDOWS ** for `suppress` and `su`:    `trimchar=20` (ASCII) or `trimchar=40` (EBCDIC),    depending on the character set of the original data. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-option-nosuppress_03f4.html",
"NOSUPPRESS",
"[[CLEP.COMMAND.FLAM.OPTION.NOSUPPRESS]] ===== NOSUPPRESS indexterm:[Constant, NOSUPPRESS, FLAM.OPTION.NOSUPPRESS] Whitespace at the end of a record is not suppressed (Windows only). See also parameter <<CLEP.COMMAND.FLAM.SUPPRESS,SUPPRESS>>. NOTE: Specification of Parameter trimchar implicitly sets `suppress`,       see also parameter <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>>. Parameters in the same Context: * <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress and nosuppress on UNIX. * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS. * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for trimchar in WINDOWS and PADCHAR in z/OS. Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for `TRUNCATE` or `cut`. * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for `nosuppress`. * WINDOWS ** `nosuppress` ** `nos` +     Whitespace at the end of records is not suppressed.     See also parameters <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>> and <<CLEP.COMMAND.FLAM.CUT,CUT>>. *Values* * WINDOWS ** none/no values *Default* * WINDOWS ** none/no default *** Note: Specification of Parameter trimchar implicitly sets `suppress`.     See also parameter <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>>. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-cut_ce4a.html",
"CUT",
"[[CLEP.COMMAND.FLAM.CUT]] ==== CUT indexterm:[Parameter, CUT, FLAM.CUT] Truncate output record (z/OS and WINDOWS only). Records with a record length longer than the maximum record length may be shortened. Syntax restrictions for FLAMv4 or older: * z/OS ** `TRUNCATE=NO/YES` ** `TRU=NO/YES` * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> * WINDOWS ** `cut` ** `truncate` (synonym for cut) ** `tru` +    Records with a record length longer than the maximum record    length may be shortened. +    See also parameter <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>>. *Values* * z/OS ** `NO` - No truncation. If records longer than specified occur,    decompression is aborted. ** `YES` - If a decompressed record is longer than specified for the    output file, the record is truncated. * WINDOWS ** none/no values *Default* * z/OS ** `TRUNCATE=NO` * WINDOWS ** none/no default *Valid for* * decompression * `YES - Yes, do it` * `NO - No, don't do it` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-nocut_b2cf.html",
"NOCUT",
"[[CLEP.COMMAND.FLAM.NOCUT]] ==== NOCUT indexterm:[Parameter, NOCUT, FLAM.NOCUT] Records with a record length larger than the maximum record length are not cut/truncated (Windows only). Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for `TRUNCATE=NO` * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION, OPTION>> for `Option=nocut` * WINDOWS ** `nocut` ** `notruncate` (synonym for cut) ** `notr` (whitespace at the end of records are not suppressed) *Values* * WINDOWS ** none/no values *Default* * WINDOWS ** none/no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-suppress_4b5d.html",
"SUPPRESS",
"[[CLEP.COMMAND.FLAM.SUPPRESS]] ==== SUPPRESS indexterm:[Parameter, SUPPRESS, FLAM.SUPPRESS] Blanks or other signs at the end of any record are be suppressed (Windows only). The character that is to be suppressed can also be specified with `<<CLEP.COMMAND.FLAM.TRIMCHAR,trimchar=characters>>`. If trimchar is not specified in addition to suppress, then the setting is `trimchar=20` (ASCII) or `trimchar=40` (EBCDIC), depending on the character set of the original data. With the specification <<CLEP.COMMAND.FLAM.TRIMCHAR, `trimchar=characters`>>, parameter `suppress` is  set automatically. Parameters in the same context: * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS * <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress and nosuppress on UNIX * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for PADCHAR in z/OS * <<CLEP.COMMAND.FLAM.TRIMCHAR,TRIMCHAR>> for trimchar in WINDOWS * <<CLEP.COMMAND.FLAM.NOSUPPRESS,NOSUPPRESS>> for nosuppress in WINDOWS Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress * WINDOWS ** `suppress` ** `su` +    See also parameter <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>>. *Values* * WINDOWS ** for suppress and su: none/no values. *Default* * WINDOWS ** for `suppress` and `su`:    `trimchar=20` (ASCII) or `trimchar=40` (EBCDIC),    depending on the character set of the original data. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-nosuppress_50ca.html",
"NOSUPPRESS",
"[[CLEP.COMMAND.FLAM.NOSUPPRESS]] ==== NOSUPPRESS indexterm:[Parameter, NOSUPPRESS, FLAM.NOSUPPRESS] Whitespace at the end of a record is not suppressed (Windows only). See also parameter <<CLEP.COMMAND.FLAM.SUPPRESS,SUPPRESS>>. NOTE: Specification of Parameter trimchar implicitly sets `suppress`,       see also parameter <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>>. Parameters in the same Context: * <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress and nosuppress on UNIX. * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS. * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for trimchar in WINDOWS and PADCHAR in z/OS. Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for `TRUNCATE` or `cut`. * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for `nosuppress`. * WINDOWS ** `nosuppress` ** `nos` +     Whitespace at the end of records is not suppressed.     See also parameters <<CLEP.COMMAND.FLAM.NOCUT,NOCUT>> and <<CLEP.COMMAND.FLAM.CUT,CUT>>. *Values* * WINDOWS ** none/no values *Default* * WINDOWS ** none/no default *** Note: Specification of Parameter trimchar implicitly sets `suppress`.     See also parameter <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>>. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-padchar_f4b3.html",
"PADCHAR",
"[[CLEP.COMMAND.FLAM.PADCHAR]] ==== PADCHAR indexterm:[Parameter, PADCHAR, FLAM.PADCHAR] During the decompression procedure, the record format and size of the decompressed file can be specified explicitly, so that the record size is greater than in the original file. In this case, the records are padded to the specified length. Parameter `PADCHAR` is used in order to pad characters at the end of an output record. Syntax restrictions for FLAMv4 or older: * z/OS ** `PADCHAR=value` *** Note: This parameter is only used when an output record has           to be filled up during decompression (e.g. the original           variable record has to be converted to a fix output format). * UNIX ** `-pad_char=hexcode` * WINDOWS ** `padchar=pad character` ** `pad=pad character` *** Note: With `padchar=xx` the character is specified with which           - if necessary - the original record is padded. +           `padchar` is also used for padding the variable length           field of 4 bytes when using `outrecformat=var_4b`, see           parameter <<CLEP.COMMAND.FLAM.OUTRECFORMAT,OUTRECFORMAT>>. Values* * z/OS ** X'..' a hex value X'00' - X'FF' ** C'.' any character * UNIX ** Hexadecimal characters between 00 and ff. * WINDOWS ** Hexadecimal characters between 00 and FF. *Default* * z/OS ** X'40' * UNIX ** none/no default * WINDOWS ** none/no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-trimchar_d6ce.html",
"TRIMCHAR",
"[[CLEP.COMMAND.FLAM.TRIMCHAR]] ==== TRIMCHAR indexterm:[Parameter, TRIMCHAR, FLAM.TRIMCHAR] Characters are suppressed at the end of record in case of decompression and text record formats (WINDOWS only). `trimchar` refers to the character in the original character set. With the specification `trimchar=characters`, `suppress` is set automatically. Parameters in the same context: * <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate in z/OS * <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress and nosuppress on UNIX * <<CLEP.COMMAND.FLAM.PADCHAR,PADCHAR>> for PADCHAR on z/OS * <<CLEP.COMMAND.FLAM.SUPPRESS,SUPPRESS>> for suppress on WINDOWS * <<CLEP.COMMAND.FLAM.NOSUPPRESS,NOSUPPRESS>> for nosuppress on WINDOWS Syntax restrictions for FLAMv4 or older: * z/OS ** see parameter <<CLEP.COMMAND.FLAM.CUT,CUT>> for truncate * UNIX ** see parameter <<CLEP.COMMAND.FLAM.OPTION,OPTION>> for suppress * WINDOWS ** `trimchar=characters` ** `tri=characters` *** Note: trimchar refers to the characters in the original character           set of the input file(s) which should be suppressed at the end           of every record. *Values* * WINDOWS ** for trimchar and tri: hex value 00 to FF. *Default* * WINDOWS ** for `trimchar` and `tri`: +    If the original data is in ASCII, then the setting is    `trimchar=20` (ASCII space). +    If the original data is in EBCDIC, then the setting is    `trimchar=40` (EBCDIC space). +    If <<CLEP.COMMAND.FLAM.TRANSLATE,translate>>=e/a is specified for    decompression and the translation table for space is 40:20,    then the setting is trimchar=40. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-maxbuffer_f596.html",
"MAXBUFFER",
"[[CLEP.COMMAND.FLAM.MAXBUFFER]] ==== MAXBUFFER indexterm:[Parameter, MAXBUFFER, FLAM.MAXBUFFER] During compression with modes cx7, cx8, and vr8 FLAM reserves the matrix buffer for the temporary storage of the records from the original file. Please note that a matrix buffer of the same size has to be available during decompression, too. This is also the case when the decompression is done on other systems. Parameter MAXBUFFER specifies the maximum size of used matrix buffer. The information about `MAXBUFFER` is stored in the FLAMFILE, so it is well known during decompression. During compression FLAM reserves the matrix buffer for the temporary storage of the records from the original file. Please note that a matrix buffer of the same size has to be available during decompression, too. This is also the case when the decompression is done on other systems. Syntax restrictions for FLAMv4 or older: * z/OS ** `MAXBUFFER=n` ** `MAXB=n` *** Note: Used for CX7, CX8 and VR8 only. +     Regarding ADC, NDC and AES this parameter is not used. In     this case selection is always a buffer of 64KB. * UNIX ** -maxbuffer=n *** Note: Used for modes CX7, CX8 and VR8 only. +     With mode adc, this parameter has no effect. * WINDOWS ** maxbuffer=n *** Note: Used for modes CX7, CX8 and VR8 only. +     Regarding ADC, NDC and AES this parameter is not used.     In this case selection is always a buffer of 64KB. *Values* * z/OS ** There are three groups of values with differing meaning *** Values between 0 and 7 map to these fixed sizes: **** 0 = 32 KiB **** 1 = 16 KiB **** 2 = 32 KiB **** 3 = 64 KiB **** 4 = 128 KiB **** 5 = 256 KiB **** 6 = 512 KiB **** 7 = 1024 KiB *** Values between 8 and 2047 are in KiB and are rounded upwards     to a value of the following list: **** 2, 4, 6, 8, 10, 12, 14, 16, 32, 48, 64, 80, 96 **** 112, 128, 144, 176, 224, 256, 288,  320, 352 **** 384, 416, 512, 640, 768, 896, 1024, 1536, 2048 *** Values from 2048 are in bytes. +     This value is rounded upwards by KiB according to     the following list or is rounded downwards to 2560 KiB: **** 8, 10, 12, 14, 16, 32, 48, 64, 80, 96 **** 112, 128, 144, 176, 224, 256, 288,  320, 352 **** 384, 416, 512, 640, 768, 896, 1024, 1536, 2048 * UNIX / WINDOWS ** Integer number between 1 and 2,621,440. +   Values n, where 0<n<2,560 are interpreted as a number of   KiB (1 KiB = 1,024 bytes), while higher values are   interpreted as a number of bytes. FLAM chooses the nearest   equal or value value (in KiB) from the list below: *** 2, 4, 6, 8, 10, 12, 14, 16, 32, 48, 64, 80, 96 *** 112, 128, 144, 176, 224, 256, 288,  320, 352, 384 *** 416, 512, 640, 768, 896, 1024, 1536, 2048, 2560 *Default* * z/OS ** 64 kByte * UNIX ** none * WINDOWS ** for CX7, CX8 and VR8: none ** for ADC, NDC and AES: Parameter is not used. Selection is always a buffer of 64KB. *Valid for* * compression, mode=cx7,cx8,vr8 NOTE: ADC/NDC use 64 kb, unchangeable. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-maxrecords_bd3e.html",
"MAXRECORDS",
"[[CLEP.COMMAND.FLAM.MAXRECORDS]] ==== MAXRECORDS indexterm:[Parameter, MAXRECORDS, FLAM.MAXRECORDS] Maximum number of records for compression in one matrix. FLAM buffers records in the matrix buffer up to the specified number and compresses them. This specified number may occasionally not be reached if the matrix buffer is too small for the full number of records. The compression efficiency generally increases with the number of records. If -maxrecords=1, the compression is sequential and record-oriented. Syntax restrictions for FLAMv4 or older: * z/OS ** `MAXRECORDS=n` ** `MAXR=n` * UNIX ** `-maxrecords=n` * WINDOWS ** `maxrecords=n` *Values* * 1 - 255  for mode CX7/CX8/VR8, see parameter <<CLEP.COMMAND.FLAM.MODE,MODE>> * 1 - 4095 for mode ADC, see parameter <<CLEP.COMMAND.FLAM.MODE,MODE>> ** Note: With modes cx7, cx8, and vr8, up to 255 records are     stored in one matrix. If a higher value is specified it takes     effect only with mode adc. *Default* * z/OS **  255 for mode CX7/CX8/VR8 ** 4095 for mode ADC * UNIX ** none * WINDOWS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-flamcode_646f.html",
"FLAMCODE",
"[[CLEP.COMMAND.FLAM.FLAMCODE]] ==== FLAMCODE indexterm:[Parameter, FLAMCODE, FLAM.FLAMCODE] This parameter specifies the character set which is to be used to represent charactercoded information in the FLAMFILE during the compression procedure, such as the filename and control characters. In adc, cx8, and vr8 modes, this only concerns the information contained in the FLAM file header, such as the original filename and a few control characters, since the compressed file is represented in binary form. In cx7 mode, all FLAM control characters in the compressed file (FLAMFILE) are also coded in this character set. The characters extracted from the original data, however, remain unaffected in all modes. Their translation can be achieved by the translate parameter, see parameter <<CLEP.COMMAND.FLAM.MODE,MODE>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `FLAMCODE=EBCDIC/ASCII` ** `FLAMC=EBCDIC/ASCII` *** Note: If the original data is in ASCII character code, a           better compression ratio is obtained using `FLAMCODE=ASCII`. * UNIX ** `-flamcode=character set` * WINDOWS ** `-flamcode=character set` *Values* * z/OS ** `EBCDIC` for FLAM syntax in EBCDIC code. ** `ASCII` for FLAM syntax in ASCII code. * UNIX / WINDOWS ** `ebcdic` for FLAM syntax in EBCDIC code. ** `ascii`  for FLAM syntax in ASCII code. *Default* * z/OS ** `EBCDIC` * UNIX ** none * WINDOWS ** none *Valid for* * compression * `SYSTEM - System specific encoding` * `ASCII - String encoding in ASCII` * `EBCDIC - String encoding in EBCDIC` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-kmdll_d22a.html",
"KMDLL",
"[[CLEP.COMMAND.FLAM.KMDLL]] ==== KMDLL indexterm:[Parameter, KMDLL, FLAM.KMDLL] With the parameter kmdll the name of a dynamically loadable library is specified (Windows only). Availability FLAM Version 4.1: This library establishes the communication to a key management system,  e.g. FKMS FLAM KEYMANAGEMENT SYSTEM. The extension .dll may be omitted. If the DLL is not located in the search path of the operating system, the filename must be specified in a fully qualified manner. Parameters in the same context: <<CLEP.COMMAND.FLAM.KMEXIT,KMEXIT>> and <<CLEP.COMMAND.FLAM.KMPARAMETER,KMPARAMETER>> Syntax restrictions for FLAMv4 or older: * WINDOWS ** `kmdll=nameOfKmDll` *Values* * WINDOWS ** character set = ebcdic for FLAM syntax in EBCDIC code. ** character set = ascii  for FLAM syntax in ASCII code. *Default* * WINDOWS ** `kmdll=flamkme.dll` *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-kmexit_c7f2.html",
"KMEXIT",
"[[CLEP.COMMAND.FLAM.KMEXIT]] ==== KMEXIT indexterm:[Parameter, KMEXIT, FLAM.KMEXIT] Activates the key management exit. This user exit is an interface to a special (e.g. user written) key management system. On encryption, parameters (KMPARM=...) are passed to the module. It returns a key for encryption of the FLAMFILE and a string up to 512 byte. These data are stored in the FLAMFILE as an user header (see parameter `COMMENT` or function `FLMPUH`). On decryption, parameters (`KMPARM=...`) and the data stored in the user header are passed to the exit. The module returns the same key as on encryption. + It is up to the module, how to create a key and what kind of information are to be stored into the  user header of the FLAMFILE. These data will help the module to find the correct key on decryption. The exit is activated via the parameter KMEXIT=<name>. The user exit module must be contained in the library that has been assigned with the STEPLIB command (z/OS only). This parameter `-kmexit=[(]func[([lib])[exparm]][)]` specifies a user exit routine for automatic key management. With this parameter, FLAM is told the name of a function it has to invoke in order to receive a password needed for encryption or decryption of a file. This function must reside in a shared library (file type .so) the name of which may be specified after the function name. After the library name, an alphanumeric string may be appended that will be passed as a parameter string to the invoked function. With the parameter kmexit the name of the procedure that is to be used from the library is specified for automatic key management. Parameters in the same context: <<CLEP.COMMAND.FLAM.KMPARAMETER,KMPARAMETER>> and <<CLEP.COMMAND.FLAM.KMDLL,KMDLL>> *Value* * z/OS ** `KMEXIT=name` or `KME=name` of the module +    Max. 8 characters for name of the module, free choice. +    The module is loaded dynamically.. * Unix, FLAM command ** `-kmexit=exit specification` *** exit specification has the general form: [(]func[([lib])[exparm]][)] *** With this parameter, FLAM is told the name of a function     it has to invoke in order to receive a password needed for     encryption or decryption of a file. This function must     reside in a shared library (file type .so) the name of which     may be specified after the function name. After the library     name, an alphanumeric string may be appended that will be     passed as a parameter string to the invoked function.           supplies  the  password  (key)  needed  for           en/decryption.           containing func. When lib is omitted, FLAM loads the function           from `libflamkm.so` which it expects to find in directory           $FLAM_PATH/../lib when that environment variable is defined,           or otherwise in /usr/lib. +            *Note:*  When entered in a shell command, each            parenthesis must be preceded by an escape character            (\\) to avoid it being interpreted by the shell.            Escape characters are not required in parameter Files.             to the password function func. It must not contain             space characters or parentheses. If it contains             commas, the entire  Exit specification must be             enclosed in parentheses. exparm must always be             preceded by a pair of parentheses which may be             empty when lib is omitted. * Unix, Programming Key Exit ** -kmfunc +    The user exits for automatic key management can be    activated via the subprogram interface flamup and - in    contrast to the access exits - through the flam command, but    not through the record interface flamrec.    This user exit can be used at encryption or decryption    to provide a password automatically. It is activated by    the parameter -kmexit=exit specification in the flam    command or in the  parameter_string  argument of the    subprogram call flamup. The actual name used instead of    kmfunc may be any valid function name.    It sends a return code when it returns control to FLAM. *** Syntax restrictions for FLAMv4 or older +               `void kmfunc(signed long *functioncode,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}signed long *returncode,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}const unsigned long *parmlen,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}const unsigned char *param,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned long *datalen,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned char *data,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned long *ckylen,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned char *cryptokey,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned long *msglen,` +               `{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}unsigned char *message);` + *** Arguments **** `functioncode` +      This argument transfers a function code to the user exit.      The valid values are as follows: ***** -1 call for version identification ***** 0 call for decryption ***** 1 call for encryption **** `returncode` +      The user exit sends a return code to FLAM with this      argument; 0 = Success, otherwise Error. **** `parmlen` +      When functioncode is 0 or 1, this argument contains the      byte length of the data in the param argument. That may      be an integer value between 0 and 256. **** `param` +      When parmlen > 0, this argument contains the exparm-      part of the exit specification in the -kmexit parameter. **** `datalen` +      When functioncode is 0 or 1, this argument contains the      byte length of the data in the data argument. That may be      an  integer  value  between  0  and  512. For calls for      encryption, it is set by the exit routine. For calls for      decryption, it is set by FLAM. **** `data` +      When datalen > 0 with calls for encryption (functioncode 1),      the exit routine returns here the data required for retrieving      the  password needed  for  decryption. FLAM stores these data      in a user-specific FLAM file header. With calls for decryption      (functioncode 0), FLAM returns here these data to the exit routine. **** `ckylen` +      After a successful call to the exit routine with      functioncode 0 or 1, this argument contains the byte      length of the password returned to FLAM in the cryptokey      argument.      Maximum key length is 64 bytes. **** `cryptokey` +      In this argument, FLAM  receives after exit calls with      functioncode 0  or  1  the  password  for  encryption      or decryption with the length specified in ckylen. **** `msglen` +      Upon return to FLAM, this argument indicates the byte      length of the string in the message argument. Maximum is      128 bytes. **** `message` +      The exit routine may put here a message text which will      be output to the log file by FLAM * Windows ** `kmeexit=nameOfKmProcedure` +    With the parameter kmexit the name of the procedure    that is to be used from the library is specified. *Default* * No default value can be set for -kme user exit. *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-kmparameter_502d.html",
"KMPARAMETER",
"[[CLEP.COMMAND.FLAM.KMPARAMETER]] ==== KMPARAMETER indexterm:[Parameter, KMPARAMETER, FLAM.KMPARAMETER] Parameter used for the KMEXIT (z/OS and WINOWS only). The string that is specified with KMPARM is passed to the key management procedure used in context with Parameter KMEXIT. NOTE: This parameter overwrites parameter <<CLEP.COMMAND.FLAM.COMMENT,COMMENT>>       in z/OS, if present. Parameters in the same context: <<CLEP.COMMAND.FLAM.KMEXIT,KMEXIT>> and <<CLEP.COMMAND.FLAM.KMDLL,KMDLL>> Syntax restrictions for FLAMv4 or older: * z/OS ** `KMPARM=any input` up to 256 characters in form of    A'...', C'...', X'...', or as a string. ** `KMP=any input` up to 256 characters in form of    A'...', C'...', X'...', or as a string. * UNIX ** see parameter <<CLEP.COMMAND.FLAM.KMEXIT,KMEXIT>> * WINDOWS ** `kmparam=parameter string` *Values* * z/OS ** Any input up to 256 characters in form of    A'...', C'...', X'...', or as a string. * WINDOWS ** string *Default* * none, no parameter *Valid for* * en-/decryption ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-header_0433.html",
"HEADER",
"[[CLEP.COMMAND.FLAM.HEADER]] ==== HEADER indexterm:[Parameter, HEADER, FLAM.HEADER] Controls file header entries in the FLAM file (z/OS only). See also parameter <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>> for UNIX and WINDOWS. NOTE: The header consists of three parts. The *first part* is independent from the operating system and contains file attributes that are compatible. The second part depends on the operating system and contains file attributes specific to the according operating system. The third part is optional and contains the filename when specified with the parameter FILEINFO. FLAM and FLAMUP evaluate the file header in order to create a file with the most similar characteristics. The simplest case is when the file is reconstructed in the original system environment. In this case, the second (operating system specific) part of the file header can be used. In all other cases only the first part can be used and the system neutral attributes are mapped on system specific attributes of the target environment. Syntax restrictions for FLAMv4 or older: * z/OS ** `HEADER=YES/NO` ** `HE=YES/NO` * UNIX / Windows ** See parameter <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>>    for `-attribute=attribute` option.    This parameter causes original file information to be entered    in the FLAMFILE header. *Values* * z/OS ** `YES` - Create file header ** `NO` - Don't create file header * UNIX / Windows ** `-none` - No information about the original file is entered in the             FLAMFILE. +             Corresponds z/OS: `FILEINFO=NO` and `HEADER=NO`. ** `common` - The organization, the record format and the record size of               the original file can be saved during the compression               procedure, together with a flag which identifies the               operating system in which the compression took place. +               Corresponds z/OS: `FILEINFO=NO` and `HEADER=YES`. ** `all` - Common file information and system-specific information            about the original file. +            Corresponds z/OS: `FILEINFO=YES` and `HEADER=YES`. *Default* * z/OS ** `YES` * UNIX ** should be set to `-attributes=all` * WINDOWS ** should be set to `attributes=all` *Valid for* * compression * `YES - Yes, do it` * `NO - No, don't do it` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-comment_1897.html",
"COMMENT",
"[[CLEP.COMMAND.FLAM.COMMENT]] ==== COMMENT indexterm:[Parameter, COMMENT, FLAM.COMMENT] With the parameter comment/label comments can be made and will be stored in the user header of the FLAMFILE during compression. These data are protocolled during decompression (z/OS and WINDOWS only). NOTE: Comments in ASCII in the FLAMFILE are translated to       EBCDIC for the output message with the internal A/E       translation table during decompression. Entering a       <<CLEP.COMMAND.FLAM.TRANSLATE,TRANSLATE>> parameter causes FLAM to use       this table. Nondisplaying characters are visualized by dots '.'. +       The FKMS uses the USER header itself. If key management is       called by parameter <<CLEP.COMMAND.FLAM.KMEXIT,KMEXIT>>,       additional data is stored as comment in the FLAMFILE during       encryption, sent to the exit for decryption (please, don't use       the parameters `COMMENT` and `KMEXIT` at the same time!). Syntax restrictions for FLAMv4 or older: * z/OS ** `COMMENT=string` ** `COMM=string` * WINDOWS ** `label=string` ** `la=string` *Values* * z/OS ** 1 - 256 characters starting with A'...', C'...', X'...' or a string.    Using A'..' all characters are translated to ASCII with the internal    translation table A/E (ch. A). * WINDOWS ** string *Default* * No comment *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-msgfile_9fd1.html",
"MSGFILE",
"[[CLEP.COMMAND.FLAM.MSGFILE]] ==== MSGFILE indexterm:[Parameter, MSGFILE, FLAM.MSGFILE] This parameter can be used to redirect FLAM message output to a file. FLAM messages are output to stderr which is generally the user's screen when working interactively. With this parameter output can be sent to a file to act as a permanent copy for documenting the compression procedure. This is important for batch processing, for example. However, logging in the message file does not begin until after the syntax and compatibility of the FLAM settings specified in the command have been checked. Error messages concerning syntax errors, missing files or invalid settings are not logged. In such cases, FLAM stops processing without creating a message file Syntax restrictions for FLAMv4 or older: * z/OS ** `MSGFILE=file name` ** `MSGF=file name` * UNIX ** `-msgfile=message file name` * WINDOWS ** `msgfile=message file name` ** `ms=message file name` ** `logfile=message file name` ** `log=message file name` *Values* * z/OS ** File name with max. 54 characters. * UNIX ** This specifies a file to which the FLAM messages must be written. * WINDOWS ** Name of the file to which the FLAM messages are to be written. *** Note: Generally the log file is opened with 'append'. +     It is possible to have the log file created on the command line by     the operating system: +     `flam4 param1 param2 param3  2>LOGFILE`. +     The  redirection of STDERR instead of the specification     msgfile=<name> has the advantage that all messages are written     to the redirected file immediately. Otherwise the messages are not     written to the specified file until the parameter msgfile is     interpreted. *Default* * z/OS ** no name * UNIX ** none * WINDOWS ** none *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-secureinfo_c733.html",
"SECUREINFO",
"[[CLEP.COMMAND.FLAM.SECUREINFO]] ==== SECUREINFO indexterm:[Parameter, SECUREINFO, FLAM.SECUREINFO] Additional information stored in the FLAMFILE. Increasing the security of data. Changing the FLAMFILE (in any way) leads to a decompression error. NOTE: Concatenation of 'secure' FLAMFILEs lead to secure violations! +       `SECUREINFO=YES` needs `MODE=ADC` or `NDC`. Syntax restrictions for FLAMv4 or older: * z/OS ** `SECUREINFO=secure option` ** `SEC=secure option` * UNIX ** -FLAMFILE is secure automatically, if encrypted with AES * WINDOWS ** `secureinfo=secure option` ** `sec=secure option` *** Note: Only in modes ADC, NDC, AES. +     AES-encrypted data is always generated with secure information. *Values* * z/OS ** `YES` - create these information (default on encryption) on compression ** `NO` - do not store any additional data ** `IGNORE` - ignore any security violations on decompression ** `MEMBER` - only member-specific security information are verified on               decompression, not the entire FLAMFILE *** Note: Concatenation of 'secure' FLAMFILEs lead to secure violations! +           `SECUREINFO=YES` needs `MODE=ADC` or `NDC`. * WINDOWS ** `**y**es` - generate resp. check secure information (default) ** `**n**o` - do not generate secure information   resp. ignore secure information *Default* * z/OS **  `NO` **  `YES` (in case of `MODE=ADC`) * WINDOWS ** YES, default on encryption *** Note: AES-encrypted data are always generated with secure information. *Valid for* * compression * decompression * `YES - Create secure information at compression` * `NO - Do not store any additional secure information` * `IGNORE - Ignore any security violations on decompression` * `MEMBER - Only member-specific security information is verified` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-msgdisp_4133.html",
"MSGDISP",
"[[CLEP.COMMAND.FLAM.MSGDISP]] ==== MSGDISP indexterm:[Parameter, MSGDISP, FLAM.MSGDISP] With parameter MSGDISP it is possible to control the output medium for messages (z/OS only). The FLAM protocol is principally stored into a file if no other instructions are given by parameter MSGDISP. All messages are written by default into a message file: or NOTE: If no file is specified despite the fact that the parameter       `MSGDISP=MSGFILE` is set, a message is written to the console via       `WTO, ROUTCDE=11` and the  program is terminated with a       condition code (`WTO=Write-To-Operator`). +       Parameters in the same context:       <<CLEP.COMMAND.FLAM.MSGFILE,MSGFILE>> and <<CLEP.COMMAND.FLAM.MSGDDN,MSGDDN>> Syntax restrictions for FLAMv4 or older: * z/OS ** `MSGDISP=TERMINAL/MSGFILE/SYSTEM` ** `MSGD=TERMINAL/MSGFILE/SYSTEM` *Values* * z/OS ** `MSGDISP=TERMINAL` +    Currently not supported. ** `MSGDISP=MSGFILE` +    The messages are written into a catalogued file. The DD-NAME of this    file is `FLPRINT` by default and can be modified using parameter `MSGDDN=<name>`. ** `MSGDISP=SYSTEM` +    Output on console with WTO, ROUTCDE=11. *Default* * z/OS **  `MSGDISP=MSGFILE` *Valid for* * compression * decompression * `TERMINAL - Log to a stream` * `MSGFILE - Log to a flat file` * `SYSTEM - Use system logging facility` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-show_0a1f.html",
"SHOW",
"[[CLEP.COMMAND.FLAM.SHOW]] ==== SHOW indexterm:[Parameter, SHOW, FLAM.SHOW] This parameter specifies which information should be shown in the FLAM control protocol. This parameter corresponds to parameter <<CLEP.COMMAND.FLAM.INFO,INFO>>. This parameter controls the information output by FLAM. You can choose between detailed information (all), error messages and warnings either with or without statistics (error or statistics) and no information (none). During the decompression procedure, you can decide just to show the information about the original file, without creating a decompressed file. Use `show=attributes` to do so. If the FLAMFILE contains compressed versions of several files, the information about each of the original files is shown one file at a time. However, this information is only shown, if this was specified when the files were compressed into the FLAMFILE (see parameter <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>>). If `-show=attributes` is specified, parameter <<CLEP.COMMAND.FLAM.FLAMOUT,FLAMOUT>>  is ignored. Syntax restrictions for FLAMv4 or older: * z/OS ** `SHOW=ALL/NONE/ATTRIBUT/ERROR/DIR` ** `SH=ALL/NONE/ATTRIBUT/ERROR/DIR` * UNIX ** `-show=none/all/attributes/error/statistics` * WINDOWS ** `show=none/all/attributes/error/statistics` ** `sh=none/all/attributes/error/statistics` *Values* * z/OS ** `ALL` - All messages and statistics - generate and display. ** `NONE` - Don't display messages. ** `ATTRIBUT` - Display the parameters for compression or decompression                 but do not execute processing. ** `ERROR` - Display error messages and end-of-program message only. ** `DIR` - The names of all files (and their attributes) that are to be            processed are listed. * UNIX ** `none` - No information is shown. ** `all` - All the available information is shown. This depends on the            invoked operation (compress or decompress), but not on whether            FLAM was invoked directly or using the parameter file. *** The following information is shown during the compression procedure: **** FLAM version **** FLAM settings ***** Operation (compress) ***** Code table ***** Compression mode ***** Matrix buffer size ***** Maximum number of records/matrix buffer ***** Character set (ASCII or EBCDIC) ***** attributes setting **** Name of the original file **** Formatting information for the original file **** Name of the compressed file (FLAMFILE) **** Formatting information for the compressed file **** Statistical information (see show=statistics) **** Error messages and warnings *** The following information is shown during the decompression procedure: **** FLAM version **** FLAM settings: ***** Operation (decompress) ***** Code table (only if the FLAM call includes the necessary specifications) **** Name of the compressed file (FLAMFILE) **** Name of the decompressed file **** Formatting information for the decompressed file **** Saved compression information (see `show=attributes`) **** Statistical information (see `show=statistics`) **** Error messages and warnings ** `attributes` - (Decompression only) +    This suppresses creation of the decompressed file. +    Only the saved compression information is shown: *** Name of the original file (only if  `-attributes=all` was     specified when it was compressed). *** Formatting information for the original file. *** Compression mode. *** Character set (ASCII or EBCDIC). *** System which created the FLAMFILE. ** `error` - Only error messages and warnings are shown. ** `statistics` - Error messages, warnings and the following statistics are     shown: *** Number of compressed records *** Number of compressed bytes *** Number of non-compressed records *** Number of non-compressed bytes *** Compression efficiency as compared with the original file (compression only) +     This efficiency is the ratio of the number of bytes     actually read to the number of bytes output and is     specified as a percentage. Record size fields, record     delimiters and characters for padding compressed records     are not taken into account ** Note: Message outputs can be redirected to a file by specifying          `2>>filename`. If `-msgfile=filename` is specified, on the other          hand, the FLAM messages are written into a file, but          system messages continue to be displayed on the screen. * WINDOWS ** `none` - no display. ** `all` - Shows all of the information available. The information    depends on the invoked operation, compression or decompression,    but not on the circumstance if FLAM was called directly or with a    parameter file. ** `attributes` - decompression only +    suppresses the creation of the decompressed file. +    only shows the saved compression information: *** name of the original file (only if compressed with `attributes=all`) *** format specifications of the original file *** compression mode *** character set ASCII or EBCDIC **** system which generated the FLAMFILE ** `error` - only shows error and warning messages. ** `statistics` - shows error and warning messages plus the    number of compressed records. *Default* * z/OS ** ALL * UNIX ** none (No information is shown/no display) * WINDOWS ** none (No information is shown/no display) *Valid for* * compression * decompression * `ALL - Print messages and statistics (default)` * `DIR - Printouts of file names but no processing` * `ATTRIBUTE - Printouts but no processing` * `ERROR - Only errors and error trace are logged` * `NONE - No logging` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-info_b712.html",
"INFO",
"[[CLEP.COMMAND.FLAM.INFO]] ==== INFO indexterm:[Parameter, INFO, FLAM.INFO] This parameter specifies which information should be shown in the FLAM control protocol (z/OS only). INFO has been replaced by the more powerful parameter <<CLEP.COMMAND.FLAM.SHOW,SHOW>>. Note: The INFO parameter should be contained in the first input line.       Otherwise it has no effect on displaying the parameter inputs.       The statistics inform about elapsed time and CPU time needed.       Also the number of bytes and records for both input and output is       computed. If relative files are decompressed the number of       records after the removal of gaps is computed in addition. For       conversion into fixed record format the resulting number of       bytes is displayed. Syntax restrictions for FLAMv4 or older: * z/OS ** `INFO=YES/NO/HOLD` ** `I=YES/NO/HOLD` *Values* * z/OS ** `YES` - Messages and statistics - generate and display. ** `NO` - Don't display messages. ** `HOLD` - Display the parameters for compression or decompression             but do not execute compression or decompression. *Default* * z/OS ** `YES` *Valid for* * compression * decompression * `YES - Print messages and statistics (default)` * `NO - No printouts but processing` * `HOLD - Printouts but no processing` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-checkall_e6a1.html",
"CHECKALL",
"[[CLEP.COMMAND.FLAM.CHECKALL]] ==== CHECKALL indexterm:[Parameter, CHECKALL, FLAM.CHECKALL] The parameter CHECKALL supports complete testing of a FLAMFILE _including_ decompression and possibly decryption, but without file output (z/OS only). CHECKALL is a short form for <<CLEP.COMMAND.FLAM.DECOMPRESS,DECOMPRESS>>, <<CLEP.COMMAND.FLAM.FLAMOUT,FLAMOUT>>=*DUMMY, <<CLEP.COMMAND.FLAM.SHOW,SHOW>>=ALL. NOTE: If the FLAMFILE has been encrypted, the key must be specified for       decryption. See also parameters <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>,       <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY/cryptkey>>,       <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>, <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>> or       <<CLEP.COMMAND.FLAM.PAASCII,PAEBCDIC>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `CHECKALL` ** `CHECKA` *Values* * z/OS ** No values *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-checkfast_f8c0.html",
"CHECKFAST",
"[[CLEP.COMMAND.FLAM.CHECKFAST]] ==== CHECKFAST indexterm:[Parameter, CHECKFAST, FLAM.CHECKFAST] The parameter is checking a FLAMFILE for integrity and completeness _without_ decompression but possibly with decryption (z/OS only). CHECKFAST is a short form for <<CLEP.COMMAND.FLAM.DECOMPRESS,DECOMPRESS>>, <<CLEP.COMMAND.FLAM.SHOW,SHOW>>=DIR. NOTE: If the FLAMFILE has been encrypted, the key must be specified for decryption.       See also parameters <<CLEP.COMMAND.FLAM.PASSWORD,PASSWORD>>,       <<CLEP.COMMAND.FLAM.CRYPTOKEY,CRYPTOKEY or cryptkey>>,       <<CLEP.COMMAND.FLAM.PAXWORD,PAXWORD>>,       <<CLEP.COMMAND.FLAM.PAASCII,PAASCII>> or       <<CLEP.COMMAND.FLAM.PAASCII,PAEBCDIC>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `CHECKFAST` ** `CHECKF` *Values* * z/OS ** No values *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-help_244d.html",
"HELP",
"[[CLEP.COMMAND.FLAM.HELP]] ==== HELP indexterm:[Parameter, HELP, FLAM.HELP] * z/OS ** If the HELP function is requested in the first input line, the generated     FLAM parameters and their values are displayed and the program is terminated     without doing compression, decompression or encrypting. * UNIX ** The parameter `-list` permits a list of the installation-specific    default values to be output. * WINDOWS ** It is possible to display the installation specific standard settings    on screen with the parameter 'list'. Syntax restrictions for FLAMv4 or older: * z/OS ** `HELP` *** Note: If the Help function is requested in the first input           line, the generated FLAM parameters and their values           are output and the program is terminated. * UNIX ** `-list[=list specification]` *** Note: With the list parameter the installation-specific           default values can be displayed. +           When a list specification is supplied, the current           setting of default value for the respective parameter is           displayed. +           When list specification is omitted, a list of all           current values is displayed except the code tables for           ASCII-EBCDIC and EBCDIC-ASCII translations. Also, the           FLAM version and its creation date are displayed. * WINDOWS ** `list` *** Note:  Output of default values to a file is possible with command:            `flam4 list 2>FILE` *Values* * z/OS ** No values * UNIX ** list specification =  Any flam parameter for which a default value can be set. * WINDOWS ** No values *Default* * none *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-fileinfo_c730.html",
"FILEINFO",
"[[CLEP.COMMAND.FLAM.FILEINFO]] ==== FILEINFO indexterm:[Parameter, FILEINFO, FLAM.FILEINFO] Transfers filename of original file into file header (z/OS only). Parameters in the same context: <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>> for UNIX and WINDOWS, <<CLEP.COMMAND.FLAM.HEADER,HEADER>>  for z/OS. Syntax restrictions for FLAMv4 or older: * z/OS ** `FILEINFO=YES/NO` ** `FI=YES/NO` * UNIX / WINDOWS ** See parameter <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>> for    `-attribute=attribute` option. This parameter causes original file    information to be written to the FLAMFILE header. *Values* * z/OS ** `YES`  -Transfer file name of original file into/out of FLAM file header. ** `NO` - Don't transfers filename (when compressing).           On decompression, a filename is generated (FILE0001-FILE9999)           which can be used for conversion rules. * UNIX / WINDOWS ** `none` - No information about the original file is written to the FLAMFILE.             Corresponds z/OS: `FILEINFO=NO` and `HEADER=NO`. ** `common`  - The organization, the record format and the record size of                the original file can be saved during the compression                procedure, together with a flag which identifies the                operating system in which the compression took place. +                Corresponds z/OS: `FILEINFO=NO` and `HEADER=YES`. ** `all`  - Common file information and systemspecific information             about the original file. +             Corresponds z/OS: `FILEINFO=YES` and `HEADER=YES`. *Default* * z/OS ** `YES` * UNIX / WINDOWS ** should be set to `-attributes=all` *Valid for* * compression * decompression * `YES - Yes, do it` * `NO - No, don't do it` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-codetable_2659.html",
"CODETABLE",
"[[CLEP.COMMAND.FLAM.CODETABLE]] ==== CODETABLE indexterm:[Parameter, CODETABLE, FLAM.CODETABLE] If code translation has been activated, the specified code table is used (WINDOWS only). The first 256 characters refer to the function translate=e/a. The characters 257 - 512 refer to the function translate=a/e. If the file has only 256 characters, these characters will be used for e/a and a/e as well. In this way, a table can serve as conversion tool for lowercase to uppercase letters or for the adjustment of umlauts, e.g. OEM<>ANSI. Parameters in the same context: <<CLEP.COMMAND.FLAM.TRANSLATE,TRANSLATE>> for UNIX, WINDOWS and z/OS. Syntax restrictions for FLAMv4 or older: * z/OS ** see <<CLEP.COMMAND.FLAM.TRANSLATE,TRANSLATE>> for `translate=translation` option.    This parameter induces a code conversion of the data of the original    file before compression * UNIX ** see <<CLEP.COMMAND.FLAM.TRANSLATE,TRANSLATE>> `-translate=code` table.    This specifies a file containing the code table. * WINDOWS ** `codetable=<name of code table>` ** `cod=<name of code table>` *Values* * WINDOWS ** name of code table *Default* * none *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-translate_47d8.html",
"TRANSLATE",
"[[CLEP.COMMAND.FLAM.TRANSLATE]] ==== TRANSLATE indexterm:[Parameter, TRANSLATE, FLAM.TRANSLATE] This parameter causes the codes for data in the original file to be translated prior to the compression procedure or those for the data in the decompressed file to be translated after the decompression procedure. If parameter `translate` is specified for the compression procedure, every record in the original file is translated according to the specified code table before it is buffered in the matrix buffer. During the decompression procedure, this specification causes every decompressed record to be translated according to the code table before it is inserted in the decompressed file. For UNIX only: + When FLAM is installed, code tables for converting from ASCII to EBCDIC and from EBCDIC to ASCII are made available as standard. If one of the code tables in the default value file is to be used, the following specifications are necessary: * a/e  to convert from ASCII to EBCDIC * e/a  to convert from EBCDIC to ASCII For WINDOWS only: + If a specific table is used for translation, it must be specified with `codetable=table` (see also parameter <<CLEP.COMMAND.FLAM.CODETABLE, CODETABLE>>). Otherwise, the default table is used (see also parameter <<CLEP.COMMAND.FLAM.HELP,HELP>> for a list). Syntax restrictions for FLAMv4 or older: * z/OS ** `TRANSLATE=<translation option>` ** `TRA=<translation option>` * UNIX ** `-translate=code table` * WINDOWS ** `translate=translation option` ** `tra=translation option` *Values* * z/OS ** `E/A` - Converts EBCDIC to ASCII. ** `A/E` - Converts ASCII to EBCDIC. ** `TRE2A00` - Converts IMB273 to ISO 8859-1. ** `TRA2E00` - Converts ISO 8859-1 to IBM273. ** `name` - Name of a data module (1-8 characters) that contains  a 256             byte table for code conversion. *** Note: The specified table is loaded dynamically. +           Code conversion may be necessary for file transfer between           heterogeneous systems. It can be performed on any system, but           it is recommended to do it on the target system, since FLAM           already contains the necessary conversion tables for that system.           Many translation tables will be found on our home page:           https://www.flam.de/en/download/addons/Flam4-TranslationTables/zSeries/zos/[Flam4-Translation Tables] * UNIX ** `a/e` - conversion from ASCII to EBCDIC ** `e/a` - conversion from EBCDIC to ASCII * WINDOWS ** `**n**one` - no conversion. ** `*a/e*` - conversion from ASCII to EBCDIC. ** `*e/a*` - conversion from EBCDIC to ASCII. *** Note: If a specific table is used for translation, it must be           specified with `codetable=table`           (see parameter <<CLEP.COMMAND.FLAM.CODETABLE,CODETABLE>>)           otherwise the default table is used           (see parameter <<CLEP.COMMAND.FLAM.HELP,HELP>> for a list). *Default* * no code conversion *Valid for* * compression * decompression * `E/A - conversion from EBCDIC to ASCII` * `A/E - conversion from ASCII to EBCDIC` * `NONE - no conversion` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-nopath_2662.html",
"NOPATH",
"[[CLEP.COMMAND.FLAM.NOPATH]] ==== NOPATH indexterm:[Parameter, NOPATH, FLAM.NOPATH] This specification has the effect that the file name of the original file is saved without path to the FLAMFILE (UNIX and WINDOWS only). When compressing with <<CLEP.COMMAND.FLAM.ATTRIBUTES,ATTRIBUTES>>=all, FLAM stores the entire absolute path name of the original file in the compressed file's file header. Trying to create a file with the original path at decompression may cause problems on systems with a different directory structure or file naming syntax. With the `nopath` parameter, only the filename is stored properly while the directory path is discarded. Syntax restrictions for FLAMv4 or older: * UNIX ** `-nopath` * WINDOWS ** `nopath` *Values* * none *Default* * none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-climit_8956.html",
"CLIMIT",
"[[CLEP.COMMAND.FLAM.CLIMIT]] ==== CLIMIT indexterm:[Parameter, CLIMIT, FLAM.CLIMIT] This parameter sets minimal compression in per cent, which FLAM would be accepted (z/os ONLY). If the compression result is worse than the predefined limit, FLAM will generate a message and will set condition code 80. The compression is finished properly anyway. This parameter is only evaluated for <<CLEP.COMMAND.FLAM.INFO,INFO>>=YES (default value for PARAMETER INFO). Syntax restrictions for FLAMv4 or older: * Z/OS ** `CLIMIT=nn` ** `CLI=nn` *Values* * Z/OS ** 0 - 90 *Default* * Z/OS ** `CLIMIT=0` *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-irplffd_3243.html",
"IRPLFFD",
"[[CLEP.COMMAND.FLAM.IRPLFFD]] ==== IRPLFFD indexterm:[Parameter, IRPLFFD, FLAM.IRPLFFD] Replacement of form feeds in case of compression. If a compression process receives a file and the parameter IRPLFFD is set, the received form feed of this uncompressed file is replaced by inserting empty records (row padding) initiated by IRPLFFD=line number before including into the FLAMFILE. Line number expresses the number of lines which will exist in every page of every file in the FLAMFILE initiated by IRPLFFD=line number. The original form feeds of input files are completely replaced by this row padding. Padded rows are empty. If the input file does not use form feed, parameter IRPLFFD is ignored. See also <<CLEP.COMMAND.FLAM.ORPLFFD,ORPLFFD>>. Syntax restrictions for FLAMv4 or older: * `IRPLFFD=line number` * `IRP=line number` *Values* * line number = between 1 - 99, which expresses the line volume per page. *Default* *  none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-orplffd_c225.html",
"ORPLFFD",
"[[CLEP.COMMAND.FLAM.ORPLFFD]] ==== ORPLFFD indexterm:[Parameter, ORPLFFD, FLAM.ORPLFFD] Replacement of form feeds in case of decompression. If a decompression process receives the parameter `ORPLFFD`, the form feeds of the contained files in the FLAMFILE are replaced by inserting empty records (row padding) during decompression initiated by `IRPLFFD=line number`. Line number expresses the number of lines which will exist in every page of every output file initiated by `ORPLFFD=line number`. The original form feed of every file contained in FLAMFILE is completely replaced by this row padding. Padded rows are empty. If the output file in FLAMFILE does not use form feed, parameter `ORPLFFD` is ignored. See also parameter <<CLEP.COMMAND.FLAM.IRPLFFD,IRPLFFD>>. Syntax restrictions for FLAMv4 or older: * `ORPLFFD=line number` * `ORP=line number` *Values* * line number = between 1 - 99, which expresses the line volume per page. *Default* *  none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-nomkdir_1724.html",
"NOMKDIR",
"[[CLEP.COMMAND.FLAM.NOMKDIR]] ==== NOMKDIR indexterm:[Parameter, NOMKDIR, FLAM.NOMKDIR] If directories don't exists at compression and decompression they are created by default.The NOMKDIR switch has to be defined to prevent this. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-exk10_4005.html",
"EXK10",
"[[CLEP.COMMAND.FLAM.EXK10]] ==== EXK10 indexterm:[Parameter, EXK10, FLAM.EXK10] The parameter EXK10 activates user exit for processing original data (z/OS only). NOTE: The module is loaded dynamically.See also parameters       <<CLEP.COMMAND.FLAM.EXK20,EXK20>>, <<CLEP.COMMAND.FLAM.EXD10,EXD10>>       or <<CLEP.COMMAND.FLAM.EXD20,EXD20>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `EXK10` ** `EXK1` *Values* * z/OS ** name of the module (max. 8 characters) *Default* * z/OS ** no user exit *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-exk20_518e.html",
"EXK20",
"[[CLEP.COMMAND.FLAM.EXK20]] ==== EXK20 indexterm:[Parameter, EXK20, FLAM.EXK20] The parameter EXK20 activates user exit for processing compressed data (z/OS only). NOTE: The module is loaded dynamically. See also parameters       <<CLEP.COMMAND.FLAM.EXD10,EXD10>>, <<CLEP.COMMAND.FLAM.EXD20,EXD20>>       or <<CLEP.COMMAND.FLAM.EXK10,EXK10>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `EXK20` ** `EXK2` *Values* * z/OS ** name of the module (max. 8 characters) *Default* * z/OS ** no user exit *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-exd10_7e60.html",
"EXD10",
"[[CLEP.COMMAND.FLAM.EXD10]] ==== EXD10 indexterm:[Parameter, EXD10, FLAM.EXD10] The parameter EXD10 activates user exit for processing decompressed data (z/OS only). NOTE: The module is loaded dynamically. See also parameters       <<CLEP.COMMAND.FLAM.EXD20,EXD20>>, <<CLEP.COMMAND.FLAM.EXK10,EXK10>>       or <<CLEP.COMMAND.FLAM.EXK20,EXK20>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `EXD10` ** `EXD1` *Values* * z/OS ** name of the module (max. 8 characters) *Default* * z/OS ** no user exit *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-exd20_1ffb.html",
"EXD20",
"[[CLEP.COMMAND.FLAM.EXD20]] ==== EXD20 indexterm:[Parameter, EXD20, FLAM.EXD20] The parameter EXD20 activates user exit for processing compressed data (z/OS only). NOTE: The module is loaded dynamically. See also parameters       <<CLEP.COMMAND.FLAM.EXD10,EXD10>>, <<CLEP.COMMAND.FLAM.EXK10,EXK10>>       or <<CLEP.COMMAND.FLAM.EXK20,EXK20>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `EXD20` ** `EXD2` *Values* * z/OS ** name of the module (max. 8 characters) *Default* * z/OS ** no user exit *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-space1_794f.html",
"SPACE1",
"[[CLEP.COMMAND.FLAM.SPACE1]] ==== SPACE1 indexterm:[Parameter, SPACE1, FLAM.SPACE1] Primary space request/allocation for FLAMFILE in Megabytes (z/OS only). Original files up to 8 MiB will be handled with the old FLAM4 defaults (2/40) Files larger than 8 MiB will allocate 1/4 of the file size as primary and the file size (4 times more) as secondary space by default. Syntax restrictions for FLAMv4 or older: * z/OS ** `SPACE1=nn` *Values* * z/OS ** 1 - 4095 *Default* * z/OS ** `SPACE1=2` *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-space2_7ae2.html",
"SPACE2",
"[[CLEP.COMMAND.FLAM.SPACE2]] ==== SPACE2 indexterm:[Parameter, SPACE2, FLAM.SPACE2] Secondary space request/allocation for FLAMFILE in Megabytes (z/OS only). Original files up to 8 MiB will be handled with the old FLAM4 defaults (2/40) Files larger than 8 MiB will allocate 1/4 of the file size as primary and the file size (4 times more) as secondary space by default. Syntax restrictions for FLAMv4 or older: * z/OS ** `SPACE2=nn` *Values* * z/OS ** 1 - 4095 *Default* * z/OS ** `SPACE1=40` *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ospace1_078e.html",
"OSPACE1",
"[[CLEP.COMMAND.FLAM.OSPACE1]] ==== OSPACE1 indexterm:[Parameter, OSPACE1, FLAM.OSPACE1] Primary space request/allocation for output file in Megabytes (z/OS only). NOTE: This value must only be specified if the FLAMFILE is non       z/OS compressed or you need a special value. A z/OS       FLAMFILE has stored the total space amount in the file       header and uses this value for allocation on decompression. Syntax restrictions for FLAMv4 or older: * z/OS ** `OPACE1=nn` *Values* * z/OS ** 1 - 4095 *Default* * z/OS ** `SPACE1=4` *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ospace2_05fb.html",
"OSPACE2",
"[[CLEP.COMMAND.FLAM.OSPACE2]] ==== OSPACE2 indexterm:[Parameter, OSPACE2, FLAM.OSPACE2] Secondary space request/allocation for output file in Megabytes (z/OS only). NOTE: This value must only be specified if the FLAMFILE is non       z/OS compressed or you need a special value. A z/OS       FLAMFILE has stored the total space amount in the file       header and uses this value for allocation on decompression. Syntax restrictions for FLAMv4 or older: * z/OS ** `OPACE2=nn` *Values* * z/OS ** 1 - 4095 *Default* * z/OS ** `SPACE2=50` *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-unit_0c8c.html",
"UNIT",
"[[CLEP.COMMAND.FLAM.UNIT]] ==== UNIT indexterm:[Parameter, UNIT, FLAM.UNIT] Unit for FLAMFILE allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `UNIT=unit name` *Values* * z/OS ** e.g. SYSDA, 3390 *Default* * z/OS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ounit_9cdd.html",
"OUNIT",
"[[CLEP.COMMAND.FLAM.OUNIT]] ==== OUNIT indexterm:[Parameter, OUNIT, FLAM.OUNIT] Unit for output file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `OUNIT=output file name` *Values* * z/OS ** e.g. SYSDA, 3390 *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-storclass_af74.html",
"STORCLASS",
"[[CLEP.COMMAND.FLAM.STORCLASS]] ==== STORCLASS indexterm:[Parameter, STORCLASS, FLAM.STORCLASS] Storage class for FLAMFILE file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `STORCLAS=name` ** `STORC=name` *Values* * z/OS ** name of the SMS storage class *Default* * z/OS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ostorclass_22c7.html",
"OSTORCLASS",
"[[CLEP.COMMAND.FLAM.OSTORCLASS]] ==== OSTORCLASS indexterm:[Parameter, OSTORCLASS, FLAM.OSTORCLASS] Storage class for output file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `OSTORCLAS=name` ** `OSTORC=name` *Values* * z/OS ** name of the SMS storage class *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-volume_a8fc.html",
"VOLUME",
"[[CLEP.COMMAND.FLAM.VOLUME]] ==== VOLUME indexterm:[Parameter, VOLUME, FLAM.VOLUME] Volume for FLAMFILE allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `VOLUME=name` ** `VOL=name` *Values* * z/OS ** name of the volume (e.g. SYSWK1) *Default* * z/OS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ovolume_90b9.html",
"OVOLUME",
"[[CLEP.COMMAND.FLAM.OVOLUME]] ==== OVOLUME indexterm:[Parameter, OVOLUME, FLAM.OVOLUME] Volume for output file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `VOLUME=name of volume` ** `VOL=name of volume` *Values* * z/OS ** name of the volume (e.g. SYSWK1) *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-dataclass_64aa.html",
"DATACLASS",
"[[CLEP.COMMAND.FLAM.DATACLASS]] ==== DATACLASS indexterm:[Parameter, DATACLASS, FLAM.DATACLASS] Data storage class for FLAMFILE allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * Z/OS ** `DATACLAS=name of the SMS data storage class` ** `DATAC=name of the SMS data storage class` *Values* * Z/OS ** name of the SMS data storage class *Default* * Z/OS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odataclass_da29.html",
"ODATACLASS",
"[[CLEP.COMMAND.FLAM.ODATACLASS]] ==== ODATACLASS indexterm:[Parameter, ODATACLASS, FLAM.ODATACLASS] Data storage class for output file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `ODATACLAS=name` ** `ODATAC=name` *Values* * z/OS ** name of the SMS data storage class *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-mgmtclass_fac1.html",
"MGMTCLASS",
"[[CLEP.COMMAND.FLAM.MGMTCLASS]] ==== MGMTCLASS indexterm:[Parameter, MGMTCLASS, FLAM.MGMTCLASS] Management class for FLAMFILE allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `MGMTCLAS=classname` ** `MGMTC=classname` *Values* * z/OS ** name of the SMS management class *Default* * z/OS ** none *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-omgmtclass_2c2a.html",
"OMGMTCLASS",
"[[CLEP.COMMAND.FLAM.OMGMTCLASS]] ==== OMGMTCLASS indexterm:[Parameter, OMGMTCLASS, FLAM.OMGMTCLASS] Management class for output file allocation (z/OS only). Syntax restrictions for FLAMv4 or older: * z/OS ** `OMGMTCLAS =name` ** `OMGMTC=name` *Value* * z/OS ** name of the SMS management class *Default* * z/OS ** none *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-dsorg_79d7.html",
"DSORG",
"[[CLEP.COMMAND.FLAM.DSORG]] ==== DSORG indexterm:[Parameter, DSORG, FLAM.DSORG] File organization for compressed file (z/OS only). See also parameter <<CLEP.COMMAND.FLAM.RECFORMAT,RECFORMAT>>. NOTE: If the compressed file shall be generated as index sequential       file, a VSAM-KSDS-file must be created. Syntax restrictions for FLAMv4 or older: * z/OS ** `DSORG=PS/ESDS/KSDS/LDS/RRDS`   (FCBTYPE=file control block type) ** `DS=PS/ESDS/KSDS/LDS/RRDS` *Values* * z/OS ** `PS` - sequential ** `ESDS` - VSAM-ESDS ** `KSDS - VSAM-KSDS ** `LDS` - VDSAM-LDS ** `RRDS` - VSAM-RRDS *Default* * z/OS ** `PS` *Valid for* * compression * `SEQ - Sequential access [DEFAULT]` * `PS - Sequential access [DEFAULT]` * `EDS - Entry data set (VSAM-ESDS)` * `ESDS - Entry data set (VSAM-ESDS)` * `KDS - Keyed data set (VSAM-KSDS)` * `KSDS - Keyed data set (VSAM-KSDS)` * `RDS - Relative data set (VSAM-RRDS)` * `RRDS - Relative data set (VSAM-RRDS)` * `LDS - Linear data set (VSAM-LDS)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-idsorg_aff2.html",
"IDSORG",
"[[CLEP.COMMAND.FLAM.IDSORG]] ==== IDSORG indexterm:[Parameter, IDSORG, FLAM.IDSORG] File organization for input file (z/OS only). See also parameter <<CLEP.COMMAND.FLAM.INRECFORMAT,INRECFORMAT>>. NOTE: This parameter is not necessary for catalogued files in z/OS. Syntax restrictions for FLAMv4 or older: * z/OS ** `IDSORG=PS/ESDS/KSDS/LDS/RRDS`   (FCBTYPE=file control block type) *Values* * z/OS ** `PS` - sequential ** `ESDS` - VSAM-ESDS ** `KSDS` - VSAM-KSDS ** `LDS` - VDSAM-LDS ** `RRDS` - VSAM-RRDS *Default* * z/OS ** `PS` *Valid for* * compression * `SEQ - Sequential data set [DEFAULT]` * `PS - Sequential data set [DEFAULT]` * `LIB - Library (ZOS-PDSE)` * `PDS - Partitioned data set (ZOS-PDS)` * `USS - UNIX files (path based)` * `EDS - Entry data set (VSAM-ESDS)` * `ESDS - Entry data set (VSAM-ESDS)` * `KDS - Keyed data set (VSAM-KSDS)` * `KSDS - Keyed data set (VSAM-KSDS)` * `RDS - Relative data set (VSAM-RRDS)` * `RRDS - Relative data set (VSAM-RRDS)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odsorg_d104.html",
"ODSORG",
"[[CLEP.COMMAND.FLAM.ODSORG]] ==== ODSORG indexterm:[Parameter, ODSORG, FLAM.ODSORG] File organization for output file (z/OS only). + See also parameter <<CLEP.COMMAND.FLAM.OUTRECFORMAT,OUTRECFORMAT>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `ODSORG=PS/ESDS/KSDS/LDS/RRDS`   (FCBTYPE=file control block type) *Values* * z/OS ** `PS` - sequential ** `ESDS` - VSAM-ESDS ** `KSDS` - VSAM-KSDS ** `LDS` - VDSAM-LDS ** `RRDS` - VSAM-RRDS *Default* * z/OS ** `PS` *Valid for* * compression * `SEQ - Sequential data set [DEFAULT]` * `PS - Sequential data set [DEFAULT]` * `LIB - Library (ZOS-PDSE)` * `PDS - Partitioned data set (ZOS-PDS)` * `USS - UNIX files (path based)` * `EDS - Entry data set (VSAM-ESDS)` * `ESDS - Entry data set (VSAM-ESDS)` * `KDS - Keyed data set (VSAM-KSDS)` * `KSDS - Keyed data set (VSAM-KSDS)` * `RDS - Relative data set (VSAM-RRDS)` * `RRDS - Relative data set (VSAM-RRDS)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-iclosdisp_aa14.html",
"ICLOSDISP",
"[[CLEP.COMMAND.FLAM.ICLOSDISP]] ==== ICLOSDISP indexterm:[Parameter, ICLOSDISP, FLAM.ICLOSDISP] Final processing for tape input file. NOTE: Currently ignored. Control of final processing may be done       via JCL (DD card). Syntax restrictions for FLAMv4 or older: * z/OS ** `ICLOSDISP=REWIND/UNLOAD/LEAVE` ** `ICLO=REWIND/UNLOAD/LEAVE` *Values* * z/OS * `REWIND` - Rewind of tape to tape start * `UNLOAD` - Rewind of tape and unload * `LEAVE` -No rewind *Default* * z/OS ** `REWIND` *Valid for* * compression * `REWIND - Rewind the tape to the beginning` * `UNLOAD - Rewind the tape and unload it` * `LEAVE - Do not rewind` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-closdisp_72bb.html",
"CLOSDISP",
"[[CLEP.COMMAND.FLAM.CLOSDISP]] ==== CLOSDISP indexterm:[Parameter, CLOSDISP, FLAM.CLOSDISP] Final processing for compressed file on tape (z/OS only). NOTE: Currently ignored. Control of final processing may be done via JCL       (DD card). Syntax restrictions for FLAMv4 or older: * z/OS ** `CLOSDISP=REWIND/UNLOAD/LEAVE` ** `CLO=REWIND/UNLOAD/LEAVE` *Values* * z/OS ** `REWIND` - Rewind of tape to tape start ** `UNLOAD` - Rewind of tape and unload ** `LEAVE` - No rewind *Default* * z/OS ** `REWIND` *Valid for* * compression * decompression * `REWIND - Rewind the tape to the beginning` * `UNLOAD - Rewind the tape and unload it` * `LEAVE - Do not rewind` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-oclosdisp_3632.html",
"OCLOSDISP",
"[[CLEP.COMMAND.FLAM.OCLOSDISP]] ==== OCLOSDISP indexterm:[Parameter, OCLOSDISP, FLAM.OCLOSDISP] Final processing of tape output file. NOTE: Currently not supported. Please use JCL (DD statement)       to control final processing. Syntax restrictions for FLAMv4 or older: * z/OS ** `CLOSDISP=REWIND/UNLOAD/LEAVE` ** `CLO=REWIND/UNLOAD/LEAVE` *Values* * z/OS ** `REWIND` - Rewind of tape to tape start ** `UNLOAD` - Rewind of tape and unload ** `LEAVE` - No rewind *Default* * z/OS ** REWIND *Valid for* * decompression * `REWIND - Rewind the tape to the beginning` * `UNLOAD - Rewind the tape and unload it` * `LEAVE - Do not rewind` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-disps_011b.html",
"DISPS",
"[[CLEP.COMMAND.FLAM.DISPS]] ==== DISPS indexterm:[Parameter, DISPS, FLAM.DISPS] DISP-Status of the FLAMFILE (z/OS only). The DISP parameter is part of the DD card in JCL. NOTE: For more information see z/OS JCL manual under DD statement.       This parameter is ignored when the FLAMFILE is allocated via       JCL. FLAM recognizes itself if a file is new or cataloged (old). JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.DISPN,DISPN>> and <<CLEP.COMMAND.FLAM.DISPA,DISPA>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `DISPS=SHR/OLD/MOD/NEW` *Values* * z/OS ** `SHR` - shareable ** `OLD` - exclusiv ** `MOD` - extend ** `NEW` - new file *Default* * z/OS ** `SHR` for input, `OLD` or `NEW` on output *Valid for* * decompression * `NEW - Disposition status NEW (brand new file)` * `SHR - Disposition status SHR (read exiting  file)` * `MOD - Disposition status MOD (append/modify file)` * `OLD - Disposition status OLD (overwrite existing file)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-dispn_e00c.html",
"DISPN",
"[[CLEP.COMMAND.FLAM.DISPN]] ==== DISPN indexterm:[Parameter, DISPN, FLAM.DISPN] Normal disposition of the FLAMFILE (z/OS only). This parameter is ignored when the file is allocated via JCL. The DISP parameter is part of the DD card in JCL. JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.DISPS,DISPS>> and <<CLEP.COMMAND.FLAM.DISPA,DISPA>>. NOTE: This parameter is ignored when the FLAMFILE is allocated via JCL. * z/OS ** `DISPN=CATLG/DELETE/KEEP/UNCATLG` *Values* * z/OS ** `CATLG` - catalog ** `DELETE` - delete ** `KEEP` - keep ** `UNCATLG` - uncatalog *Default* * z/OS ** none *Valid for* * decompression * `CATALOG - Close disposition catalog` * `CATLG - Close disposition catalog` * `DELETE - Close disposition delete` * `KEEP - Close disposition keep` * `UNCATALOG - Close disposition uncatalog` * `UNCATLG - Close disposition uncatalog` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-dispa_eb11.html",
"DISPA",
"[[CLEP.COMMAND.FLAM.DISPA]] ==== DISPA indexterm:[Parameter, DISPA, FLAM.DISPA] Abnormal termination disposition (JCL) of FLAMFILE (z/OS only). The DISP parameter is part of the DD card in JCL. JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.DISPS,DISPS>> and <<CLEP.COMMAND.FLAM.DISPN,DISPN>>. NOTE: This parameter is ignored when the FLAMFILE is allocated via JCL. * z/OS ** `DISPA=CATLG/DELETE/KEEP/UNCATLG` *Values* * z/OS ** `CATLG` - catalog ** `DELETE` - delete ** `KEEP` - keep ** `UNCATLG` - uncatalog *Default* * z/OS ** none *Valid for* * compression * decompression * `CATALOG - Close disposition catalog` * `CATLG - Close disposition catalog` * `DELETE - Close disposition delete` * `KEEP - Close disposition keep` * `UNCATALOG - Close disposition uncatalog` * `UNCATLG - Close disposition uncatalog` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odisps_0b80.html",
"ODISPS",
"[[CLEP.COMMAND.FLAM.ODISPS]] ==== ODISPS indexterm:[Parameter, ODISPS, FLAM.ODISPS] Disposition-Status (JCL) of FLAMOUT file (z/OS only). The DISP parameter is part of the DD card in JCL. NOTE: For more information see z/OS JCL manual under DD statement.       This parameter is ignored when the file is allocated via JCL.       FLAM recognizes itself if a file is new or cataloged (old). JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.ODISPN,ODISPN>> and <<CLEP.COMMAND.FLAM.ODISPA,ODISPA>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `ODISPS=SHR/OLD/MOD/NEW` *Values* * z/OS ** `SHR` - shareable ** `OLD` - exclusiv ** `MOD` - extend ** `NEW` - new file *Default* * z/OS ** `SHR` for input, `OLD` or `NEW` on output. *Valid for* * decompression * `NEW - Disposition status NEW (brand new file)` * `SHR - Disposition status SHR (read exiting  file)` * `MOD - Disposition status MOD (append/modify file)` * `OLD - Disposition status OLD (overwrite existing file)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odispn_3927.html",
"ODISPN",
"[[CLEP.COMMAND.FLAM.ODISPN]] ==== ODISPN indexterm:[Parameter, ODISPN, FLAM.ODISPN] Normal disposition of the FLAMOUT file (z/OS only). The DISP parameter is part of the DD card in JCL. NOTE: This parameter is ignored when the file is allocated via JCL. JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.ODISPS,ODISPS>> and <<CLEP.COMMAND.FLAM.ODISPA,ODISPA>>. * z/OS ** `ODISPN=CATLG/DELETE/KEEP/UNCATLG` *Values* * z/OS ** `CATLG` - catalog ** `DELETE` - delete ** `KEEP` - keep ** `UNCATLG` - uncatalog *Default* * z/OS ** none *Valid for* * decompression * `CATALOG - Close disposition catalog` * `CATLG - Close disposition catalog` * `DELETE - Close disposition delete` * `KEEP - Close disposition keep` * `UNCATALOG - Close disposition uncatalog` * `UNCATLG - Close disposition uncatalog` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odispa_27d6.html",
"ODISPA",
"[[CLEP.COMMAND.FLAM.ODISPA]] ==== ODISPA indexterm:[Parameter, ODISPA, FLAM.ODISPA] Abnormal termination disposition (JCL) of FLAMOUT file (z/OS only). The DISP parameter is part of the DD card in JCL. JCL-Syntax restrictions for FLAMv4 or older: See also parameters <<CLEP.COMMAND.FLAM.ODISPS,ODISPS>> and <<CLEP.COMMAND.FLAM.ODISPN,ODISPN>>. NOTE: This parameter is ignored when the FLAMFILE is allocated via JCL. * z/OS ** `ODISPA=CATLG/DELETE/KEEP/UNCATLG` *Values* * z/OS ** `CATLG` - catalog ** `DELETE` - delete ** `KEEP` - keep ** `UNCATLG` - uncatalog *Default* * z/OS ** none *Valid for* * decompression * `CATALOG - Close disposition catalog` * `CATLG - Close disposition catalog` * `DELETE - Close disposition delete` * `KEEP - Close disposition keep` * `UNCATALOG - Close disposition uncatalog` * `UNCATLG - Close disposition uncatalog` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-keydisp_c529.html",
"KEYDISP",
"[[CLEP.COMMAND.FLAM.KEYDISP]] ==== KEYDISP indexterm:[Parameter, KEYDISP, FLAM.KEYDISP] Key processing during decompression (z/OS only). NOTE: This parameter allows or simplifies the automatic conversion       of sequential files into index sequential files and vice versa. See also parameter <<CLEP.COMMAND.FLAM.KEYLENGTH,KEYLENGTH>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `KEYDISP=OLD/DEL/NEW` ** `KEYD=OLD/DEL/NEW` *Values* * z/OS ** `OLD` - The records of the original file are reconstructed as they            were read in (key + data). ** `DEL` - If the original file has a key length unequal 0, the key is            removed. ** `NEW` - If the output file has a key length unequal 0, a key is            generated at the key position in the specified key length.            The key is generated from a record sequence number (16            characters max.). *Default* * z/OS ** `OLD` *Valid for* * decompression * `OLD - Key disposition OLD (keep the existing key)` * `NEW - Key disposition NEW (insert record number as key)` * `DEL - Key disposition DEL (delete key from record)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-keylength_d459.html",
"KEYLENGTH",
"[[CLEP.COMMAND.FLAM.KEYLENGTH]] ==== KEYLENGTH indexterm:[Parameter, KEYLENGTH, FLAM.KEYLENGTH] Key length of an index sequential compressed file (z/OS only). NOTE: In an index sequential compressed file the key must be       positioned at the beginning of the record. The key length       should be equal to the sum of the length of all partial       keys of the original file + 1. However, it is allowed to       violate this rule. If sequential data is compressed into an       index sequential compressed file, a key length of 5 bytes       is sufficient. See also parameter <<CLEP.COMMAND.FLAM.KEYDISP,KEYDISP>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `KEYLEN=n` ** `KEYL=n` *Values* * z/OS ** 0, 1 - 255 *Default* * z/OS ** 0 (no key) *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-okeyposition_9b11.html",
"OKEYPOSITION",
"[[CLEP.COMMAND.FLAM.OKEYPOSITION]] ==== OKEYPOSITION indexterm:[Parameter, OKEYPOSITION, FLAM.OKEYPOSITION] Key position of output file (z/OS only). NOTE: This value must only be specified if the key length differs       from the original file. The position of the record key is       defined independently from the properties of a particular       operating system as the relative position within the data       part of the record. The first byte has position 1. See also parameter <<CLEP.COMMAND.FLAM.OKEYLENGTH,OKEYLENGTH>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `OKEYPOS=n` ** `OKEYP=n` *Values* * z/OS ** 0, 1 - (record length - key length + 1) *Default* * z/OS ** 1 or the value from the file header. *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-okeylength_4bd2.html",
"OKEYLENGTH",
"[[CLEP.COMMAND.FLAM.OKEYLENGTH]] ==== OKEYLENGTH indexterm:[Parameter, OKEYLENGTH, FLAM.OKEYLENGTH] Key length of output original file (z/OS only). NOTE: This value must only be specified if the key length differs       from the original file. See also parameter <<CLEP.COMMAND.FLAM.OKEYPOSITION,OKEYPOSITION>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `OKEYLEN=n` ** `OKEYL=n` *Values* * z/OS ** 0, 1-255 *Default* * z/OS ** 8 or the value from the file header *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-orgkeypos_18af.html",
"ORGKEYPOS",
"[[CLEP.COMMAND.FLAM.ORGKEYPOS]] ==== ORGKEYPOS indexterm:[Parameter, ORGKEYPOS, FLAM.ORGKEYPOS] Specification of key position for key sequential datasets (KSDS); z/OS only. If a *decompression process* contains the parameter `ORGKEYPOS` in order to create a key sequential dataset (KSDS), the specification is used to find the place, where the index field starts in order to create the necessary VSAM-KSDS key. This parameter is used together with parameter <<CLEP.COMMAND.FLAM.ORGKEYLEN,ORGKEYLEN>>. Syntax restrictions for FLAMv4 or older: * `ORGKEYPOS=position` * `ORGKEYPO=position` * `ORGKEYP=position` *Values* * between 1 and  max. record length *Default* * no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-orgkeylen_548e.html",
"ORGKEYLEN",
"[[CLEP.COMMAND.FLAM.ORGKEYLEN]] ==== ORGKEYLEN indexterm:[Parameter, ORGKEYLEN, FLAM.ORGKEYLEN] Specification of key length for key sequential datasets (KSDS); z/OS only. If a *decompression process* contains the parameter `ORGKEYLEN` in order to create a key sequential dataset (KSDS), the specification is used to define the length of the used index field. This parameter is used together with parameter <<CLEP.COMMAND.FLAM.ORGKEYPOS,ORGKEYPOS>>. Syntax restrictions for FLAMv4 or older: * `ORGKEYLEN=length` * `ORGKEYL=length` *Values* * length in bytes, > 0 and < record length *Default* * no default *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ikeyposition_4053.html",
"IKEYPOSITION",
"[[CLEP.COMMAND.FLAM.IKEYPOSITION]] ==== IKEYPOSITION indexterm:[Parameter, IKEYPOSITION, FLAM.IKEYPOSITION] Key position of input file (z/OS only). NOTE: This parameter is not necessary for catalogued files in MVS.       The key position specified in the catalogue is used. See also parameter <<CLEP.COMMAND.FLAM.IKEYLENGTH,IKEYLENGTH>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `IKEYPOS=n` ** `IKEYP=n` *Values* * z/OS ** 0, 1 - (record length - key length). *Default* * z/OS ** 1 if key exists, 0 otherwise *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-ikeylength_ed6c.html",
"IKEYLENGTH",
"[[CLEP.COMMAND.FLAM.IKEYLENGTH]] ==== IKEYLENGTH indexterm:[Parameter, IKEYLENGTH, FLAM.IKEYLENGTH] Key length of input file (z/OS only). NOTE: This parameter is not necessary for catalogued files in MVS.       The key length specified in the catalogue is used. See also parameter <<CLEP.COMMAND.FLAM.IKEYPOSITION,IKEYPOSITION>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `IKEYLEN=n` ** `IKEYL=n` *Values* * z/OS ** 0, 1-255 *Default* * z/OS ** No key *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-device_cb3c.html",
"DEVICE",
"[[CLEP.COMMAND.FLAM.DEVICE]] ==== DEVICE indexterm:[Parameter, DEVICE, FLAM.DEVICE] Device assignment for compressed file (z/OS only). NOTE: This parameter is not needed for catalogued files under z/OS. The device type is automatically assigned by the operating system. If the user exit for I/O shall be activated, `DEVICE=USER` must be specified. Syntax restrictions for FLAMv4 or older: * z/OS ** `DEVICE=DISK/TAPE/FLOPPY/STREAMER/USER` ** `DEV=DISK/TAPE/FLOPPY/STREAMER/USER` *Values* * z/OS ** `DISK` - disc unit ** `TAPE` - tape unit ** `FLOPPY` - floppy disc drive ** `STREAMER` - tape streamer ** `USER` - User specific I/O interface *Default* * z/OS ** `DISK` *Valid for* * compression * decompression * `FILE - Write to a file (equal to disk)` * `DISK - Write to a disk (equal to file)` * `TAPE - Write to a tape` * `FLOPPY - Write to a floppy` * `STREAMER - Write to a streamer tape` * `USER - Use user IO` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-idevice_9437.html",
"IDEVICE",
"[[CLEP.COMMAND.FLAM.IDEVICE]] ==== IDEVICE indexterm:[Parameter, IDEVICE, FLAM.IDEVICE] Device assignment for input file (z/OS only). NOTE: This parameter is not needed for catalogued files under z/OS.       The device type is automatically assigned by the operating system.       If the user exit for I/O shall be activated, `IDEVICE=USER`       must be specified. Syntax restrictions for FLAMv4 or older: * z/OS ** `IDEVICE=DISK/TAPE/FLOPPY/STREAMER/USER` ** `IDEV=DISK/TAPE/FLOPPY/STREAMER/USER` *Values* * z/OS ** `DISK` - disc unit ** `TAPE` - tape unit ** `FLOPPY` - floppy disc drive ** `STREAMER` - tape streamer ** `USER` - User specific I/O interface *Default* * z/OS ** `DISK` *Valid for* * compression * `FILE - Write to a file (equal to disk)` * `DISK - Write to a disk (equal to file)` * `TAPE - Write to a tape` * `FLOPPY - Write to a floppy` * `STREAMER - Write to a streamer tape` * `USER - Use user IO` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-odevice_f535.html",
"ODEVICE",
"[[CLEP.COMMAND.FLAM.ODEVICE]] ==== ODEVICE indexterm:[Parameter, ODEVICE, FLAM.ODEVICE] Device assignment for output file (z/OS only). NOTE: This parameter is not needed for catalogued files under z/OS.       The device type is automatically assigned by the operating system.       If the user interface for I/O shall be activated, ODEVICE= USER       must be specified Syntax restrictions for FLAMv4 or older: * z/OS ** `ODEVICE=DISK/TAPE/FLOPPY/STREAMER/USER` ** `ODEV=DISK/TAPE/FLOPPY/STREAMER/USER` *Values* * z/OS ** `DISK` - disc unit ** `TAPE` - tape unit ** `FLOPPY` - floppy disc drive ** `STREAMER` - tape streamer ** `USER` - User specific I/O interface *Default* * z/OS ** DISK *Valid for* * decompression * `FILE - Write to a file (equal to disk)` * `DISK - Write to a disk (equal to file)` * `TAPE - Write to a tape` * `FLOPPY - Write to a floppy` * `STREAMER - Write to a streamer tape` * `USER - Use user IO` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-splitmode_66a1.html",
"SPLITMODE",
"[[CLEP.COMMAND.FLAM.SPLITMODE]] ==== SPLITMODE indexterm:[Parameter, SPLITMODE, FLAM.SPLITMODE] Mode for splitting a FLAMFILE (z/OS only). NOTE: Splitting of FLAMFILEs has been introduced in FLAM V4.0 and       is not compatible to older versions. +       The split information is stored in the FLAMFILE. So it is       not necessary to use any parameter on decompression. See also parameters <<CLEP.COMMAND.FLAM.SPLITNUMBER,SPLITNUMBER>> and <<CLEP.COMMAND.FLAM.SPLITSIZE,SPLITSIZE>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `SPLITMODE=NONE/SERIAL/PARALLEL` ** `SPLITM=NONE/SERIAL/PARALLEL` *Values* * z/OS ** `NONE` - no split ** `SERIAL` - serial split ** `PARALELL` - parallel split *Default* * z/OS ** `NONE` *Valid for* * compression * `NONE - No splitting (default)` * `SERIAL - Serial splitting (after 1-4096 Megabyte)` * `PARALLEL - Parallel splitting (in 2, 3 or 4 files)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-splitnumber_8fa7.html",
"SPLITNUMBER",
"[[CLEP.COMMAND.FLAM.SPLITNUMBER]] ==== SPLITNUMBER indexterm:[Parameter, SPLITNUMBER, FLAM.SPLITNUMBER] Number of fragments on parallel split (z/OS only). NOTE: The information is stored in the FLAMFILE. So it is not necessary       to use any parameter on decompression. All fragments have to be       catalogued and ready to read.       It is not possible, to decompress one fragment alone.       Using this parameter requires SPLITMODE=PARALLEL. See also parameters <<CLEP.COMMAND.FLAM.SPLITMODE,SPLITMODE>> and <<CLEP.COMMAND.FLAM.SPLITSIZE,SPLITSIZE>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `SPLITNUMBER=2-4` ** `SPLITN=2-4` *Values* * z/OS ** 2 - 4 number of simultaneously written files *Default* * z/OS ** 4 *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-splitsize_ff43.html",
"SPLITSIZE",
"[[CLEP.COMMAND.FLAM.SPLITSIZE]] ==== SPLITSIZE indexterm:[Parameter, SPLITSIZE, FLAM.SPLITSIZE] Amount in MB of a fragment on serial split (z/OS only). NOTE: The number of created files depends on the amount of compressed       data. The information is stored in the FLAMFILE.       Using this parameter requires SPLITMODE=SERIAL. See also parameters <<CLEP.COMMAND.FLAM.SPLITMODE,SPLITMODE>> and <<CLEP.COMMAND.FLAM.SPLITNUMBER,SPLITNUMBER>>. Syntax restrictions for FLAMv4 or older: * z/OS ** `SPLITSIZE=n` ** `SPLITS=n` *Values* * z/OS ** 1 - 4095 *Default* * z/OS ** 100 *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-flamddn_e8e4.html",
"FLAMDDN",
"[[CLEP.COMMAND.FLAM.FLAMDDN]] ==== FLAMDDN indexterm:[Parameter, FLAMDDN, FLAM.FLAMDDN] With this parameter the DD-NAME for the compressed FLAMFILE in the DD JCL-command can be changed. It is the symbolic DD filename for the normally used compressed FLAMFILE (z/OS only). The *DD-NAME* of this compressed file is `FLAMFILE` by default and can be modified using parameter `FLAMDDN=<name>`. All output is written to a FLAM compressed file by default: or Syntax restrictions for FLAMv4 or older: * z/OS ** `FLAMDDN=filename` ** `FLAMD=filename` ** Note: This parameter allows to change the DD name of the DD          command. For decompression, `>` before the DD name means          that the file contains a list of FLAMFILE names. *Values* * z/OS ** DD-NAME with max. 8 characters. ** > DD-NAME with max. 7 characters (decompression) *Default* * z/OS ** FLAMFILE DD ...... *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-iddn_2e15.html",
"IDDN",
"[[CLEP.COMMAND.FLAM.IDDN]] ==== IDDN indexterm:[Parameter, IDDN, FLAM.IDDN] With this parameter the DD-NAME for the FLAM input file in the DD JCL-command can be changed. It is the symbolic DD file name for the normaly used FLAM input file (z/OS only). The DD-NAME of this FLAM input file is `FLAMIN` by default and can be modified using parameter `IDDN=<name>`. All input is read by default from FLAM input file: or Syntax restrictions for FLAMv4 or older: * z/OS ** `IDDN=filename` *** Note: This parameter allows to change the DD-NAME of the DD command.           A '>' before the filename means the file contains a list           of files to be compressed. *Values* * z/OS ** DD-NAME with max. 8 characters. ** > DD-NAME with max. 7 characters *Default* * z/OS **  FLAMIN DD ...... *Valid for* * compression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-oddn_4343.html",
"ODDN",
"[[CLEP.COMMAND.FLAM.ODDN]] ==== ODDN indexterm:[Parameter, ODDN, FLAM.ODDN] With this parameter the DD-NAME for the FLAM output file in the DD JCL-command can be changed. It is the symbolic DD file name for the normaly used FLAM output file (z/OS only). The DD-NAME of this FLAM output file is `FLAMOUT` by default and can be modified using parameter `ODDN=<name>`. All output is written by default to FLAM output file: or Syntax restrictions for FLAMv4 or older: * z/OS ** `ODDN=file name` *** Note: With this parameter the DD-NAME in the DD command can be changed. *Values* * z/OS ** DD-NAME with max. 8 characters *Default* * z/OS ** FLAMOUT DD ...... *Valid for* * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-msgddn_5e63.html",
"MSGDDN",
"[[CLEP.COMMAND.FLAM.MSGDDN]] ==== MSGDDN indexterm:[Parameter, MSGDDN, FLAM.MSGDDN] With this parameter the DD-NAME for the FLAM message file in the DD JCL-command can be changed. It is the symbolic DD file name for the normaly used message file (z/OS only). FLAM messages are written into a catalogued file. The DD-NAME of this file is `FLPRINT` by default and can be modified using parameter `MSGDDN=<name>`. All messages are written by default into message file: or Parameters in the same context: <<CLEP.COMMAND.FLAM.MSGFILE,MSGFILE>> and <<CLEP.COMMAND.FLAM.MSGDISP,MSGDISP>> Syntax restrictions for FLAMv4 or older: * z/OS ** `MSGDDN=file name` ** `MSGDD=file name` *** Note: With this parameter the `DD-NAME FLPRINT` in the DD command           can be changed. *Values* * z/OS ** DD-NAME with max. 8 characters. *Default* * z/OS **  FLPRINT DD ...... *Valid for* * compression * decompression ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-remove_5b6e.html",
"REMOVE",
"[[CLEP.COMMAND.FLAM.REMOVE]] ==== REMOVE indexterm:[Parameter, REMOVE, FLAM.REMOVE] At compression, the switch causes the original file(s) (specified with flamin) to be deleted after having been successfully compressed. If any errors occur while a file is being compressed, the file is not deleted. The compression procedure can be repeated. At decompression, this parameter causes a FLAMFILE to be deleted after having been successfully decompressed. If any errors occur while the FLAMFILE is being decompressed, the file remains stored. This enables the errors to be analyzed and the original data to be restored as far as possible. If you don't extract all members from the FLAMFILE, then the FLAMFILE will still remain. Single members are not removed from the archive. The switch should not be used if the target is an archive file and wildcards are used. The original files are deleted as soon as they are written to the archive. If consecutive writes to the archive file (further input files or the archive trailer) fail, the archive may end up corrupted with original files deleted. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-from_d8ce.html",
"FROM",
"[[CLEP.COMMAND.FLAM.FROM]] ==== FROM indexterm:[Parameter, FROM, FLAM.FROM] The FROM code defines the encoding string or CCSID (Coded Character Set Identifier) for the input text stream. If no CCSID is provided, the records are handle binary. In other words, the FROM code activate text record handling. The character conversion module will be setup with EBCDIC new line to line feed handling and the combined character support is deactivated. If you need more functionality (user specific conversion, subset support, special casing, normalization, ...) please use another command. When reading and the DEFAULT key word is assigned, the input data's charset is auto-detected. The charsets below can currently be detected: * ASCII (the finally used code page depends on the language code) * EBCDIC (the finally used code page depends on the language code) * UTF-8    == US-ASCII * UTF-16LE == UCS-2LE (little-endian) * UTF-16BE == UCS-2BE (big-endian) * UTF-32LE == UCS-4LE (little-endian) * UTF-32BE == UCS-4BE (big-endian) If the data is encoded in ASCII or EBCDIC, the corresponding CCSID will be derived from the appropriate environment variable LANG. On non-ASCII systems, the ASCII-CCSID is derived from the language identifier (e.g. en, de, ...). The same holds true for non-EBCDIC systems if EBCDIC is detected. When ASCII is detected on an ASCII system, the CCSID from the LANG environment variable is used (e.g. de_DE.UTF-8 => UTF-8), if present. If the LANG variable contains no CCSID, then the language identifier is used (e.g. de_DE => ISO-8859-1). The same holds true for EBCDIC systems if EBCDIC is detected. On modern platforms, the CCSID for a resource may be saved in the file system and can also be given by the FIO module. In general, however, it is recommended to set this parameter to its correct value. For default handling, the keywords DEFAULT, ASCII and EBCDIC as well as (for multibyte characters) the BOM keywords stated below can be used to help finding the correct CCSID on read operations. The SYSTEM keyword selects the system specific CCSID (on EBCDIC systems the default EBCDIC and on ASCII the default ASCII CCSID). The keyword LOCAL works like DEFAULT but it prefers the real local character set if the same kind of character set (ASCII or EBCDIC) is detected. Character conversions at decompression operation are also possible, but in this case, the BOM keywords are not supported. When writing, the FROM CCSID is usually known and does not need to be specified. In order to use the BOM keywords, a BOM sign must be part of the input data. All unique BOM characters are supported in principle, but for UTF-16/USC-2 and UTF-32/UCS-4 the same BOM sign is used. You can define by yourself which family is used. To get a list of supported encoding strings, please use the command below: Depending on the platform, this function lists all known encoding strings. Some encodings may not be supported. To determine the supported CCSIDs and corresponding encoding strings and charsets please use: To define the CCSID, you can use one of the encoding strings or the decimal number for a CCSID displayed by the command above. Example: A numeric CCSID must start with a decimal digit. * `DEFAULT - Use default CCSID (auto-detect)` * `ASCII - Use default ASCII CCSID (environment)` * `EBCDIC - Use default EBCDIC CCSID (environment)` * `BOMUTF - Determine the correct UTF CCSID from byte order mark (BOM) only when reading` * `BOMUCS - Determine the correct UCS CCSID from byte order mark (BOM)only when reading` * `SYSTEM - Use system character set (environment/logical)` * `LOCAL - Use local character set (auto-detect + system/physical)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-chrmode_a12e.html",
"CHRMODE",
"[[CLEP.COMMAND.FLAM.CHRMODE]] ==== CHRMODE indexterm:[Parameter, CHRMODE, FLAM.CHRMODE] With the CHRMODE selection you can define how an invalid or incomplete character is handled inside of a unit by this component. All possible modes are listed at the end of this chapter. This CHRMODE is valid for the content of each unit (block or record). At the end of a unit there can be an incomplete character. Such a rest will be remove from the current and add at the beginning of the next record (if another method (not KEEP) required please use another conversion commend of FLCL). The rest of the last unit of a data field will be concatenated to the first unit of the next data field. ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-to_736f.html",
"TO",
"[[CLEP.COMMAND.FLAM.TO]] ==== TO indexterm:[Parameter, TO, FLAM.TO] The TO code defines the encoding string or CCSID for the output text stream. The default value of this CCSID at compression is UTF-8. For decompression, the default value is derived from the environment variable LANG. If LANG is not set, the default ASCII or EBCDIC system-codepage is used, depending on the platform. To get a list of supported encoding strings, please use the command below: Depending on the platform, this function lists all known encoding strings. Some encodings may not be supported. To determine the supported CCSIDs please use: To define the CCSID, you can use one of the encoding strings or the decimal number for a CCSID displayed by the command above. Example: A numeric CCSID must start with a decimal digit. Optionally, you can use one of the keywords below to use the system-specific default ASCII or EBCDIC CCSID. * `DEFAULT - Use default CCSID (UTF-8)` * `ASCII - Use default ASCII CCSID (environment)` * `EBCDIC - Use default EBCDIC CCSID (environment)` * `SYSTEM - Use system character set (environment/logical)` * `LOCAL - Use local character set (system/physical)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-dir_dcf1.html",
"DIR",
"[[CLEP.COMMAND.FLAM.DIR]] ==== DIR indexterm:[Object, DIR, FLAM.DIR] This object defines multiple switches that control how input files are found. This is especially important when using wildcards in input filenames. There are switches to enable recursion into subdirectories, following symbolic links, finding hidden files, recursion into archive files, include files on tapes, resolving aliases and enforcing to not leave the filesystem. If the recursive flag is set, the filename portion of the input file string is searched for recursively. If a directory path containing wildcards is present, the filename portion is searched for recursively in all paths that match the directory path pattern, e.g. '/path/.txt' matches my/path/hugo.txt, another/path/hugo.txt as well as my/path/subdir/hugo.txt. Without the recursive flag, the last file would not be found. If the archive switch is enabled, FLAMFILES, TARBALLS, ZIP files and other kinds of supported archives are searched. All the matching members are extracted. In other words, archives are interpreted like subdirectories if the flag is enabled. If the tape switch is enabled, then datasets stored on tapes or if migrated (if VOLSER = 'MIGRAT' or 'ARCIVE' on z/OS) files are searched. If the name of such a file matches the pattern, then it might occur that console input and a manual intervention is required to retrieve the respective dataset(s). A special behavior was implemented for z/OS for files on DASD, where a SVC27(OBTAIN) is issued for nonVSAM data sets (normal PS/PO). To collect also files if the SVC27 failed the obtain switch must be set. Normally this will result in a warning and completion code 4. If the obtain switch is not defined, files without a corresponding control blocks are skipped. If the link switch is enabled, symbolic links are followed (otherwise they are ignored). Links are mainly supported on modern file systems. For dataset aliases on mainframe systems, see the alias flag. With the alias switch enabled, datasets names which are aliases of the real dataset are resolved to their actual names (otherwise they are ignored). Dataset aliases only exist on mainframe systems. This flag has no effect on other platforms. If a transparent read method (e.g. read.auto()) is used, then the archive flag is enabled by default and cannot be disabled. * `SWITCH: LINK - Include symbolic links` * `SWITCH: ALIAS - Resolve data set aliases` * `SWITCH: HIDDEN - Include hidden files` * `SWITCH: RECURSIVE - Include sub directories` * `SWITCH: ARCHIVE - Include archives (FLAMFILEs, ZIP, ...)` * `SWITCH: ONEFILESYSTEM - Don't cross file system boundaries` * `SWITCH: TAPE - Include files deposited on tapes (or if migrated or archived)` * `SWITCH: OBTAIN - Obtain control blocks if DSAD (z/OS only, warning if SVC27 failed)` ",
"",
""
],
[
"flcl_manual-flcl_commands-flam-log_5400.html",
"LOG",
"[[CLEP.COMMAND.FLAM.LOG]] ==== LOG indexterm:[Object, LOG, FLAM.LOG] The LOG parameter allows flexible adjustment for the logging of messages. It is possible to specify the destination as well as which kind of message will be written. ",
"",
""
],
[
"flcl_manual-flcl_commands-grep_6e71.html",
"GREP",
"[[CLEP.COMMAND.GREP]] === GREP indexterm:[Command, GREP, GREP] The GREP command searches for patterns in files using a Perl compatible regular expression. Writing regular expressions may seem like a daunting task if you never did so before. You can find a tutorial that will get you started quickly here:    https://www.regular-expressions.info/quickstart.html Countless other tutorials and documentation for regular expressions can be found on the web. We recommend consulting these resources to familiarize yourself with regular expressions. Advanced users can find the complete syntax documentation for writing regular expression patterns by following this URL:    https://www.pcre.org/current/doc/html/pcre2pattern.html The GREP command support directory walk using file lists with wildcards. Die `DIR` object can be used to control the directory walk. Below is a simple example. The default output will be `STREAM`, but in this case the matches are written to the file `result.txt`. The GREP command is a simplification of the conversion subprogram using READ.AUTO() with default behavior except the parameter to specify the input. For each match a row with 5 columns is created and written with WRITE.TEXT(). The table format is as shown here: The row name is `GREP`. The column `PATTERN` contains the pattern used. The column `FILE` contains the complete URL with connection parameter, the filename and the optional member name. The column `LINE` contains the line number of the match record. The column `COLUMN` contains the character position in the line of the match record. The column `DATA` contains the matching record. For more information how to define row and column definitions see chapter <<flcl.table.support,Table Support>>. Compressed files are decompressed and encrypted files are decrypted, member of archives (ZIP, FLAM, ...) are searchable by using the corresponding switches in the `DIR` object. The match is done based on UTF-8 using neutral string format. Trailing whitespace is removed. The delimiter is not part of the data element used for matching. The `NOCASE' and `EXTENDED` switches can be used to control the matching algorithm. With the format parameter the output format can be defined. There are several default formats supported using a key word, but it is also possible to provide a row specification if a special format (other order of the columns or something like this) for the output is needed. The definitions of the default formats are: FORMAT=LIST FORMAT=CSV FORMAT=XML FORMAT=JSON (currently realized using the TVD support) FORMAT=GREP (like LIST but without the character offset in the line) These default formats can be used as a base for adjustments. In the example below the CSV format without the pattern and no headlines and the line number as first column is used. Here in JCL for z/OS: NOTE: The parameter string for the format must be enclosed in double quotation marks or better backticks (it is also known as backquote, grave, or grave accent) to be interpreted in total as one string. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be set as arguments in the command line (directly or per file) or as properties taken from the corresponding property file. * `STRING: INPUT['str'/STREAM/DUMMY...] - Name/URL of files to read [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: FROM='str'/DEFAULT/ASCII/EBCDIC/BOMUTF/BOMUCS/SYSTEM/LOCAL - Conversion from this CCSID` ** `DEFAULT - Use default CCSID (auto-detect)` ** `ASCII - Use default ASCII CCSID (environment)` ** `EBCDIC - Use default EBCDIC CCSID (environment)` ** `BOMUTF - Determine the correct UTF CCSID from byte order mark (BOM) only when reading` ** `BOMUCS - Determine the correct UCS CCSID from byte order mark (BOM)only when reading` ** `SYSTEM - Use system character set (environment/logical)` ** `LOCAL - Use local character set (auto-detect + system/physical)` * `STRING: PATTERN='str' - Pattern of regular expression for matching` * `SWITCH: NOCASE - Case insensitive matching` * `SWITCH: EXTENDED - Makes parser ignore whitespace and '#' comments within the pattern (can be used for readability)` * `STRING: FORMAT='str'/LIST/CSV/XML/JSON/GREP - Format definition for output (table object with 4 strings (PATTERN, FILE, LINE, DATA)) [LIST]` ** `LIST - Colon separated list (FILE:LINE:COLUMN:DATA)` ** `CSV - CSV format ('PATTERN','FILE','LINE','DATA')` ** `XML - XML format (<GREP PATTERN='pattern')>...</GREP>` ** `JSON - JSON format ({'GREP': { 'PATTERN': 'pattern' ...}})` ** `GREP - Colon separated list (FILE:LINE:DATA) without offset (like grep)` * `STRING: TO='str'/DEFAULT/ASCII/EBCDIC/SYSTEM/LOCAL - Conversion to this CCSID` ** `DEFAULT - Use default CCSID (UTF-8)` ** `ASCII - Use default ASCII CCSID (environment)` ** `EBCDIC - Use default EBCDIC CCSID (environment)` ** `SYSTEM - Use system character set (environment/logical)` ** `LOCAL - Use local character set (system/physical)` * `STRING: OUTPUT='str'/STREAM/DUMMY - Name/URL of file to write [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `SWITCH: NORUN - Don't run the command only show parsed parameter` ",
"",
""
],
[
"flcl_manual-flcl_commands-xchk_1105.html",
"XCHK",
"[[CLEP.COMMAND.XCHK]] === XCHK indexterm:[Command, XCHK, XCHK] The XCHK command can be used, for example, to analyze local or remote files or members inside local or remote archives of various formats (without unpacking to a temporary file), generate their hash values, etc. For example, you can generate or verify hash values before or after any conversion, i.e. after decoding, decryption, decompression or character conversion. The XCHK command was designed to provide the full capacity of the powerful Frankenstein Limes Universal Converter (FLUC) without the write overhead. It supports all parameters of XCNV INPUT. To get syntax information, please use: To get help for the parameters, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or per file) or through properties read from the corresponding property file. Reads remote file 'xzfile.xz' and calculates the checksum using the default hash algorithm. Reads local file 'xzfile.xz', decompresses it and calculates the checksum using the default hash algorithm. Reads remote file 'xzfile.xz', calculate the checksum using the SHA-1 hash algorithm, decompresses the file and calculates the checksum of the decompressed data using the MD5 hash algorithm. A simplified command for hash calculation and verification is available under the name 'HASH'. ",
"",
""
],
[
"flcl_manual-flcl_commands-hash_0971.html",
"HASH",
"[[CLEP.COMMAND.HASH]] === HASH indexterm:[Command, HASH, HASH] The HASH command calculates or verifies checksums for one or more local or remote input files. Files are read in binary format. Beside hex and binary Checksums in GNU and BSD formats are supported, which are compatible with common tools like 'sha1sum' and 'md5sum' on UNIX systems. This can be useful to verify files transferred between different systems, especially to or from mainframes. If possible, hardware acceleration is used for hash calculation. The HASH command prints only minimal log output. For a more verbose output (e.g. statistics), please use the log object (see examples below). To get syntax information, please use: To get help for the parameters, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or per file) or through properties read from the corresponding property file. Calculate the checksum using the default hash algorithm (SHA1) for the file 'fileToBeHashed.exe' in default format (GNU) to the default output file (LOG). Calculate the checksum using SHA-512 hash algorithm for the remote file 'fileToBeHashed.exe'. Calculate the checksum using SHA-512 hash algorithm for the file 'fileToBeHashed.exe' and write the result to the file 'outhash.txt'. Calculate the checksum using SHA-512 hash algorithm for the file 'fileToBeHashed.exe' and write the result to the file 'outhash.txt' in IBM-1141 CCSID. Verify the file 'fileToBeHashed.exe' using SHA-512 hash algorithm by comparing to the checksum stored in file 'outhash.txt'. Calculate the checksum using SHA-512 hash algorithm for the file 'fileToBeHashed.exe'. Print log output with the default filter (more output information) If you want to get the hash value of the decompressed content of a file without decompressing it to a temporary file, please take a look at the XCHK command. It is a much more powerful command to analyze input files. * `STRING: FILE['str'/STREAM/DUMMY...] - Name/URL of file to hash [''==origin.ext]` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `NUMBER: ALGO=MD5/RIPEMD128/RIPEMD160/SHA1/SHA224/SHA256/SHA384/SHA512/SHA3-224/SHA3-256/SHA3-384/SHA3-512/CRC8/CRC16/CRC24/CRC32/CRC32C/CRC40/CRC64 - Hash algorithm [SHA1]` ** `MD5 - Message-Digest Algorithm 5 (128 bit)` ** `RIPEMD128 - RACE Integrity Primitives Evaluation Message Digest (128 bit)` ** `RIPEMD160 - RACE Integrity Primitives Evaluation Message Digest (160 bit)` ** `SHA1 - Secure Hash Algorithm 1 (160 bit)` ** `SHA224 - Secure Hash Algorithm 2 (224 bit)` ** `SHA256 - Secure Hash Algorithm 2 (256 bit)` ** `SHA384 - Secure Hash Algorithm 2 (384 bit)` ** `SHA512 - Secure Hash Algorithm 2 (512 bit)` ** `SHA3-224 - Secure Hash Algorithm 3 (224 bit)` ** `SHA3-256 - Secure Hash Algorithm 3 (256 bit)` ** `SHA3-384 - Secure Hash Algorithm 3 (384 bit)` ** `SHA3-512 - Secure Hash Algorithm 3 (512 bit)` ** `CRC8 - Cyclic Redundancy Check (8 bit)` ** `CRC16 - Cyclic Redundancy Check (16 bit)` ** `CRC24 - Cyclic Redundancy Check (24 bit)` ** `CRC32 - Cyclic Redundancy Check (32 bit)` ** `CRC32C - Cyclic Redundancy Check (32 bit) Castagnoli variant` ** `CRC40 - Cyclic Redundancy Check (40 bit)` ** `CRC64 - Cyclic Redundancy Check (64 bit)` * `NUMBER: FORMAT=GNU/BSD/HEX/BIN - Define printout format [GNU]` ** `GNU - Write output in GNU style` ** `BSD - Write output in BSD style` ** `HEX - Write output as hexadecimal string` ** `BIN - Write output as binary value (only in output file)` * `STRING: OUTPUT='str'/STDOUT/STDERR - Name of the output file [LOG]` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` * `STRING: MEMBER='str' - Member name in GNU or BSD format [original name at read, target name at write]` * `NUMBER: BLKSIZ=num - Block size for read operations [65536]` ",
"",
""
],
[
"flcl_manual-flcl_commands-diff_0c3a.html",
"DIFF",
"[[CLEP.COMMAND.DIFF]] === DIFF indexterm:[Command, DIFF, DIFF] The DIFF command uses all reading capabilities of the CONV command to compare the clear net content of two data sources independent of the data format and representation. The comparison takes place on a logical level, based on the neutral FLAM5 elements. The DIFF function does not recognize insertions or deletions to/from either source. If is one byte or element more or less in the data of one of the sources, then the comparison will fail for the whole rest. This command does not support wildcards. As an example, the DIFF command can be used to compare the logical content of two XML files, where one file is in UTF-16LE and GZIP compressed and the other one is a host data set compressed, encrypted and in EBCDIC as FLAMFILE member. The DIFF command builds a neutral element list (UTF-8) and compares the parsed XML elements. The following features are supported: * Different kinds of remote access protocols (SSH, IP-Native, MQ-Series) * Different kinds of data sources (Files, Streams, Tables) * Different kinds of archive formats (ZIP, FLAMFILE, TAR) * Different kinds of I/O methods (Binary, Character, Text, Record, FLAM) * Different data encodings (HEX (Base16), Base32, Base64) * Different encryption methods (FLAM, PGP) * Different compression methods (GZIP, BZIP2, XZ) * Automatic decoding of data encodings during read operations * Auto-detection and decoding of length fields in data blocks * Auto-detection of character sets and language based conversion * Powerful character conversion based on CCSIDs with subset support and reporting * Different logical data formatting (BIN, TEXT, XML, ...) Depending on the data formats, a dedicated method is used, to compare the logical data records or streams. If a compare of the data formats makes no sense (XML with records or blocks) then an error is issued. For example: If you use read.file='filename' and compare.file='filename' and the first file is binary and the second file is the compressed version of this binary data, then a list of binary blocks with different length is built. In this case, it makes no sense to compare the elements (they are several blocks of different sizes). Hence, we compare the logical data stream and not the element list. If the first file contains records from a host data set and the second file contains text records with trailing whitespace and line delimiter (=rest element), then only the net record elements are compared. If the first file is block-oriented, then we include the remaining rest element from the text parser in a data stream compare. With the switch 'FULLY' you can activate additional checks depending on the data formats, for example: * TEXT/TEXT: Compare the remaining rest (trailing whitespace and delimiter) * ASA-RECORD/ASA-RECORD: Compare the control character * REL-RECORD/REL-RECORD: Compare the slot numbers * XML/XML: Compare comments, formatting (whitespace) and DTD If you want to verify that two files are identical independent of the platform and representation, then don't use this switch. If you specified a report file and activate the 'OFFSET' switch, then byte offsets and byte values for each difference are written to the report file. NOTE: This can cause a very large report file! To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for the command, please use: Parameters can be defined via command line (directly or by parameter file) or via properties taken from the corresponding property file This test reads text records and remaining rest elements from a text file which was compressed and for example encoded in ASCII-CP1252 and contains 0x0D0A as record delimiter. On the other side, an FBA host data set in EBCDIC is read and the ASA control characters are detached as attributes and trailing whitespeace is removed. Both files are converted to UTF-8 and only the net record elements are compared. This example requires and compares two XML files including comments, DTD and whitespace element by element. The report file contains the byte offsets for each difference. If you don't use the 'FULLY' switch, then a data stream compare is done, i.e. only tags, attributes and data elements are compared. The example reads a UNIX text from an LZMA compressed file and compares the text records with records from an FBA data set. In order to make this compare work, trailing whitespace must be removed from the UNIX file and padding characters from the fixed-block host file. The ASA control characters are detached by default. Both texts are converted to UTF-8 and only the net record data is compared. To simplify usage of this compare feature, there is a sample utility program SCFCUDIF. This program takes options and a list of filenames from command line for a logical compare of the resulting net data after decoding, decryption, decompression, character conversion and formatting as neutral FLAM elements. It uses the FLUCDIFF subprogram and writes the report to STDOUT. The first file is compared to all remaining files in the list and the program stops at the first error. You can use this utility program to compare every type of supported file format. It supports comma separated lists, so that it can be used on mainframe system. The example below is taken from the JOBLIB(SCFCUDIF) member of your FLAM installation. The sample program SCFCUDIF is available on all platforms and the source is part of each FLAM installation (sample or SRCLIBC). You can simply adjust this program and use the provided build instructions (makefile or SBUILD job) to make your own utility. * `SWITCH: FULLY - Make a fully compare of data and elements [FALSE]` * `SWITCH: OFFSET - Print byte offsets and values to report file [FALSE]` * `STRING: REPORT='str'/STDOUT/STDERR - Generate a report file [NONE]` ** `STDOUT - Write output to stdout` ** `STDERR - Write output to stderr` ",
"",
""
],
[
"flcl_manual-flcl_commands-util_fee9.html",
"UTIL",
"[[CLEP.COMMAND.UTIL]] === UTIL indexterm:[Command, UTIL, UTIL] The UTIL command executes a function on a wildcard-based list of files. This command allows to run simple system functions like deleting or listing files that match a provided pattern which may contain wildcards. This is mainly useful on mainframe systems, for example, to find all libraries containing a certain member or to delete any kind of file under a certain qualifier. The UTIL command prints only minimal log output. For a more verbose output (e.g. notices), please use the log object (see examples below). To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for a command, please use: Parameters can be defined by the command line (directly or per file) or by properties read from the corresponding property file. ",
"",
""
],
[
"flcl_manual-flcl_commands-util-run_319f.html",
"RUN",
"[[CLEP.COMMAND.UTIL.RUN]] ==== RUN indexterm:[Overlay, RUN, UTIL.RUN] With the overlay RUN you choose which utility function to use. Be careful with the remove operation for files. Please use the list function first to see which files will get deleted when using wildcards. All standard outputs (mainly the file list) of the utility functions are written to STDOUT. You can find the currently supported functions below. Don't hesitate to request new functions that are useful with wildcard patterns. * `STRING: LIST='str' - List files` * `STRING: REMOVE='str' - Remove files` ",
"",
""
],
[
"flcl_manual-flcl_commands-util-out_0a8a.html",
"OUT",
"[[CLEP.COMMAND.UTIL.OUT]] ==== OUT indexterm:[Parameter, OUT, UTIL.OUT] With the OUT parameter you can choose the file (as STRING) or stream (STDOUT/STDERR) where the information is printed. If it is not provided STDOUT is used by default. * `STDOUT - Write output to stdout` * `STDERR - Write output to stderr` * `DUMMY - Don't write any output` ",
"",
""
],
[
"flcl_manual-flcl_commands-key_d76c.html",
"KEY",
"[[CLEP.COMMAND.KEY]] === KEY indexterm:[Command, KEY, KEY] The KEY command can be used to manage keys for several cryptographic systems and infrastructures. With the KEY command, you can, for example, generate, export and import keys for the FLAM PGP support. The KEY command utilizes the FLAM key management extension version 5 to support several hardware security modules (HSM) or crypto interfaces (PKCS#11). Normally, these functions are realized by a key management solution and FLAM supposes the static keys for encryption and signing are in place. But on some platforms, there is no solution readily available to manage PGP or other kinds of keys. In this case, these functions can be used to prepare the crypto environment so that FLAM can be used to protect confidentiality, integrity and completeness of your data. To get syntax information, please use: To get help for a parameter, please use: To read the manual page for a parameter, please use: To generate the user manual for a command, please use: Parameters can be defined by the command line (directly or per file) or by properties read from the corresponding property file. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-import_6434.html",
"IMPORT",
"[[CLEP.COMMAND.KEY.IMPORT]] ==== IMPORT indexterm:[Overlay, IMPORT, KEY.IMPORT] With the overlay IMPORT you can choose which kind of keys are imported. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-import-pgp_bb70.html",
"PGP",
"[[CLEP.COMMAND.KEY.IMPORT.PGP]] ==== PGP indexterm:[Object, PGP, KEY.IMPORT.PGP] With this object you can define parameters to import PGP keys. With the parameter USERID, you can change the user ID that is provided by the key file during key import. This is required if your cryptographic infrastructure (ICSF/CCA) does not support names and email addresses as key label name. The function can be used to import PGP public key certificates and key pairs. To decrypt the private key from the key file, the correct passphrase must be provided. For a certificate import (public key), no passphrase is required. The external key file could be in binary form or an ASCII Armor encoded text file in ASCII or EBCDIC. The encoding is detected automatically. You can provide a key id value which will be checked in front of the key import. This value are in HEX and up to 16 character (8 bytes) long. If you provide less than 8 bytes the key id is verified against the low significant / right bytes of the primary key id. Often only the right half (4 byte = 8 characters) of the key id is used for verification. * `STRING: FILE='str' - PGP key file name (binary or ASCII/EBCDIC Armor)` * `STRING: USERID='str' - User ID (additional) for the imported key [from file]` * `STRING: KIDVERIFY='bin-hex' - PGP primary key ID (right most bytes in HEX) for verification [NONE]` * `NUMBER: MODE=REMAIN/ATTACH/OVERWRITE/RECOPY - How to handle already existing keys` ** `REMAIN - Keep the existing one [DEFAULT]` ** `ATTACH - Attach new one (PKCS11 only)` ** `OVERWRITE - Overwrite the old by new` ** `RECOPY - Re-generate only the key id's for an existing key (ICSF/CCA only)` * `STRING: PASSWORD='bin'/DEFAULT - Passphrase to decrypt the PGP key file [optional]` ** `DEFAULT - FLAM5 default password` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-generate_b532.html",
"GENERATE",
"[[CLEP.COMMAND.KEY.GENERATE]] ==== GENERATE indexterm:[Overlay, GENERATE, KEY.GENERATE] With the overlay GENERATE you can choose which kind of keys are generated. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-generate-pgp_f596.html",
"PGP",
"[[CLEP.COMMAND.KEY.GENERATE.PGP]] ==== PGP indexterm:[Object, PGP, KEY.GENERATE.PGP] An object for specifying parameters used to generate PGP key pairs. Unless the parameter SIGNONLY is specified, a primary key for signing and a subkey for encryption are generated. This is the normal usage for data exchange. You can set the activation date and the validity period in days. If no activation date is provided, the current date is used. If no number of valid days is given, the key is valid indefinitely. The overlay ALGO supports different characteristics for key generation. For example, you can define the modulus length and exponent values for RSA based keys. * `STRING: USERID='str' - User ID for the generated key` * `NUMBER: MODE=REMAIN/ATTACH/OVERWRITE/RECOPY - How to handle already existing keys` ** `REMAIN - Keep the existing one [DEFAULT]` ** `ATTACH - Attach new one (PKCS11 only)` ** `OVERWRITE - Overwrite the old by new` ** `RECOPY - Re-generate only the key id's for an existing key (ICSF/CCA only)` * `SWITCH: SIGNONLY - Generate only a primary key for signing (i.e. no encryption subkey) [FALSE]` * `NUMBER: ACTIVATION=num - Activation time stamp in seconds since 1970 [0 - current]` * `NUMBER: VALIDDAYS=num - Validity period in days for the generated key [0 - forever]` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-generate-pgp-algo_9c58.html",
"ALGO",
"[[CLEP.COMMAND.KEY.GENERATE.PGP.ALGO]] ==== ALGO indexterm:[Overlay, ALGO, KEY.GENERATE.PGP.ALGO] With this overlay you choose the algorithm for key generation. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-generate-pgp-algo-rsa_9495.html",
"RSA",
"[[CLEP.COMMAND.KEY.GENERATE.PGP.ALGO.RSA]] ==== RSA indexterm:[Object, RSA, KEY.GENERATE.PGP.ALGO.RSA] This object defines the parameters for RSA key generation. * `NUMBER: MODLEN=M512/M1024/M2048/M3072/M4096/M8192 - Length of the modulus [2048]` ** `M512 - 512 bit modulus` ** `M1024 - 1024 bit modulus` ** `M2048 - 2048 bit modulus` ** `M3072 - 3072 bit modulus` ** `M4096 - 4096 bit modulus` ** `M8192 - 8192 bit modulus` * `NUMBER: EXPVAL=RANDOM/E3/E65537 - Value for the exponent [RANDOM]` ** `RANDOM - Use a random prime` ** `E3 - Prime 3 as exponent` ** `E65537 - Prime 65537 as exponent` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-export_0513.html",
"EXPORT",
"[[CLEP.COMMAND.KEY.EXPORT]] ==== EXPORT indexterm:[Overlay, EXPORT, KEY.EXPORT] With the overlay EXPORT you can choose which kind of keys are exported. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-export-pgp_aab7.html",
"PGP",
"[[CLEP.COMMAND.KEY.EXPORT.PGP]] ==== PGP indexterm:[Object, PGP, KEY.EXPORT.PGP] This object can be used to define parameters to export PGP keys. You can define a new user ID for the exported key. This is required if your cryptographic infrastructure does not support custom key labels so that you are responsible to add your email address to the certificate. To export a private key, a password must be provided to protect the resulting PGP key file. Depending on the cryptographic infrastructure, exporting private keys might not be possible. The exported keys are usually self-signed. If you provide a signer ID, then cross-signing is possible. If you provide your own user ID also as signer ID, then signing is done with the currently active user key. For example, if you export a key which will be active in the future, this key will be signed with the current active user key. When providing a timestamp, instead of the currently active key, the key is exported that is the youngest of valid keys at the given point in time. If there is more than one matching key (multiple keys with same user ID and creation date), the key with the shortest validity period is selected. If the ARMOR object is specified, the key is exported in ASCII armor format. Otherwise, the key file is written in binary form. * `STRING: FILE='str' - PGP key file name (binary or ASCII/EBCDIC Armor)` * `STRING: USERID='str' - User ID of the key(s) to be exported (search)` * `STRING: NEWUID='str' - User ID (additional) written to the key file [USERID]` * `SWITCH: PRIVATE - Also export private key [FALSE]` * `STRING: PASSWORD='bin'/DEFAULT - Passphrase for the PGP key file [optional]` ** `DEFAULT - FLAM5 default password` * `STRING: SIGNERID='str' - User ID for the signing key to certify the key file [self signed]` * `NUMBER: SIGHASH=MD5/SHA1/RIPEMD/SHA224/SHA256/SHA384/SHA512 - Hash algorithm for signature generation [preferred]` ** `MD5 - 128 bit (16 byte) MD5 checksum` ** `SHA1 - 160 bit (20 byte) SHA checksum` ** `RIPEMD - 160 bit (20 byte) RipeMD checksum` ** `SHA224 - 224 bit (28 byte) SHA checksum` ** `SHA256 - 256 bit (32 byte) SHA checksum` ** `SHA384 - 384 bit (48 byte) SHA checksum` ** `SHA512 - 512 bit (64 byte) SHA checksum` * `NUMBER: TIMESTAMP=num - Time stamp (seconds since 1970) used for key selection [0 - current]` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-export-pgp-armor_1063.html",
"ARMOR",
"[[CLEP.COMMAND.KEY.EXPORT.PGP.ARMOR]] ==== ARMOR indexterm:[Object, ARMOR, KEY.EXPORT.PGP.ARMOR] The ARMOR object activates ASCII armor encoding. It also supports EBCDIC as charset. ASCII-armored data is Base64 encoded binary data with a line length of 76 character followed by an optional checksum, surrounded by a header and trailer. The component in whose context the ARMOR object is used (usually PGP) defines the header and trailer information like in the example below: The ARMOR support adds by default several file attributes which allows FLAM to restore host datasets from such an armored file. The keywords below are supported: * Format: BINARY/RECORD/RECTXT/CHAR/TEXT/XML * Charset: Encoding string (IBM-1141/UTF-8/...) * Platform: free text (e.g. Linux on x86 with 64 bit (linx64d0)) * BinaryDelimiter: Hex-value for a binary record delimiter (DLM) * LengthField: L4X/L4I/B4X/B4I/HBX/HBI/HLX/HLI (see FMT.REC(METHOD)) * TextDelimiter:  Hex value for a text record delimiter (TXT) * FileOrganization: SEQ/RDS/KDS/EDS/... (see FIO.REC(FILORG)) * BlockSize: decimal value for the block size * RecordFormat: (see FIO.REC(RECFMT)) * RecordLength: decimal value for the record length * KeyLength: key length of VSAM KSDS * KeyPosition: key position of VSAM KSDS * SlotNumbers: Yes (8 byte slot number of an RRDS in front of the record) * PrintControl: Yes (1 byte print control character in front of the record) The printed values are decimal numbers or keywords used by FLCL. You can find a detailed description for each keyword if you search for it in this document. Below you can see an example for a VSAM Relative Record Dataset (RRDS) archived in a BZIP2 file using a binary delimiter to separate each record: * `NUMBER: FORMAT=OFF/STD/EXT - Format of ARMOR header (which information is printed) [EXT]` ** `OFF - Disable the printout of key value lines in ARMOR header` ** `STD - Only the standard key value pairs (Version, Comment, Chrset) for ARMOR header` ** `EXT - All available key value pairs are printed to ARMOR header (required for archiving)` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set [SYSTEM]` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `NUMBER: DELIM/RECDLM=HOST/BIN/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/DLM/SYSTEM - Line delimiter to use when mode is BLOCK and line>0 [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `DLM - Adds the system specific delimiter (DEFAULT)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` * `STRING: COMMENT='str' - Define comment for ARMOR header [default]` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-delete_df2a.html",
"DELETE",
"[[CLEP.COMMAND.KEY.DELETE]] ==== DELETE indexterm:[Overlay, DELETE, KEY.DELETE] With the overlay DELETE you can choose which kind of keys are deleted. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-delete-pgp_691e.html",
"PGP",
"[[CLEP.COMMAND.KEY.DELETE.PGP]] ==== PGP indexterm:[Object, PGP, KEY.DELETE.PGP] With this object you can specify parameters to delete PGP keys. The user ID defines which set of keys are to be deleted. If no timestamp is provided, the currently active key of the provided user will be deleted. The active key is the youngest of valid keys at the current point in time. If there is more than one matching key (multiple keys with same user ID and creation date), the key with the shortest validity period is deleted. When providing a timestamp, the key is deleted that matches the user ID and is the youngest of valid keys at the given point in time. Again, the one with the shortest validity period is deleted if there are multiple matches. * `STRING: USERID='str' - User ID of the PGP key group to be deleted` * `NUMBER: TIMESTAMP=num - Time stamp (seconds since 1970) used for key selection [0 - current]` ",
"",
""
],
[
"flcl_manual-flcl_commands-key-list_82a1.html",
"LIST",
"[[CLEP.COMMAND.KEY.LIST]] ==== LIST indexterm:[Overlay, LIST, KEY.LIST] With the overlay LIST you can choose which kind of keys are printed to STDOUT. ",
"",
""
],
[
"flcl_manual-flcl_commands-key-list-pgp_7865.html",
"PGP",
"[[CLEP.COMMAND.KEY.LIST.PGP]] ==== PGP indexterm:[Object, PGP, KEY.LIST.PGP] With this object you can define parameters to list PGP keys. To select keys you can use wildcards in the user ID string. With the switch ALL all matching keys are listed. If this parameter is not used (default), then only PGP keys are shown. * `SWITCH: ALL - List all kind of keys [FALSE]]` * `STRING: USERID='str' - User ID used to list keys [*]` * `NUMBER: FORMAT=LIST/XML - Specify formatting of key list [LIST]` ** `LIST - Provide information as list` ** `XML - Provide information in XML-structure` ",
"",
""
],
[
"flcl_manual-api_strings_ec79.html",
"API Strings",
"[[flcl.api.strings]] == API Strings The additional CLP strings below are available in the following APIs: * FLUC byte interface for C (FLCBYT) * FLUC record interface for COBOL/PL1/HLAS (FLCREC) * FLUC stream buffer interface for C++ (FLCBYTBF) * FLUC stream class interface for Java (FLCBYTJS) When opening a file through these APIs, a format string must be passed to describe the format in which data is returned (read mode) or expected (write mode) by the respective interface. A state string containing some additional meta data is returned by (read mode) or can be passed to (write mode) the file open function. To read or write a file through these interfaces, the 'READ' and 'WRITE' overlays of the 'CONV' command or the 'INPUT' and 'OUTPUT' object of the 'XCNV' command can be used in the corresponding file open function (ASM/C/COBOL/PL1) or constructor (C++/Java). If format.element() is used, some data conversions can be applied on a per-element basis. Conversions are applied when using the read or write functions of the byte/record interface that end with the letter v. These functions require the handle to a previously opened element converter. Multiple different element converters can be open at a time. To open a converter, a conversion string must be supplied. The 'read' conversion string describes how an element data type read from application memory is converted to the internal neutral FLAM5 representation. The 'write' conversion string defines how a neutral FLAM5 element is written to application memory when reading from a file. A from-to conversion string can be used to convert data types, e.g. numbers, between different representations. This could be used, for example, to convert the string representation of a number that was read from an XML file to a binary or BCD representation or a string of fixed length. The format strings are also used to configure the FLUC subsystem on z/OS and the FlucFS on Unix. ",
"",
""
],
[
"flcl_manual-api_strings-read_format_fed4.html",
"READ-FORMAT",
"[[CLEP.OTHERCLP.READ-FORMAT]] === READ-FORMAT indexterm:[String, READ-FORMAT, READ-FORMAT] When reading data via the byte or record interface, you can specify how to format the data (binary, character, text, xml, ...), use different conversions (Base64, OpenPGP, GZIP, CHRSET, ...) executed sequentially and different kinds of I/O methods (block, record, text, FLAM4, ...). This means that you can read compressed, encrypted and encoded files, where you can change the character set and other things as part of the read operation. Through the format string of our application programming interfaces, you specify how the data is transformed into a sequential data stream, records or FLAM5  elements before being stored in application memory. For example, if the data contains text, you can specify which delimiter to add after each line, which character set the output should be in and so on. For stream-oriented data handling, you can choose between binary, character, text and XML formatting. For read operations, you can use the auto detection capabilities. For example: This results in any kind of file (encoded, encrypted and/or compressed) being converted to records. If the content is XML, then the XML data is pretty printed into records. If it is text, then the data is parsed based on the containing delimiters. If it is binary and record lengths are detected, then the records are provided one by one. If it is binary and no record lengths are known or detected, then the data is wrapped into records. If you use record formatting, then the read and write functions do not operate like in stream-oriented I/O. Instead, the behavior is more similar to the fread (GET) and fwrite (PUT) operations in z/OS with 'type=record', except that you can define whether records are truncated (size>0) or a length error occurs (size==0) of the provided buffer is too short. With size=-1 (SIZE_MAX), there is also a zero-copy mode for optimized performance (LOC). The record formatting can be useful for normal text files to read the text record-by-record without the delimiter and null termination at the end. FLAM5 elements are parsed data elements with a type, a length, a value and more. If the element data contains printable characters, then these characters are encoded in UTF-8 by default, but can also be converted as needed. With element formatting, you can read and write a serialized form of FLAM5 elements. For example, it can be used to tokenize an XML document and read these tokens (elements) for further processing. The format string uses the syntax of the 'format' union which was specifically designed for the byte and record interface to format a byte stream based on the FLAM elements. The zero-terminated string must start with 'format.' followed by the corresponding method. The file string defines how the FLAM elements are read from or written to the file. The format string defines how the FLAM elements are converted into a byte stream, records or elements. ",
"",
""
],
[
"flcl_manual-api_strings-read_format-binary_0854.html",
"BINARY",
"[[CLEP.OTHERCLP.READ-FORMAT.BINARY]] ==== BINARY indexterm:[Object, BINARY, READ-FORMAT.BINARY] Format binary formats each element to one block/record. These binary chunks can then be used as byte stream (if the original was blocks) or as list of records. Such data blocks are the simplest form of data type handled by FLAM. You can access the data based on the byte offset, but no further knowledge about the data is known in FLAM. If record elements are processed, validation/replacement/substitution using regular expressions can be activated. For binary records, regular expression matching is performed using the local ASCII or EBCDIC single byte character set. For text records, the validation is done in UTF-8. Using only binary blocks with FLAM will mainly be equal to the behavior and ability of other encryption and compression tools. All other methods of data handling with FLAM will provide much more advantage to you. ",
"",
""
],
[
"flcl_manual-api_strings-read_format-char_28d5.html",
"CHAR",
"[[CLEP.OTHERCLP.READ-FORMAT.CHAR]] ==== CHAR indexterm:[Object, CHAR, READ-FORMAT.CHAR] Format char simply concatenate the block elements and does character conversion from UTF-8 to the default or provided character set. During the character conversion it supports: * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Reporting of ignored or substituted characters * Auto detection of charsets * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-api_strings-read_format-text_0616.html",
"TEXT",
"[[CLEP.OTHERCLP.READ-FORMAT.TEXT]] ==== TEXT indexterm:[Object, TEXT, READ-FORMAT.TEXT] Format text formats UTF-8 text elements into a list of records / lines, each terminated by a delimiter. These text records are converted to a character set defined by the CSSID. Text formatting also supports: * Different methods to define the record/line delimiter * Suppression of trailing whitespace * Replacement of horizontal tabs by whitespace characters * Suppression of remaining control characters * Validation of or replacements in records using regular expressions During character conversion these options are supported: * Stopping, ignoring or substitution when encountering an invalid or incomplete character * A freely defined substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters * Auto detection of charsets If the input was read as XML, text formatting turns it into a human- readable XML document using pretty printing, i.e. with proper indentation. You can set the indentation character, the number of indentation characters printed for each indentation level and whether to suppress XML comments. * `NUMBER: METHOD=HOST/BIN/REC/TXT/NL/USS/LF/UNIX/CR/OLDMAC/CRLF/WINDOWS/SYSTEM/ORIGINAL/L4I/L4X/B4I/B4X/S4I/S4X/HLI/HLX/HBI/HBX/HSI/HSX/DLM - Method for text formatting [SYSTEM]` ** `HOST - Adds no delimiter (HOST)` ** `BIN - Adds no delimiter (HOST)` ** `REC - Adds no delimiter (HOST)` ** `TXT - Adds the system specific delimiter (DEFAULT)` ** `NL - Adds delimiter new line (USS)` ** `USS - Adds delimiter for USS (new line)` ** `LF - Adds delimiter line feed (UNIX)` ** `UNIX - Adds delimiter for UNIX (line feed)` ** `CR - Adds delimiter carriage return (MAC)` ** `OLDMAC - Adds delimiter for old MACs (carriage return)` ** `CRLF - Adds delimiter carriage return line feed (WIN)` ** `WINDOWS - Adds delimiter for WINDOWS (carriage return line feed)` ** `SYSTEM - Adds the system specific delimiter (DEFAULT)` ** `ORIGINAL - Adds the original data at the end of a line (only for band FMT)` ** `L4I - Adds 4 byte length fields: Little endian integer, length inclusive` ** `L4X - Adds 4 byte length fields: Little endian integer, length exclusive (ZIP)` ** `B4I - Adds 4 byte length fields: Big endian integer, length inclusive` ** `B4X - Adds 4 byte length fields: Big endian integer, length exclusive (USS)` ** `S4I - Adds 4 byte length fields: System endian integer, length inclusive` ** `S4X - Adds 4 byte length fields: System endian integer, length exclusive (VAR)` ** `HLI - Adds 4 byte length fields: Little endian short (LL00), length inclusive` ** `HLX - Adds 4 byte length fields: Little endian short (LL00), length exclusive` ** `HBI - Adds 4 byte length fields: Big endian short (LL00), length inclusive (MVS)` ** `HBX - Adds 4 byte length fields: Big endian short (LL00), length exclusive` ** `HSI - Adds 4 byte length fields: System endian short (LL00), length inclusive` ** `HSX - Adds 4 byte length fields: System endian short (LL00), length exclusive` ** `DLM - Adds binary record delimiter` * `NUMBER: RPLTAB/RPLHTB=num - Replace horizontal tabulators by spaces using this tab width [0 - no replacement]` * `NUMBER: RPLVTB=num - Replace vertical tabulators by new lines using this tab width [0 = no replacement]` * `SWITCH: RPLBSP - Replace backspace (deletes the backspace and the byte before) [FALSE]` * `NUMBER: RPLCTR=SPACE/SUBSTITUTE/DELETE - Replace remaining control characters [NONE]` ** `SPACE - Replace control characters with whitespace character (0x20/0x40)` ** `SUBSTITUTE - Replace control characters with substitution character (0x1A/0x3F)` ** `DELETE - Remove control characters` * `SWITCH: SUPCTR - Suppress control characters [FALSE] (RPLCTR=DELETE)` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: DUMP - Write text dump of binary data [FALSE]` * `NUMBER: INDSIZ=num - Number of XML indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` ",
"",
""
],
[
"flcl_manual-api_strings-read_format-xml_d45e.html",
"XML",
"[[CLEP.OTHERCLP.READ-FORMAT.XML]] ==== XML indexterm:[Object, XML, READ-FORMAT.XML] Write XML formats FLAM elements containing parsed XML data. The output is a valid XML document. The output XML can be formatted using 3 different methods: * STANDARD:    The XML document is reconstructed as close to the original XML document as possible. * PRETTYPRINT: Creates an XML document with indentation suitable for human readability. * MINIMIZED:   Creates a minimized XMl document. Line breaks and whitespace are removed unless they are part of actual character data. The XML output is encoded in UTF-8 with line feed (0xA) as line delimiter unless a CCSID is supplied, in which case character conversion is performed. Format XML converts FLAM elements containing parsed XML data into an XML byte stream. The output XML can be formatted using 3 different methods: * STANDARD:    The XML document is reconstructed as close to the original XML document as possible. * PRETTYPRINT: Creates an XML document with indentation suitable for human readability. * MINIMIZED:   Creates a minimized XMl document. Line breaks and whitespace are removed unless they are part of actual character data. The XML output is encoded in UTF-8 with line feed (0xA) as line delimiter unless a CCSID is supplied, in which case character conversion is performed. During character conversion, the following options are supported: * Stop, ignore or substitution of invalid or incomplete characters * A custom substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to override the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters * Auto detection of charsets * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-api_strings-read_format-record_9fe4.html",
"RECORD",
"[[CLEP.OTHERCLP.READ-FORMAT.RECORD]] ==== RECORD indexterm:[Object, RECORD, READ-FORMAT.RECORD] Format record formats the list of elements in records. Each read operation writes only one record into memory. Format record supports: * Tables if the table object is specified * Character conversion if required * Compression, Encryption and Encoding * Free definition of padding character for fixed length formats * ASA and machine control character handling If such a record is marked as text record, character conversion from UTF-8 to a defined CCSID is performed. Character conversion supports: * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Reporting of ignored or substituted characters * Auto detection of charsets If the input was read as XML, record formatting turns it into a human- readable XML document using pretty printing, i.e. with proper indentation. You can set the indentation character, the number of indentation characters printed for each indentation level and whether to suppress XML comments. If the table object is used, then the corresponding method is set to 'record' as default and no explicit character conversion is done. The character conversion settings are used as defaults for table formatting. The table formatting allows, for example, to read a fixed length structure (copybook of an FB dataset) as record with EBCDIC strings, BCD numbers and so on, and write a CSV file in UTF-8. To get padded fixed-length records or valid ASA or MCC bytes (FIX or VAR) in front of each record, you must specify the record format. For fixed- length formats the record length must be given. If no record length is provided, then 80 will be the default for fixed-length records. If you only set the record length, then fixed-length record format is assumed. If a fixed record format is used, the padding character can be set. If no padding character is set, binary zero is used for binary records or the whitespace character in the current character set is used for text records. A record is not truncated if it is longer than the provided record length. A relative record dataset format (VSAM-RRDS) can also be used. In this case, (FIX-REL(-ASA/MCC), FR(A/M)) the slot number is prefixed as 8 bytes integer in local endianness. If no slot number is known (records not read from an RRDS) then a sequential number (1,2,3,...) is generated. * `NUMBER: RECFORMAT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format for read operation [catalog/VAR]` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLENGTH=num - Maximum record length for read operation [catalog/512]` * `STRING: PADCHAR='bin'/BINARY-ZERO/ASCII-BLANK/EBCDIC-BLANK/UTF08-BLANK/UTF16BE-BLANK/UTF16LE-BLANK/UTF32BE-BLANK/UTF32LE-BLANK - Character to pad records to a fixed length [system] or used for empty variable length records [NONE]` ** `BINARY-ZERO - Padding with 0x00` ** `ASCII-BLANK - Padding with 0x20` ** `EBCDIC-BLANK - Padding with 0x40` ** `UTF08-BLANK - Padding with 0x20` ** `UTF16BE-BLANK - Padding with 0x0020` ** `UTF16LE-BLANK - Padding with 0x2000` ** `UTF32BE-BLANK - Padding with 0x00000020` ** `UTF32LE-BLANK - Padding with 0x20000000` * `SWITCH: KEPBOM - Keep byte order mark for faster conversion` * `SWITCH: BLK2REC - Convert block with delimiter to records (including suppression of trailing whitespace` * `NUMBER: INDSIZ=num - Number of XML indentation characters per indentation level [2 (SPACE) or 1 (TAB)]` * `NUMBER: INDCHR=SPACE/TABULATOR - Indentation character used to indent XML tags [SPACE]` ** `SPACE - Use the space character as indentation character` ** `TABULATOR - Use the tabulator character as indentation character` * `SWITCH: NOCMNT - Do not write out XML comments [FALSE]` ",
"",
""
],
[
"flcl_manual-api_strings-read_format-element_649f.html",
"ELEMENT",
"[[CLEP.OTHERCLP.READ-FORMAT.ELEMENT]] ==== ELEMENT indexterm:[Object, ELEMENT, READ-FORMAT.ELEMENT] When reading from a file with FLAM, the file's original data is transformed into an internal FLAM5 element list. The type and contents of elements depends on how the original file was read. With element formatting, you can get a serialized form of those FLAM5 elements. Elements that have been created when reading the file are serialized into a specific structure and written into a given piece of memory. For example, element formatting can be used to get the XML elements produced by the read.xml() file input method that tokenizes the XML document. These XML elements (tokens) can then be used for further processing. As mentioned, the serialized elements have a certain structure. The first four bytes (32 bits) are a version field. The version field is always the first field and determines the fields of the rest of the structure. Currently, there is only one version (0) of the serialized element structure. It consists of the 4 byte integer fields below followed by a concatenation of the corresponding data fields (attributes, data, hash values) in the same order as the length fields. * Version: Version (0) of the structure * MatTyp: Matrix type * ElmTyp: Element type * AtrLen: Attribute length * DatLen: Data length * HshLen: Hash length * Reserved1: Reserved integer * Reserved2: reserved integer The presence and contents of attributes, data and hash values depend on the combination of matrix and element type. The available matrix and element types and further details can be found in the API documentation for the FLMDEF.h header (contained for example in the FLCBYT or FLCRECLB documentation). Note that hash values are currently only used with FLAM5 archives and not relevant for other data. If, for example, records containing ASA control characters are read, the data portion of the structure is the concatenation of the (binary) ASA control character (which is the attribute), followed by the character data of the record (the data portion). Please be aware that the control character is treated as a binary value (EBCDIC) and that the character data is, by default, encoded in UTF-8. By default and when using one of the read.*() operations for reading, the data fields are encoded in a neutral form which is UTF-8 if the element contains text data. You can set a different CCSID in the format.element() object to get text data fields encoded in another character set. Please be aware that certain character sets like UTF-16 or UTF-32 result in an expansion of the data. If you choose a single byte character set (EBCDIC or ASCII) then some element may be shorter after conversion. You can specify to ignore, substitute or transliterate characters which a character is not representable in the target character set. If you use DEFAULT keyword for the CCSID, then the local character set is used. * `NUMBER: ENDIANNESS=SYSTEM/BIG/LITTLE/LOCAL - Select byte order for 4 byte long integers in element structure [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` ",
"",
""
],
[
"flcl_manual-api_strings-write_format_8da5.html",
"WRITE-FORMAT",
"[[CLEP.OTHERCLP.WRITE-FORMAT]] === WRITE-FORMAT indexterm:[String, WRITE-FORMAT, WRITE-FORMAT] When writing data via the byte or record interface, you can define how to format the data (binary, character, text, xml, ...), use different conversions (Base64, OpenPGP, GZIP, CHRSET, ...) executed sequentially and different kinds of I/O methods (block, record, text, FLAM4, ...). This means that you can write compressed, encrypted and encoded files, where you can change the character set and other things as part of the write operation. Through the format string of our application programming interfaces, you specify in which format your application passes its data to the interface, be it a sequential data stream, records or FLAM5 elements. For example, if you pass text records, you can define which delimiter to add after each line, which character set the output should be in and so on to write a text file correctly formatted for the target platform. For stream-oriented data handling, you can choose between binary, character, text and XML formatting. If you use record formatting, then the read and write functions do not operate like in stream-oriented I/O. Instead, the behavior is more similar to the fread (GET) and fwrite (PUT) operations in z/OS with 'type=record', except that you can define whether records are truncated (size>0) or a length error occurs (size==0) of the provided buffer is too short. With size=-1 (SIZE_MAX), there is also a zero-copy mode for optimized performance (LOC). FLAM5 elements are parsed data elements with a type, a length, a value and more. If the element data contains printable characters, then these characters are encoded in UTF-8 by default, but can also be converted as needed. With element formatting, you can read and write a serialized form of FLAM5 elements. For example, it can be used to produce a well-formed XML document from a sequence of XML tokens. The format string uses the syntax of the 'format' union which was specifically designed for the byte and record interface to format a byte stream based on the FLAM elements. The zero-terminated string must start with 'format.' followed by the corresponding method. The file string defines how the FLAM elements are read from or written to the file. The format string defines how the FLAM elements are converted into a byte stream, records or elements. ",
"",
""
],
[
"flcl_manual-api_strings-write_format-binary_67eb.html",
"BINARY",
"[[CLEP.OTHERCLP.WRITE-FORMAT.BINARY]] ==== BINARY indexterm:[Object, BINARY, WRITE-FORMAT.BINARY] Format binary converts the provided byte stream or records into blocks of data representing an element. Such data blocks are the simplest form of data type handled by FLAM. You can access the data based on the byte offset, but no further knowledge about the data is known in FLAM. For records, data validation using a regular expression can be activated. If binary records are processed, the regular expression is matched using the local ASCII or EBCDIC single byte character set. For text records the validation is done in UTF-8. Using only binary blocks with FLAM will mainly be equal to the behavior and ability of other encryption and compression tools. All other methods of data handling with FLAM will provide much more advantage to you. * `NUMBER: DECODE=NONE/ARCHIVE/FIODEC/DECRYP/CRYDEC/DECOMP/CMPDEC/ALWAYS - Decode encoded, encrypted or compressed data [0=NONE]` ** `NONE - No automated decoding` ** `ARCHIVE - Transparently read archives` ** `FIODEC - Base decoding after file IO, before decryption` ** `DECRYP - Decryption of encrypted data` ** `CRYDEC - Base decoding after decryption, before decompression` ** `DECOMP - Decompression of compressed data` ** `CMPDEC - Base decoding after decompression, before formatting` ** `ALWAYS - Always decode encoded data (causes the same as DECOMP)` ",
"",
""
],
[
"flcl_manual-api_strings-write_format-char_cf0e.html",
"CHAR",
"[[CLEP.OTHERCLP.WRITE-FORMAT.CHAR]] ==== CHAR indexterm:[Object, CHAR, WRITE-FORMAT.CHAR] Format char reads the byte stream for character conversion. There is no delimiter parsing. The data stream is simply split into block elements defined by the block size parameter. The character data is converted from the provided CCSID to UTF-8. If no CCSID is provided, a system-dependent process is used to find the default CCSID. First, if available, the stored CCSID from the filesystem is used. If this is not successful, the environment variable LANG is used to determine the default CCSID. If this fails too, ISO-8859-1 (Latin-1) is used on a ASCII and IBM-1047 (Open Systems Latin-1) on EBCDIC systems. During the character conversion, these options are supported: * Stop, ignore or substitution of invalid or incomplete character * A free defined substitution character list * Different system substitution / transliteration tables * A user defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of char sets * Reporting of ignored or substituted characters * Auto detection of charsets * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `NUMBER: DECODE=NONE/FIODEC/CRYDEC/CMPDEC/ALWAYS - Decode encoded data first (remove base encodings)` ** `NONE - No automated decoding` ** `FIODEC - Base decoding after file IO, before decryption` ** `CRYDEC - Base decoding after decryption, before decompression` ** `CMPDEC - Base decoding after decompression, before formatting if XML` ** `ALWAYS - Always decode encoded data (like CMPDEC but also if CHAR or TEXT)` ",
"",
""
],
[
"flcl_manual-api_strings-write_format-text_c581.html",
"TEXT",
"[[CLEP.OTHERCLP.WRITE-FORMAT.TEXT]] ==== TEXT indexterm:[Object, TEXT, WRITE-FORMAT.TEXT] Format text operates on blocks of text data. First, the text data is converted to the UTF-8 character set. Then the text data is split into record and rest elements based on text delimiters. The data must contain a valid text delimiter within the provided record/line length. A text record contains all text between two delimiters, optionally without trailing whitespace. The optional trailing whitespace and the delimiter make up the rest element. Taken together, the record and the rest elements represent the original data. List of valid text delimiters (Unicode codepoints): * 0x00 (padding character (can be changed)) * 0x0A (carriage return) * 0x0D (line feed) * 0x0A, 0x0D (carriage return line feed) * 0x0A, ..., 0x0A, 0x0D (dirty delimiters) * 0x0A, 0x0D, ..., 0x0D (dirty delimiters) * 0x0C (form feed) * 0x85 (next line (EBCDIC 0x15, optional if single byte ASCII)) The character data will be converted from the provided CCSID to UTF-8. If no CCSID is provided, a system dependent default CCSID is used: If available, the CCSID stored in the file system is used. If this is unset or not supported, the environment variable LANG is used. If this is also not set to a valid value, ISO-8859-1 (Latin-1) is used on ASCII and IBM-1047 (Open Systems Latin-1) on EBCDIC systems. While text formatting, form feed characters may optionally be replaced by empty records. A padding character can be defined as special delimiter that, unlike other delimiters, is not added to the rest element after a record as it is not considered part of the original data. Text formatting also supports: * Different methods to define the record/line delimiter * Suppression of trailing whitespace * Replacement of horizontal tabs by whitespace characters * Replacement of vertical tabs by whitespace and newline characters * Replacement of remaining control characters * Validation of records using regular expressions During character conversion these options are supported: * Stopping, ignoring or substitution when encountering an invalid or incomplete character * A freely defined substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to change the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters * Auto detection of charsets * `NUMBER: RECLENGTH=num - Maximum record length (Host) / line length (Unix/Win) for text parsing [512]` * `SWITCH: SUPTWS - Suppress trailing whitespaces [FALSE]` * `SWITCH: NELDLM - Activate NEL (0x85) as delimiter for ASCII character sets [FALSE]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` * `NUMBER: RPLFFD=num - Replace form feeds, filling rest of page with blank lines assuming n lines per page [60]` * `NUMBER: PADCHAR=num - Padding character to be regarded as additional delimiter [0x00]` * `NUMBER: DECODE=NONE/FIODEC/CRYDEC/CMPDEC/ALWAYS - Decode encoded data first (remove base encodings)` ** `NONE - No automated decoding` ** `FIODEC - Base decoding after file IO, before decryption` ** `CRYDEC - Base decoding after decryption, before decompression` ** `CMPDEC - Base decoding after decompression, before formatting if XML` ** `ALWAYS - Always decode encoded data (like CMPDEC but also if TEXT)` ",
"",
""
],
[
"flcl_manual-api_strings-write_format-xml_7817.html",
"XML",
"[[CLEP.OTHERCLP.WRITE-FORMAT.XML]] ==== XML indexterm:[Object, XML, WRITE-FORMAT.XML] Format XML reads a byte stream and parses the data into XML elements. Before parsing takes place, the data must be converted to UTF-8 unless it is already in UTF-8 or ASCII. Line delimiters must be one of 0x0A, 0x0D or 0x0D0A. During parsing, all line delimiters are normalized to line feed characters (0xA) as defined by the XML specification. If a CCSID is provided, the character data will be converted from the provided CCSID to UTF-8. If no CCSID is provided, no character conversion will be done. During character conversion, the following options are supported: * Stop, ignore or substitution of invalid or incomplete characters * A custom substitution character list * Different system substitution / transliteration tables * A user-defined substitution table to override the system tables * Case management (upper, lower, folding and special casing) * Transliteration between subsets (mapping) and normalization * BOM management and automatic detection of character sets * Reporting of ignored or substituted characters * Auto detection of charsets * `SWITCH: NOCMNT - Ignore XML comments [FALSE]` * `SWITCH: NODFLT - Ignore XML default elements (i.e. whitespace before/after root tag) [FALSE]` * `SWITCH: NOEMPD - Ignore XML empty/whitespace data elements (not in CDATA section) [FALSE]` * `SWITCH: ADDEMP - Add an empty XML data element if end tag follows direct a start tag [FALSE]` * `SWITCH: NOPINS - Ignore XML processing instructions [FALSE]` * `SWITCH: NODTD - Ignore XML document type definitions[FALSE]` * `SWITCH: CCDATA - Collect CDATA to simple data elements [FALSE]` * `NUMBER: DATLEN=num - Minimum length to collect data elements in one element [1024]` * `SWITCH: LENERR - Return an error if minimum data element length exceeded [FALSE]` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-api_strings-write_format-record_bddf.html",
"RECORD",
"[[CLEP.OTHERCLP.WRITE-FORMAT.RECORD]] ==== RECORD indexterm:[Object, RECORD, WRITE-FORMAT.RECORD] Format record converts records into memory. If a record is text data, this can be signaled this by setting the correct CCSID, which will result in character set conversion from the provided CCSID to UTF-8 for each record. If no CCSID is provided, the record is treated as binary data (no conversion). Format record supports: * Tables if the table object is specified * Decoding, decryption and decompressing * Character conversion if required If the table object is used, then no explicit character conversion is performed. The character conversion settings are used as defaults for table formatting. The table formatting allows, for example, to read a fixed-length structure (copybook of an FB dataset) as record with EBCDIC strings, BCD numbers and so on, and write a CSV file in Latin-1. When providing records with print control characters (1 byte ASA or MCC) and/or slot numbers (64 bit integer in local endianness), the corresponding record format must be specified. Additionally, a record length (with out control characters and space for slot numbers) can be specified, but this length is only relevant for file allocation. Print control character handling can be used to define how a ASA or MCC byte is processed by FLAM. For a MCC or ASA record, the control character must be the first of the record. For relative record datasets (VSAM-RRDS), the written record must start with an 8 byte unsigned integer in local endianness. Relativ records with print control characters (FIX-REL-ASA/MCC, FRA, FRM) must be prefixed with 9 bytes: 8 bytes for the slot number of the RRDS and 1 byte for ASA or MCC. The maximum length of a record is not limited and must be checked by the application. If ASA/MCC or REL are used, the minimum length of the provided record must be 1, 8 or 9 depending on the record format. * `NUMBER: RECFORMAT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format for read operation [catalog/VAR]` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLENGTH=num - Maximum record length for read operation [catalog/512]` * `NUMBER: RECCOUNT=num - Amount of records handled in one read operation [catalog/128]` * `NUMBER: DECODE=NONE/ARCHIVE/DECOMP/RECORD/CMPDEC/ALWAYS - Decode encoded, encrypted or compressed data [0=NONE]` ** `NONE - No automated decoding` ** `ARCHIVE - Transparently read archives` ** `DECOMP - Decryption and decompression of encrypted and/or compressed data` ** `RECORD - Decode record length fields or delimiter (is default) after decompression` ** `CMPDEC - Additional base decoding after decompression, before formatting` ** `ALWAYS - Always decode encoded data (causes the same as CMPDEC)` * `SWITCH: SKIPEQUAL - Skip conversion if formats are equal (e.g. UTF-8 to UTF-8)` * `SWITCH: KEEPBOM - Keep byte order mark for faster conversion` ",
"",
""
],
[
"flcl_manual-api_strings-write_format-element_d142.html",
"ELEMENT",
"[[CLEP.OTHERCLP.WRITE-FORMAT.ELEMENT]] ==== ELEMENT indexterm:[Object, ELEMENT, WRITE-FORMAT.ELEMENT] FLAM5 elements are parsed data elements with a type, a length, a value and more. The element formatter reads a serialized FLAM5 element from application memory and collects multiple elements to fill a matrix (vector). One use case is, for example, to read XML elements from memory and write them to an XML file with correct XML syntax. To write an element, the data passed to the element formatter must have a certain structure. The first four bytes (32 bits) are a version field. The version field is always the first field and determines the fields of the rest of the structure. Currently, there is only one version (0) of the serialized element structure. It consists of the 4 byte integer fields below followed by a concatenation of the corresponding data fields (attributes, data, hash values) in the same order as the length fields. * Version: Version (0) of the structure * MatTyp: Matrix type * ElmTyp: Element type * AtrLen: Attribute length * DatLen: Data length * HshLen: Hash length * Reserved1: Reserved integer * Reserved2: reserved integer The presence and contents of attributes, data and hash values depend on the combination of matrix and element type. The available matrix and element types and further details can be found in the API documentation for the FLMDEF.h header (contained for example in the FLCBYT or FLCRECLB documentation). Note that hash values are currently only used with FLAM5 archives and not relevant for other data. The element count specifies how many elements are collected internally before they are converted to the output format and written to the destination. If this value is not set, a default is used that depends on the matrix type. For data blocks the default element count is 1, for text records with rest element it is 256 and for all other matrix types the limit is 128. The data fields must be provided in the corresponding neutral form which is expected by the write operation. Some metadata can be passed when opening a file by means of a state string. If you provide elements containing text data fields in another codepage than the local character set, you can define the correct inbound CCSID (e.g. UTF-8) via the state string or in the format.element() clause. If no CCSID is provided, then the inbound CCSID is not defined then the local character set is assumed at write and the string is converted to UTF-8. The default CCSID for text data fields of neutral FLAM5 elements is UTF-8. If no character conversion requested at read, then the UTF-8 strings are returned. The element formatting object supports character set conversion from a certain CCSID to UTF-8. If the CCSID is set to UTF-8, no character conversion is done on the input data, but the character set is now known to FLAM and all other conversions (e.g. appending of the correct line delimiter) are done in the right manner. Character conversion is, for example, required for XML elements which are not in UTF-8. So, if you wish to write an XML file based on your XML element that you passed to the element formatter and the element data is EBCDIC encoded, you would use a format string similar to format.element(ccsid=IBM1047) and a file string similar to write.xml(file=output.xml). This results in your element data being converted from IBM1047 to UTF-8 and passed to the XML writer which generates XML documents in UTF-8 by default. * `NUMBER: MATRIX=NONE/DATBLK/STDREC/STDASAREC/STDMCCREC/RELREC/RELASAREC/RELMCCREC/TXTREC/TXTDLM/TXTRST/XMLELM - Matrix type for the elements [NONE]` ** `NONE - Unknown matrix type` ** `DATBLK - Simple data block (no attributes)` ** `STDREC - Simple standard record (no attributes)` ** `STDASAREC - Standard record with ASA control characters (1 byte) as attributes` ** `STDMCCREC - Standard record with machine control characters (1 byte) as attributes` ** `RELREC - Relative record with 8 byte slot number as attribute` ** `RELASAREC - Relative record with slot number (8 byte) and ASA control character (1 byte) as attribute` ** `RELMCCREC - Relative record with slot number (8 byte) and machine control character (1 byte) as attribute` ** `TXTREC - Standard text record (no attributes)` ** `TXTDLM - Record with text delimiter at the end (no attributes)` ** `TXTRST - Text records with data and rest element (no attributes)` ** `XMLELM - XML elements (no attributes)` * `NUMBER: ELMCOUNT=num - Amount of elements handled in one read operation [AUTO]` * `NUMBER: ENDIANNESS=SYSTEM/BIG/LITTLE/LOCAL - Select byte order for 4 byte long integers in element structure [SYSTEM]` ** `SYSTEM - Byte order of the default logical system` ** `BIG - Big endian byte order` ** `LITTLE - Little endian byte order` ** `LOCAL - Byte order of the real physical system` ",
"",
""
],
[
"flcl_manual-api_strings-conv_read_3631.html",
"CONV-READ",
"[[CLEP.OTHERCLP.CONV-READ]] === CONV-READ indexterm:[String, CONV-READ, CONV-READ] The READ overlay for an element data conversion allows to choose a type specific conversion when writing. It specifies how the data is read from application memory and converted into a neutral FLAM5 data type. With 'format.element()', you can use a set of functions with names ending with the letter v in the byte and record interface. These functions accept an additional conversion handle as parameter to replace the default conversion (e.g. a simple copy) from or to the application memory by an individual conversion. You can open an unlimited number of converters to apply different conversions to different elements. The currently supported data types and conversions are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-api_strings-conv_write_cf98.html",
"CONV-WRITE",
"[[CLEP.OTHERCLP.CONV-WRITE]] === CONV-WRITE indexterm:[String, CONV-WRITE, CONV-WRITE] The WRITE overlay for a element data conversion allows to choose a type specific conversion when reading. It specifies how the data is converted from a neutral read FLAM5 data type and written to application memory. With 'format.element()', you can use a set of functions with names ending with the letter v in the byte and record interface. These functions accept an additional conversion handle as parameter to replace the default conversion (e.g. a simple copy) from or to the application memory by an individual conversion. You can open an unlimited number of converters to apply different conversions to different elements. The currently supported data types and conversions are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-api_strings-from_to_conv_c0df.html",
"FROM-TO-CONV",
"[[CLEP.OTHERCLP.FROM-TO-CONV]] === FROM-TO-CONV indexterm:[String, FROM-TO-CONV, FROM-TO-CONV] The CONV overlay for element data conversion allows to choose a type specific conversion. It specifies how the data is read from and written to application memory. With 'format.element()', you can use a set of functions with names ending in the letter v in the byte and record interface. These functions accept an additional conversion handle as parameter to replace the default conversion (e.g. a simple copy) from or to the application memory by an individual conversion. You can open an unlimited number of converters to apply different conversions to different elements. The currently supported data types and conversions are explained in a dedicated chapter. ",
"",
""
],
[
"flcl_manual-api_strings-from_to_conv-memory_f21f.html",
"MEMORY",
"[[CLEP.OTHERCLP.FROM-TO-CONV.MEMORY]] ==== MEMORY indexterm:[Object, MEMORY, FROM-TO-CONV.MEMORY] The conversion object for memory allows to convert from an external data representation to another external data representation of a complex data structure including format conversion (XML, CSV, FIX, VAR, ...), compression (GZIP, BZIP2, XZ, ...), encryption (PGP, ...) and encoding (Base64/32/16) schemes. ",
"",
""
],
[
"flcl_manual-api_strings-from_to_conv-memory-read_e810.html",
"READ",
"[[CLEP.OTHERCLP.FROM-TO-CONV.MEMORY.READ]] ==== READ indexterm:[Overlay, READ, FROM-TO-CONV.MEMORY.READ] NONE ",
"",
""
],
[
"flcl_manual-api_strings-state_c4c5.html",
"STATE",
"[[CLEP.OTHERCLP.STATE]] === STATE indexterm:[String, STATE, STATE] The state string contains some metadata representing the internal state of FLUC. When opening a file for reading (fcbopen2('read.'/'input()')), this state string is returned. It can be passed to a successive file open call for writing (fcbopen2('write.'/'output()') or FCROPN('write.'/'output()')) to give FLUC additional hints about the data that is to be written. The state string contains mainly file attributes which must be known to fill header information for archives (GZIP, FLAM) correctly, but also some information about elements when working in element formatting mode. On C/C++ interfaces, the parameter is a pointer to a pointer to a string. In read mode, if you pass a non-null pointer, the pointer target will be a pointer to a null-terminated string dynamically allocated in heap memory (i.e. you must free() it!) containing the state string after the opening function returns. In write mode, if you pass a non-null pointer to a pointer to a state string, this state string is used to set the internal state. Otherwise, the state is initialized with default values. On the record interface, the application must provide the memory and a length error is returned if the buffer is too small. The state mainly contains file attributes which describe the source. This information is important for example to store the right values in GZIP or FLAM headers. The status object can be used to pass the source's characteristics to the write operation. * `STRING: ORGF='str'/STREAM/DUMMY - Original name of the file (used for defined mappings, if empty then FILE is used)` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: FILE='str'/STREAM/DUMMY - Current name of the file (with appended extensions, if empty then ORGF is used)` ** `STREAM - Read from stdin or write to stdout` ** `DUMMY - Read EOF or write nothing` * `STRING: MEMBER='str' - Name or Index of the member` * `STRING: COMMENT='str' - Comment for headers` * `NUMBER: CHRSET=NONE/SYSTEM/ASCII/UCS1/UTF8/EBCDIC/UCS2BE/UTF16BE/UCS2LE/UTF16LE/UCS4BE/UTF32BE/UCS4LE/UTF32LE/LOCAL - Character set` ** `NONE - No character set defined` ** `SYSTEM - SYSTEM (environment specific (on mainframe EBCDIC else ASCII))` ** `ASCII - ASCII (mainly used in the for open system)` ** `UCS1 - UCS-1 (for text formatting identical to ASCII < 64k)` ** `UTF8 - UTF-8 (for text formatting identical to ASCII < 2M)` ** `EBCDIC - EBCDIC (mainly used on IBM mainframe)` ** `UCS2BE - UCS-2 Big Endian (multibyte character set < 64k)` ** `UTF16BE - UTF-16 Big Endian (multibyte character set < 2M)` ** `UCS2LE - UCS-2 Little Endian (multibyte character set < 64k)` ** `UTF16LE - UTF-16 Little Endian (multibyte character set < 2M)` ** `UCS4BE - UCS-4 Big Endian (multibyte character set < 64k)` ** `UTF32BE - UTF-32 Big Endian (multibyte character set < 2M)` ** `UCS4LE - UCS-4 Little Endian (multibyte character set < 64k)` ** `UTF32LE - UTF-32 Little Endian (multibyte character set < 2M)` ** `LOCAL - LOCAL (platform specific (on mainframe EBCDIC else ASCII))` * `STRING: CCSID='str' - CCSID / Character encoding` * `NUMBER: SPACE=num - Required space for the target in byte` * `NUMBER: BLKSIZE=num - Block size` * `NUMBER: RECFORMAT=NONE/BIN/TXT/TXT-ASA/TXT-MCC/DLM/DLM-ASA/DLM-MCC/VAR/VAR-ASA/VAR-MCC/FIX/FIX-ASA/FIX-MCC/VAR-REL/VAR-REL-ASA/VAR-REL-MCC/FIX-REL/FIX-REL-ASA/FIX-REL-MCC/F/FA/FM/FS/FSA/FSM/FB/FBA/FBM/FBS/FBSA/FBSM/FE/FEA/FEM/FK/FKA/FKM/FR/FRA/FRM/U/UA/UM/V/VA/VM/VS/VSA/VSM/VB/VBA/VBM/VBS/VBSA/VBSM/VE/VEA/VEM/VK/VKA/VKM/VR/VRA/VRM/ORG - Record format` ** `NONE - No format defined` ** `BIN - Open - Binary (undefined) data (only the last record are shorter then record length)` ** `TXT - Open - Text data with standard delimiter (result is a stripped variable length records)` ** `TXT-ASA - Open - Text data with standard delimiter and ASA byte in front (result variable length records with ASA attribute)` ** `TXT-MCC - Open - Text data with standard delimiter and MCC byte in front (result variable length records with MCC attribute)` ** `DLM - Open - Records separated by a special delimiter with the result of variable length records` ** `DLM-ASA - Open - ASA records separated by a special delimiter with the result of variable length records` ** `DLM-MCC - Open - MCC records separated by a special delimiter with the result of variable length records` ** `VAR - Open - Variable length record (if necessary define length format)` ** `VAR-ASA - Open - Variable length record with ASA print control character (if necessary define length format)` ** `VAR-MCC - Open - Variable length record with machine print control codes (if necessary define length format)` ** `FIX - Open - Fixed-length record (file size = N * record length)` ** `FIX-ASA - Open - Fixed-length record with ASA print control character (file size = N * (record length + 1))` ** `FIX-MCC - Open - Fixed-length record with machine print control codes (file size = N * (record length + 1))` ** `VAR-REL - Open - Variable relative record (if necessary define length format)` ** `VAR-REL-ASA - Open - Variable relative record with ASA print control character (if necessary define length format)` ** `VAR-REL-MCC - Open - Variable relative record with machine print control codes (if necessary define length format)` ** `FIX-REL - Open - Fix relative record (file size = N * (record length + 8))` ** `FIX-REL-ASA - Open - Fix relative record with ASA print control character (file size = N * (record length + 9))` ** `FIX-REL-MCC - Open - Fix relative record with machine print control codes (file size = N * (record length + 9))` ** `F - Host - Fixed-length, unblocked` ** `FA - Host - Fixed-length, unblocked, ASA print control characters` ** `FM - Host - Fixed-length, unblocked, machine print control codes` ** `FS - Host - Fixed-length, standard` ** `FSA - Host - Fixed-length, standard, ASA print control characters` ** `FSM - Host - Fixed-length, standard, machine print control codes` ** `FB - Host - Fixed-length, blocked` ** `FBA - Host - Fixed-length, blocked, ASA print control characters` ** `FBM - Host - Fixed-length, blocked, machine print control codes` ** `FBS - Host - Fixed-length, blocked, standard` ** `FBSA - Host - Fixed-length, blocked, standard, ASA print control characters` ** `FBSM - Host - Fixed-length, blocked, standard, machine print control codes` ** `FE - Host - Fixed-length, ESDS` ** `FEA - Host - Fixed-length, ESDS, ASA print control characters` ** `FEM - Host - Fixed-length, ESDS, machine print control codes` ** `FK - Host - Fixed-length, KSDS` ** `FKA - Host - Fixed-length, KSDS, ASA print control characters` ** `FKM - Host - Fixed-length, KSDS, machine print control codes` ** `FR - Host - Fixed-length, RRDS` ** `FRA - Host - Fixed-length, RRDS, ASA print control characters` ** `FRM - Host - Fixed-length, RRDS, machine print control codes` ** `U - Host - Undefined-length` ** `UA - Host - Undefined-length, ASA print control characters` ** `UM - Host - Undefined-length, machine print control codes` ** `V - Host - Variable` ** `VA - Host - Variable, ASA print control characters` ** `VM - Host - Variable, machine print control codes` ** `VS - Host - Variable, spanned` ** `VSA - Host - Variable, spanned, ASA print control characters` ** `VSM - Host - Variable, spanned, machine print control codes` ** `VB - Host - Variable, blocked` ** `VBA - Host - Variable, blocked, ASA print control characters` ** `VBM - Host - Variable, blocked, machine print control codes` ** `VBS - Host - Variable, blocked, spanned` ** `VBSA - Host - Variable, blocked, spanned, ASA print control characters` ** `VBSM - Host - Variable, blocked, spanned, machine print control codes` ** `VE - Host - Variable, ESDS` ** `VEA - Host - Variable, ESDS, ASA print control characters` ** `VEM - Host - Variable, ESDS, machine print control codes` ** `VK - Host - Variable, KSDS` ** `VKA - Host - Variable, KSDS, ASA print control characters` ** `VKM - Host - Variable, KSDS, machine print control codes` ** `VR - Host - Variable, RRDS` ** `VRA - Host - Variable, RRDS, ASA print control characters` ** `VRM - Host - Variable, RRDS, machine print control codes` ** `ORG - Use original record format as default (like none)` * `NUMBER: RECLENGTH=num - Record length` * `NUMBER: KEYPOSITION=num - Key position (>=1)` * `NUMBER: KEYLENGTH=num - Key length (>=1)` * `NUMBER: DATFMT=NONE/BLOCK/RECORD/ELEMENT - Data format (not required at write)` ** `NONE - Unknown data format` ** `BLOCK - Block oriented data` ** `RECORD - Record oriented data` ** `ELEMENT - Element oriented data` * `NUMBER: DATTYP=NONE/BINARY/RECORD/RECTXT/CHAR/TEXT/XML/TABLE - Data type (not required at write)` ** `NONE - Unknown data type` ** `BINARY - Binary data (not printable)` ** `RECORD - Binary record (not printable)` ** `RECTXT - Text record (printable)` ** `CHAR - Character data (no delimiter)` ** `TEXT - Text data (with delimiter)` ** `XML - XML data (like CHAR)` ** `TABLE - Table (various elements per record)` * `NUMBER: MATRIX=NONE/DATBLK/STDREC/STDASAREC/STDMCCREC/RELREC/RELASAREC/RELMCCREC/TXTREC/TXTDLM/TXTRST/XMLELM - Matrix type of the elements list` ** `NONE - Unknown matrix type` ** `DATBLK - Simple data block (no attributes)` ** `STDREC - Simple standard record (no attributes)` ** `STDASAREC - Standard record with ASA control characters (1 byte) as attributes` ** `STDMCCREC - Standard record with machine control characters (1 byte) as attributes` ** `RELREC - Relative record with 8 byte slot number as attribute` ** `RELASAREC - Relative record with slot number (8 byte) and ASA control character (1 byte) as attribute` ** `RELMCCREC - Relative record with slot number (8 byte) and machine control character (1 byte) as attribute` ** `TXTREC - Standard text record (no attributes)` ** `TXTDLM - Record with text delimiter at the end (no attributes)` ** `TXTRST - Text records with data and rest element (no attributes)` ** `XMLELM - XML elements (no attributes)` * `SWITCH: REDUNDANT - Data is known as redundant` * `SWITCH: NOTREDUNDANT - Data is known as not redundant` ",
"",
""
],
[
"flcl_manual-api_strings-log_6e72.html",
"LOG",
"[[CLEP.OTHERCLP.LOG]] === LOG indexterm:[String, LOG, LOG] The log string can be used to define the log message types to be written to the in-memory log. Additionally, a custom identifier can be set and an output format can be selected. (minimal is default) * `STRING: IDENT='str' - Identifier used to identify log entries [owner]` * `NUMBER: FORMAT=STANDARD/DIALOG/MINIMAL - Format of log message [STANDARD]` ** `STANDARD - Standard logging format (timestamp ident *level* message)` ** `DIALOG - For dialog processing (ident *level* message)` ** `MINIMAL - For output processing (message)` ",
"",
""
],
[
"flcl_manual-fluc_filesystem_for_linux_7ea7.html",
"FLUC Filesystem for Linux",
"[[flcl.appendix.flucfs]] == FLUC Filesystem for Linux *flucFS* uses https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] to mount an existing directory in some other folder. Everything written to the mounted folder is transparently converted, encrypted, compressed as defined in the configuration. If no match is found in its configuration, the data is passed through without any change. The configuration is done with the argument strings of the FLUC byte interface API. However, since flucFS is a filesystem and uses only the read and write functions of the API, the element access features of the API are not useable with flucFS. === Dependencies ==== Kernel module The fuse kernel module must be loaded in order to use any fuse filesystem. This kernel module is usually installed with the linux kernel. This can be checked with To load it, just run with root permissions. In unusual circumstances, https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] support might be built into the kernel image. ==== Library *flucFS* depends on the https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] user space library. This library and the required utilities are installed with on https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux[RedHat Enterprise Linux] or https://www.centos.org[CentOS]. on https://www.suse.com[SLES] or https://www.opensuse.org[openSUSE] on https://www.debian.org[Debian] or https://www.ubuntu.com[Ubuntu] on https://www.archlinux.org[ArchLinux] or https://www.manjaro.org[Manjaro] === Usage The current version of the https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] library is 3.1.1 and uses a slightly different API than older versions (starting with 2). It is possible to have both versions of the https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] library installed at the same time. Since some Linux distributions only provide an older version (2) two executables are shipped: *flucFS* and *flucFS2* In case only an older version is available the executable *flucFS* will NOT work. Use *flucFS2* instead when executing any of the following commands. To mount the folder /var/data on the folder /home/hugo/mydata execute this command: If this is started from within the folder /home/hugo it can be abbreviated with If no logfile is specified, *flucFS* will NOT run as daemon and the logging is done to stderr. To unmount the filesystem execute or, if it was not running as a daemon, just hit <Ctrl>-C After it is unmounted, all data was written to the logfile. In case of errors, the contents will help us at limes datentechnik to figure out the cause. For further details of **flucFS** please see the documentation: link:../flucFS.html[flucFS(1)] === Known issues If a mount command fails with this message: Users NOT belonging to the group *fuse* are usally denied access to /dev/fuse **Solution:** The preferred solution is to add the required users to the *fuse* group. This is done by adding them to end of the line starting with *fuse* in /etc/group An alternative solution is to alter the permissions of the device node /dev/fuse to allow read and write for any user in order to mount a https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] filesystem by a user other than root. This can be done by executing If a mount command fails with this message: the https://en.wikipedia.org/wiki/Filesystem_in_Userspace[FUSE] library is too old for the shipped flucFS2. **Solution:** * Get a newer version of libfuse.so, at least 2.8 * Contact limes datentechnik to provide you with a version of   **flucFS2** that is built for such an old library. 2.8.0 was released on   August 18th 2009 (see: https://github.com/libfuse/libfuse/releases[FUSE releases]) ",
"",
""
],
[
"flcl_manual-fluc_subsystem_for_z_os_75bc.html",
"FLUC Subsystem for z/OS",
"[[flcl.appendix.flucsub]] == FLUC Subsystem for z/OS This appendix describes the handling of the FLUC subsystem in IBM z/OS environment. FLUC-sub is an interface to FLAM (z/OS), the compression and encryption utility, and may only be used in conjunction with a license for FLAM utility and FLUC subsystem. Further information on FLAM can be found at the beginning of this manual. === FLUC as a subsystem FLUC (FLAM Universal Converter) is part of the FLAM family and converts, compresses and encrypts whole files. While FLAM focuses on FLAMFILES as archive/exchange file, FLUC focuses on processing any file regardless of its origin (original z/OS files, PC files, FLAM, GZIP, OpenPGP, XML, ZIP, ...). Data can be consciously converted and prepared for / by a target system. The data is read/written as z/OS files, USS files or can be sent directly, e.g. via SSH. FLAM and FLUC contain interfaces (APIs) that can be used by custom applications. This allows flexible adaptation to existing tasks that cannot be handled by the utility alone. While a reprogramming of the interface is certainly no problem, an embedding into existing programs is always associated with effort. FLUC-sub is a subsystem of the z/OS operating system and is activated by the subsystem interface of the command language (JCL). All calls of an application program to file operations (e.g. opening, closing a file, reading and writing sentences) are received and processed by FLUC-sub. Changes are usually not necessary in the calling programs, the calling program does not notice any difference to conventional file processing. If necessary, DCB specifications must be specified in the DD statement or utilities (such as IEBGENER, SORT, special assembler routines). Without DCB information, the subsystem makes this data available when DISP=SHR. If the application program opens its file, FLUC-sub opens the file named in the parameters. If a data set is written, compressed, encrypted or converted, FLUC-sub converts it into this file. If a data set is read, FLUC-sub takes it from the file and transfers it to the application program decrypted, decompressed and converted. Closing the original file also causes the named file to be closed. With the parameter inputs, the entire variety of FLUC is available to the application program, i.e. an existing application program (in Cobol, PL/1, Assembler, C, Java) can use FLUC-sub to convert, compress, encrypt each data record during writing and store the data generated in this way directly in the same system, transport it to the target computer using an SSH connection. The file can then be a completely different type, completely independent of the one defined in the program, such as a FLAMFILE, GZIP, OpenPGP,ZIP, ... Likewise, the data can be formatted as required in the program, regardless of the origin of the data (ASCII, EBCDIC, XML, UTF8/16/32, ..., PC format, ...). And here too, the file to be read by FLUC is completely independent of the file defined in the program. The actual processing does not take place in the address space of the application program but in a subtask of the server (started task). Thus the address space is relieved and only small resources are used by the caller. A subtask is used for each file. The number of subtasks thus determines the number of files to be processed simultaneously. === Calling FLUC subsystem FLUC-sub is a subsystem of the z/OS operating system and is activated by the subsystem interface of the command language (JCL). The name of the subsystem is FLUC. This instructs the file with *ddname* to be processed with the FLUC subsystem. A file name is arbitrarily selectable and has no meaning for the processing and can also be omitted (then JES generates a name). This file name is transferred into a FLAMFILE when writing, so flexible use is possible. FLUC parameters have to be given to the process, as you are used to with FLCL in the utility. Parameters for controlling the subsystem are only recognized, if they are specified first. Faulty parameters are rejected by FLAM as JCL errors, so the job does not start at all. The JES check of the DD command remains unchanged. If `DISP=SHR` is specified in the DD command, FLUC-sub inserts the DCB specifications of a file to be read into the JCL, if no specifications have been made and the file name can be recognized in the parameters (`READ.xxxx(FILE=filename)`). The number of files to be processed 'simultaneously' by the subsystem depends on the number of generated subtasks of the server, otherwise FLUC does not limit it. With this technique, almost any file can be processed sequentially in read or write mode, which otherwise could not be processed in the application program (see the example collection). If DCB attributes are specified for ddname in the DD command, FLUC interprets them (in addition to the application program) as values for the original data, otherwise the specifications are defined in the program. === Principle of operation Before a batch job is started by JES, all JCL specifications are checked. JES passes the parameters for the subsystem; these are checked by FLUC-sub. If an error occurs, the DD statement is rejected as a JCL error. In addition, a message is displayed in the JCL list (see Example Collection; Messages). The job is therefore only started if there are no errors and is otherwise terminated as usual. The connection to the FLUC subsystem is established by calling the OPEN command in the program. For Open Input only read, decrypted if necessary, decompressed and converted, for Open Output only write, converted if necessary, compressed, encrypted. With OPEN, the file type, file organization, record and block length are taken from the caller's program (or the DCB specifications in the JCL) and used to process the data records. At the open time, the FLUC parameters specified in the JCL are also active and the processing routines are set accordingly. If an error occurs, the error routine remains active in the calling program and is not overlaid by the subsystem. The error return codes returned by the subsystem correspond to those of the file system (see also: https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R3sc236852/$file/idad500_v2r3.pdf[Manual DFSMS/MVS Macro Instructions for Data Sets]) for VSAM error codes, that is, the error routines do not have to be changed. For FLUC errors and subsystem errors, additional messages are output using WTO, Routcde=11 using FLUC-sub (see Messages; Example Collection). They are documented both in the system log and in the JESYSMSG list. With CLOSE on the file, the actually processed file is also closed by FLUC-sub. A new OPEN call is allowed. FLUC-sub requires only small resources in the address space of the user. A possible error or termination of a program, file access or similar has no influence on subsystem accesses of other processes and users. The 'actual' processing and thus the utilization of resources takes place in a server (started task FLAMSTC). Sub-tasks are generated in the server at startup. Each OPEN on a file is assigned to such a task. The number of these tasks thus determines the maximum number of files to be processed in parallel. With a CLOSE on the file, the corresponding task is released again. The maximum possible number of tasks is ultimately limited by the size of the memory area required. Errors that are detected in the server are reported to the application program as errors in the I/O system, and processing may not be continued.  The associated sub-task is restarted in the server if necessary and is available for the next OPEN call. System errors (such as a classic addressing error 0C4) in the calling program are recognized, the file to be processed in the server is closed, and the server sub-task is terminated. The server sub-task is again available to a new Open. === Preconditions FLAM/FLUC must be installed both as a utility and as a subsystem on the current computer, the associated started task (the server) must be active. Data records can be written or read. The accesses must be logical, i.e. in sequential order. Access via key or pointer is not possible ! If no file attributes are defined in the application program (such as record or block size), these specifications can be defined in the DD statement (see example collection). For example, utilities such as IEBGENER or SORT require these specifications. It is also possible to set the desired format using the FORMAT parameter specification. With DISP=SHR in the DD command, the file attributes recognized in the FLUC are set accordingly. When reading, the record buffers must match the data to be read. If the buffer is too small, the subsystem reports an error (RC=44 (VSAM)). === Restrictions Following restrictions apply: ==== DCB calls (for PS files) * If you omit record and block length specifications in programs (utilities such as IEBGENER or SORT work in this way),   you can specify the attributes in the DD command. With DISP=SHR in the allocation, the subsystem sets data in the JFCB (DD command). * Writing in LOCATE mode is rejected. * A temporary Close call for BSAM accesses (CLOSE ...,TYPE=T) is not forwarded to the subsystem and has no effect. * POINT for BSAM accesses is rejected with the error message IEC141I 013-BC .. (is not passed on to the subsystem at all). * Although a file with RECFM=VS or VBS (spanned records) can be written to, it can no longer be read via the subsystem interface   (error message IEC141I 013-A8 ...). ==== ACB/RPL calls (for VSAM files) Programming languages with a Runtime System (like COBOL, C, ...) do not allow VSAM files via FLUC subsystem as input/output. Unlike in the FLAM subsystem, FLUC-sub can only support assembler programs that do not (so accurately) check whether a VSAM file really exists. * Accesses with multiple RPLs (RPL list) are not supported (only the first RPL is evaluated). * Asynchronous calls are executed synchronously by FLUC-sub (but the reaction to errors does not occur until CHECK as usual). * CNVTAD returns invalid data or zero. * ENDREQ (Terminate a Request) has no effect. * VERIFY (Synchronize End of Data) has no effect (VSAM control blocks are not updated). * SHOWCB ACB=... +   The fields are not changed by the subsystem and retain their previous value. === Used FLUC-sub parameters Parameters for FLUC are transferred in the DD statement with the SUBSYS specification: or also ==== Subsystem parameter SUBSYS-parameter is used to control the subsystem itself and must be specified _before_ the FLUC parameters.         Output is logged both in the calling process and in the started task and on the operator console. +         Note: The amount of output can be very large.            if necessary, implemented accordingly. +            Without this parameter, the automatic analysis is not used. +            Note: Possible OPEN errors are only reported when writing records or in CLOSE! *PARMDD=ddname* Often the bytes allowed for parameters are not sufficient. With the specification the *ddname* of a parameter file (DSORG=PS,RECFM=V/VB/F/FB) is specified, as is now also common in the EXEC PGM statement. E.G. NOTE: Subsequent parameters are ignored. ==== FLUC parameter The FLUC parameters correspond to those of the FLUC Utilities (see also: https://flam.de/ftp/FL5/flcl/index.html[FLCL manual]). === Subsystem messages FLUC-sub only displays a message at the console in case of an error (via WTO ,ROUTCDE=11). It is also logged in the JCL log. The letter after the message number specifies the time at which the error was detected: * `I` - during initialization * `C` - when analyzing the JCL * `O` - when opening a file * `D` - during the I/O process * `E` - when closing a file Apart from the initialization of the subsystem, errors only affect the specified file of the respective job, i.e. the subsystem remains active for the other files and users. [width='100%',cols='^h,12',align='right',frame='none', grid='none'] |FLM0500I |*INITIALIZATION OF SUBSYSTEM FLUC COMPLETED* +             The FLUC subsystem has been initialized correctly and is now available.             Response: None |FLM0501I |*SUBSYSTEM FLUC NOT INSTALLED ON THIS SYSTEM* +             The subsystem cannot be initialized. It has not been             installed on the computer.             Response: Define and start the started task in SYS1.PROCLIB. |FLM0502I |*SUBSYSTEM FLUC ALREADY INITIALIZED* +             The subsystem is already defined and active, a             restart was rejected. The already active subsystem             remains active.             Response: FLUC-sub need not be restarted. |FLM0503I |*NO MEMORY RECEIVED FOR INITIALIZATION* +             The operating system cannot make any memory available for initialization.             The subsystem is not active.             Response: Increase REGION specification, analysis may be required             (system dump). |FLM0504I |*SUBSYSTEM COULD NOT FREE SYSTEM MEMORY* +             The memory made available by the operating system             cannot be freed. The subsystem has nevertheless been             initialized and is now available.             Response: An analysis is necessary (system dump). |FLM0505I |*SUBSYSTEM FLUC FUNCTION MODULE NOT FOUND* +             The work area received from the operating system             could not be released.             However, the subsystem has been initialized and             is ready.             Response: Set the subsystem modules in a library             of the master identification (SYS1.) and link them             with the LINKLIB. |FLM0510I |*INTERNAL ERROR. RC = no* +             An internal error has been detected.             The subsystem has not been initialized.             Response: Please inform your sales partner. |FLM0515I |*INITIALIZATION OF SUBSYSTEM FLUC FAILED* +             The subsystem cannot be initialized due to an error.             The error situation was documented in a previous             message. |FLM0519I |*FLUC SUBSYSTEM IS NOT LICENSED* +             Your license does not allow using the subsystem.             Response: Please inform your sales partner. |FLM0520C |*PARAMETER ERROR: ...* +             An invalid parameter was entered in the DD statement             of the JCL for FLUC-sub.             Response: Correct parameters and restart job. |FLM0523C |*NO MEMORY RECEIVED FOR JCL-CONVERTION* +             A subsystem module was not allocated any memory by             the operating system.             Response: An analysis is necessary (system dump). |FLM0530A |*PARAMETER ERROR: ...* +             An invalid parameter was entered in the DD statement             of the JCL for FLAM-sub.             The invalid parameter is displayed.             Response: Correct parameters and restart job. |FLM0531A |*NO MEMORY RECEIVED FOR ALLOCATION* +             A subsystem module was not allocated any memory by             the operating system.             Response: Increase REGION specification, analysis                       may be required (system dump). |FLM0540O |*OPEN ERROR. DDNAME=ddname. RC= no FLUC/VSAM* +             An error was detected for the file assigned with ddname             in the JCL at open time. FLUC return codes are decimal,             VSAM errors are decimal             (see also:             https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R3sc236852/$file/idad500_v2r3.pdf[manual DFSMS/MVS Macro Instructions for Data Sets]). +             This message is followed by the IEC141I 013-C0 message of             the data management system, where the DD name used by the             program is output. For VSAM accesses, the message IEC161             is output if necessary.             The FLUC error codes correspond to the utility.             Here are the most important ones:             40  = Error when reading the 1st record of a file +             84  = Parameter error +             135 = Connection could not be established             Reaction: +             RC = 40 is often used when reading with READ.RECORD a             file created in the Openwelt without format specification.             It is then assumed to be variable (corresponds to the             FILEDATA=RECORD of a DD statement). If necessary, specify                             READ.BIN (read binary) with recl=nnn. +             RC = 84 Errors in a parameter file are not detected until             Open is called. +             RC = 135 is a general return code that the connection to             the server was aborted. Further information is output in             the log of the Started Task. |FLM0541O |*OPEN ERROR. MESSAGE FROM FLAM-SERVER:* +             The message of the server about the Open error is logged. |FLM0552D |*I/O ERROR. DDNAME = ddname. RC = no (FLUC)/RPLERRCD file-name* +             An error was detected by the FLUC subsystem while             reading or writing in the specified file ddname. FLUC             return codes are specified in decimal format and             VSAM errors RPLERRCD in hexadecimal format.             All FLUC return codes are described in             the https://flam.de/ftp/FL5/flcl/index.html[FLCL manual].             You can find a list of VSAM return codes in the             https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R3sc236852/$file/idad500_v2r3.pdf[manual DFSMS/MVS Macro Instructions for Data Sets]).             The message is followed by IEC020I 001-Message of the DMS.             Some VSAM return codes: +             2C = Record length error, the record to be read is larger than the             block buffers created in the calling program. |FLM0553D |*NO MEMORY RECEIVED FOR I/O OPERATIONS* +             A subsystem module was not allocated any memory by             the operating system. Consequently, no other information is available.             Response: Specify a higher value for REGION in the EXEC statement,             an analysis may be required (system dump). |FLM0570E |*CLOSE ERROR. DDNAME = ddname. RC = no file-name* +             An error was detected when an attempt was made to             close the specified file.             Since records may still have to be written when             closing a file, see message FLUC552D. === Subsystem management The subsystem is administered via a Started Task (Server). The name of the Started Task is freely selectable, the name  in the delivery is FLAMSTC. It should be stored in the file SYS1.PROCLIB or correspondingly. When starting the Started Task from the Console both the server and the FLUC subsystem are started. terminates the server and the subsystem. If the command is inserted into the member COMMNDxx in SYS1.PARMLIB, FLUC-sub is automatically started at the IPL of the operating system and does not have to be entered extra at the console. displays the names and versions of the modules involved in the console: The list of generated tasks is displayed, as well as their status (active/inactive), the last function and the job name: releases the task with index number ## (from the list of the command LIST, TASKS, see above) again. If a task is blocked for any reason, it is terminated and restarted. If it is necessary to start or stop the subsystem independently from the server, the following commands are available: After deactivating FLUC-sub, modules of a newer FLUC-sub version could be installed, which could then be activated (after a LLA REFRESH to the library)  by a new `F FLAMSTC,FLUC,START`. === Examples ==== General information The subsystem has only a limited ability to output error messages. As a rule, the application program only receives corresponding return codes, and of course it depends on the program how it reacts. Since the parameter entries are identical to those of the utility, we recommend that you first test the specifications with the utility: You receive detailed messages on the process. Files are always read and written in the address space of the server (sub)tasks. The rights (RACF) of the caller apply. ===== Parameter file For reasons of simplification, we write all parameters in the examples to a file and assign them to the subsystem: and e.g. In the examples only the parameter input is described. ===== DCB specifications When reading and writing via a subsystem, there are basically two different cases: a) At the open time of the file, the program has specified the block and block length in the control block (e.g. in the FD section for COBOL). Then the SUBSYS specification in the DD statement is sufficient: Since the 'correct' values are specified in the calling program, the data records are passed/received by the subsystem according to these specifications. If the specifications with the file to be processed are not correct, error codes are set and a message is output (I/O error). Here the 'correct' values can be set by the FORMAT specification, the read data records are then converted into the format string according to the statement. b) The calling program has not defined block lengths. The format is also missing. In the 'normal case' (without subsystem) this information would be taken from the file catalog and entered into the control block (IEBGENER, SORT and many utility programs work in this way). Additional DCB attributes can be specified in the DD statement: If you do not know the record length, we recommend that you specify the following if possible. When reading and specifying DISP=SHR, the known attributes of the file are set correctly by the subsystem. If, for example, a FLAMFILE is to be read,  the attributes of the compressed file are specified. For unknown file attributes (such as files in USS, Unix, Windows, ...), the is set. It must be possible to recognize the file name in the parameter specification of the subsystem (PARMDD= does not work there). If necessary, a separate parameter file can be specified with the READ command (READ=file name), which contains the file name to be read (see also: https://flam.de/ftp/FL5/flcl/index.html[FLCL manual]). Finally, the attributes can also be specified by the FORMAT specification (FORMAT.RECORD(RECL= ....)). See: https://flam.de/ftp/FL5/flcl/index.html[FLCL manual]. ===== IEF... operating system messages In the JESYSMSG listing you can recognize the subsystem activity by the system messages: If no file name is specified in the DD statement, the operating system generates a name. This name is visible in the message IEF285I. ===== Differences BIN,CHAR,FLAM,RECORD,TEXT in reading/writing In FLUC the concept of sentence has been extended. The sentence format, length, blocking  of a file catalogued in z/OS no longer determines what a 'sentence' is.  This 'physical format' can be used to interpret a 'logical' one (see also: https://flam.de/ftp/FL5/flcl/index.html[FLCL manual]). [width='90%',cols='^1,9',align='center'] |*BIN*    | * Reads / writes all bytes (delimiter and padding are part of the data).   Possible record length fields (e.g. with RECFM=V) are not part of the data and   are ignored when reading or inserted when writing. + * The result is binary blocks in length of recl (FLUC parameter). |*CHAR*   | * reads all characters (delimiters are part of the data). Possible record length fields are not   part of the data and are omitted or inserted when writing. * automatic character set conversion. * The result is text blocks. |*FLAM*   | * reads records of the originally compressed file,   as they are stored in the FLAMFILE are stored. * Writes each transferred block to a FLAMFILE. |*RECORD* | * FIX, all records have the same length. * VARIABLE, data records have different lengths. * DELIM, data contains a delimiter (like read.text, but only a   certain Delimiter). The set ends then (only) with this Delimiter,   independent of the possible cataloged record length. * Character set conversion only if CCSID is specified, otherwise   binary processing. The result is binary or text sentences.   Without DELIM, this corresponds to the conventional sentence   term in z/OS (reading/writing a sentence as allocated/cataloged). |*TEXT*   | * Reads for (all) delimiters, cutting into sets * Automatic character set conversion. The result are sets   (without delimiter) in set length up to the delimiter. The   original record length of the physically read records in the file is irrelevant. * When writing, the system delimiters (X'15' for z/OS and USS, X'0A' for Unix,   X'0D0A' for Windows) are inserted at the end of the record. The data is written   in physical units to a z/OS file as specified by the catalog or parameter   in the DD statement. ==== Reading z/OS cataloged file The file USER.EXAMPLE.INPUT is a file cataloged in the z/OS system. This file must be read via FLUC-sub. Parameter: as a minimum. For this purpose several conversion, decompression, decryption and formatting instructions could be specified. The file USER.EXAMPLE.INPUT could be a normal sequential PS file with the same record format, length as defined in the program, but also of the type FLAMFILE, GZIP, ZIP, ..., whose original files in the compressed files have these (max.) record lengths. Instead of READ.RECORD you can also specify READ.TEXT, READ.BIN, READ.FLAM, etc. (see: https://flam.de/ftp/FL5/flcl/index.html[FLCL manual]). NOTE: If blocks longer than defined in the program (or specified in the DD statement) are read via FLUC, FLUC reports a block length error. If the cataloged file is one with print control characters (e.g. FBA), a special feature applies: By default, FLUC removes the control character from the record, so that for an FBA file with a cataloged record length of 133 bytes, only 132 are passed (as with FLCL utility). If the control character is to be retained, the following must be entered without further FORMAT specification or must be specified ! ==== Writing a z/OS file The file USER.EXAMPLE.OUTPUT is a file of the z/OS system.  It has to be written via FLUC-sub. If the file is not cataloged, it is created again. Parameter: as a minimum. In addition, several conversion, compression, encryption and formatting instructions could be specified. ==== Reading/writing a USS file The file `/srv/ftp/input/sample.txt` is stored in the USS under the UserID of the caller. It is a text file (i.e. it contains printable characters with delimiters). Parameter (reading): Parameter (writing): ==== Reading a Unix file via SSH The file `/srv/ftp/input/beispiel.bin` can be read binary via the SSH protocol in units of 1024 bytes. It is located on a foreign server, the access is protected with a password. Parameter: The special feature here is the cutting of the binary data by FLUC in units of 1024 bytes (parameter RECL). The application program must be able to process this length, if necessary RECFM=VB,LRECL=1028 must be specified in the DD statement. Of course, other record lengths, as required by the program, can also be specified here. NOTE: Without RECL specification, blocks of 64 KB are transferred! ==== Creating an OpenPGP file All records are to be written to a password encrypted OpenPGP file in the USS (Zip archive). Parameter: ",
"",
""
],
[
"flcl_manual-lexemes_4a30.html",
"Lexemes",
"[[CLEP.APPENDIX.LEXEMES]] == Lexemes The regular expressions used by the command line compiler are shown below. This content is printed on the screen with the built-in function `LEXEMES`. 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. ",
"",
""
],
[
"flcl_manual-grammar_2f56.html",
"Grammar",
"[[CLEP.APPENDIX.GRAMMAR]] == 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. ",
"",
""
],
[
"flcl_manual-properties_4944.html",
"Properties",
"[[CLEP.APPENDIX.PROPERTIES]] == Properties All properties can be written to a global property file with the built-in function <<CLEP.BUILTIN.GENPROP,GENPROP>>: A property file for a certain command can be generated with: 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: 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. ",
"",
""
],
[
"flcl_manual-properties-remaining_documentation_0ca7.html",
"Remaining Documentation",
"=== 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. The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll The SYSTEM destination allows the log messages to be written to the logging system of the operating system. On Unix and z/OS(R) systems the syslog() call is used. On Windows(R) the event logging facility is used. This registry key will be created by using the DLL flevent.dll ",
"",
""
],
[
"flcl_manual-properties-predefined_defaults_6a39.html",
"Predefined Defaults",
"=== 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. ",
"",
""
],
[
"flcl_manual-return_codes_ac55.html",
"Return Codes",
"[[CLEP.APPENDIX.RETURNCODES]] == Return Codes 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>>. The command line is interpreted by CLE the command string by CLP. For example: 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. ",
"",
""
],
[
"flcl_manual-return_codes-special_condition_codes_dd8c.html",
"Special Condition Codes",
"=== Special Condition Codes Special condition codes are issued for a dedicated job/batch control. For error conditions, which must be handled in a special way, the condition codes below are defined.          operation was done (FLMRTC_LIM).          as being a FLAM compressed file. The very beginning of the          file is corrupted to such an extent that the FLAM syntax          cannot be recognized or the file is empty (FLMRTC_CFF).          be detected as an ASCII-based charset if the first block of          data contains only ASCII characters (<128). In consequence,          character conversion will eventually run into an 'malformed          encoding' (ENOMSG) error on the first multi-byte character          which results in this condition code. In this case, it makes          sense to re-run the command with the correct ASCII CCSID, for          example Latin-1 (FLMRTC_TAS).          Please restart the job with a larger block size.          This could happen, for example, if PGP is used with BZIP2          compression and large (900 KiB) blocks. In this case, 1 MiB          would be a reasonable block size (FLMRTC_NBS). ",
"",
""
],
[
"flcl_manual-return_codes-reason_codes_8cea.html",
"Reason Codes",
"[[CLEP.APPENDIX.REASONCODES]] === Reason Codes 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 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 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 * 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 * 151 - Already exists * 152 - Tell offset in file does not work * 153 - Record too long * 154 - Record too short * 155 - Dynamic allocation of a file failed * 156 - Re-open of file failed * 157 - No such file or directory * 158 - Permission denied * 159 - No space left on device * 160 - Restart with larger block size required * 161 - Close/end encountered (special handling required) * 162 - Missing field definition * 163 - Element already deleted * 164 - Error from ZSTD library * 165 - Crypto error * 166 - Open of side/parameter file failed * 167 - Write of side/parameter file failed * 168 - Length mismatch * 169 - Compile of regular expression failed * 170 - Validation based on regular expression failed * 171 - Replacement based on regular expression failed * 172 - Ignore record ",
"",
""
],
[
"flcl_manual-version_bb9f.html",
"Version",
"[[CLEP.APPENDIX.VERSION]] == 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. ",
"",
""
],
[
"flcl_manual-about_d486.html",
"About",
"[[CLEP.APPENDIX.ABOUT]] == About This is the about information for the program (flcl). Its content is printed on the screen if the built-in function <<CLEP.BUILTIN.ABOUT,ABOUT>> is used. ",
"",
""
],
[
"flcl_manual-glossary_8e8d.html",
"Glossary",
"[glossary] == Glossary    compression algorithm of FLAM4.    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.    7-Bit encoding, which is the source for later character sets    based on more bits.    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.    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.    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.    from the byte order mark (BOM).    from the byte order mark (BOM).    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.    individual Unicode characters and sequences of Unicode    characters.    lowercase or some special representation (CASE=UPPER/LOWER).    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]    components which transform data stream in data stream (e.g. character    conversion, compression, de/encryption, de/encoding, ...).    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.    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.    if their full compatibility decompositions are identical.    methods via the CONV command. These are various read and write    procedures, many useful conversion tools and some special data    formatting features.    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.    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.    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]    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.    Service provider interface to connect FLAM till version 4 with    different kinds of cryptographic infrastructure, hardware security    modules and/or key management systems.    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 utilization, 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.    name of a Flamfile or that of a member.    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.    the graphical user interface for running FLAM, FLUC and FLIES, quasi    a dialogue utility    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 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.    converter with special focus on the high requirements in    professional internationalization projects, where Mainframes and    external applications are used as central backend.     conversion.    All components to parse a data stream in FLAM5 element list or build    a data stream from FLAM5 elements list.    used as source encoding for character conversion.    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).    commands on the command line.    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.    (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.    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.    important information, input data) can be logged. The messages    can be redirected from stderr to stdout or a file.    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.    copying data in FLAM4.    Canonical Composition).    by Canonical Composition).    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.    storage positions. Padding bytes are most commonly appended after the    the last data byte. When reading padded data, the padding bytes are    discarded.    zero or more members,    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 .    work independently from the used operating system. Operating systems    can be for example LINUX, UNIX-like systems, WINDOWS(R) or z/OS(R).    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]    see also: https://en.wikipedia.org/wiki/Secure_Shell/[SSH]    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.    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.    it will be converted to a converter-defined substitute character.    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.    the transliteration of characters. This is comparable to    'translit.h' of iconv under LINUX.    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.    System. +    see also: https://www.ecb.europa.eu/paym/target/target2/html/index.en.html/[TARGET]    another. The TO-Code specifies the output encoding that characters    are converted to.    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.    original language into any target language; the process will be also    denoted as 'Translating'.    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.    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).    see also: https://en.wikipedia.org/wiki/URL/[URL]    substitution table to transliterate those characters that are not    handled respectively replaced by the system table.    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.    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.    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.#    see also: https://www.ibm.com/support/knowledgecenter/zosbasics/com.ibm.zos.zconcepts/zconcepts_169.htm/[VSAM] ",
"",
""
],
[
"flcl_manual-imprint_2c32.html",
"Imprint",
"[colophon] == Imprint ",
"",
""
],
]);
