NEWS - user visible changes				-*- outline -*-

 GnuCOBOL 3.2     (20230728)
 GnuCOBOL 3.2rc1  (20230118)
 GnuCOBOL 3.2rc2  (20230210)

* New GnuCOBOL features

** Support for LINE SEQUENTIAL file type as per COBOL 2023
  * OPEN INPUT-OUTPUT and REWRITE are allowed (note that INPUT-OUTPUT
    leads to slower IO for LINE SEQUENTIAL files)
  * validation of data on (RE-)WRITE and READ, active by default,
    can be adjusted with the new runtime option COB_LS_VALIDATE

** New intrinsic functions

  BIT-OF, BIT-TO-CHAR, HEX-OF, HEX-TO-CHAR

** Support for COBOL 2023 directive COBOL-WORDS

** Support for bit operations according to COBOL 2023 with MF compatibility

** Support for additional $SET directives: ODOSLIDE

** Support for the EXTFH has been greatly enhanched and now includes support
   for FH--FCD and FH--KEYDEF, fixed use of different attributes and changing
   pointers and now supports - for 32-bit builds - an internal conversion
   between FCD2 and FCD3 for cases where existing programs are coded with FCD2

** OCCURS with multiple VALUEs supported (BS2000 format, FROM and TO pending)

** new function to call COBOL from C that doesn't abort the program in case
   of runtime errors or STOP RUN: cob_call_with_exception_check()

** Support for the GCOS 7 (Bull) dialect, including:
   * PICTURE strings with L character (variable length fields)
   * CONTROL DIVISION with SUBSTITUTION SECTION (full support) and DEFAULT
     SECTION (partial support)

** Multiple sequential files can be concatenated by specifying multiple
   files with a separator in the ASSIGN name (either directly or via
   environment), see the new runtime options
   COB_SEQ_CONCAT_NAME (defaults to false) and COB_SEQ_CONCAT_SEP

** Initial "testing support" of CODE-SET clause to convert between ASCII and
   EBCDIC on READ/WRITE/REWRITE for sequential and line-sequential files

** Initial "testing support" of FLOAT-EXTENDED (long double type)

** minimal "parsing support" for USAGE UTF-8 and UTF-8 literals

** Support to exit the runtime from COBOL as hard error (including possible
   [core-]dump and stacktrace) with "STOP ERROR" statement or by
   CALL "CBL_RUNTIME_ERROR"

** COB_PHYSICAL_CANCEL can now be configured as "never" to prevent unloading
   of COBOL modules, both on CANCEL and on process exit, which is useful for
   analysis tools such as callgrind or perf to keep all symbols until the end
   of the COBOL process

** the system function x'91' has been extended to support more functions

* Changes that potentially effect existing programs:

** ALLOCATE statement: earlier versions of GnuCOBOL initialized the memory
   (to binary zero) if the INITIALIZED clause was not specified,
   this isn't done anymore so if you need the memory to be initialized
   specify that explicit in the source and recompile

** variable-length RECORD SEQUENTIAL files, data validation on READ:
   the length of the record as stored in the file is now checked for correct
   format and is then compared against the record size defined in the program;
   if the minimal record size specified is bigger, then the data is only
   written up to the record length for that record, the other data is
   undefined and io status 04 returned; if the record length is bigger than
   the record size the record from the file is truncated, io status 04 set
   and the following READ will start at the next record;
   additionally on OPEN the length of the first record is read and if it
   isn't within the above rulesan io status 39 is returned; as the default
   format "COB_VARSEQ_TYPE = 0" contains two NULL bytes this will likely
   make most LINE SEQUENTIAL files not declared as this type fail on OPEN

** LINE SEQUENTIAL files, data validation: in case of bad printable data
   (less than SPACE) a READ may result in io status 09 and WRITE may error
   with io status 71; see the new runtime option COB_LS_VALIDATE to disable
   this validation (= old behavior) and to increase performance on line
   sequential file io;
   if LS_NULLS is active and invalid data (bad encoded or missing encoding)
   is found io status 71 is returned

** LINE SEQUENTIAL files, handling of records that are "too long":
   in case of "overflowing" records previous versions of GnuCOBOL cut the
   data, set io status 00 and skipped the file until the next line
   terminator is found;
   the default changed (per COBOL 2023 and other compilers) so the data is
   returned as "multiple" records and a warning (status 06) is issued;
   setting COB_LS_SPLIT = false will have the old behaviour of truncating
   the record, but will now set status 04

** FUNCTION RANDOM: the internal randomizer was changed from "C" to "GMP"
   this means that the sequence of random numbers are different when using
   the same seed as versions before 3.2
   while the changed use has the downside of taking longer for each seeding,
   it provides a much better distributed sequence and increases portability
   (switching to a different "C" runtime or operating system won't change the
   sequences); additional the implementor-defined default seeding was changed
   from "0 in most cases" to a random seed;
   if you _want_ the return values to be identical you always need to specify
   a seed (including possibly 0);
   the old behaviour can be enforced by compiling GnuCOBOL with
   LIBCOB_CPPFLAGS=-DDISABLE_GMP_RANDOM

** FUNCTION EXCEPTION-LOCATION: if the source raising an exception was not
   compiled with location information this function previously returned
   a single space; GnuCOBOL now always returns the module name, a procedure-
   name " " and the source (line) identifier "0"

** FUNCTIONs NUMVAL, NUMVAL-C, NUMVAL-F: if the argument does not match the
   argument rules previous versions returned zero; now invalid data is skipped;
   for example: "1. A-0B4.5" now returns -1.045 (or -1045 when the
   DECIMAL-POINT IS COMMA clause is in effect);
   as with previous versions the argument can be validated before using the
   FUNCTIONs TEST-NUMVAL, TEST-NUMVAL-C, TEST-NUMVAL-F or the exception can
   be checked afterwards using the EXCEPTION related functions;
   the old behaviour can be enforced by compiling GnuCOBOL with
   LIBCOB_CPPFLAGS=-DINVALID_NUMVAL_IS_ZERO

** Handling of invalid numeric USAGE DISPLAY data:
   previously the complete character was inspected and adjusted for conversion,
   now only the second half-byte is used;
   this yields in different results, for example both the zero and space
   character in both ASCII and EBCDIC charset will now result in a numeric
   zero; previously invalid data could result in huge or negative numbers in
   internal intermediate items;
   as this was both adjusted in the runtime and in the the generated modules
   invalid data may have additional unexpected results if programs are not
   recompiled

** ORGANIZATION INDEXED (with BDB backend): internal changes in record and
   file locking, fixing some related bugs

** extended screen io with PDCurses (most Win32 builds): blink and bolding
   are now enabled, when supported

** extended screen io: support for color codes 8-15 (implied highlight/blink
   attribute); only the three lower bits are now considered during evaluation
   of the color-number, leading to a previous value of 21 (which was ignored
   until now) being interpreted as 5, see FR #387

** extended screen io with single-fields: runtime-adjustable attributes by
   support of extension clauses COLOR and CONTROL for ACCEPT and DISPLAY
   statements, see FR #189 + FR #355; note: while COLOR and CONTROL are parsed
   for SCREEN SECTION they are ignored at runtime

