Issues for Ada 2003 Revision Task Force

List of issues (green=resolved, yellow=pending Board vote, red=unresolved)

List options: All ; Open Issues only; or Closed Issues only

Issue 733: Ada mapping deficiency - orbos/97-09-26
Issue 734: Ada mapping deficiency - orbos/97-09-26 (2)
Issue 735: Ada mapping deficiency - orbos/97-09-26 (3)
Issue 996: Ada mapping issue
Issue 1112: Ada issue: Type string in package CORBA spec
Issue 1320: Ada and the POA
Issue 1359: Ada Language Mapping: Section 23.5.5, Mapping for Interface
Issue 1387: IDL to Ada Mapping: Ada package CORBA.Object (01)
Issue 1388: Mapping of IDL to Ada: Ada package CORBA.Object
Issue 1504: Chapter 23.2.7 of CORBA 2.2, IDL to Ada Mapping ( pragma Subsystem)
Issue 1702: Nil object reference (CORBA v. 2.2)
Issue 1806: Mapping of structure, union or exception types
Issue 1807: Mapping of sequesnce types
Issue 1808: Mapping for typedef
Issue 1809: Mapping for standard exceptions
Issue 1810: NamedValue in 23.6.1
Issue 1811: TypeCode in 23.6.6
Issue 1812: list_initial_services and resolve_initial_references are missing
Issue 1813: 23.6.8 Object circularities
Issue 1814: Parameter Result in Createrequest cannot be "in out NamedValue
Issue 1818: Mapping of Operations (23.5.9) "Returns" parameter
Issue 1846: 23.5.5 Mapping for Interfaces (Client-Side Specific)
Issue 1856: 23.5.5 Mapping for Interfaces (Client-Side Specific)
Issue 1896: 23.8.1 Package CORBA
Issue 2036: Error in section 21.3.3
Issue 2043: Section 21.8.9: Examples
Issue 2044: The name of the mapped type shall be "Fixed_" prepended
Issue 2209: Method for converting an Object to a Ref
Issue 2262: Impl methods should be dispatchable
Issue 2458: Name and scope of instantiation of CORBA.Sequences.{Un}Bounded
Issue 2459: Mapping of operation parameters of same interface type.
Issue 2632: ptc/99-02-02 page 21-5 Server Side, common root type CORBA.Object.Objec

Issue 733: Ada mapping deficiency - orbos/97-09-26 (ada-rtf)

Summary: Inconsistencies between sections 21.2.1 and 21.7.3. The change from CORBA.Object.Object to CORBA.Implementation_Defined.Object is not reflected in 21.2.1 and 21.7.3. The private section still contains CORBA.Objetc.Object. The context clause  "with CORBA.object" should be changed to "with CORBA.Implementation_Defined"

 closed issue

Summary: The pseude-object specifications in the main body of the text do not match with the appendices. There are differences between specs and appendices include NVlist, Context, TypeCode, BOA, and Object

 closed issue

Summary: Inconsistencies in section 21.5.8 (standard exceptions) and Appendix A1 (package CORBA): Changes to standard exceptions section have not been reflected in Appendix 1A (System_Exception_Members, exception members type) The example exception members type is referred to as Unknown_Members and Unknown_Exception_Members. It is not clear how type Unknown_Members is used

 received issue

Summary: Please refer to Chapter 22 of ptc/98-01-04  and provide Ada language
 mappings for the operations that have been added to CORBA::Object and
 CORBA::ORB from Security Service in Core Revn 2.2 and 2.3.
 Ada Mapping issue

Summary: I have a suggestion regarding the current (CORBA version 2.2) IDL to Ada
 >mapping which concerns the type String in the package CORBA spec. 
 >Here is a diff of the addition that I propose:
 >
 >*** corba.ads.orig	Mon Mar  2 09:38:27 1998
 >--- corba.ads	Wed Mar 25 08:35:28 1998
 >***************
 >*** 29,34 ****
 >--- 29,37 ----
 >     type    Octet          is new Interfaces.Unsigned_8;
 >     type    String         is new Ada.Strings.Unbounded.Unbounded_String;
 >  
 >+    Null_Unbounded_String : constant String
 >+                       := String
 >(Ada.Strings.Unbounded.Null_Unbounded_String);
 >+ 
 >     -- Exceptions
 >  
 >     type IDL_Exception_Members is abstract tagged null record;
 >
 >
 >The lack of the Null_Unbounded_String constant in the current CORBA spec 
 >means it is cumbersome to compare a CORBA.String against the 
 >Ada.Strings.Unbounded.Null_Unbounded_String, as such comparison requires a 
 >type conversion.
 

Summary: The Ada language binding has not been updated to deal with the
 deletion of the BOA and the introduction of the native type for the POA.
 

 received issue

