Order files

android/tools/jdk-osx/lib/ir.idl

@@ -0,0 +1,778 @@
+/*
+ * Copyright (c) 1999, 2001, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ * This file contains OMG IDL from  CORBA V2.0, July 1995.
+ * It also contains the TypeCode creation APIs in CORBA::ORB
+ **/
+
+#pragma prefix "omg.org"
+
+module CORBA {
+    typedef string Identifier;
+    typedef string ScopedName;
+    typedef string RepositoryId;
+
+    enum DefinitionKind {
+	dk_none, dk_all,
+	dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
+	dk_Module, dk_Operation, dk_Typedef,
+	dk_Alias, dk_Struct, dk_Union, dk_Enum,
+	dk_Primitive, dk_String, dk_Sequence, dk_Array,
+	dk_Repository,
+	dk_Wstring, dk_Fixed,
+	dk_Value, dk_ValueBox, dk_ValueMember, // orbos 98-01-18: Objects By Value
+	dk_Native
+    };
+
+
+    interface IRObject
+    /**
+      An IRObject IDL interface represents the most generic interface
+      from which all other Interface Repository interfaces are derived,
+      even the Repository itself.
+     */
+    {
+	// read interface
+	readonly attribute DefinitionKind def_kind;
+
+	// write interface
+	void destroy ();
+    };
+
+
+
+    typedef string VersionSpec;
+
+    interface Contained;
+    interface Repository;
+    interface Container;
+
+    interface Contained : IRObject
+    /**
+       The Contained Interface is inherited by all Interface Repository
+       interfaces that are contained by other objects.
+     */
+    {
+	// read/write interface
+
+	attribute RepositoryId id;
+	attribute Identifier name;
+	attribute VersionSpec version;
+
+	// read interface
+
+	readonly attribute Container defined_in;
+	readonly attribute ScopedName absolute_name;
+	readonly attribute Repository containing_repository;
+
+	struct Description {
+	    DefinitionKind kind;
+	    any value;
+	};
+
+	Description describe ();
+
+	// write interface
+
+	void move (
+	    in Container new_container,
+	    in Identifier new_name,
+	    in VersionSpec new_version
+	    );
+    };
+
+
+    interface ModuleDef;
+    interface ConstantDef;
+    interface IDLType;
+    interface StructDef;
+    interface UnionDef;
+    interface EnumDef;
+    interface AliasDef;
+    interface InterfaceDef;
+    interface ExceptionDef;
+    interface ValueDef;		// orbos 98-01-18: Objects By Value
+    interface ValueMemberDef;	// orbos 98-01-18: Objects By Value
+    interface ValueBoxDef;	// orbos 98-01-18: Objects By Value
+    interface NativeDef;
+
+
+    typedef sequence <InterfaceDef> InterfaceDefSeq;
+
+
+    typedef sequence <Contained> ContainedSeq;
+
+    struct StructMember {
+	Identifier name;
+	TypeCode type;
+	IDLType type_def;
+    };
+    typedef sequence <StructMember> StructMemberSeq;
+
+    struct UnionMember {
+	Identifier name;
+	any label;
+	TypeCode type;
+	IDLType type_def;
+    };
+    typedef sequence <UnionMember> UnionMemberSeq;
+
+
+    typedef sequence <Identifier> EnumMemberSeq;
+
+    // orbos 98-01-18: Objects By Value -- begin
+    typedef short Visibility;	
+    const Visibility PRIVATE_MEMBER = 0; 
+    const Visibility PUBLIC_MEMBER = 1;
+
+    struct ValueMember {
+        Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+        TypeCode type;
+        IDLType type_def;
+        Visibility access;
+    };
+    typedef sequence <ValueMember> ValueMemberSeq;
+
+    struct Initializer {
+        StructMemberSeq members;
+    };
+    typedef sequence <Initializer> InitializerSeq;
+
+    typedef sequence <ValueDef> ValueDefSeq;
+    
+    // orbos 98-01-18: Objects By Value -- end
+
+
+    interface Container : IRObject
+    /**
+      The Container interface is used to form a containment hierarchy
+      in the Interface Repository. A Container can contain any number
+      of objects derived from the Contained interface.
+    */
+    {
+	// read interface
+
+	Contained lookup ( in ScopedName search_name);
+
+	ContainedSeq contents (
+	    in DefinitionKind limit_type,
+	    in boolean exclude_inherited
+	    );
+
+	ContainedSeq lookup_name (
+	    in Identifier search_name,
+	    in long levels_to_search,
+	    in DefinitionKind limit_type,
+	    in boolean exclude_inherited
+	    );
+
+	struct Description {
+	    Contained contained_object;
+	    DefinitionKind kind;
+	    any value;
+	};
+
+	typedef sequence<Description> DescriptionSeq;
+
+	DescriptionSeq describe_contents (
+	    in DefinitionKind limit_type,
+	    in boolean exclude_inherited,
+	    in long max_returned_objs
+	    );
+
+	// write interface
+
+	ModuleDef create_module (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version
+	    );
+
+	ConstantDef create_constant (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType type,
+	    in any value
+	    );
+
+	StructDef create_struct (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in StructMemberSeq members
+	    );
+
+	UnionDef create_union (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType discriminator_type,
+	    in UnionMemberSeq members
+	    );
+
+	EnumDef create_enum (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in EnumMemberSeq members
+	    );
+
+	AliasDef create_alias (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType original_type
+	    );
+
+        ExceptionDef create_exception (
+            in RepositoryId    id,
+            in Identifier      name,
+            in VersionSpec     version,
+            in StructMemberSeq members
+        );
+
+
+	InterfaceDef create_interface (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in boolean is_abstract,
+	    in InterfaceDefSeq base_interfaces
+	    );
+
+	// orbos 98-01-18: Objects By Value
+	ValueDef create_value(
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in boolean is_custom,
+	    in boolean is_abstract,
+	    in octet flags,	// must be 0
+	    in ValueDef base_value,
+	    in boolean has_safe_base,
+	    in ValueDefSeq abstract_base_values,
+	    in InterfaceDefSeq supported_interfaces,
+	    in InitializerSeq initializers
+	    );
+	
+	// orbos 98-01-18: Objects By Value
+	ValueBoxDef create_value_box(
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType original_type_def
+	    );
+	
+	NativeDef create_native(
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version
+	    );
+	
+    };
+
+
+
+    interface IDLType : IRObject
+    /**
+       The IDLType interface is an abstract interface inherited by all
+       IR objects that represent the OMG IDL types. It provides access
+       to the TypeCode describing the type, and is used in defining the
+       other interfaces wherever definitions of IDLType must be referenced.
+    */
+    {
+	readonly attribute TypeCode type;
+    };
+
+
+
+    interface PrimitiveDef;
+    interface StringDef;
+    interface SequenceDef;
+    interface ArrayDef;
+
+    enum PrimitiveKind {
+	pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
+	pk_float, pk_double, pk_boolean, pk_char, pk_octet,
+	pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref
+    };
+
+    interface Repository : Container
+    /**
+      Repository is an interface that provides global access to the
+      Interface Repository. Repository objects can contain constants,
+      typedefs, exceptions, interfaces, and modules.
+    */
+    {
+	// read interface
+
+	Contained lookup_id (in RepositoryId search_id);
+
+	PrimitiveDef get_primitive (in PrimitiveKind kind);
+
+	// write interface
+
+	StringDef create_string (in unsigned long bound);
+
+	SequenceDef create_sequence (
+	    in unsigned long bound,
+	    in IDLType element_type
+	    );
+
+	ArrayDef create_array (
+	    in unsigned long length,
+	    in IDLType element_type
+	    );
+    };
+
+
+    interface ModuleDef : Container, Contained
+    /**
+      A ModuleDef can contain constants, typedefs, exceptions, interfaces,
+      and other module objects.
+    */
+    {
+    };
+
+    struct ModuleDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+    };
+
+
+    interface ConstantDef : Contained
+    /**
+      A ConstantDef object defines a named constant.
+    */
+    {
+	readonly attribute TypeCode type;
+	attribute IDLType type_def;
+	attribute any value;
+    };
+
+    struct ConstantDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	TypeCode type;
+	any value;
+    };
+
+
+    interface TypedefDef : Contained, IDLType
+    /**
+      TypedefDef is an abstract interface used as a base interface for
+      all named non-object types(structures, unions, enumerations,
+      aliases). The TypedefDef interface is not inherited by the definition
+      objects for the primitive or anonymous types.
+    */
+    {
+    };
+
+    struct TypeDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	TypeCode type;
+    };
+
+
+    interface StructDef : TypedefDef, Container
+    /**
+       A StructDef represents an OMG IDL structure definition.
+    */
+    {
+	attribute StructMemberSeq members;
+    };
+
+
+    interface UnionDef : TypedefDef, Container
+    /**
+       A UnionDef represents an OMG IDL union definition.
+     */
+    {
+	readonly attribute TypeCode discriminator_type;
+	attribute IDLType discriminator_type_def;
+	attribute UnionMemberSeq members;
+    };
+
+
+    interface EnumDef : TypedefDef
+    /**
+      A EnumDef represents an OMG IDL enum definition.
+     */
+    {
+	attribute EnumMemberSeq members;
+    };
+
+
+    interface AliasDef : TypedefDef
+    /**
+       An AliasDef represents an OMG IDL typedef that aliases other
+       definition.
+    */
+    {
+	attribute IDLType original_type_def;
+    };
+
+
+    interface PrimitiveDef: IDLType
+    /**
+      A PrimitiveDef represents one of the IDL primitive types. As
+      primitive types are unnamed, this interface is not derived from
+      TypedefDef or Contained.
+     */
+    {
+	readonly attribute PrimitiveKind kind;
+    };
+
+
+    interface StringDef : IDLType
+    /**
+      A StringDef represents an OMG IDL string type. As string
+      types are anonymous, this interface is not derived from TypedefDef
+      or Contained.
+    */
+    {
+	attribute unsigned long bound;
+    };
+
+
+    interface SequenceDef : IDLType
+    /**
+      A SequenceDef represents an OMG IDL sequence type. As sequence
+      types are anonymous, this interface is not derived from TypedefDef
+      or Contained.
+     */
+    {
+	attribute unsigned long bound;
+	readonly attribute TypeCode element_type;
+	attribute IDLType element_type_def;
+    };
+
+    interface ArrayDef : IDLType
+    /**
+      An ArrayDef represents an OMG IDL array type. As array
+      types are anonymous, this interface is not derived from TypedefDef
+      or Contained.
+    */
+    {
+	attribute unsigned long length;
+	readonly attribute TypeCode element_type;
+	attribute IDLType element_type_def;
+    };
+
+
+    interface ExceptionDef : Contained, Container
+    /**
+      An ExceptionDef represents an exception definition.
+    */
+    {
+	readonly attribute TypeCode type;
+	attribute StructMemberSeq members;
+    };
+    struct ExceptionDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	TypeCode type;
+    };
+
+
+
+    enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};
+
+    interface AttributeDef : Contained
+    /**
+      An AttributeDef represents the information that defines an
+      attribute of an interface.
+    */
+    {
+	readonly attribute TypeCode type;
+	attribute IDLType type_def;
+	attribute AttributeMode mode;
+    };
+
+    struct AttributeDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	TypeCode type;
+	AttributeMode mode;
+    };
+
+
+
+    enum OperationMode {OP_NORMAL, OP_ONEWAY};
+
+    enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
+    struct ParameterDescription {
+	Identifier name;
+	TypeCode type;
+	IDLType type_def;
+	ParameterMode mode;
+    };
+    typedef sequence <ParameterDescription> ParDescriptionSeq;
+
+    typedef Identifier ContextIdentifier;
+    typedef sequence <ContextIdentifier> ContextIdSeq;
+
+    typedef sequence <ExceptionDef> ExceptionDefSeq;
+    typedef sequence <ExceptionDescription> ExcDescriptionSeq;
+
+    interface OperationDef : Contained
+    /**
+      An OperationDef represents the information that defines an
+      operation of an interface.
+     */
+    {
+	readonly attribute TypeCode result;
+	attribute IDLType result_def;
+	attribute ParDescriptionSeq params;
+	attribute OperationMode mode;
+	attribute ContextIdSeq contexts;
+	attribute ExceptionDefSeq exceptions;
+    };
+
+    struct OperationDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	TypeCode result;
+	OperationMode mode;
+	ContextIdSeq contexts;
+	ParDescriptionSeq parameters;
+	ExcDescriptionSeq exceptions;
+    };
+
+
+
+    typedef sequence <RepositoryId> RepositoryIdSeq;
+    typedef sequence <OperationDescription> OpDescriptionSeq;
+    typedef sequence <AttributeDescription> AttrDescriptionSeq;
+
+    interface InterfaceDef : Container, Contained, IDLType
+    /**
+      An InterfaceDef object represents an interface definition. It can
+      contains constants, typedefs, exceptions, operations, and
+      attributes.
+     */
+    {
+	// read/write interface
+
+	attribute InterfaceDefSeq base_interfaces;
+	attribute boolean is_abstract;
+
+	// read interface
+
+	boolean is_a (in RepositoryId interface_id);
+
+	struct FullInterfaceDescription {
+	    Identifier name;
+	    RepositoryId id;
+	    RepositoryId defined_in;
+	    VersionSpec version;
+	    boolean is_abstract;
+	    OpDescriptionSeq operations;
+	    AttrDescriptionSeq attributes;
+	    RepositoryIdSeq base_interfaces;
+	    TypeCode type;
+	};
+
+	FullInterfaceDescription describe_interface();
+
+	// write interface
+
+	AttributeDef create_attribute (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType type,
+	    in AttributeMode mode
+	    );
+
+	OperationDef create_operation (
+	    in RepositoryId id,
+	    in Identifier name,
+	    in VersionSpec version,
+	    in IDLType result,
+	    in OperationMode mode,
+	    in ParDescriptionSeq params,
+	    in ExceptionDefSeq exceptions,
+	    in ContextIdSeq contexts
+	    );
+    };
+
+    struct InterfaceDescription {
+	Identifier name;
+	RepositoryId id;
+	RepositoryId defined_in;
+	VersionSpec version;
+	RepositoryIdSeq base_interfaces;
+    };
+
+
+    // orbos 98-01-18: Objects By Value -- begin
+
+    interface ValueMemberDef : Contained
+
+      /** A <code>ValueMemberDef</code> object represents the public
+      and private data member definition of a <code>Value</code> type
+      */
+
+ {
+        readonly attribute TypeCode type;
+	         attribute IDLType type_def;
+		 attribute Visibility access;
+    };
+
+    interface ValueDef : Container, Contained, IDLType
+      /**
+	A ValueDef object represents the definition of the
+	<code>Value</code> object used to pass the object state
+	between hosts
+	*/
+
+      {
+	   // read/write interface
+	    attribute InterfaceDefSeq supported_interfaces;
+	    attribute InitializerSeq initializers;
+	    attribute ValueDef base_value;
+	    attribute ValueDefSeq abstract_base_values;
+	    attribute boolean is_abstract;
+	    attribute boolean is_custom;
+	    attribute octet flags; // always 0
+	    attribute boolean has_safe_base;
+
+	    // read interface
+	    boolean is_a(in RepositoryId value_id);
+
+	    struct FullValueDescription {
+	      Identifier 	name;
+	      RepositoryId 	id;
+	      boolean 	is_abstract;
+	      boolean 	is_custom;
+	      octet 		flags; // always 0
+	      RepositoryId 	defined_in;
+	      VersionSpec 	version;
+	      OpDescriptionSeq operations;
+	      AttrDescriptionSeq attributes;
+	      ValueMemberSeq 	members;
+	      InitializerSeq 	initializers;
+	      RepositoryIdSeq supported_interfaces;
+	      RepositoryIdSeq abstract_base_values;
+	      boolean 	has_safe_base;
+	      RepositoryId	base_value;
+	      TypeCode	type;
+	  };
+
+	  FullValueDescription describe_value();
+
+	  // write interface
+
+	  ValueMemberDef create_value_member(
+	      in RepositoryId id,
+	      in Identifier name,
+	      in VersionSpec version,
+	      in IDLType type_def,
+	      in Visibility access
+	  );
+
+	  AttributeDef create_attribute(
+	      in RepositoryId id,
+	      in Identifier   name,
+	      in VersionSpec  version,
+	      in IDLType      type,
+	      in AttributeMode mode
+	  );
+
+	  OperationDef create_operation(
+	      in RepositoryId id,
+	      in Identifier   name,
+	      in VersionSpec  version,
+	      in IDLType      result,
+	      in OperationMode     mode,
+	      in ParDescriptionSeq params,
+	      in ExceptionDefSeq   exceptions,
+	      in ContextIdSeq contexts
+	  );
+    };
+    struct ValueDescription {
+        Identifier name;
+        RepositoryId id;
+        boolean is_abstract;
+        boolean is_custom;
+        octet   flags; // always 0
+        RepositoryId defined_in;
+        VersionSpec version;
+        RepositoryIdSeq supported_interfaces;
+        RepositoryIdSeq abstract_base_values;
+        boolean has_safe_base;
+        RepositoryId base_value;
+    };
+
+    interface ValueBoxDef : IDLType 
+
+      /** ValueBoxDef is an interface that reresents a value type with
+	a single data member inside its state section and no
+	inheritance or methods. For example, when transmitting a
+	string or sequence as an actual parameter on an interface
+	operation or as a data member of a value type that is an
+	actual parameter, it may be important to preserve any sharing
+	of the string or sequence within the object graph being
+	transmitted. Because current IDL data types do not preserve
+	referential integrity in this way, this requirement is
+	conveniently handled by using a value type. Value types also
+	support the transmission of nulls (as a distinguished value),
+	whereas IDL data types such as string and sequence (which are
+	mapped to empty strings and sequences) do not. The Java to IDL
+	mapping requires both preservation of referential integrity
+	and transmission of nulls. Because it would be cumbersome to
+	require the full IDL syntax for a value type for this specific
+	usage, this shorthand notation is introduced to cover this use
+	of value types for simple containment of a single data member.
+	*/
+
+{
+        attribute IDLType original_type_def;
+    };
+    
+    // orbos 98-01-18: Objects By Value -- end
+
+    interface NativeDef : TypedefDef {
+    };
+};

android/tools/jdk-osx/lib/orb.idl

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+// IDL not generated by rmic, do not edit
+// These are all in IDL module CORBA
+// The Java classes are in the package org.omg.CORBA
+// See ValueType Semantics:Standard Value Box Definitions (5.3) in CORBA 2.3 spec
+
+#ifndef __org_omg_CORBA__
+#define __org_omg_CORBA__
+
+#pragma prefix "omg.org"
+
+module CORBA{
+
+    valuetype StringValue string;
+    valuetype WStringValue wstring;
+
+};
+
+#include "ir.idl"
+
+#pragma prefix ""
+
+#endif