** extended screen io with single-fields: the ACCEPT statement now supports
   the extension CURSOR clause, additional to the standard-defined
   CONTROL phrase in SPECIAL-NAMES

** the programmable runtime switches "SWITCH A" through "SWITCH Z" internally
   used 1-26 and now use 11-36 to be able to combine then with switches 0-7;
   if you set those via COB_SWITCH environment variables you need to adjust
   their numbers

* Changes that potentially effect recompilation of existing programs:

** the reserved word list and intrinsic functions was updated, especially
   to cater for new features of COBOL 2023; if compiling with any non-strict
   dialect you may need to unreserve any conflicting words / functions

** in 64-bit environments, the default size for BY VALUE parameters has changed:
   If no explicit SIZE IS clause is specified,
	old behavior: parameter passed as 32-bit value
	new behavior: parameter passed as 64-bit value
   To specify a 32-bit BY VALUE parameter, change the COBOL source to use
   SIZE IS 4.  To continue to rely on the default size, both caller and
   callee modules that use BY VALUE must be compiled with the same version of
   GnuCOBOL, either prior this release, or since.

** cobc now uses a two-pass preprocessing algorithm, where replacements for
   COPY-REPLACING are done in a first pass, and the replacements for
   REPLACE are done in a second pass. Note that, however, both
   statements are parsed before the first replacement pass, so
   COPY-REPLACING cannot impact a REPLACE statement itself.

* Changes to the COBOL compiler (cobc) options:

** new -fformat dialect option, and extended SOURCE FORMAT directives,
   with the following newly supported reference-formats (in addition
   to FIXED/FREE):

   COBOL85      Fixed-form format with enforcement of Area A
   COBOLX       GCOS 7 extended format
   CRT          ICOBOL Free-form format
   TERMINAL     ACUCOBOL-GT Terminal format
   VARIABLE     Micro Focus Variable Fixed-form format
   XCARD        ICOBOL xCard (extended card) format
   XOPEN        X/Open Free-form format

   These formats come with Area A enforcement (except for XOPEN), that
   checks whether division, section, and paragraph names start in Area
   A (i.e, before margin B), and so do level indicators FD, SD, RD,
   and CD, and level numbers 01, and 77.  The underlying checks are
   enabled or disabled by default using dialect option `areacheck`,
   and then with `$SET AREACHECK` and `$SET NOAREACHECK` compiler
   directives.

   As a result of reference format being a dialect option, Area A
   enforcement is available and enabled by default for dialects BS2000
   COBOL, CA Realia II, COBOL85, GCOS COBOL, IBM COBOL, MVS/VM COBOL,
   RM-COBOL, and X/Open COBOL.

   Area A enforcement additionally enables detection of missing
   periods before level numbers that lie in Area A in the DATA
   DIVISION, and before paragraph and section names in the PROCEDURE
   DIVISION.  More generally, some, but not all, missing periods can
   be reported and recovered from.  This is configurable with option
   `missing-period`.

   If not specified, the compiler tries to automatically recognize the format,
   using either fixed or free, depending on column 7 in the first non-space
   line. This feature can be disabled by setting the format manually
   with `-free`, `-fixed` or `-fformat`.

** the new -febcdic-table option enables one to specify the
   translation table used when dealing with EBCDIC codeset;
   these translation tables are stored as new configuration files with
   an extension of ".ttbl", currently available tables are:

   default    translation to extended ASCII as per MF
   alternate  translation from restricted ASCII only
   ebcdic500_ascii7bit   EBCDIC 500 <-> 7-bit ASCII as per IBM
   ebcdic500_ascii8bit   EBCDIC 500 <-> 8-bit ASCII as per GCOS7
   ebcdic500_latin1      EBCDIC 500 <-> latin-1 as per iconv

   This option supersedes the -falternate-ebcdic flag (still available
   for backwards compatibility), which is equivalent to
   -febcdic-table=alternate.

** the compile flag -fodoslide was moved to a dialect configuration,
   while -fodoslide still works as before it is now implied with
   -std=ibm/mvs/bs2000, if you use those dialects consider to recompile
   affected programs (with OCCURS DEPENDING ON) or compile with additional
   -fno-odoslide to get the same results as with older GnuCOBOL versions

** the compile flag -fdefaultbyte (initialization for data-items without
   an explicit VALUE) was moved to a dialect configuration;
   while -fdefaultbyte still works as before it is now implied as binary
   zero with -std=ibm/mvs/bs2000/realia, space for -std=mf/acu/rm, and
   no defined initialization for -std=cobol85/cobol2002/cobol2014/xopen,
   it is unchanged for -std=default (initialize to PICTURE/USAGE);
   for compatibility to previous behavior compile with -fdefaultbyte=init;
   note that initialization for INDEXED BY items honors the defaultbyte
   configuration now, too

** new dialect init-justified that applies right justification by JUSTIFIED
   clause for VALUE clause; this is applied to IBM dialects, if you want
   the previous behavior compile with -fno-init-justified

** depending on the new dialect option "using-optional" (included in the
   the default dialect), checks for arguments not passed are now done (only)
   on CALL, not on their (possibly many) references; if you want the old
   "postponed" check either specify the parameter as OPTIONAL or use
   -fusing-optional=skip; note: the non-strict dialects will raise a warning
   on the first use of this feature, then automatically enable it

** the dialect configuration option larger-redefines-ok was replaced by
   the support option larger-redefines; if specified on the command-line
   it is now -f[no-]larger-redefines instead of -f[no-]larger-redefines-ok,
   which allows to also raise a warning for those with -flarger-redefines=warn
   Note: the short one works both in current and older versions of cobc

** the subscript checking enabled with -fec=bound-subscript (implied with
   --debug) now generates checks depending on the new dialect configuration
   option subscript-check if OCCURS DEPNDING ON is used;
   the full check according to ISO COBOL, which checks against the ODO item
   is still used in the default dialect, but several dialects now only check
   against the maximum only

** the GnuCOBOL extension of auto-adding the RECURSIVE attribute
   if a program potentially calls its own PROGRAM-ID was moved
   to a dialect option; it is now only active with -std=default
   (and raises a warning as previously with -Wextra); if you want
   to use this extension for other dialects use the new
   -fself-call-recursive=warning (or "ok")

** the option -g does no longer imply -fsource-location; but it auto-includes
   references to the COBOL-paragraphs to further ease source level debugging

** -fsource-location generates source references to copyboooks in DATA
   DIVISION, enabling to inspect the initial VALUE setting as well as
   "list"ing those copybooks with a source level debugger

** new flag -fstack-extended (implied with --debug and --dump) to include
   the origin of entrypoints and PERFORM, this is used for the internal
   stack trace on abort and can be used for improved source level debugging

** new flag -fmemory-check (implied with --debug) to do some validation
   of internal memory used during CALL; this can help in finding otherwise
   hard to diagnose overwrite of memory and as it is only done on CALL
   has a much smaller footprint than -fec=bounds (as both check different
   aspects at different places it is also reasonable to use both);
   to disable it use -fmemory-check=none or limit by -fmemory-check=pointer

