ACT ANNOUNCES: GNAT 3.11p now available!

[robert_dewar@my-dejanews.com]

ADA CORE TECHNOLOGIES AND ACT EUROPE ARE HAPPY TO ANNOUNCE
----------------------------------------------------------

The following ports of GNAT 3.11p are now available at
the NYU ftp site (ftp://cs.nyu.edu/pub/gnat)

   sparc-sun-solaris2.5.1
   alpha-dec-osf4.0d
   hppa1.1-hp-hpux10.20
   powerpc-ibm-aix4.1.4.0
   i386-pc-solaris2.6     (Solaris x86)
   i686-pc-linux-gnu      (Redhat 5)
   i686-pc-linux-gnulibc1 (Redhat 4)

Corresponding precompiled binary versions of the new Ada
aware GDB/GDBTK debugger can be found in the gdb directory.

In addition, corresponding versions of ASIS and GLADE are
also available. These are distributed in source form:

   Asis 3.11p
   Glade 3.11p

Separately available are two new tools:

   gnatelim (unused subprogram elimination)
   gnatstub (generation of stubs from package specs)

   (these are ASIS based tools)

We expect the following additional ports of 3.11p to be
available in the near future, watch this space!

   Windows 95 / Windows NT
   mips-sgi-irix5.3
   Alpha OpenVMS
   x86 IBM OS/2

With these distributions of publicly available open source
versions of the only complete Ada 95 technology (including
the core and all annexes), Ada Core Technologies continues
its commitment to the Ada community. We hope that these
public versions of GNAT will be of use to students,
academic researchers and others who want to experiment
with the use of the Ada 95 language.

Fully supported commercial versions of this technology
(under the name GNAT Professional) are available from
Ada Core Technologies (sales@gnat.com) and from
ACT Europe (sales@act-europe.fr).

Robert Dewar
Ada Core Technologies

+---------------------------------------------+
|The following are new features in GNAT 3.11p |
|      (as compared with GNAT 3.10p)          |
+---------------------------------------------+

The Windows NT/Windows 95 GNAT compiler no longer has any
cygwin32 based components. The only remaining cygwin32
based tool distributed is make. All the others tools
(debugger, linker, assembler...) have been built totally
using the mingw32 system. (Microsoft C library).

A null rendezvous body (do null; end) is now handled more
efficiently (it is treated as though no body were present).

The use of package Ada.Calendar and the use of delay
statements do not depend on the tasking run-time (and on a
thread library) any more. This means smaller and simpler
executables for non-tasking programs.

pragma Task_Info is now available for Digital Unix 4.0D and
can be used to specify on which processor a given Ada task
should run.

pragma Task_Info is also available for Solaris and can be
used to specify the relationship between tasks and
lightweight processes (LWP's), and between LWP's and
processors.

A new pragma Suppress_Initialization can be used to
suppress all initialization (both implicit and explicit)
for the given type.

Tight packing (with no padding bits) of arrays was formerly
implemented only up to element sizes of 32 bits. GNAT now
provides tight packing up to 64 bits.

A new attribute VADS_Size provides a size attribute that is
intended to be compatible with the results provided by the
Size attribute on VADS compilers (VADS is a trademark of
Rational Software Inc).

A corresponding configuration pragma Use_VADS_Size causes
any Size attribute in the source to be interpreted as
though it were VADS_Size. This pragma and the corresponding
attribute are intended to ease the porting of large VADS
programs that rely on the specific values of Size returned
by VADS.

Many additional tests for unassigned variables have been
added, resulting in additional warning messages. For
example, these checks are now performed on variables
declared within nested blocks.

This version of GNAT uses the new GCC 2.8 release. The
effect should mostly be transparent, but the new version of
GCC contains many code generation fixes and improvements.

The compiler generates additional encodings for GDB, and
together with the latest version of GDB, essentially all
Ada data structures are now handled correctly by GDB.

In the VMS version, GDB recognizes the VAX floating-point
formats automatically.

A new tool, gnatelim, allows for the elimination of unused
subprograms. This is an ASIS based tool, that can be used
on any GNAT target.

A new tool, gnatstub, allows for the automatic creation of
stubs from specifications. This is an ASIS based tool that
can be used on any GNAT target.

A new tool, gnatmem, provides a method for systematically
detecting memory leaks that arise from dynamic allocations
with no corresponding free operation.

A complete version of ASIS is now available for this
version of GNAT. This is a separately supported product.
Contact sales@gnat.com for full details.

The number of cases in which aggregates are treated
statically at compile time is significantly increased,
leading to faster and smaller code, as well as improved
compile time for programs with large aggregates.

Internal variables are now eliminated from the debugging
information, leading to a reduction in the size of
generated debugging data.

A new restriction identifier No_Elaboration_Code ensures
that a compilation does not generate any executable
elaboration code. This is different from pragma
Preelaborate in both directions, there are preelaborable
packages that generate executable elaboration code, and
there are packages which are not preealborable in the RM
sense that generate no elaboration code.

A new pragma Unreserve_All_Interrupts allows an
implementation to specify that normally reserved interrupts
(e.g. SIGINT for handling Ctrl-C) are to be unreserved, so
that the application program may handle these interrupts as
it pleases.

Many examples of unnecessary generation of internal
"actual" subtypes have been suppressed, resulting in more
efficient code, particularly at lower optimization levels,
and also in speeded up compilation.

The GNAT package GNAT.Htable has been enhanced. A Remove
procedure has been added to Simple_Htable, and an iterator
interface allowing retrieval of all elements of the table
has been added to both Simple_HTable and Static_HTable.
These additions have been done in an upwards compatible
manner, so existing clients should not be affected.

A new package GNAT.Table has been added which provides a
simple extensible array abstraction. As usual, this is
completely documented in the spec, which can  be found in
file g-table.ads.

A new implementation dependent attribute R.C'Bit_Position,
where R is a record object and C is one of its fields
returns the bit offset of the start of field C from the
start of the record as a universal integer.

The Address attribute is now fully implemented for
references involving elements of bit packed arrays
(formerly this was not permitted).

The efficiency (both space and time) of code for multiple
concatenations (where three or more values are
concatenated) has been improved.

The Unrestricted_Access attribute is now allowed even for
pool-specific access types (i.e. those declared without ALL
or CONSTANT) keywords. This is consistent with the intent
of this attribute, which is that it be essentially
equivalent to the use of 'Address followed by an
unchecked conversion to the access type.

In a number of situations, allocators are now handled
statically at compile time. Notably if an allocator is at
the outer level in elaboration code, then it can typically
be handled statically.

A new attribute Code_Address is provided. It applies only
to subprogram entities, and it returns the address of the
start of the code for the subprogram. This is often, but
not always, the same value as returned by 'Address.
Examples where it may differ are when the 'Address value
points to a descriptor, such as the "trampoline" used to
call nested procedures on some architectures. Generally the
'Address value is the one to use for calling subprogram
(via typical Ada 83 tricks for making the address be used
for the call). Code_Address always yields the starting
address of the contiguous code for the subprogram.

A warning is now generated for address clauses that are
intended to overlay two entities, when the type of the
entities includes an initialization. In such cases, the
initialization of the entity for which the address clause
is given will affect (i.e. destroy) the variable that it
overlays, unless the entity is labelled with a
pragma Import. A clear warning is now emitted for this
common and useful, but potentially dangerous, programming
idiom.

The Ident pragma now permits a general static string
expression, rather than just a string literal. This is an
upwards compatible extension.

A new attribute Has_Discriminants may be applied to a type
and yields true if the given type has Discriminants. It can
be used with generic types to indicate if the corresponding
actual type has discriminants.

A new warning switch -gnatwu causes warnings about unused
entities and with'ed units to be generated. This facility
replaces the use of -x1 and -x2 switches in gnatf. It is
more convenient than the use of gnatf (since it is embedded
into the compiler), and also more complete and accurate,
since a number of gnatf bugs have been corrected in this
new implementation of this warning feature.

Warning messages are now generated if an unchecked
conversion is used to convert an access type to another
access type with more strict alignment requiremnts (since
this can generate pointers whose designated object does not
meet the alignment requirements of the generated code using
this access type).

The UTF-8 encoding scheme for wide characters is now
supported both by the compiler (-gnatW8) and for
Wide_Text_IO files (WCEM=8). The  default wide character
encoding for Wide_Text_IO files is now set to
the wide character encoding specified for the main program
source.

Gnatmake behaves exactly in the same way whether or not
the .adb extension is omitted on the main source file. In
particular, it searches the path to look for the main
program if no directory is included, but a file extension
is present (See gnatmake section in gnat_ug for details).

Objdump has been added to the binary distribution.  Objdump
can be  used in conjuction with compiling with -g -S to
view code in accordance with pragma Reviewable.

An Ada-aware version of binutils utility addr2line has been
added to the binary distribution.

A new package GNAT.Regexp (in files g-regexp.ads and
g-regexp.adb) provides a complete facility for string
matching using Unix-style regular expression syntax.

A new package GNAT.Directory_Operations (in files
g-dirope.ads and g-dirope.adb) provides operations on
directories, including opening, reading, and changing the
current directory.

A new package GNAT.Command_Line (in files s-comlin.ads and
s-comlin.adb) provides a high level interface for scanning
command line switches, parameters and file names (including
wild card expansion).

GNAT now generates by default cross-reference information
in the  generated ali files (this can be suppressed with
the -gnatx switch). This information is used by the four
following capabilities. Note that this capability replaces
the now obsolete gnatf format.

A new tool gnatfind can be used to quickly locate
declarations or all references to a specified entity or
entities. This utility uses the new cross-reference
information in the ali files.

A new tool gnatxref can be used to generate complete
cross-reference reports. This utility uses the new
cross-reference information in the ali files.

A perl script gnathtml provides the capability of
converting sources to html, including the generation of
links using the new cross- reference information in the ali
files. Keywords and comments are appropriately highlighted.

A new version of GNAPSE (the GNAT version of EMACS with Ada
support) includes an interface to the cross-reference
information in the ali files to quickly locate declarations
and references.

There is a new version of gnatchop with enhanced
functionality, including the ability to chop multiple
files, and a special  "compilation" mode that provides
optional handling for configuration
pragmas according to the procedures in the RM.

The new version of gnatchop now respects an existing
Source_Reference pragma in the input file, and when used
with -r generates Source_Reference pragmas in the output
file that refer to the original input file. This is
particularly convenient when using gnatprep and gnatchop
together to process a file with multiple units and
preprocessing statements.

The unit System.Machine_Code (in file s-maccod.ads) is now
declared Pure, allowing the use of machine code intrinsics
in pure units.

The main program generated by the binder can now optionally
be generated in Ada rather than in C. To activate this
option, use the -A switch in both the gnatbind and gnatlink
steps.

The compiler now generates far more information on complex
data types in -g mode for use by the debugger. For best
results make sure you have the latest GDB.

A new pragma Eliminate is available which specifies that
certain declarations are to be eliminated from the program.
This is in preparation for a new tool gnatelim, which is
included as part of the 3.11 release, which provides for
removal of unused declarations and subprograms.

A new pragma Stream_Convert allows a unit to provide for
proper handling of stream attributes for a type if they are
used, without unconditionally incurring the overhead of
dragging in all the stuff for handling streams (which is
what happens if the stream attributes are defined in the
conventional manner).

The gnatchop utility now detects the case where the file to
be chopped contains multiple copies of the same unit, and
if so, does not write any files unless -w is specified (in
which case the last copy is the one to be written).

Attach_Handler and Interrupt_Handler capabilities are now
fully implemented on all targets as appropriate to the
target.

The "info tasks" under the latest ada-aware GDB now gives
additional information on the state of tasks.

A new unit g-tasloc provides an inexpensive global locking
capability for creating critical regions without reduced
overhead compared to implementing this lock in pure Ada
code.

The runtime has been extensively reworked. A number of
timing windows have been eliminated, and many small errors
have been caught and fixed. The result should be generally
improved reliability in the tasking implementation,
especially in the multi-processing case.

The "old GNULLI" routines have been entirely eliminated,
since all targets are now using the new low-level interface
("new GNULLI"). The result is an improved interface, which
solves a number of problems, and also a significant
reduction in the number of target dependent
tasking files.

In the NT version, we have the general capability of
installing bindings at the time that the system is
installed, and the standard distribution takes advantage of
this feature to offer the option of installing a version of
the Win32 bindings.

An archive is used for the standard library distribution on
all implementations, including OS/2. This improves linker
performance and reduces the number of individual files in
the installation.

A run time task that was previously systematically created
is now elaborated only for programs that use Asynchronous
Transfer of Control constructs. This means that a tasking
program will use less resources (threads and memory) and
that the start up will be faster.

The run time now properly and explicitly shut down all the
tasks before exiting. This avoids some target specific
problems like hanging and system errors.

Two functions Errno and Set_Errno have been added to
GNAT.OS_Lib to get and set the task-safe errno.

The GNAT makefile is now more portable, since it avoids the
use of Unix specific features, in favor of using GNUMAKE on
all targets. This makes integration of the OS/2 and VMS
versions more straightforward.

Calling and receiving stubs for the distributed systems
annex are now generated directly as object files; the
plain-Ada intermediate phase has been suppressed. The
compilation time has been dramatically reduced for
distributed programs containing a large number of RCI
packages.

Remote access to subprograms and generic RCI packages are
now fully implemented.

The incorrect attempt to use directory separators in the
file name argument of a Source_File_Name pragma is now
properly diagnosed.

The timed entry call and selective wait with delay
alternative tasking constructs have been highly improved in
term of efficiency and reliability.

On the AIX version, it is now possible to choose between
native threads, and simulated threads for the tasking.
Default is now native threads.

On the NT version, a fast locking mechanism is now used
that improves performance for tasking applications.

The NT version now allows linking with resources on NT as
well as on Win 95 and Win 98.

On AIX, Digital Unix and HPUX versions, gnatlink will now
automatically utilize the system dependent linker option to
read the set of object files from a named file rather than
the command line in cases where the linker cannot handle
the length of the object list. These particular OS systems
had fairly short allowable linker lines.

The Enum_Rep attribute can now be applied directly to an
object of an enumeration type, or to a non-overloaded
enumeration literal name.

--------- end of list of 3.11p new features --------


-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own