Improved warnings for use of Address aspect
For an address attribute definition clause, there is a warning if a smaller item is overlaid with a larger one, and the warning about possible lack of reference to the entity is suppressed (on the grounds that aliasing may well be occurring). The same warning improvements are now implemented for the address aspect.

Improved indentation of conditional expressions
Ada 2012 If-expressions and case-expressions are better handled by the indentation engine and in particular extra indentation levels are used for each case branch.

WB: Debug tooltip
When debugging an ada application, if the mouse cursor is over a variable that can be printed by the debugger, the tooltip displays the variable current value. This feature requires WRWB 3.3 or later.

Macros in configuration file
A macro expansion system is now provided for PolyORB runtime configuration parameters, when PolyORB is compiled with GNATCOLL.

GB: warning editing files not part of a GB project
When the Ada editor opens a file not part of a GNATbench project, a dialog is displayed to inform the user that some features will not work properly until the file is part of a GNATbench project. This dialog can be disabled through Ada Editor Preferences page.

Use host name instead of IP address in CORBA IORs
IIOP listening endpoint addresses can now be specified to be published by host name (rather than by IP address) in IORs.

More accurate warnings for generic bodies
Warnings on generic bodies (e.g. for suspicious unchecked conversions) are now properly controlled by the setting of warning flags at the point of instantiation (rather than the settings in effect when the instance bodies are analyzed. This allows finer control over warnings from generic bodies.

To_Address attribute can handle high addresses
Previously, if the argument of To_Address was given as a literal or other untyped static expression, the argument of To_Address could be no greater than 2**63-1 even on 64-bit machines where addresses up to 2**64-1 make sense. This attribute now handles static address values up to 2**m-1, where m is the memory size (typically 32 or 64).

Better messages for Ada 2012 feature not allowed
When an Ada 2012 feature is used, and some other Ada mode is active, then the error message (which used to always advise using the -gnat2012 switch) will now point to the relevant pragma if the incompatible mode was set by the use of a pragma.

GNAT tools recognize—help and—version switches
All gnat utilities (gnatkr, gnatls, gnatpp, etc) now recognize the --help switch (to output usage information), and --version (to output version and copyright information).

Warn on ineffective use of -gnateE
Some run times (those that do not support full exception semantics) are unable to implement the extra exception information option set by the use of the -gnateE switch. A warning is now issued if -gnateE is used on such a configuration.

Switches -gnatc and -gnatR cannot be used together
Output of representation information (-gnatR) requires code to be generated, so this switch is incompatible with the use of -gnatc. This prohibition is now documented in the users guide and checked by the compiler.

Add For_Each and Sort_Table to GNAT.Table
Procedures For_Each and Sort_Table have been added to GNAT.Table to make the interface closer to that of GNAT.Dynamic_Tables.

Switch -gnatRm to dump convention/mechanisms
The switch -gnatRm (/REPRESENTATION_INFO=MECHANISMS in VMS) causes the convention and parameter passing mechanisms to be listed for all subprograms. Note: this is actually not a new feature, it was added some time ago, but never got documented until now, so that is why it appears in this version of the features file.

Ada Basics Training Course in Paris Offices

AdaCore is organizing a public training from June 17th to June 21st, on Ada basics. This training targets people that have programming knowledge in languages such as Java, C or C++, but with little or no Ada knowledge. It is particularly appropriate for programmers that have just joined an Ada project, or are planning to in the next 12 months.

This training combines theory and practice. The practical exercises are carried out on a GNAT Pro installation. The following topics will be studied:

• Programming structures (declarations, types, instructions, arrays, record, exceptions)
• Software architecture (subprograms, packages, encapsulation, access types, inheritance, limited types, genericity)
• Ada 2012 Overview of advanced concepts (object orientation, low level programming, concurrency)

Please contact info@adacore.com for additional information.

 

New attribute Restriction_Set
This attribute allows compile testing of whether a restriction is set. The allowed restrictions that can be tested are No_Dependence, and all boolean (no parameter) restrictions for which the binder enforces consistency. This is primarily intended for specialization of library code, but can be used in applications programs as well.

Improved error message for illegal trigger
The error message for an illegal triggering statement in an asynchronous transfer of control now has an RM reference to clarify the legality rule.

GB: Ada elements now displayed in Properties view
When any element contributed to the Project Explorer or Outline view by GNATbench is selected, you will now see properties of that element in the Properties view.

Partition_Elaboration_Policy pragma in System
A pragma Partition_Elaboration_Policy pragma may now appear in package System (in file system.ads), to set an elaboration policy for a library (and any program using this library.

Restriction SPARK_05 replaces SPARK
The restriction SPARK is replaced by SPARK_05 (since this restriction is specifically about violating rules of SPARK 2005). The restriction SPARK is retained for backward compatibility, but will generate a warning that it is obsolescent if it is used.

Implicit packing for multi-dimensional arrays
The Implicit_Packing pragma now applies to multi-dimensional packed arrays. Previously it was only applicable to single-dimensioned arrays.

X’Img can be renamed as function
In analogy with the 'Image attribute, the GNAT attribute 'Img can be renamed as a function, and used as an actual for a formal subprogram in an instance.

Removal of most soft preconditions
CodePeer used to generate "soft" preconditions to guard against errors that may occur only on some paths through a subprogram, but not all paths. This led to false positives in the callers, as well as some imprecise results. Most of these soft preconditions have now been suppressed. Instead, CodePeer relies on the mechanism of conditional preconditions, which states exactly on which paths the guard is needed, and on the assumptions that all computed inputs of the subprogram should be initialized at subprogram call (which leads to precondition checks for initialization at call sites).

Unchecked_Union types with multiple discriminants
Unchecked_Union record types can now have multiple discriminants with nested variants controlled by different discriminants.

Allow comments to line up with previous line
An additional allowed indentation for comments when style checking for comments is enabled allows a comment that lines up with the previous non-blank source line.

gprinstall now supports cross-environment
gprinstall will work in cross-environment by using the newly added --target option. This way it is possible to install a .dll created from a Windows cross-compiler on GNU/Linux for example.

New aspect and pragma Contract_Cases
A new implementation-defined aspect Contract_Cases and corresponding pragma are now available. This is considered to be an assertion that is controllable using Assertion_Policy or Check_Policy. It is a form of exteded precondition and postcondition testing in which several cases are presented each with a corresponding consequence, and as a postcondition, the consequence that corresponded to the case that was true on entry must hold on exit. For example: Contract_Cases => (P => Q, R => S) means that on entry either P or R must be true (but not both), and on exit, Q must be true if P was true on entry, and S must be true if R was true on entry.

Recognize variables initialized at declaration
CodePeer avoids issuing messages about uninitialized variables in cases where the variables are known to be fully initialized at the point of their declaration, either by an explicit expression or implicitly due to default initialization.

Ada 2012 mode enabled by default
The compiler now defaults to the current Ada standard (Ada 2012) instead of Ada 95, which was the historical default. This is basically equivalent to specifying the -gnat2012 switch. You can override this default setting via e.g. -gnat95/-gnat2005 switches or pragma Ada_95/Ada_2005 if needed. Note that Ada 2012 is generally upwards compatible with Ada 95 and Ada 2005, so even if your program is in one of these older versions, it will typically compile in Ada 2012 mode without needing one of these special switches.

Add Reason parameter for pragma Warnings
All forms of the pragma Warnings now allow an optional extra argument (Reason => static_string_EXPRESSION) that is intended for documenting the purpose of a Warnings pragma. The compiler checks that the argument is a static string expression, but otherwise ignores it. The string is left in the tree, so other tools (e.g. ASIS tools) can read the reason string and possibly provide specialized processing for it.

GB: Show Ada content in Project Explorer view
GNATbench now uses the Project Explorer view rather than the now deprecated GNAT Project Explorer view. This is the standard view in Eclipse for viewing projects, folders, files, etc. There's also a new view filter that can hide any folders/files that are not relevant to the current build configuration. Working sets are supported now as well.

GNATCOLL.Traces display microseconds precision
When the stream DEBUG.MICRO_TIME is actived, the time displayed by DEBUG.ABSOLUTE_TIME will show microseconds, instead of just milliseconds by default.

New attribute Loop_Entry
A new attribute Loop_Entry is available. This can be used only within a Loop_Variant or Loop_Invariant pragma to refer to the value of an expression on entry to the loop.

Cross-building GNATCOLL
Using 'configure --target=...' can now be used to build GNATCOLL for a cross-target. The --target will be passed as is to gprbuild.

New attribute Update
A new attribute Update is available. This allows creation of copies of array and record values with specified components modified. The components to be modified are specified by using an argument to the attribute consisting of an aggregate (with no others choice) that specifies the components that are to be modified (e.g. R'Update((2 => 4)) creates a copy of the array value R which is unchanged except that element 2 is changed to 4.

DSA application without name server
Facilities are now provided to override the location of RCI units using run-time configuration parameters (from configuration file, command line, or environment variables). When all RCI locations are provided through configuration, the DSA name server can be disabled altogether, by specifying "None" as the name server type in the gnatdist configuration.

Executable name in traces
The name of the executable can now optionally be included in trace messages logged to standard error. This feature is enabled by setting "exe_name=true" in section [log] of the PolyORB configuration.

Examiner option to ignore SPARK 2014 aspects
If the language profile is set to 2014 (-lang=2014) the Examiner will ignore SPARK 2014 aspects in the source text. This allows both SPARK annotations and aspects to be present in the same code, enabling it to be analysed with the existing SPARK toolset and the new SPARK 2014 tools. This is designed to be useful when migrating existing SPARK code to SPARK 2014.

New gnatls switch -aPdir
A new switch -aPdir is added to gnatls. When gnatls is called with one or several switches -aPdir and also switch -v, the directories specified in the -aP switches are displayed immediately after the current directory in the Project Search Path. A new warning is issued by gnatls for switches that are not recognized by gnatls. The GNAT driver when called as "gnat ls/list -aPdir ..." will also use the switch -aPdir in its invocation of gnatls.

New pragma Loop_Variant
A new assertion pragma Loop_Variant appears in loops to specify expressions whose value is guaranteed to increase or decrease on each loop iteration. This can be used to guarantee that a loop makes progress, and is useful in helping to show that loops always terminate.

GPS: simplified CodePeer report window
The CodePeer report window has been simplified to improve usability and remove unneeded information. Access to the various filters is also improved.

New pragma Assert_And_Cut
A new pragma Assert_And_Cut is available. This is identical to Assert (except that the name Assert_And_Cut must be used in an Assertion_Policy pragma to control it). The intention is that it be used in the middle of the code for a subprogram, to sum up all the work done up to that point.

New pragma Assume
A new pragma Assume is available. This is identical to Assert (except that the name Assume must be used in an Assertion_Policy pragma to control it). The intention is that this be used for assumptions about the external environment that cannot be verified from the program alone.

New check name Predicate_Check
A new check name Predicate_Check is available that can be used in Suppress and Unsuppress pragmas. This allows predicate checks to be turned on and off for specific sections of code (unlike the effect of Assertion_Policy which is to enable or disable predicates at the point where they are defined).

New manual review classification
When doing a manual review of a message, the user can no longer change the message ranking, but instead specify a review classification and the name of the reviewer.

New procedure: Set_Close_On_Exec for sockets
A new procedure GNAT.Sockets.Set_Close_On_Exec is now available, allowing users to indicate that a given socket should not be inherited by spawned processes (on platforms where this is supported).

gprinstall now preserves timestamps
gprinstall now preserves timestamps when copying the source files, object files and libraries.

Support for—version/—help switches
CodePeer now recognizes the --version and --help switches in addition to the existing -v and -help, for consistency with other tools.

New package GNATCOLL.Iconv
This optional package provides a binding to libiconv, to convert between various character encodings.

AI-285 New function Value with default
A new function Value is added to package Ada.Environment_Variables:

   function Value (Name : in String; Default : in String) return String;

if the external execution environment supports environment variables and an environment variable with the given name currently exists, then Value returns its value; otherwise, it returns Default.

New function Value with default
Change in Ada.Environment_Variables as described in AI 285. A new function Value is added to package Ada.Environment_Variables: function Value (Name : in String; Default : in String) return String; If the external execution environment supports environment variables and an environment variable with the given name currently exists, then Value returns its value; otherwise, it returns Default.

GNAT.Ctrl_C available on VMS
This functionality now works on VMS. Ctrl/C from the terminal and/or SIGINT raised from the code is caught and the installed user handler is run as an AST (asynchronous system trap).

gnatclean -f ignores missing directories
When gnatclean is called with -f and -P, then if there are missing object, exec or library directories, these directories are ignored and gnatclean does not fail.

Pragma Contract_Case replaced by Contract_Cases
GNAT pragma Contract_Case is replaced by the more powerful Contract_Cases (plural). The new pragma allows defining fine-grain specifications that can complement or replace the contract given by a precondition and a postcondition, and it can be used anywhere a precondition or a postcondition are allowed. A corresponding aspect is also defined, which can be used in Ada 2102 mode.

Allow extended syntax for Check_Policy pragma
Check_Policy now permits a syntax analogous to that allowed by the new Assertion_Policy form (e.g. Check_Policy (kind => policy, kind => policy ..). The old syntax, Check_Policy (kind, policy) is still recognized.

AI-0272 Restrictions No_Use_Of_Pragma and others
Restrictions No_Use_Of_Pragma and No_Use_Of_Attributes are now recognized.

Additional Ada 2012 Restrictions
Several restrictions introduced late in the Ada 2012 revision process are now recognized: No_Access_Parameter_Allocators, No_Coextensions, No_Use_Of_Pragma, No_Specification_Of_Aspect, and No_Use_Of_Attribute.

AI-0290 Extensions to Assertion_Policy control
Assertion_Policy as now implemented in extended form. The main improvements are that it can appear in any declarative part with scope rules like pragma Suppress, and it can be applied to individual assertion aspects. GNAT extensions allow it to also apply to GNAT assertion aspects and pragmas. Check_Policy is enhanced in a consistent manner. Finally Debug pragmas are now controllable with Assertion_Policy.

New Ada 2012 Assertion_Policy control
Assertion_Policy as implemented as described in AI 290. The improvements are that it can appear in any declarative part with scope rules like pragma Suppress, and it can be applied to individual assertion aspects. GNAT extensions allow it to also apply to GNAT assertion aspects and pragmas. Check_Policy is enhanced in a consistent manner. Finally Debug pragmas are now controllable with Assertion_Policy.

New ASIS query to obtain end labels
A new Corresponding_End_Name query is added to Asis.Elements package. The query returns the name that is repeated at the end of a declaration or a statement. The returned Element is not visited by Traverse_Element, so adding this query does not affect existing ASIS applications.

Remove unneeded error checking for Connect_Socket
If the version of Connect_Socket with timeout is called with a timeout of 0.0, the subprogram returns immediately without attempting to poll the socket for connection completion, thus ensuring that no exception is raised if the initial call to connect(2) either succeeded immediately or return a connection-in-progress status.

New gnatcheck option to annotate diagnoses
A new '--show-rule' is added to gnatcheck. With this option, gnatcheck appends the name of the corresponding rule to each diagnosis generated.

Catch additional cases of style errors
Normally when a body is compiled with style checking set (-gnaty), then style errors in the spec are also flagged. In cases where the spec was explicitly with'ed indirectly, these style errors were not caught. Now they will be caught which may result in additional cases of correct style errors being flagged in existing code.

Implement VMS RMS keys in file I/O
This implements passing VMS RMS keys in Ada.Streams.Stream_IO. Currently the only keys implemented are "Context=Force_Stream_Mode" for forcing a byte stream read on a file with a record context and "Context=Force_Record_Mode" for forcing a record style read.

Support for setting priorities
It is now possible to set the priorities of different tasks used by AWS. There are four priority categories supported. One for the HTTP server, one for the WebSocket handler, one for the session data cleaner task and one for all other optional services (Jabber protocol handler, Server Push...).

Multiprocessors[.Dispatching_Domains] ok in Ada 95
System.Multiprocessors and System.Multiprocessors.Dispatching_Domains are now available in Ada 95 and Ada 2005 modes. These are Ada 2012 defined units but with this change we permit them in earlier versions of Ada where they are technically implementation-defined units (Ada implementations are allowed to add children to System).

New environmment variable GPR_PROJECT_PATH_FILE
A new environment variable GPR_PROJECT_PATH_FILE is used by the Project Manager to set up the project path. When defined, GPR_PROJECT_PATH_FILE indicates the path of a text file that contains directories to be added to the project path. GPR_PROJECT_PATH_FILE is taken into account before GPR_PROJECT_PATH. A warning is issued if the text file cannot be found.

Extend static initialization to discriminated types
In general the declaration of an object of a discriminated type requires a call to the compiler-generated initialization procedure. This prevents the declaration of such objects in a package to which No_Elaboration_Code applies. This patch makes it possible to initialize such objects statically, by generating an aggregate with static components whenever possible. This transformation is applicable if the restriction No_Initialize_Scalars is present, if the discriminant values are static, and if other components have static default values or none.

Empty Run_Path_Origin
It is now allowed to specify attribute Run_Path_Origin as an empty string. This allows the run paths to be absolute paths. Then an executable may be moved to another directory without moving the shared libraries it needs.

GPS: return block completion
Add "return ... end return;" statement support for complete block completion

ECL: automatic scenario set for Android projects
When the new-project wizard creates a new Ada for Android project the "OS" scenario variable will be set to "linux" automatically. This setting is essential for creating proper library names for subsequent use by the Android OS.

AI-0054 A raise expression does not fail for IN
If a predicate contains a raise expression, and this raise is evaluated as part of an IN membership test, then the result is simply that the membership test fails. The exception is not raised.

Implement raise expression in membership test
This implements the requirement that if a raise exppression is evaluated as part of a predicate test for an IN membership test, then the result is simply false (i.e. the predicate is not satisfied) and no exception is raised. This feature is fully documented in Ada 2012 AI12-0054-1.

AI-0022 Raise expressions
An expression can contain a raise expression. This is a new kind of relation which has the form "raise exception_NAME [with string_EXPRESSION]. The effect is to raise the given exception. This is particularly useful in the context of assertions such as preconditions, where it can be used to specify the exception that is raised if the assertion fails.

Implement raise expression (new Ada 2012 feature)
This implements the "raise expression" feature that has been added to Ada 2012. This allows you to write "raise NAME [with STRING]" in an expression and the effect is to raise the given exception. This is particularly useful in the case of assertions such as preconditions because it allows you to change which exception a precondition raises if it fails. This feature is fully documented in Ada 2012 AI12-0022-1.

GB: Enhance block completions
The block completion facility has been extended to cover additional constructs e.g. extended return statement, protected entry bodies, variant parts inside record declarations.

New cross-reference engine based on sqlite
GPS and GNATbench both have a new xref engine, based on sqlite. This new engine is expected to bring extra performance (since the xref database becomes persistent across sessions and GPS will no longer need to parse ALI files on the fly), as well as more stability (by using an external process to fill the database, and relying on sqlite's very good stability). This engine is currently disabled by default, but can be enabled by adding a line "ENTITIES.SQLITES=yes" in $HOME/.gps/traces.cfg .

A talk presenting OTAWA toolbox for WCET computation - AdaCore Internal Seminar

AdaCore Internal Seminar - Wednesday april 3, 2013.

Hugues Cassé, one of the principal architects and developers of the toolbox, will come to the AdaCore Paris offices to give a talk presenting the OTAWA toolbox for WCET computation.

OTAWA is a set of libraries and static analysis tools aimed at allowing WCET computation based on an abstract representation of the machine code and the target hardware, with existing mappings for a set of popular processors. For more details, see http://www.otawa.fr

If you are interested in attending this talk, please send email to events@adacore.com.

Performance improvements for unions
Several adjustments have been made to the circuitry that handles the marshalling and unmarshalling of aggregates, and in particular unions with enum discriminant. This results in a significant performance improvement when handling such data.

Faster analysis time on large aggregates
CodePeer now takes much less time analyzing code containing large aggregates used e.g. for default initialization of objects.

GB: Export GNATbench preferences like CDT
GNATbench preferences can now be exported via the export preferences wizard and imported into another workspace via the import preferences wizard.

Backup copies of project files with gnatname
When invoked with an existing project file, gnatname creates a backup copy of the project file, unless it is invoked with the new switch --no-backup. This does not apply to VMS, where multiple versions take care of this need.

Switches—RTS for gprclean
gprclean may now be called with switches --RTS= or --RTS:<lang>=. The runtimes specified with these switches are taken into account in the invocation of gprconfig in auto-configuration. This allows gprclean to have more accurate file names to delete, for example when the executable extension depends on the runtime.

GPS: autofix on missing constant with preferences
Autofix has always done fixes in lowercases. This enhancement performs the fixes on missing constants following the user defined preferences specified in Preferences/Editor/Ada/Reserved word casing

Improved messages for explaining non-staticness
The messages that explain why an expression is non-static (when it is required to be static), are improved, and in particular, if a string concatenation involves a non-static aggregate, this case is now clearly identified in the message.

More efficient handling of others for string case
Aggregates of the form (others => 'X') which are similar in effect to the use of a string literal are now handled more efficiently. Note that it is still the case that such aggregates are not static from a language point of view, so cannot be used in contexts requiring a static string.

Pragma No_Inline to suppress inlining
A new pragma No_Inline has been implemented to suppress inlining for a subprogram or for the instances of a generic subprogram.

Profile (Rational) and pragma Overriding_Renamings
A new profile has been introduced to simplify porting legacy code that compiles with the Rational APEX compiler. This profile enables the pragmas Implicit_Packing and Use_VADS_Size, as well as the new pragma Overriding_ Renamings, which makes legal the renaming of an inherited operation with the same name in its own scope.

Pragma Loop_Optimize to control loop optimizations
A new pragma Loop_Optimize has been implemented to control optimizations applied to loops. It makes it possible for the programmer to provide the compiler with optimization hints for loops on an individual basis.

gnatcoll_db2ada allows specifying postgresql port
It is now possible to specify which port number the postgreSQL server runs on, when running gnatcoll_db2ada.

Support Ada.Execution_Time on PowerPC bare board
Ada.Execution_Time is now supported by the Ravenscar runtimes on ppc-elf and p55-elf.

GPS: move Serialize to /Edit/Rectangle/
This menu was previously in /Edit/Selection, but is more logical in the Rectangle submenu since it conceptually applies to a rectangle.

Support for certificate checking has been added
Support for certificate checking has been added. The actual status code can be retrieved and the corresponding message if needed. It is then possible to know why a certificate has been rejected from the verify user's callback.

POGS -l option to ignore missing Simplifier logs
The new -l command line option causes POGS to ignore missing slg files rather than raising errors. This option is designed to be used with the Simplifier's -nolog option.

Pragma Warnings and GCC back-end warnings
Pragma Warnings can now be used in conjunction with the warnings of the GCC back-end to exercise finer control over these warnings.

Use discriminant subtype constraints in derivation
The compiler now takes into account the subtype constraints added by renaming discriminants in the derivation of untagged discriminated types to determine the size of mutable objects of the derived types.

Project_Path searched before ADA_PROJECT_PATH
Project_Path values are searched before ADA_PROJECT_PATH. This behavior is better as if Project_Path is defined for the aggregate project we do not want to pick a random project found in ADA_PROJECT_PATH.

Avoid false elab warnings on assertion calls
The warning circuit for elaboration calls has been enhanced to avoid some false positive warnings for functions called assertion expressions (e.g. the argument of a Postcondition pragma or Post aspect).

Ada 2012 aspects allowed on renaming declarations
In Ada 2012 mode, aspects are now allowed on all renaming declarations. This is relevant only for implementation-defined aspects (e.g. Warnings => Off).

New Linker attribute Trailing_Switches
A new attribute Trailing_Switches has been added in package Linker of project files. These switches are added in the linking command line after the required switches, so that they can override these switches.