Summary: Ada Language Mapping:  Section 23.5.5, “Mapping for Interfaces”
 
 **The following text is added to the Ada language mapping within section
 23.5.5 at the end of the subsection titled, “Narrowing Object
 References”.**
 
 Narrowing an object reference can require a remote invocation (to either
 the target object or to an Interface Repository) to verify the
 relationship between the actual object and the desired narrow
 interface.  For cases where the application programmer wishes to avoid
 the possibility of this remote invocation, conforming implementations
 must provide a primitive subprogram in each interface package to perform
 an unchecked narrow operation.
 Each interface mapping shall include a function with specification:
 
 function Unchecked_To_Ref(The_Ref : in CORBA.Object.Ref’CLASS) return
 Ref;
 
 Regardless of whether or not The_Ref is known to support the desired
 interface, the provided implementation returns a narrowed reference.
 
 

Summary: I have a few suggestions concerning the Mapping of OMG IDL to 
 Ada (chapter 23 of the CORBA V2.2 spec.)
 
 The C++ mapping in the same document among other defines a class
 Object (see chapter 20.32.2). This class provides a number of
 methods that the equivalent Ada package CORBA.Object (chapter
 23.8.8) does not.
 
 My first suggestion is to supply the verbatim text of the IDL
 interface Object on which the Ada package CORBA.Object is
 based. (This is chapter 20.32.1 in the C++ mapping.)
 

Summary: My further suggestion is to adopt a single IDL specification as 
 the basis for both the C++ and the Ada language mappings for the
 interface Object (and other predefined interfaces). This is in
 the interest of compatibility of programming interfaces.
 
 In particular, I find the following methods lacking in the Ada
 package CORBA.Object that are present in the C++ class Object:
 

Summary:  Chapter 23.2.7 of the CORBA v2.2 Mapping of OMG IDL to Ada
 mentions:
 
 " Files (actually inclusion streams) create a package to contain the
   "bare" definitions defined in IDL"s global scope. The package name
   is formed from the concatenation of the file name and _IDL_File. 
 "
 
 In the absence of a pragma Subsystem, this solution is felt to be
 unsatisfying.

Summary: Section 20.3.5 of the OMG IDL to C++ Mapping states:
 
 " The mapping for an interface defines a static member function 
   named _nil that returns a nil object reference of that interface 
   type [...] "
 
 Although the section "Object Reference Operations" in the OMG IDL 
 to Ada Mapping chapter 23.5.5 defines a function
 
   function Is_Nil (Self : Ref) return Boolean;
 
 the mapping does not define a Nil operation.
 
 

Summary: In the mapping of structure, union or exception types, the same 
 complex_declarator component may occur in two or more structure 
 definitions, the name of the generated types will collide in the 
 proposed mapping. It would be wise to prepend the name of the 
 enclosing structure:   
 mapping of structure, union or exception types

 Close with no change:

Summary: The mapping of the sequence types does not corresponds to the 
 definition of the packages defined in 23.8.12, 23.8.13 and 23.8.14 :
 - with clauses are not correct
 - there is no array type as generic formal parameter
 
 

 Addressed by previousRTF:

Summary: In the mapping for typedef, if the ancestor type is the Object type 
 or an interface, then subtyping should occur in place of derivation.
 This would avoid several difficulties either in the generated code 
 and in the application code.
 

Summary: In the mapping of standard exceptions, ex_body maps to 
 System_Exception_Members which is defined as Ex_Body in the Corba 
 package.
 

Summary: In 23.6.1 NamedValue, the len component is useless and meaningless in 
 Ada.
 

 received issue

Summary: In 23.6.6 TypeCode, the package TypeCode should correspond to the 
 pseudo-IDL given in the CORBA 2 specification.
 

 received issue

Summary: In 23.6.7 ORB, the operations list_initial_services and 
 resolve_initial_references are missing. They need an ORB object to 
 apply to.
 ORB_init is nowhere defined but it could be added to Corba.Orb.
 

Summary: In 23.6.8 Object,
 - there are circularities as Corba.ImplementationDef.Ref and 
 Corba.InterfaceDef.Ref are derived from Corba.Object.Ref. One 
 solution to these circularities is to replace these types by 
 Corba.Object.Ref"class.
 

 Accept with Modification:

Summary: - The parameter Result in CreateRequest cannot be an "in out 
 NamedValue" as the result will be unreachable once the operation has 
 completed. Instead, it should be of an access type to NamedValue.
 

Summary: Section 23.5.9, 2nd paragraph, states that
 
   [...] The non-void result, if any, is returned via an added 
   argument with name "Returns".
 
 The word "added" would seem to imply that the Returns parameter 
 shall appear at the end of the parameter list. However, the 
 standard should be more explicit about the required parameter 
 position of the Returns parameter.
 
 