** the option -g does no longer imply -fno-remove-unreachable; if you want to
   keep those in you need to explicit specify this

** the option -O0 now implies -fno-remove-unreachable

** new options to ensure structured code-flow:
   -fsection-exit-check to ensure sections don't "fall through" (are always
    entered and left by PERFORM)
   -fimplicit-goback-check to ensure modules are not left by implicit GOBACK
    at end of PROCEDURE DIVISION

** adjustments to warning options:
   -Wconstant-expression was changed to a group warning and includes
    the new, previously integrated, -Wconstant-numlit-expression
   -Wtyping as a new warning raises only very suspicious MOVEs,
   -Wstrict-typing, which will warn as before even for MOVE 1 TO PICX-FLD
    is not included in -Wall any more
   -Wlarger-01-redefines as new warning (enabled by -Wextra) to check for
    the only larger REDEFINES that is explicit allowed by the COBOL standard
   -Wno-unsupported -Wunsupported new option to disable or only warn
    on use of features the runtime is not configured for;
    this new option defaults to an error (= -Werror=unsupported)
   -Wgoto-different-section as new warning (enabled by -Wall) to check for
    GO TO that are likely to break the flow of PERFORM some-section
   -Wgoto-section as new warning (enabled by default) to check for
    GO TO a section instead of a paragraph; while allowed this is often
    a coding error
   -Wsuspicious-perform-thru (enabled by default) to check for PERFORM ranges
    that are likely to create unwanted behaviour
   -Wother now  warns for suspicious reference-modification which is likely to
    create out-of-bounds access at runtime

** new compiler command line option to list the known runtime exception names
   and fatality `cobc --list-exceptions`

** new compiler command line option -ftcmd to enable printing of the command
   line in the source listing, -fno-timestamp to suppress printing of the time
   and -ftittle to set a title instead of GnuCOBOL and version (_ chars are
   replaced by spaces in the title)

** new compiler command line option --coverage to instrument binaries
   for coverage checks

** the command line options -MT and -MF, which are used for creating a
   dependency list (used copybooks) to be used for inclusion in Makefiles
   or other processes, and which were removed in GnuCOBOL 2 are back in their
   original version; note: their use will be adjusted where they don't match
   GCC's same options in later versions, including addition of -M and -MD

** new -std options:

   gcos            GCOS compatibility
   gcos-strict     GCOS compatibility                - strict

   We define the GCOS dialect based on the COBOL85 standard, with new
   dialect configuration options accompanying each specificity
   introduced by the dialect.

** new diagnostic format for errors: the diagnostics now print the source
   code context with a left margin showing line numbers, configurable with
   -fno-diagnostics-show-line-numbers, and possible to disable completely
   with -fno-diagnostics-show-caret;

   the option -fdiagnostics-plain-output was added to request that diagnostic
   output look as plain as possible and stay more stable over time

** the -P flag accepts - as argument for stdout

* Important Bugfixes:

** for dialects other than the GnuCOBOL default different reserved "alias" words
   were not usable, for example SYNCHRONIZED or COMPUTATIONAL. This was fixed
   and reserved words updated for the dialects "acu" (to ACUCOBOL-GT 10.4),
   "ibm" (to Enterprise COBOL 6.3) and "mf" (to Micro Focus Visual COBOL 6.0)

** for all "lax" varants SYNC was handled even if commonly ignored by the strict
   dialects, this was fixed so SYNC is ignored depending on the dialect

** COBOL programs compiled with versions before GnuCOBOL 3 that used files with
   ORGANIZATION INDEXED or RELATIVE crashed when executed with newer versions,
   this has been fixed so that all modules compiled with GnuCOBOL 2.2 can be
   executed with GnuCOBOL 3.2

** FUNCTION RANDOM could return 1 in rare cases (more likely on win32),
   it now returns a value in the range 0 <= x < 1, as defined

** the internal signal handler could crash or deadlock the process on hard
   errors (either in called library functions or when running COBOL without
   runtime checks); the signal handling is now completely rewritten to fix
   this issue and all executed code from the signal handler but the COBOL data
   dump is now signal and thread safe

** TYPEDEF items got storage and attribute assigned, leading to bigger modules,
   longer loading time and longer compile times; if you use those a recompile
   is highly suggested

** several bugs in COPY REPLACING / REPLACING were fixed along with adding
   support for exensions related to REPLACING LEADING / TRAILING

** for PICTURE P several fixes were made, so results may vary compared with
   previous versions; sources with *leading* P never worked correct before,
   and *must* be recompiled after upgrading

** since its addition to GnuCOBOL ROUNDING MODE PROHIBITED just prevented
   rounding; its behaviour changed to match the specification by doing that,
   raising EC-SIZE-TRUNCATION and changed: not adjust the target field if
   rounding would be necessary to store the data

* Listing changes

** the timestamp in the header was changed from ANSI date format like
   "Tue Sep 28 09:49:43 2021" to formatted time (year after day); this may be
   changed during `configure` with adding a define to COBC_CPPFLAGS;
   to either use the old format, adding add `-DLISTING_TIMESTAMP_ANSI`,
   or to use an explicit format (cut at 26 characters, may raise false-positives
   in listing tests) e.g. date only `-DLISTING_TIMESTAMP_FORMAT="%Y-%m-%d"`

** new compile options to adjust the listing, see above

* More notable changes

** in general, the maximum field size in LINKAGE SECTION was increased from
   268435456 bytes (999999998 bytes for OCCURS UNBOUNDED) to the system
   specific INT_MAX - 1, which is commonly 2 GB

** in 64-bit environments, the maximum field size outside of LINKAGE SECTION
   was increased from 268435456 bytes to 2 GB

** numeric DISPLAY can store and may contain a positive zero after arithmetic,
   PACKED-DECIMAL may contain negative zero (x'0D') after arithmetic; as before
   numeric comparisions to ZERO / 0 / +0 / -0 will all be identical

** quotes around filenames and parts that are resolved by environment variables
   are internally ignored

** the exception check for EC-PROGRAM-ARG-MISMATCH is now generated, validating
   that non-optional PROCEDURE DIVISION USING items are passed and that their
   size in the caller is at least as big as in the program

** in case of any runtime features being used that are not available an error
   is generated during compile (may be reduced to a warning by -Wunsupported
   or be suppressed by -Wno-unsupported) and if the feature is actually used
   at runtime a related exception status is set

** the call-stack show on error and/or in the dump file now contains all
   parameters given to the program via command line options, if any;
   if full debugging information is available it includes all PERFORMs executed

** the dump that is created on abort for all programs that were compiled with
   -fdump can be explicit disabled by setting COB_DUMP_FILE=NONE; it is
   automatically disabled if the process ends upon signals SIGINT/SIGTERM and
   now also disabled upon SIGHUP/SIGPIPE

** additional or instead of the internal COBOL dump a coredump file may be
   created on runtime errors and when configured in the system also after
   the signal handler; see the new runtime option COB_CORE_ON_ERROR for
   details (the default is a best match to the old behavior)

