Development Log

  • SPARK Pro
    Nov 24th, 2014

    Removed redundant warning of null globals assumed
    The tools used to issue a warning of "null globals assumed" both at the declaration of an imported subprogram and whenever that subprogram was called. The tools now only emit the later. These warnings can be suppressed via the use of a pragma Warnings. However, the proper solution would be to provide a global contract for the imported subprogram.

  • GNAT Pro
    Nov 23rd, 2014

    Warn when fixed-point end-points are out of range
    The compiler is allowed to adjust the declared end points of a fixed-point type by delta (RM 3.5.9(13)). This can result in a declared end-point of the range being outside the actual range of the type. GNAT takes advantage of this when it can result in the type just fitting in a convenient size (e.g. 32 bits instead of 33 bits). This situation now generates a warning.

  • GNAT Pro|GPRbuild
    Nov 21st, 2014

    GPRinstall new—no-build-var option
    A new option --no-build-var has been introduced and is meant to be use for project with a single configuration (single installation). In this case there is no build/scenario variable generated.

  • SPARK Pro
    Nov 20th, 2014

    Actual parameters with property Async_Writers
    Actual volatile parameters with enabled external property Async_Writers can now appear in procedure calls where the corresponding formal is of mode OUT.

  • GNAT Pro
    Nov 20th, 2014

    Do not trust Elaborate in SPARK
    In normal GNAT static elaboration mode, a pragma Elaborate is trusted to be sufficient, and the use of such a pragma disables the static checking. In SPARK mode, the pragma Elaborate is allowed, but it is not trusted to be sufficient, since this cannot be verified at compile time. This means that we may require Elaborate_All even if a pragma Elaborate is present.

  • GNAT Pro
    Nov 20th, 2014

    New directories in project path for gnatls—RTS=
    Two new directories are added in the project path, when gnatls is invoked with --RTS=, just before the two directories for the target. When the runtime is a single name, the directories are:

      <prefix>/<target>/<runtime>/lib/gnat
      <prefix>/<target>/<runtime>/share/gpr
    
    Otherwise, the runtime directory is either an absolute path or a path relative to the current working directory and the two added directories are:
      <runtime_directory>/lib/gnat
      <runtime_directory>/share/gpr
    

  • GNAT Pro
    Nov 19th, 2014

    Ignore Suppress (Elaboration_Check) in SPARK
    In normal GNAT mode, Suppress (Elaboration_Check) disconnects the normal static elaboration mode circuitry. We don't want that in SPARK, where the elaboration rules are important static legality rules that must not be compromised. So in SPARK mode, we ignore the attempt with a warning.

  • GNAT Pro
    Nov 18th, 2014

    Require Elaborate_All for SPARK mode variable ref
    In SPARK mode, a variable reference to a variable in another package requires an explicit Elaborate_All call, and this is now implemented. Note that the current SPARK manual specified this is only required for read/write references, so the rule implemented is more restrictive. It is not clear exactly what constitutes a read/write reference, which is why the more general, more easily stated, rule is implemented.

  • SPARK Pro
    Nov 17th, 2014

    Tune options for CVC4
    The options used for CVC4 have been tuned, so that more VCs are discharged automatically.

  • GNAT Pro
    Nov 16th, 2014

    Handle aspects before initialization expression
    Aspect specifications belong after the initialization expression in an object declaration, not before, but the compiler now accepts them before with a clear error message

  • GNAT Pro
    Nov 16th, 2014

    Require Elaborate_All for calls in SPARK mode
    In SPARK mode, we always operate in the static elaboration mode, but we do not generate implicit Elaborate_All pragmas; instead we require such pragmas to be explicitly present for calls in elaboration code. This requirement is now implemented

  • GNAT Pro
    Nov 14th, 2014

    gnatpp:—split-line-before-op
    The --split-line-before-op switch is added to gnatpp. If it is necessary to split a line at a binary operator, by default the line is split after the operator, as always. With this option, it is split before the operator.

  • CodePeer
    Nov 13th, 2014

    Faster analysis of logical expressions
    CodePeer has improved the time necessary to perform the analysis of complex expressions that combine a large number of logical operators.

  • GNAT Pro
    Nov 13th, 2014

    Better error message for No_Elaboration_Code_All
    The error message for a violation of pragma No_Elaboration_Code_All now clearly identifies the offending package (the one that lacks the required pragma or restriction) in the case where the system.ads file contains the pragma No_Elaboration_Code_All.

  • GNAT Pro
    Nov 13th, 2014

    Forbid pragma Elaborate in SPARK mode
    The SPARK RM forbids the use of pragma Elaborate in SPARK mode (instead it is required to write pragma Elaborate_All explicitly). This rule is now properly enforced.

  • SPARK Pro
    Nov 12th, 2014

    CVC4 shipped with SPARK, enabled by default
    The SPARK toolset has provided the option --prover to select other automatic provers, but it was shipped only with prover Alt-Ergo, and by default proof was attempted only with this prover. Now, SPARK also comes with the SMT prover CVC4, and the new default setting of option --prover is

      --prover=cvc4,altergo
    
    
    This increases greatly the proof capabilities of the tool, while only slightly increasing running time.

  • GNAT Pro
    Nov 12th, 2014

    Numeric_Literals gnatcheck rule is improved
    The gnatcheck Numeric_Literals rule no longer flags numeric literals in aspect specifications and aspect clauses (representation clauses).

  • GNAT Pro
    Nov 12th, 2014

    Better handling of discriminants in Unchecked_Union
    The compiler no longer generates a warning for a "missing" component clause for a discriminant in an Unchecked_Union (since the discriminant is not stored, it does not need one), and also avoids listing the representation of such a discriminant in the output from use of -gnatR2.

  • GNAT Pro
    Nov 11th, 2014

    CPU_Set implemented
    AI12-0033-1, "Sets of CPUs when defining dispatching domains" is now implemented. This allows Dispatching_Domains to be defined as arbitrary sets of processors, rather than just ranges. See System.Multiprocessors.Dispatching_Domains (s-mudido.ads).

  • GNAT Pro
    Nov 10th, 2014

    Inter-unit inlining of expression functions
    Expression functions declared in package specifications are now inlined across units with -O1 or -O2 and -gnatn (which is equivalent to -gnatn1). They were previously inlined across units only with -O3 -gnatn (which is equivalent to -gnatn2).

  • GNAT Pro
    Nov 9th, 2014

    No_Elaboration_Code_All allowed for generics
    The pragma No_Elaboration_Code_All may now be applied to generic units (generic package specs and generic subprogram specs).

  • SPARK Pro
    Nov 7th, 2014

    Possibility to attempt proof for all VCs
    Normally, the SPARK toolset stops attempting to prove a check as soon as one VC has not been proved. This is well-suited for automatic proof and provides timely tool results. However, to combine automatic and manual proof, it may be useful to attempt proof of all VCs of a check. This can be done now by selecting the proof mode together with the mode for VC attempts, for example the switch

      --proof=progressive:all
    
    
    selects progressive splitting of VCs, while attempting proof on all, and
      --proof=per_path:lazy
    
    
    selects one VC per check and path, stopping at the first unproved VC per check.

  • CodePeer
    Nov 7th, 2014

    Comparison to baseline in different location
    It is now possible to compare the results of an analysis to a baseline of the same project established in a different location, as long as they share the same database.

  • GNAT Pro
    Nov 7th, 2014

    GNAAMP: Optimize literal indexing of global arrays
    On the AAMP target, with -O1 the compiler emits shorter code sequences for indexing of library-level arrays by literals.

  • SPARK Pro
    Nov 6th, 2014

    Support for tagged types
    Tagged types, interfaces and dynamic dispatch are now supported in SPARK. The new aspect Extensions_Visible (documented in the SPARK RM) controls if any extensions of a controlling parameter need to be considered or are visible. This aspect also controls if it is possible to convert a parameter to a class-wide type. By default this aspect is False in SPARK_Mode. Class-wide globals and depends (which are currently assumed to be equal to the non-class-wide globals and depends) will be checked by flow analysis. Flow analysis also checks that LSP (Liskov Substitution Principle) holds for class-wide globals and depends. Class-wide preconditions and postconditions are supported and checked by proof where appropriate. Proof also checks that LSP (Liskov Substitution Principle) holds for class-wide preconditions and postconditions.

  • SPARK Pro
    Nov 5th, 2014

    Better support for Refined_Post
    The SPARK toolset now fully supports the Refined_Post aspect. Previously, even callers who had visibility of the refined postcondition could not make use of it and only used the regular postcondition instead. This has been improved now.

  • SPARK Pro
    Nov 5th, 2014

    Warning about uninitializable state abstractions
    Flow analysis now issues a warning whenever a state abstraction is impossible to initialize.

  • GNAT Pro
    Nov 5th, 2014

    Unordered enumerate warning suppressed for generic
    The warning about inappropriate usage for an unordered enumeration type is now suppressed for generic types in the template (since the instantiation may be with an ordered enumeration type where the usage is legitimate).

  • GNAT Pro
    Nov 4th, 2014

    Type extensions always inherit parent SSO
    A type extension must have the same scalar storage order as its parent (as per the definition of the Scalar_Storage_Order aspect). The compiler now ensures that the default scalar storage order for a tagged derived type is set to this required value even in the presence of a Default_Scalar_Storage_Order pragma specifying a different value, so that the user does not have to repeat the parent SSO.

  • SPARK Pro
    Nov 3rd, 2014

    Do not stop analysis on empty range check
    As GNATprove implements stricter rules than those mandated by Ada RM, in particular by issuing errors on compile-time known constraint errors which should not prevent compilation, it stopped analysis on empty range checks, which appear legitimately on deactivated code. Such empty range checks do no stop analysis anymore, instead a check is generated by GNATprove during proof.

  • GNAT Pro
    Nov 2nd, 2014

    Duplicate pragma Linker_Section is detected
    If a duplicate pragma Linker_Section is encountered for a single entity, an error message is now given.

  • CodePeer
    Oct 29th, 2014

    Suppressing analysis via Annotate pragmas
    By adding "pragma Annotate (CodePeer, Skip_Analysis);" at the start of the declaration list of a subprogram body or a package body, CodePeer's analysis of selected subprogram bodies can be suppressed. This is typically done in order to improve performance. For details, see CodePeer User's Guide section 2.4 ("Running CodePeer Faster").

  • GNAT Pro
    Oct 29th, 2014

    Windows GNAT.OS_Lib.Wait_Process improvement
    On Windows the Wait_Process routine now follows the UNIX semantics more closely. The main improvement are:

     - It is possible to have multiple tasks waiting for a child process
       to terminate.
     - When a child terminates, a single wait call will receive the
       corresponding process id.
     - A call to wait will handle new incoming child processes.
    

  • SPARK Pro
    Oct 24th, 2014

    Better error locations for flow analysis
    Flow analysis used to point at the export (Something) when it issued messages like

      warning: incorrect dependency "Something => State"
    
    We now point at the incorrect dependency (State) instead.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Oct 23rd, 2014

    GPS:—version and—help no longer require GUI
    The switches are parsed before GPS attempts to connect to the GUI environment. As a result, it is possible to get the help or the version even when the environment is not setup for GUI.

  • GNAT Pro
    Oct 23rd, 2014

    Support for overriding keyword in Ada 95 mode
    For compatibility with some Ada 95 compilers which support only the overriding keyword of Ada 2005, the -gnatd.D debug switch can now be used along with -gnat95 to achieve a similar effect with GNAT.

  • GNAT Pro
    Oct 22nd, 2014

    Win32Ada has some WinCrypt support
    Some Windows WinCrypt routines has been added into the Win32Ada binding. They can be found into the Win32-WinCrypt unit.

  • SPARK Pro
    Oct 21st, 2014

    Mark Ghost functions in formal containers
    Functions First_To_Previous, Current_To_Last and Strict_Equal introduced in units of the formal container library should only be used in contracts and assertions, as they are very inefficient. They are now marked as Ghost functions, which prevents use outside assertions and ghost code.

  • GNAT Pro
    Oct 21st, 2014

    Use of floating-point in fixed-point operations
    In the presence of restriction No_Floating_Point, a multiplication of two fixed point quantities of the same fixed point type in an integer context does not generate conversions to floating-point for run-time evaluation.

  • SPARK Pro
    Oct 20th, 2014

    Raise, no-return and statically-false assertions
    Flow analysis now ignores all statements that inevitably lead to a raise statement, a statically-false assertion or a non-returning procedure. Additionally, all statements that follow a raise statement, a statically-false assertion or a non-returning procedure that are not otherwise reachable from the start of the subprogram are also ignored.

  • SPARK Pro
    Oct 20th, 2014

    New implementation of Ghost entities
    The SPARK toolset now implements the new semantic and legality rules of Ghost entities. This feature now encompases states, objects, subprograms, packages and types. As a result, convention Ghost has been replaced with aspect Ghost.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Oct 17th, 2014

    Support for Runtime & Target attributes in projects
    These two new attributes are now supported by GPS and should replace the use of the IDE'Gnatlist attribute to specify the same information.

  • GNAT Pro|GPRbuild
    Oct 15th, 2014

    GPRslave control of simultaneous responses
    A new option has been added to GPRslave to control the number of simultaneous responses (sending back object code and ALI files) supported. This was hard coded to 2, it is now possible to set this value between 1 and the maximum number of simultaneous compilations.

  • SPARK Pro
    Oct 14th, 2014

    Replay facility always reissue warnings
    When a unit or the units on which it depends have not changed, GNATprove detects it and avoids re-analyzing the unit. This caused some warnings to be issued only the first time a unit was analyzed. Now, a new replay facility is used in GNATprove to always reissue warning and check messages when a unit is considered, even when it does not require re-analysis.

  • PolyORB
    Oct 13th, 2014

    Extend fast-path CDR marshalling to nested arrays
    The fast-path CDR marsahlling circuitry, allowing efficient marshalling of common aggregates such as arrays of bytes or integers, has been extended to the case of nested arrays.

  • GNAT Pro|GPRbuild
    Oct 13th, 2014

    Runtime specific directories in the project path
    For each non default runtime, there are now two more directories in the project path: <runtime_root>/lib/gnat and <runtime_root>/share/gpr, where <runtime_root> is either:

      - <runtime> ifthe runtime is explicitly specified as an absolute path
      - <compiler_root>/<target>/<runtime> if the runtime is not explicitly
        specified as an absolute path
    

  • GNAT Pro|GPRbuild
    Oct 13th, 2014

    Project path depends on compilers
    For tools gprbuild, gprclean and gprinstall, the project path depends on the compilers, not the prefix of the tool. For each compiler driver in a "bin" subdirectory, the compiler root is the parent directory of this "bin" subdirectory and the directories in the project path are, in order:

       <compiler_root>/<target>/lib/gnat
       <compiler_root>/<target>/share/gpr
       <compiler_root>/share/gpr
       <compiler_root>/lib/gnat
    

  • GNAT Pro|GPRbuild
    Oct 13th, 2014

    New gprbuild option—complete-output
    A new option --complete-output is added to gprbuild, allowed only on the command line and incompatible with option --distributed=. When this option is used, the standard output and standard error of the compiler are redirected to text files. When these files exist for a source that is up to date, their content is output to stdout and stderr.

  • GNAT Pro
    Oct 13th, 2014

    New function Non_Blocking_Spawn
    A new function Non_Blocking_Spawn is added to GNAT.OS_Lib. This function redirects standard error and standard output to two different files.

  • GNAT Pro
    Oct 10th, 2014

    Inlining of renamed subprograms
    The compiler supports inlining of renamed subprograms.

  • GNAT Pro
    Oct 10th, 2014

    Inlining of unchecked conversion instantiations
    Compiling with back-end inlining enabled the compiler supports implicit inlining of unchecked conversions defined in inlined subprograms (i.e. it is not necessary to add pragma Inline to instantiations of unchecked conversion defined in inlined subprograms).

  • GB: better scenario variables support
    Scenario variables editor added capability to:

     * set the variable for all projects
     * unset the variable for all projects to use GNAT project default value
    
    Scenario variables changes are taken into account immediately without having to restart GNATbench.

  • GB: add Ada/Environment preferences page
    New Ada/Environment preferences page allows the configuration of the environment used when GNATbench launch any command.

  • GNAT Pro
    Oct 7th, 2014

    Support for POSIX binding shared library
    Florist, the GNAT implementation of the standard Ada binding to the POSIX API, can now be built as a shared library by passing "--enable-shared" to its configure script.

  • SPARK Pro
    Oct 3rd, 2014

    Output of assumptions of verification results
    The SPARK toolset now supports the option --assumptions. With this option, the tool outputs for each verication result in the result file gnatprove.out, the assumptions it depends on. Assumptions are properties which should hold for the verification results to be true, but which the SPARK toolset could not verify by itself. This can happen because the corresponding code is not in the SPARK subset or the verification of that code was not finished. Currently, output assumptions only include the assumptions on called subprograms of analysed subprograms, but not assumptions about the calling context of analysed subprograms.

  • SPARK Pro
    Oct 3rd, 2014

    Support for list of provers to try
    The option --prover of the SPARK toolset has now been improved to allow a list of provers, e.g. the command line option --prover=altergo,cvc4 will first try to prove a VC with altergo, and if that fails, try again with CVC4. The same steps or timeout option applies to all provers.

  • GB: add support for “On File Change” builder target
    A builder target having its launch mode set to "On File Change" will be automatically launched each time an ada file is saved. Wind River Workbench users can use this feature to have ada code analyzed as soon as it is saved. Builder target settings are accessible through Ada / Builder Targets preferences page.

  • SPARK Pro
    Sep 30th, 2014

    Tools now warn on hidden unexposed state
    The SPARK toolset now issues a warning per hidden state of a package that is not exposed through a state abstraction while an enclosing package declares abstract state.

  • CodePeer
    Sep 29th, 2014

    New switches -show-reviews and -show-reviews-only
    A new switch -show-reviews (relevant with using -output-msg) shows the messages which have been reviewed, with their review information. -show-reviews-only is introduced and replaces the previous -show-manual-reviews switch.

  • GNAT Pro
    Sep 29th, 2014

    Improved elimination of useless range checks at -O2
    The compiler now eliminates more range checks that can never fail when the optimization level -O2 or above is specified.

  • GNAT Pro
    Sep 27th, 2014

    Support for 32bit and 64bit Windows registry views
    GNAT.Registry has been enhanced to be able to open or create a key into either of the registry view on Windows 64bit.

  • SPARK Pro
    Sep 26th, 2014

    New categorization of messages
    The SPARK toolset used to issue not suppressible errors for violations of legality rules and important analysis problems, and suppressible warnings for less severe problems and suspicious situations. There is now a third category of messages, called checks. Some previous errors and warnings have become checks. The new categorization is that only violations of legality rules are errors, only suspicious situations are warnings, and all messages which impact the soundness of the code or the tool output are checks. Checks are suppressible, but the mechanism for suppression is different, so this represents an incompatible change. See the users guide for more details about messages and how to suppress them.

  • GNAT Pro|GPRbuild
    Sep 26th, 2014

    gprconfig issues an error for compiler not found
    When gprconfig cannot find a compiler for a language specified with a switch --conf, it now issues an error, even in quiet mode, indicating the language, the target and the runtime.

  • PolyORB
    Sep 23rd, 2014

    Lifted limitations on IAC command line
    IAC used to support only 64 preprocessor arguments, and 64 search path elements at most. Both limitations have been removed.

  • CodePeer
    Sep 22nd, 2014

    Ability to exclude source files from analysis
    A new project attribute Excluded_Source_Files in package CodePeer is available to easily exclude source files from analysis.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 19th, 2014

    GPS: outline showing C structs and typedefs
    The outline will now show entries for the named C structs (i.e. not those defined as part of a typedef). For instance, "struct foo {}" and "typedef struct foo bar" will generated entries, but not "typedef struct { ... } bar"

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 19th, 2014

    GPS: alignment preserves the selection
    When using the contextual menu Align, this will now preserve the selection so that multiple such commands can be chained.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 18th, 2014

    CodePeer: display check kinds for messages
    GPS and GNATbench now display corresponding check kinds for CodePeer precondition messages. GPS allows filtering out messages based on these check kinds.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 18th, 2014

    GPS: save scenario on exit and restore on startup
    The value for the scenario variables is saved when GPS exits or you load a new project, and restored when the same project is loaded in the future (unless a new value is specified via environment variables or the -X command line parameter).

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 17th, 2014

    GPS: Review handling of auto-saved files
    When you open a file for which there exists an auto-save file, GPS displays a dialog asking whether you would like to load this auto-save file instead of the actual file. This dialog was enhanced with the following capabilities: not displayed when the auto-save file contains the same thing as the file itself; loading the auto-save file can be undone, thus ending with the actual file, or redone, thus going back to the auto-save file.

  • GNAT Pro
    Sep 17th, 2014

    Better error msg for illegal deferred constants
    The compiler provides a more explicit message when a deferred constant is declared with an anonymous array type, explaining that the type of the full declaration is a different type.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 16th, 2014

    GPS: remove the GPS Shell console
    Although the GPS shell scripting is still supported for this language, the console itself has been removed. We recommend using the Python console instead. Most commands are available there, with the following replacements possible:

              GPS Shell         |    Python
                  cd            | os.chdir('...')
                  pwd           | os.getcwd()
                  ls            | os.listdir('...')
                  help          | help(...)
    

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 16th, 2014

    GPS: save browser contents in desktop
    When GPS is restarted, the contents of the various browsers (call graph, project dependencies, file dependencies or entities) is restored.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 16th, 2014

    GPS: new File Operations menu in project view
    The File Operations menu, already available in the Files view, has also been added to the Project view. Through this contextual menu, it is possible to easily create new files or directories, rename existing files or directories, and delete them.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Sep 16th, 2014

    GPS: folding compartments in entity view
    It is now possible to fold the attributes or operations compartment in the Entities browser. A new local configuration is also available to chose whether to display fully qualified names or simple names for the boxes.

  • GNAT Pro
    Sep 16th, 2014

    Support for C/C++ xrefs and symlinks
    The -fdump-xref compiler switch for C and C++ sources no longer resolves symbolic links under unix systems, thus allowing generation of cross references on the direct files, as used by e.g. some CM systems.

  • CodePeer
    Sep 11th, 2014

    Faster processing of enumeration type data
    CodePeer has improved the analysis of very large enumeration type declarations.

  • GNAT Pro
    Sep 8th, 2014

    Improve recognition of misspelled aspects
    The compiler now does a better job of recognizing and diagnosing misspelled aspects (such as Prelaborate for Preelaborate).

  • GNAT Pro
    Sep 8th, 2014

    Improve error recovery for bad comma/semicolon
    The compiler now gives a clearer error message for the case of an extra comma or semicolon after a logical phrase when more follow (e.g. X > 3; and then).

  • GNAT Pro
    Sep 7th, 2014

    Implement No_Tagged_Streams pragma and aspect
    A new pragma No_Tagged_Streams allows selective suppression of generation of stream routines for tagged types for which no stream operations are used. There are two forms, one with no parameters which appears in a package spec or declarative region and applies to all subsequent declarations of root tagged types in the package or declarative region, and one with an argument that names a specific root tagged type for which streams are not allowed. The latter form has a corresponding aspect.

  • PolyORB
    Sep 6th, 2014

    Changed preference order for Ada compiler
    When looking for an Ada compiler, the PolyORB configure scripts now favor "gcc" over "gnatgcc" or "adagcc". The default Ada compiler can always be overridden at configure time using the "ADA" environment variable.

  • GNAT Pro
    Sep 4th, 2014

    Inter-unit inlining of instantiated subprograms
    The compiler now considers instantiations of generic subprograms subject to pragma Inline or with an Inline aspect as equivalent for inter-unit inlining to regular subprograms subject to the pragma or aspect. Previously they were much less likely to be inlined across units.

  • SPARK Pro
    Sep 4th, 2014

    Individual checks for each Loop_Invariant Pragma
    For a given loop, the SPARK toolset used to generate a single check for all loop invariant pragmas in a group of loop invariants of that loop. This made it difficult to see which loop invariants were not proved. Now, the SPARK toolset generates a check for each Loop_Invariant pragma individually.

  • Ada Web Server
    Sep 3rd, 2014

    Add support for controlling WebSocket lifetime
    It is now possible to control the WebSocket's lifetime. First the new configuration option Max_WebSocket can be used to allow a maximum of simultaneous opened WebSocket and so avoid using all operating system file descriptor. Second the new configuration option WebSocket_Timeout can be used to control the time without activity after which a WebSocket is in timed-out mode. A timed-out WebSocket can be closed if the maximum number of WebSocket is reached.

  • GNATCOLL.Email: Reset multipart to single part
    Procedure Convert_To_Single_Part now takes an additional formal parameter Purge (default False). When Purge is set True, the message is reset to an empty single part text/plain payload, regardless of previous contents.

  • CodePeer
    Sep 2nd, 2014

    Switch -update-scil now enabled by default
    The switch -update-scil is now the default, so can be omitted. A switch -no-update-scil is provided for compatibility with the previous default behavior in the rare cases where it is useful to separate SCIL generation from codepeer analysis. This means that a typical launch of codepeer now looks like:

      codepeer -P<project>
    

  • GPS: on-the-fly syntax error reporting for Python
    GPS now runs the pep8 syntax checking library on Python source editors and reports errors as you type.

  • GNAT Pro
    Aug 29th, 2014

    Improve error message for illegal iterator
    The compiler provides an improved error mesage on an Ada 2012 iterator specification whose name is a function call, when the function does not yield a type that implements the predefined iterator interface.

  • GNATCOLL.SQL: support for bigint
    Add support for the standard sqlite type BIGINT, mapping to a Long_Long_Integer.

  • GNAT Pro
    Aug 28th, 2014

    Parameter for Positional_Parameters gnatcheck rule
    A parameter is added to the gnatcheck Positional_Parameters rules, it causes the rule to flag all the positional associations that can be replaced with named associations according to Ada rules.

  • GNAT Pro
    Aug 22nd, 2014

    Pragma/aspect Suppress_Initialization for variables
    Suppress_Initialization can now be used as a boolean aspect as well as a pragma, and now applies to variables as well as types. When applied to a variable it suppresses all implicit initialization for that variable.

  • GNAT Pro
    Aug 22nd, 2014

    Improved messages in configurable run-time mode
    The error messages for unsupported features in a configurable run-time have been enhanced for the cases of task rendezvous not supported, and specified array packing not supported. Instead of just listing the (possibly obscure) name of the missing entity in these cases, a clear error message is now given saying that the feature is not supported. In the latter case an error is now issued on the array type declaration itself, as well as on packed operations.

  • SPARK Pro
    Aug 21st, 2014

    Support for manual proof with Coq
    GNATprove now offers suppor to use of Coq to manually prove SPARK 2014 VCs. This includes:

       - Extraction and verification of files containing SPARK 2014 VC that must
         be completed by the user with proof.
       - Definition of a project attribute to specify the location of VC files.
       - Communication with GPS environment for SPARK 2014 to perform manual
         proof from the IDE.
    

  • GNAT Pro|GPRbuild
    Aug 20th, 2014

    —target and CodePeer mode
    When gprbuild is called with switches --codepeer and --target, it now issues a clear error message indicating that these two switches cannot be used simultaneously, instead of hard to understand errors such as:

        no languages defined for this project
    

  • CodePeer
    Aug 20th, 2014

    Compiler specific libraries
    CodePeer now provides compiler specific libraries to ease analysis of Ada code used with most compilers.

  • GNAT Pro
    Aug 19th, 2014

    Pragma Warnings with string literal OK in Ada 83
    The compiler now accepts the two argument form of pragma Warnings in Ada 83 with a string literal as the second argument. This was previously not allowed because a static string expression was required, and there is no such thing in Ada 83.

  • SPARK Pro
    Aug 19th, 2014

    Support for Default_Initial_Condition
    Both proof and flow analysis now support aspect Default_Initial_Condition.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Aug 17th, 2014

    Improved indentation of conditional expressions
    Indentation of Ada 2012 conditional expressions (if and case expressions) spanning multiple lines has been improved.

  • GNAT Pro
    Aug 17th, 2014

    New application unit System.Atomic_Counters
    The unit System.Atomic_Counters is now officially available to application programmers. This unit provides an atomic counter type, along with increment, decrement and test operations using hardware synchronization primitives. It is available for most targets: See documentation for complete list of supported targets.

  • GNAT Pro|GNATbench | GNAT Pro|GPS
    Aug 15th, 2014

    GPS: auto-load plugin
    GPS now loads project-specific plugin named <project>.ide.py when root <project>.gpr is open.

   1  2  3     Next »