ridl 2.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdf34fc099b40aa14fd02ec34323831225dce823
+  data.tar.gz: dd3dcb56caf4338fcf0ba487850d6db251590bc8
+SHA512:
+  metadata.gz: 2779b950bf28dded230a3b4a89d127f4663c2b33632df056000a825c5ea17b902970a5e05bd4ec7971052bc2e658e91a41e7a746388a0dd19f4380aceb89bb45
+  data.tar.gz: e5f56246051d5083ee5f09e47f2a7841427bd6c471d038f503c12adc2712d6397625aae63e51874945b60dee15a5f3e34502bd1fde83f7a9aa599d703df87527

data/LICENSE

@@ -0,0 +1,49 @@
+RIDL LICENSE
+
+RIDL (Licensed Product) is protected by copyright, and is distributed
+under the following terms.
+
+RIDL (Ruby IDL compiler) is an open source tool, developed by Remedy IT and
+written in Ruby. It is designed to provide a flexible parser/compiler
+frontend for OMG standard IDL.
+RIDL provides a generic parser component for OMG IDL and a flexible framework
+for plugging in (code) generation backends.
+
+Since RIDL is open source and free of licensing fees, you are free to use,
+modify, and distribute the source code, as long as you include this
+copyright statement.
+
+In particular, you can use RIDL to build proprietary software and are
+under no obligation to redistribute any of your source code that is built
+using RIDL. Note, however, that you may not do anything to the RIDL
+code, such as copyrighting it yourself or claiming authorship of the RIDL
+code, that will prevent RIDL from being distributed freely using an open
+source development model.
+
+Warranty
+
+LICENSED PRODUCT IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE, NON-INFRINGEMENT, OR ARISING FROM A COURSE OF DEALING, USAGE OR
+TRADE PRACTICE.
+
+Support
+
+LICENSED PRODUCT IS PROVIDED WITH NO SUPPORT AND WITHOUT ANY OBLIGATION ON
+THE PART OF REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES TO ASSIST IN
+ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT.
+
+Remedy IT provides support to users who have agreed on the terms of a support
+contract.
+
+Liability
+
+REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY
+WITH RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS
+BY LICENSED PRODUCT OR ANY PART THEREOF.
+
+IN NO EVENT WILL REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE
+FOR ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL
+DAMAGES, EVEN IF REMEDY IT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+RIDL is Copyright Remedy IT. Nijkerk, The Netherlands, 2006-2013.

data/README.rdoc