** source references shown in diagnostic messages and for trace at runtime
   as well as during debugging were extended, for example each executed WHEN,
   VARYING and UNTIL phrases are now seen

** condition-names are made available for source-level debugging

** cobc's parsing time was significantly reduced for big programs

** execution times were significantly reduced for the following:
	INSPECT that use big COBOL fields (multiple KB)
	MOVE and comparisions in general (especially with enabled runtime
	   checks, to optimize those a re-compile is needed)
	CALL data-item, and first time for each CALL
	ACCEPT DATE/TIME/DAY, most if numeric items are accepted
	datetime related FUNCTIONs
	runtime checks for use of LINKAGE/BASED fields and/or
	  subscripts/reference-modification (re-compile needed)
	general: execution of programs generated with -fsource-location
	  (implied with --debug and -fec), especially when many "simple"
	  statements or lot of sections/paragraphs are used (re-compile needed)

* New system functions

  CBL_GC_SET_SCR_SIZE  option to resize extended screen

* New build features

** configure now honors BDB_LIBS and BDB_CFLAGS
** configure now honors MATH_LIBS
** configure now checks for XCurses and allows --with-curses=xcurses
   (experimental)
** configure now checks for PERL and passes that as default to make test
** cobc handles SOURCE_DATE_EPOCH now, allowing to override timestamps in
   generated code and listing files, allowing reproducible builds of both
   GnuCOBOL (extras folder) and COBOL programs

* Obsolete features (will be removed in the next version if no explicit user
  requests are raised)

** use of old non-GMP randomizer for FUNCTION RANDOM

** undocumented option -tsymbols, which was replaced by -ftsymbols in 3.0


* Known issues in 3.2 (and 3.1)

** testsuite:
  * if built with vbisam, cisam or disam, depending on the version used, some
    tests will lead to UNEXPECTED PASS, while others may fail
  * possibly failing tests (false positives):
    * temporary path invalid
    * compiler outputs (assembler)
    * compile from stdin
  * NIST: OBNC1M.CBL false positive (the test runner uses a nonportable way of
    emulating a program kill)
  * if build with -fsanitize, then some tests will fail; while we accept patches
    to improve that, we don't consider the failing tests as bug in GnuCOBOL

** the recent additions of ">> TURN" and "variable LIKE variable" may not work
   as expected in all cases

** floating-point comparison for equality may return unexpected results as it
   involves a necessary tolerance; you may adjust the default tolerance of
   0.0000001 by compiling GnuCOBOL for example with
   LIBCOB_CPPFLAGS="-DCOB_FLOAT_DELTA=0.0000000000001";
   we seek input for a reasonable default for GnuCOBOL 4 (use the mailing list
   or discussion board to share your comments on this topic, keeping in mind
   that this has to take both mathematical and "C compiler portability" into
   account)

** variables containing PICTURE symbol P may lead to wrong results in rare
   cases (especially screenio) - please send a bug report if you catch a case;
   since GC 3.2 rc3 all arithmetic operations and MOVE are believed to be
   correct

** features that are known to not be portable to every environment yet
   (especially when using a different compiler than GCC)
    * function with variable-length RETURNING item
    * USAGE POINTER, which may need to be manually aligned

** all versions of GnuCOBOL so far: EVALUATE evaluates all subjects on *each*
   WHEN (the standard explicit requests a one-time evaluation of the subjects,
   then comparing the value); to work around possible issues move more complex
   subjects like variables with subscripts and reference-modification, as well
   as calculated subjects and function calls to a temporary variable and use
   this as subject for the EVALUATE

For more known issues see the bug tracker.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 GnuCOBOL 3.1.2 released (20201223)
 GnuCOBOL 3.1.1 released (20201208) containing INITIALIZE bug #694
 GnuCOBOL 3.1 released   (20201111) had build issues that were fixed

* New GnuCOBOL features

** XML GENERATE statement
   (note: runtime support needs additional library libxml2)

** JSON GENERATE statement
   (note: runtime support needs additional library cJSON or JSON-C)

** CONTINUE AFTER statement (COBOL 2023) implemented, also handle fractions
   of seconds in C$SLEEP now

** TYPEDEF and SAME AS (COBOL 2002) implemented, including the MicroFocus
   and RM/COBOL variants

** >>TURN (COBOL 2002) directive implemented, allowing some exception checks
   to be turned on/off per source as desired

** Improved support for different compiler extensions (ACUCOBOL, IBM,
   Fujitsu, MicroFocus COBOL, Microsoft COBOL, RM/COBOL, CA Realia and more)

** file handling: include support for a callable EXTFH interface also provided
   by several compilers including Micro Focus
   This allows users to insert an external file handler while retaining
   all the normal COBOL I/O functions with a possible callback to libcob.
   To have the compiled program call `yourfh()` for file I/O use:
   `cobc -fcallfh=yourfh`
   In turn `yourfh()` may call `EXTFH()` to use I/O functions from GnuCOBOL.
   The external file handler can also be directly invoked from COBOL, too,
   using `CALL "EXTFH"`.
   ** Note: Not each flag contained in the FCD3 is handled already **

** file handling: added support for [RE]WRITE FILE file FROM source

** file handling: name mapping adjusted (improved MF and ACU-compatibility):
   entries starting with a period or number are not resolved any more,
   periods in the external identifier are always replaced by underscore
    -> MY.FILE is resolved by DD_MY_FILE, dd_MY_FILE, MYFILE now;
   prefixes "-F " and "-D " are removed from external names;
   if filename is not absolute after translation, COB_FILE_PATH is now
   still applied;
   File name mapping now applies both to COBOL statements and CALLable
   CBL_ and C$ file routines.

** Screen I/O: initial mouse support (for details see runtime.cfg),
   use of CURSOR clause in SPECIAL-NAMES for positioning on ACCEPT

** on abort a stack trace will be generated, this can be suppressed by
   runtime configuration option COB_STRACK_TRACE

** the dump that is generated on abort (depending on -fdump at compile-time)
   was heavily improved and combines consecutive identical OCCURS items,
   leading to smaller dump files

** changes in handling COPY statement:
   * copybook names that contain an extension aren't searched with additional
     extensions [as post-rc1-change this may be set to old behavior by
     defining COB_MULTI_EXTENSION when building GnuCOBOL/cobc]
   * library names are now tested for environment "COB_COPY_LIB_libname",
     allowing the directory to specified externally (also as no-directory
     by exporting with empty value) and has a fallback (with a warning) to
     be effectively ignored (as previous versions did this)

* Removed functions

** SCREEN SECTION, REPORT-WRITER module: removed non-standard extension
   "LINE / COL signed-integer" (inadvertently available since 2.2/3.0rc1);
   which will now raise an error "unsigned integer expected";
   if used replace by standard "LINE / COL +/- integer"

* Obsolete features (will be removed in the next version if no explicit user
  requests are raised)

** support for Borland C compiler and linker
** -fif-cutoff flag for cobc (currently disabled, see entry below in 3.0rc1)
** old OpenCOBOL-only-EXTFH

* Changes to the COBOL compiler (cobc) options:

