



 Problems fixed by the images on this kit include:

              o  The run-time library had bad code that would access memory 
		 just freed to advance a pointer.  In multi-threaded code, 
		 another thread could reuse that memory before the original 
		 thread had a chance to advance its pointer.  This has been 
		 fixed by updating accesses prior to freeing pointers.
            
              o  A new process-wide exception processing mode -- pure_unix -- 
		 has been introduced. In this mode, non-C++ exceptions, also 
		 known as VMS conditions, cannot be caught in a C++ catch-all 
		 handler. This mode can be requested by calling 
		 cxxl$set_condition(condition_behavior) with a pure_unix 
		 argument:

			cxxl$set_condition(pure_unix);

                 condition_behavior enum declared in <cxx_exception.h> header 
		 has been extended to include pure_unix member.

                 To demonstrate how pure_unix mode works, consider the program
		 below. As it is written, it crashes with ACCVIO. If the call 
		 to cxxl$set_condition() is commented out, the program outputs
		 "caught" and exits. 

                 #include <stdio.h>
                 #include <cxx_exception.h>

                 void generateACCVIO() { *((int*)0) = 0; }

                 int main() {
			     cxxl$set_condition(pure_unix);
			                  try {
							generateACCVIO();
								     }
                     catch(...) {
				puts("caught");
                     }
                 }

                 Note: to make use of this new functionality you must have a 
		 new version of cxx_exception.h which is included in the 
		 CXXL$ANSI_DEF.TLB provided with the V7.3 compiler (or higher). 

              o  The run-time library sometimes failed to destruct objects of 
		 automatic storage duration defined in a function, if such a 
		 function exited via an exception that could be caught.  This 
		 has been fixed.

              o  The run-time library now allows the thread cancel signal
                 (CMA$_ALERTED) and the thread exit signal (CMA$_EXIT_THREAD) 
		 to be caught in a catch handler with a pointer or a reference
		 to type CXXL$PTHREAD_CANCEL (or CX6L$PTHREAD_CANCEL) and 
		 CXXL$PTHREAD_EXIT (or CX6L$PTHREAD_EXIT) respectively, if 
		 catching the signals are enabled.
                 The new types catch these signals exclusively.

                 Note: to make use of this new functionality you must have a 
		 new version of cxx_exception.h which is included in the 
		 CXXL$ANSI_DEF.TLB provided with the V7.3 compiler (or higher). 

	      o	The C++ RTL has changed its internal mapping of SIGTRAP from
		SS$_BREAK to SS$_TBIT, to match a recent CRTL change.

	      o The C++ RTL used to call std::terminate() when a destructor
		raised an exception during stack unwinding, even if that 
		destructor did not exit via the exception.  This has been fixed.

	      o The C++ RTL used to call std::terminate(), if a foreign 
	        exception (such as a non-C++ VMS condition) was raised while 
		a C++ exception was being processed.  This behavior has been 
		refined to calling std::terminate() only if the raised 
		VMS condition also leads to unwinding the stack.

	      o Because VMS conditions can be caught in C++ catch handlers, the
		C++ RTL converts the conditions to an internal format that 
		matches the representation of C++ exceptions.  This conversion
		would sometimes lead to incorrect information being shown in 
		the traceback.  This has been fixed.

For customers using the V7.3 compiler (or higher)  you will also find 
              The following problems are fixed in this version of the
              C++ Library:

              o  As described in
                 <http://issues.apache.org/jira/browse/STDCXX-397>, 
		 __introsort_loop() function in <algorithm.cc>
                 header has a bug which, for some input sequences, can
                 adversely affect performance of std::sort. See the
                 Apache tracker for the issue STDCXX-397 at URL above
                 for more details.

                 The bug has been fixed. However, for some input
                 sequences, the fix can change the behaviour of
                 std::sort with regard to the relative order in which
                 elements that have equivalent ordering are placed into
                 the sorted sequence. While this change in behaviour
                 is permissible because, unlike std::stable_sort,
                 std::sort does not guarantee any particular relative
                 order of elements having equivalent ordering, to avoid
                 breaking applications that rely on existing behaviour
                 of std::sort, the fix is conditionalized with __RW_
                 FIX_APACHE_STDCXX_397 macro and is in effect only
                 when the program is compiled with this macro defined.
                 [L2028]

              o  When compiled in standard GNU mode, the library now
                 defines the _RWSTD_NO_IMPLICIT_INCLUSION macro which
                 causes library headers to #include their respective
                 template definition files. This is necessary because in
                 standard GNU mode, implicit inclusion is disabled.

                 Before this change, the program below would link with
                 undefined symbol when compiled in standard GNU mode:

                  #include <vector>

                  int main() {
                    std::vector<int> v;
                    v.push_back(0);
                  }

           o  According to section 27.6.1.3 [lib.istream.unformatted]
              of the C++ Standard, the following get member
              functions of the std::basic_istream class should call
              setstate(failbit) if no characters have been stored, as
              is the case for an empty line. While on I64 systems the
              functions set failbit, on Alpha systems they do not:

              istream_type& get(char_type *s, streamsize n, char_type delim);
              istream_type& get(char_type *s, streamsize n);



