Version 6.7

Version 6.7 is a large release containing both initial support for running
multiple front end threads in the same process (see the Changes entry for
EDGcpfe/27800 to get a detailed overview) and initial support for the front
end generating its own variant of the IFC module file format (though for
this release, this comes with several caveats noted below).  Several
additional C23, C++23, and C++26 features have also been implemented.  As
usual, this release also contains numerous bug fixes, performance
improvements, and numerous smaller changes (building on those made in 6.6)
moving towards full support for C++20 modules.  Support for experimental
reflection (initiated in version 6.6) has been improved in many ways and
support for reflection-adjacent features under discussion in the committee
has also been added (see below).

This release includes the following new C23, C++23, and C++26 features:

- C23: nullptr keyword and nullptr_t type (EDGcpfe/25950)
- C++23: Delimited escape sequences (EDGcpfe/25510)
- C++23: Unencodable and multi-character wide character literals
  (EDGcpfe/25508)
- C++23: Line splice with white space after \ (EDGcpfe/24778)
- C++23: Static operator() (EDGcpfe/25514)
- C++23: Named universal character escapes (EDGcpfe/25513)
- C++26: Unencodable string literal characters (EDGcpfe/26451)
- C++26: constexpr structured bindings (EDGcpfe/27456)
- C++26: Deleting a pointer to incomplete type (EDGcpfe/27422)

Performance issues have been addressed for diagnostics involving
excessively recursive template argument lists (EDGcpfe/26892).
Additionally, this release includes several general performance
optimizations (EDGcpfe/27200, EDGcpfe/27047, EDGcpfe/27256, and
EDGcpfe/26048).

Version 6.7 contains experimental support for reflection and
metaprogramming features currently under discussion in the C++ Standards
Committee; see

https://docs.google.com/document/d/1bTYIwQ46l1shwM_9mdnpRnvn6Y4o6oxmY_sn74ooTc0/edit?usp=sharing

and EDGcpfe/26698. The principal (evolving) paper describing reflection
features is P2996 (targeted for C++26).  Our experimental implementation
implements much of that paper, but some parts are still missing and some
parts haven't tracked the latest changes.  In particular, the define_class
API is still based on P2996R1 (whereas the evolving P2996 has since renamed
define_class to define_aggregate and changed its interface significantly).
In addition to P2996 reflection, the front end now also implements
experimental support for additional reflection-adjacent proposals: P3289:
"consteval blocks" P3394: "Annotations for Reflection" (except the
annotate(...) API) P3294: "Code Injection with Token Sequences" (the
non-macro part of that proposal). To enable support for all these
experimental features, the front end must be built with
REFLECTION_ENABLING_POSSIBLE set to TRUE, and either the build must set
DEFAULT_REFLECTION_ENABLED to TRUE or the command-line option
--set_flag=reflection must be specified when the front end is invoked.  In
addition, a new header, found in the release as
.../include_c++/experimental/meta.stdh, must be included in source files
(typically as #include <experimental/meta>). The new header includes some
C++ standard library headers that are not provided by EDG (<optional>,
<string_view>, and <vector>) and that must therefore be provided
independently.

Version 6.7 updates built-in function support to clang version 19 and gcc
version 15. It also adds built-in function signatures for ARM32 and ARM64
architectures (EDGcpfe/26215,EDGcpfe/26329). Unicode support now reflects
version 16.0.0 the Unicode standard (EDGcpfe/27636).

Version 6.7 incorporates significant improvements in memory safety, with
calls to sprintf being replaced by memory-safe alternatives
(EDGcpfe/26704).  We do not believe version 6.6 actually contained any
memory safety bugs related to sprintf calls.  However, particularly on the
MacOS platform, this eliminates a large number of compiler warnings.

The front end’s host environment integration has additionally seen some
modernization in 6.7.  In particular, for all major operating systems, the
front end now defaults to using system-provided facilities for creating
temporary files and directories (EDGcpfe/27777).  This was primarily done
to reduce collisions when operating in a multi-threaded configuration but
also provides an increased security posture by reducing predictability of
temporary files.

The front end continues to support consumption of Microsoft IFC 0.43 files
produced by the Microsoft compiler when the compiler’s respective
--microsoft_verison is specified.  A large number of fixes and improvements
were made to improve compatibility with the Microsoft IFC 0.43 file format
in this release.  Versions 0.33, 0.41, and 0.42 are also accepted by the
front end, but their use is not recommended.

The front end in this release (as previously noted) sees the introduction
of support for producing and consuming an EDG variant of the IFC 0.43
module file format.  This initial release is effectively a tech demo that
is limited to C++20 module header units that contain a subset of the C++
language.

This support can be tried out by using the --create_header_unit and
--header_unit flag:

  eccp --c++20 --create_header_unit=test.h.eifc test.h
  eccp --c++20 --header_unit test.h=test.h.eifc test.c

We know C++20 modules support is highly anticipated.  While we do not
anticipate complete support, we expect to deliver much more significant
C++20 modules progress in our 6.8 release building on this initial support.

Attempting to use any other IFC version than those mentioned above is
unsupported and will result in the front end issuing an error.

New files have been added to the front end source in this release for the
improved IFC module implementation, the new multi-threaded daemon, and for
named universal character escapes.  These files include:

- cfe_daemon.c
- cfe_daemon_common.h
- direct_allocator.h
- ifc_map_functions_mut.c
- ifc_modules_internal.h
- ifc_modules_read.c
- ifc_modules_write.c
- unicode_name_fsm.c

Starting with version 6.0, the front end must be compiled as C++ code. The
minimum compiler versions are unchanged from version 6.6:

	g++:    4.8.1
	clang:  3.3
	MSVC:   VS 2015 (tested with build 19.00.24215.1)

The front end can be self-compiled with a C-generating back end version for
platforms that lack a native C++ compiler. We do not use exception handling
or RTTI, so those can be disabled to produce more efficient code.

We use only the C subset of the C++ standard library, so if your code uses
the C++ standard library you don’t have to worry about possible collisions
between incompatible versions.

As usual, we have fixed bugs, added many minor features, and continued to
improve our various compatibility modes. Full details are found in the
Changes_6.7 file (approximately 6000 lines).