** new options:
   -f[no]-ec=exception-name to tune the exception checks similar to the >>TURN
       directive, you may also leave out the "EC-" prefix here, example to
       enable all checks but disable all bound checks but OCCURS DEPENDING ON:
       cobc -debug -fno-ec=bound -fec=bound-odo

** adjustments to warning options:
   -Wextra "new" option to enable every possible warning that is not dialect
       specific (this option used to be called -W)
   -Wadditional  new warning group for all warnings that don't have a group
       on their own
   -Wno-error and -Wno-error=<warning> to treat all or a specific <warning>
       not as error
   -Wdangling-text for raising the warning "source text after program area",
       not included in -Wall any more
   -Wno-ignored-error allows to suppress messages that normally would be an
       error and are only allowed because they are never executed
   -Wcorresponding is now enabled by default

   -f[no]-diagnostics-show-option, enabled by default, shows the
    command line option responsible for the diagnostic message

   extra information to a warning (or error) is now marked as "note:"

** the internal Xref performance has improved, has all references in ascending
   order now and includes the total amount of direct references

** the internal listing got a speedup and has all error references in
   ascending order now

** cobc -g (and configure --enable-debug) use the most expressive
   debugging options available on the system

** cobc -g now auto-includes references to the COBOL source file and to
   all ENTRY and SECTION elements to ease source level debugging

** allow 3-byte CRT STATUS variable according to X/Open standard



* Changes in the COBOL runtime (libcob)

** messages from the COBOL runtime are also translated now (if installed);
   to prevent this, disable translations in general with using the configure
   option --disable-nls (or by deactivating ENABLE_NLS in config.h)

** first-time file-locking under Win32

** handle CRT STATUS either numerically, alphanumerically (4 digits) or as 3
   bytes according to X/Open standard, depending on format and size

** execution times of INSPECT and INITIALIZE with OCCURS were heavily cut down,
   to fully benefit from this a recompile is necessary

** libcob.h does no longer auto-include gmp.h (behavior since 2.x), if you link
   against libcob and need cob_decimal include gmp.h/mpir.h yourself before;
   otherwise you do not need it in your include path anymore

** convenience functions for direct C access to COBOL fields and for debugging
   were added, see new C-API documentation

** Breaking change: previously the return-code of registered error handlers
   (by CBL_ERROR_PROC) were ignored. This was changed according to the
   documentation for CBL_ERROR_PROC -> a RETURN-VALUE of ZERO skips further
   error handlers to be called, including the internal one.


* New build features

** Running the internal tests by make check now fails if the testsuite has any
   unexpected result.

** The modules and test programs in the NIST COBOL-85 test suite (tests/cobol85)
   may now be build and/or tested and/or the test results checked separately.
   You now may also run the tests with a previous installed version of GnuCOBOL
   (or a version specified by a manual temporary setup).
   For details see tests/cobol85/README.

** new configure option --with-math=ARG to specify which math multiple precision
   library is to be used, where ARG may be: check (default), gmp, mpir

** new configure options --with-xml2 / -without-xml2 to explicit force/disable
   XML runtime support, otherwise it will be included if found as working

** new configure option --with-json / -without-json to explicit force/disable
   JSON runtime support, otherwise it will be included if found as working
   Note: As a special case you may built-in cJSON by placing its source in
   the folder "libcob". If it is included there, this version will be compiled
   into libcob. It may be enforced with --with-json=local,
   like --with-json=cjson and --with-json=json-c enforce the given library.

** To adjust the build system for GMP/MPIR you may use the new variables
   GMP_CFLAGS / MPIR_CFLAGS and GMP_LIBS / MPIR_LIBS.
   If unset configure will try pkg-config.

** To adjust configure to use libxml2 you may use the new variables XML2_CFLAGS
   and XML2_LIBS. If unset configure will use pkg-config / xml2-config.

** To adjust configure to use libcjson you may use the new variables CJSON_CFLAGS
   and CJSON_LIBS, similar JSON_C_CFLAGS and JSON_C_LIBS for libjson-c.
   If unset configure will use pkg-config.

** new configure option --enable-hardening to either enable GNU C's
   hardening options or leave as-is, or disable (which previous versions
   effectively did)

** build system: defaults.h is not created or included anymore, all configure
   provided defines are now found in the single header config.h

** Any time after `make` you can call `pre-inst-env` script to use the still-
   uninstalled binaries. Samples:
   pre-inst-env cobc -xj prog.cob
   pre-inst-env cobcrun -M prog start
   pre-inst-env may also be called without parameters to start a new shell
   session with the environment adjusted to use the uninstalled version.


* Too many bug fixes to list here (please check ChangeLogs for full details),
  includes the following CVEs:

** compiler (may be triggered with special crafted source files)
   CVE-2019-14468, CVE-2019-14486, CVE-2019-14528, CVE-2019-14541,
   CVE-2019-16396, CVE-2019-16395

* GnuCOBOL's getopt implementation honors POSIXLY_CORRECT now:
  if set to any value the option parsing in cobc, cobcrun and CBL_GC_GETOPT
  stops at the first nonoption, otherwise it stays with the old behavior and
  re-orders nonoptions to the end)


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 GnuCOBOL 3.0-rc1 released (20180422)

* New GnuCOBOL features

** REPORTWRITER module added

** INDEXED file handling: added support for sparse and split keys

** file handling: added support for [RE]WRITE FILE file FROM source

** DISPLAY ... UPON PRINTER may be redirected to an external command
   (new runtime configuration COB_DISPLAY_PRINT_PIPE) or appended to a file
   (new runtime configuration COB_DISPLAY_PRINT_FILE, which takes precedence)

** XML GENERATE statement
   (note: runtime support needs additional library libxml2)

** JSON GENERATE statement
   (note: runtime support needs additional library cJSON)

** Improved support for different compiler extensions (ACUCOBOL, IBM,
   Fujitsu, MicroFocus COBOL, Microsoft COBOL, RM/COBOL and more)

** Parser support for many features of different compilers, for example
   PIC 1 / USAGE BIT, ACUCOBOL extensions for graphical controls
   VALIDATE statement and much more.
   Most of them will be fully implemented in a later version...

** Option to dump (partial) data of modules on abort.
   Use new cobc option -fdump=<scope> to prepare the module and optional
   use new runtime configuration options COB_DUMP_FILE and COB_DUMP_WIDTH
   to adjust the dump.

** C interface: new functions cob_set_runtime_option / cob_get_runtime_option
   to set/get special runtime options (currently FILE * for trace and printer
   output) or to reload the runtime configuration after changing environment

** file handling: include support for a callable EXTFH interface also provided
   by several compilers including Micro Focus
   This allows users to insert an external file handler while retaining
   all of the normal COBOL I/O functions with a possible callback to libcob.
   To have the compiled program call `yourfh()` for file I/O use:
   `cobc -fcallfh=yourfh`
   In turn `yourfh()` may call `EXTFH()` to use I/O functions from GnuCOBOL.
   The external file handler can also be directly invoked from COBOL, too,
   using `CALL "EXTFH"`.
   ** Note: Not all flags contained in the FCD3 are handled already **


* Changed cobc options:

** The option -debug (runtime checks) no longer implies -ftrace (option to
   trace program flow of the generated module with COB_SET_TRACE).
   You may specify -ftrace[all] along -debug if you want to use this feature.

** The option -E (preprocess file) does not imply an output file any more.
   If no output file is explicit specified with -o filename.i the output will
   be written to stdout (behavior of versions 1.1 is restored).
   Requesting output to stdout explicit by using a dash as output name is
   also possible.

** Changed options for listing:
   The option -tsymbols was replaced by -ftsymbols and therefore can now also
   be explicit deactivated by specifying -fno-tsymbols.
   New options for suppressing (or explicit requesting) parts of the listing:
   -fno-theader    suppress all headers from listing while keeping page breaks
   -fno-tmessages  suppress warning and error summary from listing
   -fno-tsource    suppress actual source from listing (for example to only
                   produce the cross-reference)

** The option -fif-cutoff (option to change generated C sources to use
   a label + goto for nested if/else) was deactivated to allow the C compiler
   to fully control the program flow.
   ** Please report if you have a need for this option as it will be **
   ** removed permanently in the next release of GnuCOBOL otherwise. **


* Changes in the COBOL runtime (libcob)

** updated exception handling, GnuCOBOL now only cleans raised exceptions when
   requested by SET LAST EXCEPTION TO OFF

** The standard-format for program tracing was changed and is now adjustable
   by the runtime configuration option COB_TRACE_FORMAT.

* New build features

** New test suite for manual tests (especially SCREEN I/O),
   run with `make checkmanual`.
   Note: You may want to adjust the test runner tests/run_prog_manual.sh which
   defaults to xterm in GUI environments and screen in terminal environments.

** new configure option --enable-debug-log to allow *internal* tracing
   of GnuCOBOL (intended for developers of GnuCOBOL only)

* Too many bug fixes to list here (please check ChangeLogs for full details).

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 GnuCOBOL 2.2 released (20170906)

* Move to GPL/LGPL 3

* Most noteworthy new GnuCOBOL features (too many to list them all)

** User Defined Functions, FUNCTION-ID.

** New intrinsic functions

  ABSOLUTE-VALUE                   alias for ABS
  CURRENCY-SYMBOL                  CURRENCY-SYMBOL of the current program
  FORMATTED-CURRENT-DATE           ISO 8601 datetime function
  FORMATTED-DATE                   ISO 8601 datetime function
  FORMATTED-DATETIME               ISO 8601 datetime function
  FORMATTED-TIME                   ISO 8601 datetime function
  TEST-FORMATTED-DATETIME          ISO 8601 datetime function
  INTEGER-OF-FORMATTED-DATE        date to integer
  HIGHEST-ALGEBRAIC                now implemented
  LOWEST-ALGEBRAIC                 now implemented
  LOCALE-COMPARE                   now implemented
  NUMVAL-F                         now implemented
  TEST-NUMVAL                      now implemented
  TEST-NUMVAL-C                    now implemented
  TEST-NUMVAL-F                    now implemented
  LENGTH-AN                        alias for BYTE-LENGTH
  MODULE-CALLER-ID                 return the name of the caller
  MODULE-DATE                      current module: compilation date
  MODULE-TIME                      current module: compilation time
  MODULE-FORMATTED-DATE            current module: formatted datetime
  MODULE-ID                        current module: PROGRAM-ID
  MODULE-PATH                      current module: path on compile time
  MODULE-SOURCE                    current module: name on compile time
  MONETARY-DECIMAL-POINT           LOCALE based fiscal decimal point
  MONETARY-THOUSANDS-SEPARATOR     LOCALE based fiscal visual grouping separator

  Note:
  The functions that are actually available as intrinsic functions depend
  on the -std used. Function names that aren't marked as intrinsic functions
  by the current -std can be used freely as user defined words or
  even as user defined functions.

** New system functions

  C$CALLEDBY                       return the name of the caller
  CBL_GC_FORK                      fork current process (not on Windows)
  CBL_GC_WAITPID                   wait for process to end
  CBL_GC_GETOPT  (CBL_OC_GETOPT)   command line option parser for COBOL
  CBL_GC_PRINTABLE (C$PRINTABLE)   check if character is printable
  CBL_GC_HOSTED (CBL_OC_HOSTED)    provides access to C extern variables,
                                   like stdin, errno
  CBL_GC_NANOSLEEP                 CBL_OC_NANOSLEEP
  CBL_GET_SCR_SIZE                 get current terminal size - if any
  CBL_READ_KBD_CHAR                get character from terminal
  CBL_SET_CSR_POS                  set current position on terminal
  x'E4'                            clear terminal screen
  x'E5'                            ring the bell

** full support for ANSI 85 debugging module:
   USE FOR DEBUGGING declarative procedures (only part of the generation if
   WITH DEBUGGING MODE is active during compilation) and special register:
   01 DEBUG-ITEM.
      02 DEBUG-LINE      PIC X(6).
      02 FILLER          PIC X VALUE SPACE.
      02 DEBUG-NAME      PIC X(30).
      02 FILLER          PIC X VALUE SPACE.
      02 DEBUG-SUB-1     PIC S9(4).
      02 FILLER          PIC X VALUE SPACE
      02 DEBUG-SUB-2     PIC S9(4).
      02 FILLER          PIC X VALUE SPACE.
      02 DEBUG-SUB-3     PIC S9(4).
      02 FILLER          PIC X VALUE SPACE.
      02 DEBUG-CONTENTS  PIC X(n).
   With "n" being at least 30, size is increased if USE FOR DEBUGGING identifier
   is used and the identifier has a longer size.
   Note: COB_SET_DEBUG activates the specified debugging sections at runtime

** many new / extended COBOL statements from COBOL2002/2014 and extensions
   from different COBOL dialects

** more SWITCHes: from SWITCH-01 to SWITCH-36 and its variants from many
   COBOL dialects

** more IEEE numeric types added, FLOAT-DECIMAL-16, FLOAT-DECIMAL-34, etc

** more literal types added, numeric boolean etc.

** most of the COBOL 2014 spec Compiler Directive Facility is in

** optional: stricter syntax checks

** Optimization: in cases where the condition in IF/WHEN is resolved down
   to TRUE or FALSE at compile time cobc doesn't emit any code

** refactored and extended compiler and runtime messages with available
   translations (currently to Spanish, Portuguese and Dutch, partial to German)

** screen IO: many extended ACCEPT DISPLAY and SCREEN SECTION changes

** Direct call interface for C:
  CALL-CONVENTION for CALLs and PROCEDURE DIVISION
  ENTRY-CONVENTION for PROCEDURE DIVISION and ENTRY statement
  SIZE of parameters specified for CALL ... BY VALUE
  RETURN NOTHING for calling void functions
  RETURN ADDRESS OF VAR for calling functions returning a pointer
  PROCEDURE DIVISION RETURNING OMITTED -> callable as void function

** Much, much more!


* New cobc options:

