Re: How to exit an Ada program with (unix shell) error code?

[anon@anon.org (anon)]

Martin.

  You misread RM 10.2 (29), its quoted below.

Both of the subprograms types are valid and portable and even though 
RM 10.2 (29) allows a vendor to restrict the main subprogram. Adacore 
(GNAT) and IBM which follow the RM to the letter have decided to allow 
and support both main subprograms types in Ada 83/95/2005 specs.

Note: At this time Adacore and IBM are the only ones supporting Ada 2005.

Now, in the GNAT design the "GNATBIND" process actually wraps the main 
subprogram ( "procedure main" or a "function main return integer" ) within 
a function called "main" within a package called "ada_main".  And if the 
"main" subprogram is a procedure, the binder function "main" calls this 
procedure and returns the exit status which is normally set to zero unless it 
is altered by "Ada.Command_Line.Set_Exit_Status". But if main subprogram 
is a function type of partition, then the binder function "main" returns the 
value returned from the partition "function main" to the OS as the exit 
status. To see this, just compile any program and then bind it. Check the 
resulting output files "b~<name>.adb" and its spec file before linking. 

Note: normally during linking the linker "GNATLINK" deletes the 
binder source/object files.


So both of these are valid in the RM.  It just that most programmers prefer 
the "Procedure" type of partitions design.

--
-- main subprograms as a procedure 
--
procedure main is
  begin -- main
     null ;
  end main ;
--
-- or main subprograms as a public parameterless function
--
function main return integer is
  begin -- main
     return ( 0 ) ; -- 0 := normal exit status.
  end main ;



Ada RM -- quoted 


  RM 10.2 Program Execution
   ...

                         Implementation Permissions
   ...

29    An implementation may restrict the kinds of subprograms it supports as
                        ------------
main subprograms. However, an implementation is required to support all main
                                                            ----------------
subprograms that are public parameterless library procedures.
-----------


  RM 10.1 Separate Compilation


1     A program unit is either a package, a task unit, a protected unit, a
protected entry, a generic unit, or an explicitly declared subprogram other
                                       ------------------------------
than an enumeration literal. Certain kinds of program units can be separately
compiled. Alternatively, they can appear physically nested within other
program units.



In <8ef6052e-4f51-416b-bae7-ff83d7024267@t11g2000vbc.googlegroups.com>, Martin <martin.dowie@btopenworld.com> writes:
>On May 4, 5:09=A0pm, a...@anon.org (anon) wrote:
>> --
>> -- =A0Besides the Ada.Command_Line you can just use functions for
>> -- =A0the instead of procedures for your nain program. This design is
>> -- =A0great for application where Command_Line is not used.
>> --
>>
>> function work return Integer is
>>
>> =A0 begin
>> =A0 =A0 return ( 0 ) ; -- no error status code
>> =A0 end work ;
>
>Be aware that this is not portable. The only main subprogram that all
>compilers must support (if they support a main subprogram) is "public
>parameterless library procedures" (RM2005 10.2, 29 - previous RMs have
>similar requirements), i.e.
>
>   procedure Main is
>   ...
>
>Cheers
>-- Martin