Summary: 23.5.5 Mapping for Interfaces (Client-Side Specific)
 
 The section "Nil Object Reference" states:
   [...] This mapping relies on the Is_Nil function to detect 
   uninitialized object references, and does require or allow 
   definition of a Nil constant.
 
 Could it be that this should read: "... does NOT require ..." ?
 

Summary: 23.5.5 Mapping for Interfaces (Client-Side Specific)
 
 The section "Object Reference Operations" has some lines in 
 typewriter font:
 
   function Is_Nil(Self : Ref) return Boolean;
 
   procedure Release(Self : Ref"CLASS);
 
 I believe these lines should instead be:
 
   function Is_Nil(Self : Ref"CLASS) return Boolean;
 
   procedure Release(Self : in out Ref"CLASS);
 
 Also, the Release operation is missing from 23.6.8 (Object) 
 and lacking the "CLASS attribute in 23.8.8 (package CORBA.Object)
 
 

Summary: I propose the addition of two functions to the  package CORBA:  function To_CORBA_String (Source :  Standard.String) return CORBA.String;
 function To_Standard_String (Source :  CORBA.String) return Standard.String;  In my opinion, the frequency with which these  conversion functions are 
 needed when dealing with the type CORBA.String  justify their inclusion 
 in the CORBA package.

Summary: Ada"s "not" is not specified for signed integers.
 
 If the table entry is to be read as "for signed integers, use the expression
 -(value-1)", then it would be more obvious, if the check sign appeared in
 the second line (where the expression is), not in the first line (where the
 not operator is).
 
 At least a comment seems appropriate.
 

Summary: Section 21.8.9:
 
 Example Chicken.idl:
 
 Freezing rules (ARM 13.14) cause the packages Egg and Chicken to be illegal.
 The declaration of
   function To_Ref (The_Ref : in Corba.Object.Ref"Class) return Ref;
 has to occur before the declaration of
     package Convert is new Egg/Chicken_Forward.Convert (Ref);
 ARM 13.14(5,16).
 
 
 Example Tank:
 
 package Tank is
 
   type Ref is new Vehicle.Ref with record
     Mixin: Asset.Ref;
   end record;
 
 If I"m not missing something fundamental, this mixin is needed to allow
 reference to Asset.Op1/2.
 

 in Corba.Object.Ref"Class) return Ref;

Summary: Section 21.10:
 
 The name of the mapped type shall be "Fixed_" prepended [rather than
 appended] to the IDL specified number of digits, ...
 

Summary: The Ada mapping lacks a method for converting an 
 implementation side Object to the corresponding 
 proxy side Ref. The C++ mapping defines a method, 
 _this(), for this purpose (see CORBA V2.2 chapter 
 20.34.2.)
 
 I propose the addition in the code generated for an 
 interface A, in package A.Impl:
 
    function To_Ref (Self : access Object) return Ref;
 

Summary: I suggest that the IDL to Ada mapping standard specifically 
 mention that Impl side methods be dispatching. In order to 
 achieve this, the Impl package spec generated for an 
 interface A should contain the marked declaration:
 
 with POA_A;
 package A.Impl is
    type Object is new POA_A.Object with private;
    -------- ADDITION :
    type Object_Access is access all Object"Class;
    -------- END OF ADDITION
 
    -- example method:
    procedure Meth (Self : access Object);
 
 end A.Impl;
 

Summary: CORBA V2.2 section 23.5.6, Mapping for Sequence Types, 
 states that
 
 " The name and scope of the instantiation
   [of CORBA.Sequences.Bounded or CORBA.Sequences.Unbounded]
   is left implementation defined. "
 
 However, the drawing.idl mapping example in the same section 
 suggests that
 
 1) the name of the instantiation be the simple_type_spec 
    with "IDL_SEQUENCE_" prepended
 
 2) the instantiation be located within the same scope as 
    the corresponding IDL sequence type declaration.
    (This could be expanded to state that if the sequence 
    type declaration appears at the IDL file scope level, 
    then the instantation shall appear within the 
    synthesized IDL_FILE_ package.)
 

Summary: It is a natural consequence of the Ada language rules that an operation
 parameter of the same interface type, other than the implied parameter,
 must be mapped to a class-wide reference type. The Ada language rules
 disallow two controlling parameters, and the first added Ref parameter must
 be the controlling parameter. So, for an operation that has an implicit
 parameter of the enclosing interface, a special mapping rule is needed so
 that the operation is not primitive on that parameter. 
 

Summary: The Ada RTF submission for the CORBA 2.4 Ada Mapping, 
 document ptc/99-02-02, under section 21.2.1 Interfaces 
 and Tagged Types, Server Side, states
 
 " The package contains a declaration for the Object 
   type, derived from the parent interface"s object type 
   or from a common root, CORBA.Object.Object, [...] "
 
 The common root type should be PortableServer.Servant_Base.