@@ -0,0 +1,42 @@
+= RIDL Compiler
+
+home :: https://osportal.remedy.nl/projects/ridl
+
+== Description
+ 
+RIDL is a Ruby library implementing an OMG \IDL parser/compiler 
+frontend with support for pluggable (and stackable) backends.
+
+== Synopsis
+
+RIDL provides a framework for implementing compiler/generators for
+OMG standard \IDL interface definitions.
+The framework includes:
+
+* a RACC based parser supplemented with a custom scanner/tokenizer
+* a complete AST class hierarchy for representing parsed \IDL specifications
+* a complete Type class hierarchy
+* \IDL constants expression support
+* a builtin \IDL preprocessor expression parser/evaluator
+* a flexible framework for pluggable (and stackable) backends
+* basic support for backend code <b>re</b>generation
+
+RIDL is compliant with the latest OMG \IDL standard.
+
+== Bugs
+
+If you find a bug, please report it at the RIDL project's
+{issues tracker}[https://osportal.remedy.nl/projects/ridl/issues].
+
+== License
+
+RIDL is Copyright (c) 2007-2013 Remedy IT Expertise BV, The Netherlands.
+
+It is free software, and may be redistributed under the terms specified in
+the LICENSE file.
+
+== Warranty
+
+This software is provided "as is" and without any express or implied
+warranties, including, without limitation, the implied warranties of
+merchantibility and fitness for a particular purpose.

data/lib/idl/BiDirPolicy.pidl

@@ -0,0 +1,28 @@
+/* This file contains OMG IDL from  CORBA V2.3.1
+ * $Id$
+ */
+
+#ifndef __BiDirPolicy_IDL
+#define __BiDirPolicy_IDL
+
+#include <orb.idl>
+
+#pragma prefix "omg.org"
+
+// Self contained module for Bi-directional GIOP policy
+
+module BiDirPolicy {
+
+  typedef unsigned short BidirectionalPolicyValue;
+
+  const BidirectionalPolicyValue NORMAL = 0;
+  const BidirectionalPolicyValue BOTH = 1;
+
+  const CORBA::PolicyType BIDIRECTIONAL_POLICY_TYPE = 37;
+
+  interface BidirectionalPolicy : CORBA::Policy {
+    readonly attribute BidirectionalPolicyValue value;
+  };
+};
+
+#endif /* __BiDirPolicy_IDL */

data/lib/idl/CosNaming.idl

@@ -0,0 +1,260 @@
+// $Id$
+
+#ifndef COS_NAMING_IDL
+#define COS_NAMING_IDL
+
+#pragma prefix "omg.org"
+
+/**
+ * This module provides interface for using COS Naming Service.
+ */
+module CosNaming
+{
+  /// Define a typedef for String.  Maybe at some point, <Istring> will
+  /// be different to support Internationalization.
+  typedef string Istring;
+
+  /*
+   * This is a 'simple' name.
+   *
+   * Both id and kind fields are used in resolving names.
+   */
+  struct NameComponent
+  {
+    /// This is the name that is used to identify object references.
+    Istring id;
+
+    /// Stores any additional info about the object reference.
+    Istring kind;
+  };
+
+  /// This is a compound name: <c1; c2; c3; cn> where c1 to cn-1 are
+  /// the names of the nested contexts, and cn is the name of the
+  /// object bound in cn-1.
+  typedef sequence <NameComponent> Name;
+
+  enum BindingType
+  {
+    /// object binding.
+    nobject,
+
+    /// Naming context binding.
+    ncontext
+  };
+
+  struct Binding
+  {
+    /// Simple name, under which an object is bound in a given context.
+    Name binding_name;
+
+    /// Indicates whether the binding_name identifies a context, and, therefore, can
+    /// participate in name resolution.
+    BindingType binding_type;
+  };
+
+  typedef sequence <Binding> BindingList;
+
+  // Forward declaration.
+  interface BindingIterator;
+
+  /// Interface for managing name bindings and naming contexts.
+  interface NamingContext
+    {
+      // = Exceptions.
+
+      enum NotFoundReason
+      {
+        missing_node,
+        not_context,
+        not_object
+      };
+
+      /// Indicates that the name does not identify a binding.
+      exception NotFound
+      {
+
+        NotFoundReason why;
+        Name rest_of_name;
+      };
+
+      /// Implementation may throw this exception if some reason it cannot
+      /// complete the operation.  This is currently not used in TAO.
+      exception CannotProceed
+      {
+
+        NamingContext cxt;
+        Name rest_of_name;
+      };
+
+      /// A name of length 0 is invalid.  Implementations may place
+      /// further restrictions.
+      exception InvalidName
+      {
+      };
+
+      /// Indicates that the specified name is already bound to
+      /// some object.  Only one object can be bound to a
+      /// particular name in an context.  To change the binding,
+      /// <rebind> and <rebind_context> can be used.
+      exception AlreadyBound
+      {
+      };
+
+      /// Indicates that the context is not empty.
+      exception NotEmpty
+      {
+      };
+
+      // = Binding operations.
+
+      /// Create a binding for name <n> and object <obj> in the naming
+      /// context.  Compound names are treated as follows: ctx->bind
+      /// (<c1; c2; c3; cn>, obj) = (ctx->resolve (<c1; c2;
+      /// cn-1>))->bind (<cn>, obj) if the there already exists a
+      /// binding for the specified name, <AlreadyBound> exception is
+      /// thrown.  Naming contexts should be bound using <bind_context>
+      /// and <rebind_context> in order to participate in name
+      /// resolution later.
+      void bind (in Name n, in Object obj)
+        raises (NotFound, CannotProceed, InvalidName, AlreadyBound);
+
+      /// This is similar to <bind> operation above, except for when
+      /// the binding for the specified name already exists in the
+      /// specified context.  In that case, the existing binding is
+      /// replaced with the new one.
+      void rebind (in Name n, in Object obj)
+        raises (NotFound, CannotProceed, InvalidName);
+
+      /// This is the version of <bind> specifically for binding naming
+      /// contexts, so that they will participate in name resolution
+      /// when compound names are passed to be resolved.
+      void bind_context (in Name n, in NamingContext nc)
+        raises(NotFound, CannotProceed, InvalidName, AlreadyBound);
+
+      /// This is a version of <rebind> specifically for naming
+      /// contexts, so that they can participate in name resolution
+      /// when compound names are passed.
+      void rebind_context (in Name n, in NamingContext nc)
+        raises (NotFound, CannotProceed, InvalidName);
+
+      // = Resolving names.
+
+      /// Return object reference that is bound to the name.  Compound
+      /// name resolve is defined as follows: ctx->resolve (<c1; c2;
+      /// cn>) = ctx->resolve (<c1; c2 cn-1>)->resolve (<cn>) The
+      /// naming service does not return the type of the object.
+      /// Clients are responsible for "narrowing" the object to the
+      /// appropriate type.
+      Object resolve (in Name n)
+        raises (NotFound, CannotProceed, InvalidName);
+
+      // = Unbinding names.
+
+      /// Remove the name binding from the context.  When compound
+      /// names are used, unbind is defined as follows: ctx->unbind
+      /// (<c1; c2; cn>) = (ctx->resolve (<c1; c2; cn-1>))->unbind
+      /// (<cn>)
+      void unbind (in Name n)
+        raises (NotFound, CannotProceed, InvalidName);
+
+      // = Creating Naming Contexts.
+
+      /// This operation returns a new naming context implemented by
+      /// the same naming server in which the operation was invoked.
+      /// The context is not bound.
+      NamingContext new_context ();
+
+      /// This operation creates a new context and binds it to the name
+      /// supplied as an argument.  The newly-created context is
+      /// implemented by the same server as the context in which it was
+      /// bound (the name argument excluding the last component).
+      NamingContext bind_new_context (in Name n)
+        raises (NotFound, AlreadyBound, CannotProceed, InvalidName);
+
+      // = Deleting contexts.
+
+      /// Delete the naming context.  @note the user should <unbind>
+      /// any bindings in which the given context is bound to some
+      /// names before invoking <destroy> operation on it.
+      void destroy ()
+        raises (NotEmpty);
+
+
+      // = Listing the naming context.
+
+      /// Returns at most the requested number of bindings @a how_many
+      /// in @a bl.  If the naming context contains additional bindings,
+      /// they are returned with a BindingIterator.  In the naming
+      /// context does not contain any additional bindings @a bi
+      /// returned as null.
+      void list (in unsigned long how_many,
+                 out BindingList bl,
+                 out BindingIterator bi);
+    };
+
+  /// Interface for iterating over Bindings returned with the
+  /// <list> operation.
+  interface BindingIterator
+    {
+      /// This operation returns the next binding.  If there are no
+      /// more bindings false is returned.
+      boolean next_one (out Binding b);
+
+      /// This operation returns at most the requested number of
+      /// bindings.
+      boolean next_n (in unsigned long how_many,
+                      out BindingList bl);
+
+      /// This operation destroys the iterator.
+      void destroy ();
+    };
+
+  /// Interface for providing operations required to use URLs and
+  /// stringified names.
+  ///
+  /// Reference to: Document orbos/98-10-11 (Interoperable Naming Joint Revised Submission)
+  /// Joint Submission by BEA Systems, DSTC, IONA, and Inprise
+  interface NamingContextExt : NamingContext
+    {
+      /// Stringified form of a Name.
+      typedef string StringName;
+
+      /// URL address such as myhost.xyz.com.
+      typedef string Address;
+
+      /// Stringified form of a URL address componoent.
+      typedef string URLString;
+
+      /// This operation accepts a Name and returns a stringified
+      /// name. If the name is invalid, an InvalidName exception is
+      /// raised.
+      StringName to_string (in Name n)
+        raises (InvalidName);
+
+      /// This operation returns a Name. If the input stringified
+      /// name is syntactically malformed or violates an
+      /// implementation limit, an InvalidName exception is
+      /// raised.
+      Name to_name (in StringName sn)
+        raises (InvalidName);
+
+      /// Indicates that the URL address is invalid.
+      exception InvalidAddress {
+      };
+
+      /// It performs any escapes necessary on the stringified name
+      /// and returns a fully formed URL string. An exception is
+      /// raised if either the protocol or name parameters are invalid.
+      URLString to_url (in Address addr,
+                        in StringName sn)
+        raises (InvalidAddress, InvalidName);
+
+      /// This is similar to @c resolve as in the
+      /// CosNaming::NamingContext interface, except that it accepts
+      /// a stringified name as an argument instead of a Name.
+      Object resolve_str (in StringName n)
+        raises (NotFound, CannotProceed, InvalidName);
+    };
+};
+
+#endif /* COS_NAMING_IDL */

data/lib/idl/IOP.pidl

@@ -0,0 +1,98 @@
+// $Id$
+
+#ifndef _IOP_IDL_
+#define _IOP_IDL_
+
+#include <orb.idl>
+
+#pragma prefix "omg.org"
+
+module IOP
+{
+    local interface Codec
+    {
+        exception InvalidTypeForEncoding {};
+        exception FormatMismatch {};
+        exception TypeMismatch {};
+
+        CORBA::OctetSeq encode (in any data) raises (InvalidTypeForEncoding);
+        any decode (in CORBA::OctetSeq data) raises (FormatMismatch);
+        CORBA::OctetSeq encode_value (in any data) raises (InvalidTypeForEncoding);
+        any decode_value (in CORBA::OctetSeq data, in CORBA::TypeCode tc)
+            raises (FormatMismatch, TypeMismatch);
+    };
+
+    typedef short EncodingFormat;
+    const EncodingFormat ENCODING_CDR_ENCAPS = 0;
+
+    struct Encoding {
+        EncodingFormat format;
+        octet major_version;
+        octet minor_version;
+    };
+
+    local interface CodecFactory
+    {
+        exception UnknownEncoding {};
+
+        Codec create_codec (in Encoding enc) raises (UnknownEncoding);
+    };
+
+    typedef unsigned long  ProfileId;
+    const ProfileId         TAG_INTERNET_IOP = 0;
+    const ProfileId         TAG_MULTIPLE_COMPONENTS = 1;
+
+    struct TaggedProfile {
+        ProfileId  tag;
+        CORBA::OctetSeq profile_data;
+    };
+
+    typedef sequence <TaggedProfile>  TaggedProfileSeq;
+
+    struct IOR {
+        string        type_id;
+        TaggedProfileSeq profiles;
+    };
+
+    typedef unsigned long ComponentId;
+
+    const ComponentId TAG_ORB_TYPE = 0;
+    const ComponentId TAG_CODE_SETS= 1;
+    const ComponentId TAG_POLICIES= 2;
+    const ComponentId TAG_ALTERNATE_IIOP_ADDRESS = 3;
+    const ComponentId TAG_ASSOCIATION_OPTIONS = 13;
+    const ComponentId TAG_JAVA_CODEBASE = 25;
+    // ... others
+
+    struct TaggedComponent {
+        ComponentId  tag;
+        CORBA::OctetSeq component_data;
+    };
+
+    typedef sequence <TaggedComponent> MultipleComponentProfile;
+    typedef sequence<TaggedComponent> TaggedComponentSeq;
+
+    typedef unsigned long ServiceId;
+
+    struct ServiceContext {
+        ServiceId context_id;
+        CORBA::OctetSeq context_data;
+    };
+    typedef sequence <ServiceContext> ServiceContextList;
+
+    const ServiceId        TransactionService = 0;
+    const ServiceId        CodeSets = 1;
+    const ServiceId        ChainBypassCheck = 2;
+    const ServiceId        ChainBypassInfo = 3;
+    const ServiceId        LogicalThreadId = 4;
+    const ServiceId        BI_DIR_IIOP = 5;
+    const ServiceId        SendingContextRunTime = 6;
+    const ServiceId        INVOCATION_POLICIES = 7;
+    const ServiceId        FORWARDED_IDENTITY = 8;
+    const ServiceId        UnknownExceptionInfo = 9;
+    const ServiceId ExceptionDetailMessage = 14;
+    const ServiceId        SecurityAttributeService = 15;
+
+};  // IOP module
+
+#endif