Re: Overloading attributes

[anon@att.net]

As for RM 1.1.3 "Conformity of an Implementation with the Standard"

This is just a small list of errors within the GNAT system.
Lets see GNAT violates a number of paragraphs such as:

    2  Translate and correctly execute legal programs written in Ada,
       provided that they are not so large as to exceed the capacity of
       the implementation;

   15  A conforming implementation of this International Standard shall 
       produce for the execution of a given Ada program a set of 
       interactions with the external environment whose order and timing 
       are consistent with the definitions and requirements of this 
       International Standard for the semantics of the given program.

When the GNAT compiler see a raise statement like 

         raise Program_Error ;

instead of converting the routine into something like is 

         Raise_Exception ( Program_Error'Identity,
                           Integer'Image ( Line_Number ) ) ;
or maybe 

         Raise_Exception ( Program_Error'Identity,
                           "was explicit raise by <filename> at line" 
                           & Integer'Image ( Line_Number ) ) ;

it converts it to 

         RCheck_15 ( "<filename>", Line_number ) ;

that not translate and correctly. and the routines that must be 
executed may interfer with the program timing.


    5  Supply all language-defined library units required by this
       International Standard;

   16  An implementation that conforms to this Standard shall support 
       each capability required by the core language as specified.  In 
       addition, an implementation that conforms to this Standard may 
       conform to one or more Specialized Needs Annexes (or to none).  
       Conformance to a Specialized Needs Annex means that each 
       capability required by the Annex is provided as specified.

A number of packages in GNAT do not function as stated in the Standard 
an example is System.RPC and another is Ada.Asynchronous_Task_Control.

For the "Partition Communication Subsystem", Ada uses System.RPC which 
an older communication but is still in the RM and is still useful.

Also, since GNAT compiler can process a program for multi-environments 
it is required that all language-defined library units be fully 
functional so Ada.Asynchronous_Task_Control should be fully functional 
as well.

    6  Contain no variations except those explicitly permitted by this
       International Standard, or those that are impossible or
       impractical to avoid given the implementation's execution
       environment;

GNAT is always adding extra features that may or may not be in the 
next Standard version that can causes corruptions to occur with current 
Standard. Plus, there are a number of statements designs that are not 
functional like the "representation_clause" within the "Protected Units"


   10  The execution of certain code_statements (see 13.8); which 
       code_statements cause external interactions is implementation 
       defined.


While the System.Machine_Code package may be optional, but the coding of 
"code_statements" are not optional. GNAT does not allow "code_statements" 
of any kind. Actually the GNAT compiler does contains the code for 
processing a "code_statement" but it is deactivated.



Adacore GNAT compiler and RTL is one of two Ada leading Ada systems, the 
other is IBM/APEX system.  Since GNAT can not even meet the complete 
definition that is in "RM 1.1.3" that indicates that one or the other is 
corrupted or and should not be used.


This might expain one reason the Dod drop the mandated use of Ada.


In <f10225e5-d894-4ccb-924a-6cf741781fe4@t16g2000vba.googlegroups.com>, Mark Lorenzen <mark.lorenzen@gmail.com> writes:
>On 29 Nov., 12:58, a...@att.net wrote:
>> Where in the RM does it say that the compiler and RTL is the implementation?
>> As everyone says the Ada RM is the final word! And if it is not defined in
>> the RM then the compiler and RTL are not the implementation, but are the
>> tools for the implementation.
>
>I think that chapter 1.1.3 ("Conformity of an Implementation with the
>Standard") pretty well describes the expectations for an
>implementation. To me it's pretty obvious that the standard is talking
>about the toolchain and the RTL.
>
>Regards,
>
>Mark L