** New -std options:

  cobol2014       COBOL 2014 Standard
  xopen           X/Open COBOL Standard
  mf-strict       Micro Focus COBOL compatibility   - strict
  ibm-strict      IBM COBOL compatibility           - strict
  ibm-strict      MVS/VM COBOL compatibility        - strict
  acu             ACUCOBOL-GT compatibility
  acu-strict      ACUCOBOL-GT compatibility         - strict
  bs2000          BS2000 COBOL compatibility (back again)
  bs2000-strict   BS2000 COBOL compatibility        - strict
  rm              RM-COBOL compatibility
  rm-strict       RM-COBOL compatibility            - strict

  Note:
  The GnuCOBOL compiler tries to limit both the feature-set and reserved words
  to the specified compiler when the "strict" dialects are used.
  COBOL sources compiled with these dialects are therefore likely to compile
  with the specified compiler and vice versa: sources that were compiled on
  the specified compiler should compile without any issues with GnuCOBOL.

  With the "non-strict" dialects GnuCOBOL will activate the complete
  feature-set where it doesn't directly conflict with the specified dialect,
  including reserved words and GnuCOBOL specific extensions.
  COBOL sources compiled with these dialects therefore may work only
  with GnuCOBOL. COBOL sources may need a change because of rich feature-set
  and reserved words in GnuCOBOL, otherwise offending words may be removed
  by `-fno-reserved=word`.
  COBOL-85, X/Open COBOL, COBOL 2002 and COBOL 2014 are always "strict".

** New listing options:

  -t listing, -T wide listing, --tlines=lines, lines per page of listing;
  -Xref now handled internally, if you want to use cobxref define
  COB_EXTERNAL_XREF during configure

  Note: -P, generate preprocessor listing, is still available (and improved)

** All compiler configuration flags may be set on command line
   to override a specific setting of the current -std, see cobc --help

** All warnings can be explicit enabled/disabled or even marked as error,
   see cobc --help, examples:
  -Wunreachable         warn about likely unreachable statements
  -Wno-dialect          do not warn about dialect specific issues
  -Werror               treat all warnings as errors
  -Werror=<warning>     treat specified <warning> as error

** Options for the C compiler/linker:
  -K <entry>, compile entry point as static (resolve at link time)
  -A, add options to C compile phase
  -Q, add options to C link phase

** Miscellaneous
  -i -info, display build/environment
  -D define symbol for Compiler Directive Facility
  -j -job=args, run job after compile
  input filename of '-' reads source from standard in
  For more: see cobc --help

* Changed cobc options:

** The option -ffunctions-all (allow use of intrinsic functions without
   FUNCTION keyword) was replaced by -fintrinsics=ALL.
   -fintrinsics allows to also specify that only specific functions may
   be used without the FUNCTION keyword.
   The preferred option is to not use these cobc options at all but to
   specify this within the COBOL code (CONFIGURATION SECTION. REPOSITORY.)


* New cobcrun options:

  -i -info, display build/environment
  -r -runtime-config, display runtime configuration
  -c -config, set runtime config from file
  -M -module, set path/module name when looking for entry


* New build features

  make test      downloads NIST testsuite if necessary
                 now usable with parallel builds (make -j4 test)
  make checkall  runs both the internal and the NIST testsuite

** testsuite defaults to coloured output

** Windows(tm) Visual Studio build support files added,
   options to validate the software generated with VS against both test suites

** removed maintainer mode - if files need a rebuild because of a change
   they are always rebuild

** help2man, bison and flex are checked during configure,
   if they need to be invoked and are missing a useful error message is given

** All files created by GnuCOBOL runtime use the same file permission settings
   now: COB_FILE_MODE which was changed to 0666

** The maximum number of fields passed via CALL changed from hard-wired 64 fields
   to a configuration option (defaulting to 192, current max. 252)

** changed unix package name from "gnu-cobol" to "gnucobol"

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 GnuCOBOL 1.1 released (20140118)

* Change unix package name to gnu-cobol, and project to GnuCOBOL
* for a full list of changes see
  https://gnucobol.sourceforge.io/faq/
  #what-are-the-differences-between-opencobol-1-1-and-gnucobol-1-1

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 OpenCOBOL 1.1 released (20090206)

* Note: was tagged as pre-release and later on as full version

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 OpenCOBOL 1.0 released

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Changes in OpenCOBOL 0.33

* New compile option '-x'. This causes the compiler to produce an
  executable program. '-fmain' is deprecated.

* Remove long option --verbose. Use '-v' for verbosity. Problem is
  with getopt_long_only which does not like eg. -mv

* New conformity option -std=bs2000.

* FUNCTION is implemented. See cobc/reserved.c for a list of what is
  implemented.

* Nested programs are partially supported.

* LINAGE is implemented.

* EXTERNAL on FD is implemented.

* SAME RECORD AREA is implemented.

* New config variables -
  "perform-osvs", "sticky-linkage". These are
  activated for -std=ibm and -std=mvs.
  "relax-level-hierarchy". Allows mismatched data
  description level numbers. Activated for
  -std=mf, ibm, mvs and bs2000.

* Support for non-gcc compilers.

* Large file support, system dynamic loading and Berkeley DB inclusion
  are default for the configure.
  ie. ./configure assumes --with-db --with-lfs64 --with-dl

* New configure option --with-patch-level=<n>
  Default is 0.

* At run time, version checking is done. ie. When executing/loading
  Cobol programs, the version (eg. 0.33) and the patch level (eg. 0)
  are checked against the OC library version/patch level.

* Libtool is not required for systems that support native dynamic
  loading. This includes GNU/Linux, Cygwin and MingW amongst others.

* Note to developers : See README for required software versions.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Changes in OpenCOBOL 0.32

* Stability update - See individual ChangeLogs

* New internal register - NUMBER-OF-CALL-PARAMETERS

* New config variables - larger-redefines-ok, relaxed-syntax-check

* Powerpc changes - We now pass all OC and Cobol85 tests

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Changes in OpenCOBOL 0.31

* Stability update - See individual ChangeLogs

* New driver program - "cobcrun"
  This allows all application programs to be compiled as
  modules and driven by "cobcrun" similar to MF's "cobrun".
  Syntax - cobcrun <MAINPROG> [Arguments to program "MAINPROG"]
  As "cobcrun" is linked with the static version of OpenCOBOL
  libraries, it is easier to maintain concurrent versions on the
  same system.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Changes in OpenCOBOL 0.30

* Installation changes

** No longer use readline.

** No longer use run-time configuration file (libcob.conf)

** libdb is now optional.
Use the new configure option --with-db1 to link with libdb1.
Use the new configure option --with-db to link with libdb.
Otherwise, libdb will not be linked, and indexed files and
SORT/MERGE statements will not work.

*** New subdirectory `config' will be installed under
$prefix/share/gnucobol.

** Compatibility changes

*** New -std options:

  default       used when you omit -std
  cobol85       COBOL 85 Standard
  cobol2002     COBOL 2002 Standard
  ibm           IBM COBOL compatibility
  mf            Micro Focus COBOL compatibility
  v023          OpenCOBOL 0.23 compatibility

*** Compile-time options can be stored in a "config" file.
See config/default.conf for details.

*** Binary data items are now big endian.
The config option `binary-byteorder' controls this.

*** Numeric sign of USAGE DISPLAY items has been changed as follows:

  Positive: 0123456789  Negative: pqrstuvwxy

The config option `display-sign' controls this.

*** Data items defined in the working-storage section are
initialized at the beginning of program by default.
The config option `auto-initialize' controls this.

*** SORT statement now creates a temporary file in /tmp for sorting
and removes it after sorting.

** Feature changes

*** COPY statements try to complement the following file extensions:
.CBL, .COB, .cbl, or .cob.

*** COPY / REPLACE statements are reimplemented for better replacement.

*** SPECIAL-NAMES. FORMFEED IS ...

*** ALPHABET ... IS EBCDIC.

*** EXTERNAL clause.

*** SHARING clause.

*** USAGE COMP-5 and COMP-X.

*** USAGE POINTER and ADDRESS OF operator.

*** LENGTH OF operator.

*** PROCEDURE DIVISION USING BY REFERENCE/CONTENT/VALUE.

*** DISPLAY ... ENVIRONMENT-NAME.  ACCEPT ... ENVIRONMENT-VALUE.

*** COLLATING SEQUENCE in the SORT and MERGE statements.

*** EXIT PERFORM [CYCLE] statement.

*** SORT table.

*** OPEN ... WITH NO REWIND / WITH LOCK recognized, though not working.

*** Literal concatenation (the `&' operator).

** Compiler changes

*** New compiler environment variable TMPDIR.

*** New compiler environment variable COB_LDFLAGS.

*** The runtime environment variable COB_CONFIG_FILE has been removed.

*** New runtime environment variable COB_DYNAMIC_RELOADING.

*** New compiler option `--list-reserved', which list all reserved words.

*** New compiler option `-conf', which specifies the config file.

*** New compiler option `-ext', which specifies the copy file extension.

*** The compiler option `-O' now does C level optimization.

*** New compiler option `-O2', which does further C level optimization.

*** New compiler option `-L' and `-l', which are passed to the C compiler.

*** New compiler option `-ftrace', which display section names at run time.

*** New compiler option `-fsyntax-only', which does syntax error check
only without any output.

*** New compiler option `-fstatic-call', which is equivalent to `-static'.

*** New compiler option `-fdebugging-line', which enables debugging lines.

*** New compiler option `-fsource-location', which includes source location
in the output.

*** New compiler option `-fline-directive', which includes line directive
in the output.

*** New compiler option `-fruntime-inlining', which is the replacement
of obsolete options `-finline-move' and `-finline-get-int'.

*** New compiler option `-w', which inhibits warnings.

*** New compiler option `-Wredefinition', which warns redefined names.

*** The compiler options `-static' and `-dynamic' are obsolete.

*** The compiler option `-column' removed.

** Many improvement for compatibility.

** Many many bug fixes.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.23

** Installation changes

*** We use the GNU MP library again.

** Run-time library changes

*** `cob_resolve' now search the main program for the module name.

** Bug fixes

*** Duplicate use of intermediate field variables.

*** fseek issues on the MinGW environment.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.22

** Installation changes

*** We no longer depend on the GNU MP library.

Decimal arithmetic is done by using `long long'.

** Compiler changes

*** Alphabet-name has been implemented.

*** Variable-length table has been implemented.

*** De-editing (move numeric-edited to numeric) has been implemented.

** Bug fixes

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.21

** Installation changes

*** New configure argument --with-lfs64.

** Compiler changes

*** New option -std, which specifies which COBOL standard to use.

Currently the following standards are available:

  gnu           GnuCOBOL (default)
  cobol85       COBOL 85
  cobol2002     COBOL 2002
  mvs           IBM COBOL for MVS & VM

*** New option -O, which enables some optimization.

*** New option -debug, which enables run-time error checking.

*** New option -Wobsolete, which reports obsolete features.

*** New option -Warchaic, which reports archaic features.

*** -Wnext-sentence has been removed.  Use -Warchaic instead.

*** -fdebugging-line has been removed.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.20

** cobpp has been integrated into cobc.

Now cobc is the only binary program.

** cobc now generates an executable without `-main' flag.

`-main' has been renamed to `-fmain', which is turned on
by default if none of -E, -C, -S, -c, or -m is given.

** The default source format is now the fixed form.

The format will not be detected automatically.  You need
to use SOURCE FORMAT compiler directive as described below.
This conforms to the COBOL 2002 standard.

** Compiler directive "SOURCE FORMAT" is now supported.

Put the following line at the beginning of file if you
want to use the free-form:

  >>SOURCE FORMAT IS FREE

** Option `-semi-fixed' has been removed.

If you want to expand the program text area over 72 columns,
use the option `-column' instead.

** New option `-column', which specifies the end of program text area.

** New option `-T', which specifies the tab width.

** New warning options:

  -Wall                 Enable all warnings
  -Wcolumn-overflow     Warn any text after column 72
  -Wconstant            Warn inconsistent constant
  -Wparentheses         Warn lacks of parentheses around AND within OR
  -Wnext-sentence       Warn uses of NEXT SENTENCE
  -Wimplicit-terminator Warn lacks of scope terminator (END-XXX)
  -Wstrict-typing       Warn type mismatch strictly

** Option `debug' has been renamed to `-fdebugging-line'.

** USAGE PACKED-DECIMAL is now supported.

** Improved error checking.

** Additional testsuite entries.

** Bug fixes.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.12

** Improved compile-time error check.

** Additional testsuite entries.

** Bug fixes.

* Changes in OpenCOBOL 0.11

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

** Part of run-time library interface has been redesigned.

** Bug fixes.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.10

** Autoconf 2.57, Automake 1.7.2, Libtool 1.4.3, and Gettext 0.11.5
are used for packaging.

** New file cob.pc, which is used by pkg-config script.

** libcob.conf is now installed under sysconfdir (i.e., $(PREFIX)/etc).
The default value of COB_CONFIG_FILE has been changed appropriately.

** The directory `tests' includes new testsuites.
"make check" will run the tests.

** We use db1 again instead of db2 or db3.

** New option -semi-fixed.

** New option -Wtrailing-line.

** CALL statements now accept CONTENT LENGTH OF clause.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.9.7

** The default value of COB_CONFIG_FILE has been changed to
"$PREFIX/etc/gnucobol/libcob.conf".

** SORT and MERGE statements have been impelemented.

** Preliminary implementation of SCREEN SECTION.

** Many bug fixes and improvements.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.9.6

** cobc now requires `-main' flag to build an executable from a COBOL file.

Without -main, cobc does not generate a main function.
See manual for details.

** Run-time configuration file: libcob.conf

The environment variable `COB_CONFIG_FILE' specifies the file name
(default: "${prefix}/share/gnucobol/libcob.conf").

** Use gettext for international messages.

** Include the test suite in subdir `testsuite'.

** Many bug fixes and improvements.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.9.5

** Support Berkeley DB 2.0.

** Many bug fixes.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Changes in OpenCOBOL 0.9.4

** OpenCOBOL now requires Berkeley DB 3.0 or later.

** File I/O routine (libcob/fileio.c) has been reimplemented.

** New NIST Test Suite modules: SM, IC, SQ, RL, IX.

** Many bug fixes.